{"version":3,"file":"static/js/vendors-f23ac594.501b97b4.js","mappings":"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","sources":["../pdfjs-dist/build/pdf/webpack/universalModuleDefinition","../pdfjs-dist/build/pdf/src/display/display_utils.js","../pdfjs-dist/build/pdf/node_modules/@babel/runtime/regenerator/index.js","../pdfjs-dist/build/pdf/node_modules/@babel/runtime/node_modules/regenerator-runtime/runtime.js","../pdfjs-dist/build/pdf/src/shared/util.js","../pdfjs-dist/build/pdf/src/shared/compatibility.js","../pdfjs-dist/build/pdf/src/shared/is_node.js","../pdfjs-dist/build/pdf/node_modules/core-js/es/global-this.js","../pdfjs-dist/build/pdf/node_modules/core-js/modules/es.global-this.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/export.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/global.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/object-get-own-property-descriptor.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/descriptors.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/fails.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/function-call.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/object-property-is-enumerable.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/create-property-descriptor.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/to-indexed-object.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/indexed-object.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/function-uncurry-this.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/classof-raw.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/require-object-coercible.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/to-property-key.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/to-primitive.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/is-object.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/is-callable.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/is-symbol.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/get-built-in.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/object-is-prototype-of.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/use-symbol-as-uid.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/native-symbol.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/engine-v8-version.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/engine-user-agent.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/get-method.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/a-callable.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/try-to-string.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/ordinary-to-primitive.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/well-known-symbol.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/shared.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/is-pure.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/shared-store.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/set-global.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/has-own-property.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/to-object.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/uid.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/ie8-dom-define.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/document-create-element.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/create-non-enumerable-property.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/object-define-property.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/an-object.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/redefine.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/inspect-source.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/internal-state.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/native-weak-map.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/shared-key.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/hidden-keys.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/function-name.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/copy-constructor-properties.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/own-keys.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/object-get-own-property-names.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/object-keys-internal.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/array-includes.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/to-absolute-index.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/to-integer-or-infinity.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/length-of-array-like.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/to-length.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/enum-bug-keys.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/object-get-own-property-symbols.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/is-forced.js","../pdfjs-dist/build/pdf/node_modules/dommatrix/dist/dommatrix.js","../pdfjs-dist/build/pdf/node_modules/core-js/es/object/from-entries.js","../pdfjs-dist/build/pdf/node_modules/core-js/modules/es.array.iterator.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/add-to-unscopables.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/object-create.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/object-define-properties.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/object-keys.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/html.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/iterators.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/define-iterator.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/create-iterator-constructor.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/iterators-core.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/object-get-prototype-of.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/correct-prototype-getter.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/set-to-string-tag.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/object-set-prototype-of.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/a-possible-prototype.js","../pdfjs-dist/build/pdf/node_modules/core-js/modules/es.object.from-entries.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/iterate.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/function-bind-context.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/is-array-iterator-method.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/get-iterator.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/get-iterator-method.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/classof.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/to-string-tag-support.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/iterator-close.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/create-property.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/path.js","../pdfjs-dist/build/pdf/node_modules/core-js/es/promise/index.js","../pdfjs-dist/build/pdf/node_modules/core-js/modules/es.aggregate-error.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/clear-error-stack.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/array-slice-simple.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/install-error-cause.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/normalize-string-argument.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/to-string.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/error-stack-installable.js","../pdfjs-dist/build/pdf/node_modules/core-js/modules/es.object.to-string.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/object-to-string.js","../pdfjs-dist/build/pdf/node_modules/core-js/modules/es.promise.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/native-promise-constructor.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/redefine-all.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/set-species.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/an-instance.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/check-correctness-of-iteration.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/species-constructor.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/a-constructor.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/is-constructor.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/task.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/function-apply.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/array-slice.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/engine-is-ios.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/engine-is-node.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/microtask.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/engine-is-ios-pebble.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/engine-is-webos-webkit.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/promise-resolve.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/new-promise-capability.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/host-report-errors.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/perform.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/engine-is-browser.js","../pdfjs-dist/build/pdf/node_modules/core-js/modules/es.promise.all-settled.js","../pdfjs-dist/build/pdf/node_modules/core-js/modules/es.promise.any.js","../pdfjs-dist/build/pdf/node_modules/core-js/modules/es.promise.finally.js","../pdfjs-dist/build/pdf/node_modules/core-js/modules/es.string.iterator.js","../pdfjs-dist/build/pdf/node_modules/core-js/internals/string-multibyte.js","../pdfjs-dist/build/pdf/node_modules/web-streams-polyfill/dist/ponyfill.js","../pdfjs-dist/build/pdf/src/display/base_factory.js","../pdfjs-dist/build/pdf/src/display/api.js","../pdfjs-dist/build/pdf/src/display/font_loader.js","../pdfjs-dist/build/pdf/src/display/node_utils.js","../pdfjs-dist/build/pdf/src/display/annotation_storage.js","../pdfjs-dist/build/pdf/src/display/canvas.js","../pdfjs-dist/build/pdf/src/display/pattern_helper.js","../pdfjs-dist/build/pdf/src/display/worker_options.js","../pdfjs-dist/build/pdf/src/shared/message_handler.js","../pdfjs-dist/build/pdf/src/display/metadata.js","../pdfjs-dist/build/pdf/src/display/optional_content_config.js","../pdfjs-dist/build/pdf/src/display/transport_stream.js","../pdfjs-dist/build/pdf/src/display/xfa_text.js","../pdfjs-dist/build/pdf/src/display/annotation_layer.js","../pdfjs-dist/build/pdf/src/shared/scripting_utils.js","../pdfjs-dist/build/pdf/src/display/xfa_layer.js","../pdfjs-dist/build/pdf/src/display/text_layer.js","../pdfjs-dist/build/pdf/src/display/svg.js","../pdfjs-dist/build/pdf/src/display/node_stream.js","../pdfjs-dist/build/pdf/src/display/network_utils.js","../pdfjs-dist/build/pdf/src/display/content_disposition.js","../pdfjs-dist/build/pdf/src/display/network.js","../pdfjs-dist/build/pdf/src/display/fetch_stream.js","../pdfjs-dist/build/pdf/webpack/bootstrap","../pdfjs-dist/build/pdf/webpack/runtime/node module decorator","../pdfjs-dist/build/pdf/src/pdf.js"],"sourcesContent":["(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 ","/* 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  assert,\n  BaseException,\n  isString,\n  removeNullCharacters,\n  shadow,\n  stringToBytes,\n  Util,\n  warn,\n} from \"../shared/util.js\";\nimport {\n  BaseCanvasFactory,\n  BaseCMapReaderFactory,\n  BaseStandardFontDataFactory,\n  BaseSVGFactory,\n} from \"./base_factory.js\";\n\nconst DEFAULT_LINK_REL = \"noopener noreferrer nofollow\";\nconst SVG_NS = \"http://www.w3.org/2000/svg\";\n\nconst PixelsPerInch = {\n  CSS: 96.0,\n  PDF: 72.0,\n\n  /** @type {number} */\n  get PDF_TO_CSS_UNITS() {\n    return shadow(this, \"PDF_TO_CSS_UNITS\", this.CSS / this.PDF);\n  },\n};\n\nclass DOMCanvasFactory extends BaseCanvasFactory {\n  constructor({ ownerDocument = globalThis.document } = {}) {\n    super();\n    this._document = ownerDocument;\n  }\n\n  _createCanvas(width, height) {\n    const canvas = this._document.createElement(\"canvas\");\n    canvas.width = width;\n    canvas.height = height;\n    return canvas;\n  }\n}\n\nasync function fetchData(url, asTypedArray = false) {\n  if (\n    (typeof PDFJSDev !== \"undefined\" && PDFJSDev.test(\"MOZCENTRAL\")) ||\n    isValidFetchUrl(url, document.baseURI)\n  ) {\n    const response = await fetch(url);\n    if (!response.ok) {\n      throw new Error(response.statusText);\n    }\n    return asTypedArray\n      ? new Uint8Array(await response.arrayBuffer())\n      : stringToBytes(await response.text());\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, /* asTypedArray = */ true);\n\n    if (asTypedArray) {\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 data;\n        if (asTypedArray && request.response) {\n          data = new Uint8Array(request.response);\n        } else if (!asTypedArray && request.responseText) {\n          data = stringToBytes(request.responseText);\n        }\n        if (data) {\n          resolve(data);\n          return;\n        }\n      }\n      reject(new Error(request.statusText));\n    };\n\n    request.send(null);\n  });\n}\n\nclass DOMCMapReaderFactory extends BaseCMapReaderFactory {\n  _fetchData(url, compressionType) {\n    return fetchData(url, /* asTypedArray = */ this.isCompressed).then(data => {\n      return { cMapData: data, compressionType };\n    });\n  }\n}\n\nclass DOMStandardFontDataFactory extends BaseStandardFontDataFactory {\n  _fetchData(url) {\n    return fetchData(url, /* asTypedArray = */ true);\n  }\n}\n\nclass DOMSVGFactory extends BaseSVGFactory {\n  _createSVG(type) {\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    // Normalize the rotation, by clamping it to the [0, 360) range.\n    rotation %= 360;\n    if (rotation < 0) {\n      rotation += 360;\n    }\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, \"RenderingCancelledException\");\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 {HTMLAnchorElement} 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\nfunction isDataScheme(url) {\n  const ii = url.length;\n  let i = 0;\n  while (i < ii && url[i].trim() === \"\") {\n    i++;\n  }\n  return url.substring(i, i + 5).toLowerCase() === \"data:\";\n}\n\nfunction isPdfFile(filename) {\n  return typeof filename === \"string\" && /\\.pdf$/i.test(filename);\n}\n\n/**\n * Gets the filename from a given URL.\n * @param {string} url\n * @returns {string}\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\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 (isDataScheme(url)) {\n    warn('getPdfFilenameFromUrl: ignore \"data:\"-URL for performance reasons.');\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\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 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 * @param {boolean} [removeScriptElement]\n * @returns {Promise<void>}\n */\nfunction loadScript(src, removeScriptElement = false) {\n  return new Promise((resolve, reject) => {\n    const script = document.createElement(\"script\");\n    script.src = src;\n\n    script.onload = function (evt) {\n      if (removeScriptElement) {\n        script.remove();\n      }\n      resolve(evt);\n    };\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\n/**\n * NOTE: This is (mostly) intended to support printing of XFA forms.\n */\nfunction getXfaPageViewport(xfaPage, { scale = 1, rotation = 0 }) {\n  const { width, height } = xfaPage.attributes.style;\n  const viewBox = [0, 0, parseInt(width), parseInt(height)];\n\n  return new PageViewport({\n    viewBox,\n    scale,\n    rotation,\n  });\n}\n\nexport {\n  addLinkAttributes,\n  deprecated,\n  DOMCanvasFactory,\n  DOMCMapReaderFactory,\n  DOMStandardFontDataFactory,\n  DOMSVGFactory,\n  getFilenameFromUrl,\n  getPdfFilenameFromUrl,\n  getXfaPageViewport,\n  isDataScheme,\n  isPdfFile,\n  isValidFetchUrl,\n  LinkTarget,\n  loadScript,\n  PageViewport,\n  PDFDateString,\n  PixelsPerInch,\n  RenderingCancelledException,\n  StatTimer,\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  define(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 = GeneratorFunctionPrototype;\n  define(Gp, \"constructor\", GeneratorFunctionPrototype);\n  define(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  define(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  define(Gp, iteratorSymbol, function() {\n    return this;\n  });\n\n  define(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, in modern engines\n  // we can explicitly access globalThis. In older engines 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  if (typeof globalThis === \"object\") {\n    globalThis.regeneratorRuntime = runtime;\n  } else {\n    Function(\"r\", \"regeneratorRuntime = r\")(runtime);\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\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/**\n * Refer to the `WorkerTransport.getRenderingIntent`-method in the API, to see\n * how these flags are being used:\n *  - ANY, DISPLAY, and PRINT are the normal rendering intents, note the\n *    `PDFPageProxy.{render, getOperatorList, getAnnotations}`-methods.\n *  - ANNOTATIONS_FORMS, ANNOTATIONS_STORAGE, ANNOTATIONS_DISABLE control which\n *    annotations are rendered onto the canvas (i.e. by being included in the\n *    operatorList), note the `PDFPageProxy.{render, getOperatorList}`-methods\n *    and their `annotationMode`-option.\n *  - OPLIST is used with the `PDFPageProxy.getOperatorList`-method, note the\n *    `OperatorList`-constructor (on the worker-thread).\n */\nconst RenderingIntentFlag = {\n  ANY: 0x01,\n  DISPLAY: 0x02,\n  PRINT: 0x04,\n  ANNOTATIONS_FORMS: 0x10,\n  ANNOTATIONS_STORAGE: 0x20,\n  ANNOTATIONS_DISABLE: 0x40,\n  OPLIST: 0x100,\n};\n\nconst AnnotationMode = {\n  DISABLE: 0,\n  ENABLE: 1,\n  ENABLE_FORMS: 2,\n  ENABLE_STORAGE: 3,\n};\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 AnnotationActionEventType = {\n  E: \"Mouse Enter\",\n  X: \"Mouse Exit\",\n  D: \"Mouse Down\",\n  U: \"Mouse Up\",\n  Fo: \"Focus\",\n  Bl: \"Blur\",\n  PO: \"PageOpen\",\n  PC: \"PageClose\",\n  PV: \"PageVisible\",\n  PI: \"PageInvisible\",\n  K: \"Keystroke\",\n  F: \"Format\",\n  V: \"Validate\",\n  C: \"Calculate\",\n};\n\nconst DocumentActionEventType = {\n  WC: \"WillClose\",\n  WS: \"WillSave\",\n  DS: \"DidSave\",\n  WP: \"WillPrint\",\n  DP: \"DidPrint\",\n};\n\nconst PageActionEventType = {\n  O: \"PageOpen\",\n  C: \"PageClose\",\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  TYPE1STANDARD: \"TYPE1STANDARD\",\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  /** @deprecated unused */\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  signatures: \"signatures\",\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  errorFontBuildPath: \"errorFontBuildPath\",\n  errorFontGetPath: \"errorFontGetPath\",\n  errorMarkedContent: \"errorMarkedContent\",\n  errorContentSubStream: \"errorContentSubStream\",\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 * @param {Object} [options]\n * @returns Either a valid {URL}, or `null` otherwise.\n */\nfunction createValidAbsoluteUrl(url, baseUrl = null, options = null) {\n  if (!url) {\n    return null;\n  }\n  try {\n    if (options && typeof url === \"string\") {\n      // Let URLs beginning with \"www.\" default to using the \"http://\" protocol.\n      if (options.addDefaultProtocol && url.startsWith(\"www.\")) {\n        const dots = url.match(/\\./g);\n        // Avoid accidentally matching a *relative* URL pointing to a file named\n        // e.g. \"www.pdf\" or similar.\n        if (dots && dots.length >= 2) {\n          url = `http://${url}`;\n        }\n      }\n\n      // According to ISO 32000-1:2008, section 12.6.4.7, URIs should be encoded\n      // in 7-bit ASCII. Some bad PDFs use UTF-8 encoding; see bug 1122280.\n      if (options.tryConvertEncoding) {\n        try {\n          url = stringToUTF8String(url);\n        } catch (ex) {}\n      }\n    }\n\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  if (\n    typeof PDFJSDev === \"undefined\" ||\n    PDFJSDev.test(\"!PRODUCTION || TESTING\")\n  ) {\n    assert(\n      prop in obj,\n      `shadow: Property \"${prop && prop.toString()}\" not found in object.`\n    );\n  }\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, name) {\n    if (this.constructor === BaseException) {\n      unreachable(\"Cannot initialize BaseException.\");\n    }\n    this.message = message;\n    this.name = 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, \"PasswordException\");\n    this.code = code;\n  }\n}\n\nclass UnknownErrorException extends BaseException {\n  constructor(msg, details) {\n    super(msg, \"UnknownErrorException\");\n    this.details = details;\n  }\n}\n\nclass InvalidPDFException extends BaseException {\n  constructor(msg) {\n    super(msg, \"InvalidPDFException\");\n  }\n}\n\nclass MissingPDFException extends BaseException {\n  constructor(msg) {\n    super(msg, \"MissingPDFException\");\n  }\n}\n\nclass UnexpectedResponseException extends BaseException {\n  constructor(msg, status) {\n    super(msg, \"UnexpectedResponseException\");\n    this.status = status;\n  }\n}\n\n/**\n * Error caused during parsing PDF data.\n */\nclass FormatError extends BaseException {\n  constructor(msg) {\n    super(msg, \"FormatError\");\n  }\n}\n\n/**\n * Error used to indicate task cancellation.\n */\nclass AbortException extends BaseException {\n  constructor(msg) {\n    super(msg, \"AbortException\");\n  }\n}\n\nconst NullCharactersRegExp = /\\x00+/g;\nconst InvisibleCharactersRegExp = /[\\x01-\\x1F]/g;\n\n/**\n * @param {string} str\n */\nfunction removeNullCharacters(str, replaceInvisible = false) {\n  if (typeof str !== \"string\") {\n    warn(\"The argument for removeNullCharacters must be a string.\");\n    return str;\n  }\n  if (replaceInvisible) {\n    str = str.replace(InvisibleCharactersRegExp, \" \");\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  if (\n    typeof PDFJSDev === \"undefined\" ||\n    PDFJSDev.test(\"!PRODUCTION || TESTING\")\n  ) {\n    assert(\n      typeof value === \"number\" && Math.abs(value) < 2 ** 32,\n      `string32: Unexpected input \"${value}\".`\n    );\n  }\n  return String.fromCharCode(\n    (value >> 24) & 0xff,\n    (value >> 16) & 0xff,\n    (value >> 8) & 0xff,\n    value & 0xff\n  );\n}\n\nfunction objectSize(obj) {\n  return Object.keys(obj).length;\n}\n\n// Ensure that the returned Object has a `null` prototype; hence why\n// `Object.fromEntries(...)` is not used.\nfunction objectFromMap(map) {\n  const obj = Object.create(null);\n  for (const [key, value] of map) {\n    obj[key] = value;\n  }\n  return obj;\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 hexNumbers = [...Array(256).keys()].map(n =>\n  n.toString(16).padStart(2, \"0\")\n);\n\nclass Util {\n  static makeHexColor(r, g, b) {\n    return `#${hexNumbers[r]}${hexNumbers[g]}${hexNumbers[b]}`;\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) ** 2 - 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  // From https://github.com/adobe-webplatform/Snap.svg/blob/b365287722a72526000ac4bfcf0ce4cac2faa015/src/path.js#L852\n  static bezierBoundingBox(x0, y0, x1, y1, x2, y2, x3, y3) {\n    const tvalues = [],\n      bounds = [[], []];\n    let a, b, c, t, t1, t2, b2ac, sqrtb2ac;\n    for (let i = 0; i < 2; ++i) {\n      if (i === 0) {\n        b = 6 * x0 - 12 * x1 + 6 * x2;\n        a = -3 * x0 + 9 * x1 - 9 * x2 + 3 * x3;\n        c = 3 * x1 - 3 * x0;\n      } else {\n        b = 6 * y0 - 12 * y1 + 6 * y2;\n        a = -3 * y0 + 9 * y1 - 9 * y2 + 3 * y3;\n        c = 3 * y1 - 3 * y0;\n      }\n      if (Math.abs(a) < 1e-12) {\n        if (Math.abs(b) < 1e-12) {\n          continue;\n        }\n        t = -c / b;\n        if (0 < t && t < 1) {\n          tvalues.push(t);\n        }\n        continue;\n      }\n      b2ac = b * b - 4 * c * a;\n      sqrtb2ac = Math.sqrt(b2ac);\n      if (b2ac < 0) {\n        continue;\n      }\n      t1 = (-b + sqrtb2ac) / (2 * a);\n      if (0 < t1 && t1 < 1) {\n        tvalues.push(t1);\n      }\n      t2 = (-b - sqrtb2ac) / (2 * a);\n      if (0 < t2 && t2 < 1) {\n        tvalues.push(t2);\n      }\n    }\n\n    let j = tvalues.length,\n      mt;\n    const jlen = j;\n    while (j--) {\n      t = tvalues[j];\n      mt = 1 - t;\n      bounds[0][j] =\n        mt * mt * mt * x0 +\n        3 * mt * mt * t * x1 +\n        3 * mt * t * t * x2 +\n        t * t * t * x3;\n      bounds[1][j] =\n        mt * mt * mt * y0 +\n        3 * mt * mt * t * y1 +\n        3 * mt * t * t * y2 +\n        t * t * t * y3;\n    }\n\n    bounds[0][jlen] = x0;\n    bounds[1][jlen] = y0;\n    bounds[0][jlen + 1] = x3;\n    bounds[1][jlen + 1] = y3;\n    bounds[0].length = bounds[1].length = jlen + 2;\n\n    return [\n      Math.min(...bounds[0]),\n      Math.min(...bounds[1]),\n      Math.max(...bounds[0]),\n      Math.max(...bounds[1]),\n    ];\n  }\n}\n\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, 0x2d8,\n  0x2c7, 0x2c6, 0x2d9, 0x2dd, 0x2db, 0x2da, 0x2dc, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n  0, 0, 0, 0, 0, 0, 0, 0, 0x2022, 0x2020, 0x2021, 0x2026, 0x2014, 0x2013, 0x192,\n  0x2044, 0x2039, 0x203a, 0x2212, 0x2030, 0x201e, 0x201c, 0x201d, 0x2018,\n  0x2019, 0x201a, 0x2122, 0xfb01, 0xfb02, 0x141, 0x152, 0x160, 0x178, 0x17d,\n  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 \"(\", \")\", \"\\n\", \"\\r\" and \"\\\"\n  // by \"\\(\", \"\\)\", \"\\\\n\", \"\\\\r\" and \"\\\\\"\n  // in order to write it in a PDF file.\n  return str.replace(/([()\\\\\\n\\r])/g, match => {\n    if (match === \"\\n\") {\n      return \"\\\\n\";\n    } else if (match === \"\\r\") {\n      return \"\\\\r\";\n    }\n    return `\\\\${match}`;\n  });\n}\n\nfunction isAscii(str) {\n  return /^[\\x00-\\x7F]*$/.test(str);\n}\n\nfunction stringToUTF16BEString(str) {\n  const buf = [\"\\xFE\\xFF\"];\n  for (let i = 0, ii = str.length; i < ii; i++) {\n    const char = str.charCodeAt(i);\n    buf.push(\n      String.fromCharCode((char >> 8) & 0xff),\n      String.fromCharCode(char & 0xff)\n    );\n  }\n  return buf.join(\"\");\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  for (let i = 0, ii = arr1.length; i < ii; i++) {\n    if (arr1[i] !== arr2[i]) {\n      return false;\n    }\n  }\n  return true;\n}\n\nfunction getModificationDate(date = new Date()) {\n  const buffer = [\n    date.getUTCFullYear().toString(),\n    (date.getUTCMonth() + 1).toString().padStart(2, \"0\"),\n    date.getUTCDate().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\nfunction createObjectURL(data, contentType = \"\", forceDataSchema = false) {\n  if (URL.createObjectURL && typeof Blob !== \"undefined\" && !forceDataSchema) {\n    return URL.createObjectURL(new Blob([data], { type: contentType }));\n  }\n  // Blob/createObjectURL is not available, falling back to data schema.\n  const digits =\n    \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\";\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\nexport {\n  AbortException,\n  AnnotationActionEventType,\n  AnnotationBorderStyleType,\n  AnnotationFieldFlag,\n  AnnotationFlag,\n  AnnotationMarkedState,\n  AnnotationMode,\n  AnnotationReplyType,\n  AnnotationReviewState,\n  AnnotationStateModelType,\n  AnnotationType,\n  arrayByteLength,\n  arraysToBytes,\n  assert,\n  BaseException,\n  bytesToString,\n  CMapCompressionType,\n  createObjectURL,\n  createPromiseCapability,\n  createValidAbsoluteUrl,\n  DocumentActionEventType,\n  escapeString,\n  FONT_IDENTITY_MATRIX,\n  FontType,\n  FormatError,\n  getModificationDate,\n  getVerbosityLevel,\n  IDENTITY_MATRIX,\n  ImageKind,\n  info,\n  InvalidPDFException,\n  isArrayBuffer,\n  isArrayEqual,\n  isAscii,\n  isBool,\n  IsEvalSupportedCached,\n  IsLittleEndianCached,\n  isNum,\n  isSameOrigin,\n  isString,\n  MissingPDFException,\n  objectFromMap,\n  objectSize,\n  OPS,\n  PageActionEventType,\n  PasswordException,\n  PasswordResponses,\n  PermissionFlag,\n  removeNullCharacters,\n  RenderingIntentFlag,\n  setVerbosityLevel,\n  shadow,\n  StreamType,\n  string32,\n  stringToBytes,\n  stringToPDFString,\n  stringToUTF16BEString,\n  stringToUTF8String,\n  TextRenderingMode,\n  UnexpectedResponseException,\n  UnknownErrorException,\n  unreachable,\n  UNSUPPORTED_FEATURES,\n  utf8StringToString,\n  Util,\n  VerbosityLevel,\n  warn,\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\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: Firefox<65, Chrome<71, Safari<12.1, Node.js<12.0.0\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  // 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  // Support: Node.js\n  (function checkDOMMatrix() {\n    if (globalThis.DOMMatrix || !isNodeJS) {\n      return;\n    }\n    globalThis.DOMMatrix = require(\"dommatrix/dist/dommatrix.js\");\n  })();\n\n  // Provides support for Object.fromEntries in legacy browsers.\n  // Support: Firefox<63, Chrome<73, Safari<12.1, Node.js<12.0.0\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 *recent* additions to the Promise specification,\n  // however basic Promise support is assumed to be available natively.\n  // Support: Firefox<71, Chrome<76, Safari<13, Node.js<12.9.0\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.allSettled) {\n      return;\n    }\n    globalThis.Promise = require(\"core-js/es/promise/index.js\");\n  })();\n\n  // Support: 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    if (typeof PDFJSDev !== \"undefined\" && PDFJSDev.test(\"CHROME\")) {\n      // Slightly reduce the size of the Chromium-extension, given\n      // that `ReadableStream` has been supported since Chrome 43.\n      return;\n    }\n    if (globalThis.ReadableStream || !isNodeJS) {\n      return;\n    }\n    globalThis.ReadableStream =\n      require(\"web-streams-polyfill/dist/ponyfill.js\").ReadableStream;\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://tc39.es/ecma262/#sec-globalthis\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  options.name        - the .name of the function if it does not match the key\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 es/no-global-this -- safe\n  check(typeof globalThis == 'object' && globalThis) ||\n  check(typeof window == 'object' && window) ||\n  // eslint-disable-next-line no-restricted-globals -- safe\n  check(typeof self == 'object' && self) ||\n  check(typeof global == 'object' && global) ||\n  // eslint-disable-next-line no-new-func -- fallback\n  (function () { return this; })() || Function('return this')();\n","var DESCRIPTORS = require('../internals/descriptors');\nvar call = require('../internals/function-call');\nvar propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar toPropertyKey = require('../internals/to-property-key');\nvar hasOwn = require('../internals/has-own-property');\nvar IE8_DOM_DEFINE = require('../internals/ie8-dom-define');\n\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// `Object.getOwnPropertyDescriptor` method\n// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor\nexports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {\n  O = toIndexedObject(O);\n  P = toPropertyKey(P);\n  if (IE8_DOM_DEFINE) try {\n    return $getOwnPropertyDescriptor(O, P);\n  } catch (error) { /* empty */ }\n  if (hasOwn(O, P)) return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P]);\n};\n","var fails = require('../internals/fails');\n\n// Detect IE8's incomplete defineProperty implementation\nmodule.exports = !fails(function () {\n  // eslint-disable-next-line es/no-object-defineproperty -- required for testing\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","var call = Function.prototype.call;\n\nmodule.exports = call.bind ? call.bind(call) : function () {\n  return call.apply(call, arguments);\n};\n","'use strict';\nvar $propertyIsEnumerable = {}.propertyIsEnumerable;\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// Nashorn ~ JDK8 bug\nvar NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({ 1: 2 }, 1);\n\n// `Object.prototype.propertyIsEnumerable` method implementation\n// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable\nexports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {\n  var descriptor = getOwnPropertyDescriptor(this, V);\n  return !!descriptor && descriptor.enumerable;\n} : $propertyIsEnumerable;\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 global = require('../internals/global');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar fails = require('../internals/fails');\nvar classof = require('../internals/classof-raw');\n\nvar Object = global.Object;\nvar split = uncurryThis(''.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 -- safe\n  return !Object('z').propertyIsEnumerable(0);\n}) ? function (it) {\n  return classof(it) == 'String' ? split(it, '') : Object(it);\n} : Object;\n","var FunctionPrototype = Function.prototype;\nvar bind = FunctionPrototype.bind;\nvar call = FunctionPrototype.call;\nvar callBind = bind && bind.bind(call);\n\nmodule.exports = bind ? function (fn) {\n  return fn && callBind(call, fn);\n} : function (fn) {\n  return fn && function () {\n    return call.apply(fn, arguments);\n  };\n};\n","var uncurryThis = require('../internals/function-uncurry-this');\n\nvar toString = uncurryThis({}.toString);\nvar stringSlice = uncurryThis(''.slice);\n\nmodule.exports = function (it) {\n  return stringSlice(toString(it), 8, -1);\n};\n","var global = require('../internals/global');\n\nvar TypeError = global.TypeError;\n\n// `RequireObjectCoercible` abstract operation\n// https://tc39.es/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 toPrimitive = require('../internals/to-primitive');\nvar isSymbol = require('../internals/is-symbol');\n\n// `ToPropertyKey` abstract operation\n// https://tc39.es/ecma262/#sec-topropertykey\nmodule.exports = function (argument) {\n  var key = toPrimitive(argument, 'string');\n  return isSymbol(key) ? key : key + '';\n};\n","var global = require('../internals/global');\nvar call = require('../internals/function-call');\nvar isObject = require('../internals/is-object');\nvar isSymbol = require('../internals/is-symbol');\nvar getMethod = require('../internals/get-method');\nvar ordinaryToPrimitive = require('../internals/ordinary-to-primitive');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TypeError = global.TypeError;\nvar TO_PRIMITIVE = wellKnownSymbol('toPrimitive');\n\n// `ToPrimitive` abstract operation\n// https://tc39.es/ecma262/#sec-toprimitive\nmodule.exports = function (input, pref) {\n  if (!isObject(input) || isSymbol(input)) return input;\n  var exoticToPrim = getMethod(input, TO_PRIMITIVE);\n  var result;\n  if (exoticToPrim) {\n    if (pref === undefined) pref = 'default';\n    result = call(exoticToPrim, input, pref);\n    if (!isObject(result) || isSymbol(result)) return result;\n    throw TypeError(\"Can't convert object to primitive value\");\n  }\n  if (pref === undefined) pref = 'number';\n  return ordinaryToPrimitive(input, pref);\n};\n","var isCallable = require('../internals/is-callable');\n\nmodule.exports = function (it) {\n  return typeof it == 'object' ? it !== null : isCallable(it);\n};\n","// `IsCallable` abstract operation\n// https://tc39.es/ecma262/#sec-iscallable\nmodule.exports = function (argument) {\n  return typeof argument == 'function';\n};\n","var global = require('../internals/global');\nvar getBuiltIn = require('../internals/get-built-in');\nvar isCallable = require('../internals/is-callable');\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\nvar USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid');\n\nvar Object = global.Object;\n\nmodule.exports = USE_SYMBOL_AS_UID ? function (it) {\n  return typeof it == 'symbol';\n} : function (it) {\n  var $Symbol = getBuiltIn('Symbol');\n  return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, Object(it));\n};\n","var global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\n\nvar aFunction = function (argument) {\n  return isCallable(argument) ? argument : undefined;\n};\n\nmodule.exports = function (namespace, method) {\n  return arguments.length < 2 ? aFunction(global[namespace]) : global[namespace] && global[namespace][method];\n};\n","var uncurryThis = require('../internals/function-uncurry-this');\n\nmodule.exports = uncurryThis({}.isPrototypeOf);\n","/* eslint-disable es/no-symbol -- required for testing */\nvar NATIVE_SYMBOL = require('../internals/native-symbol');\n\nmodule.exports = NATIVE_SYMBOL\n  && !Symbol.sham\n  && typeof Symbol.iterator == 'symbol';\n","/* eslint-disable es/no-symbol -- required for testing */\nvar V8_VERSION = require('../internals/engine-v8-version');\nvar fails = require('../internals/fails');\n\n// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing\nmodule.exports = !!Object.getOwnPropertySymbols && !fails(function () {\n  var symbol = Symbol();\n  // Chrome 38 Symbol has incorrect toString conversion\n  // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances\n  return !String(symbol) || !(Object(symbol) instanceof Symbol) ||\n    // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances\n    !Symbol.sham && V8_VERSION && V8_VERSION < 41;\n});\n","var global = require('../internals/global');\nvar userAgent = require('../internals/engine-user-agent');\n\nvar process = global.process;\nvar Deno = global.Deno;\nvar versions = process && process.versions || Deno && Deno.version;\nvar v8 = versions && versions.v8;\nvar match, version;\n\nif (v8) {\n  match = v8.split('.');\n  // in old Chrome, versions of V8 isn't V8 = Chrome / 10\n  // but their correct versions are not interesting for us\n  version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);\n}\n\n// BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0`\n// so check `userAgent` even if `.v8` exists, but 0\nif (!version && 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;\n","var getBuiltIn = require('../internals/get-built-in');\n\nmodule.exports = getBuiltIn('navigator', 'userAgent') || '';\n","var aCallable = require('../internals/a-callable');\n\n// `GetMethod` abstract operation\n// https://tc39.es/ecma262/#sec-getmethod\nmodule.exports = function (V, P) {\n  var func = V[P];\n  return func == null ? undefined : aCallable(func);\n};\n","var global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\nvar tryToString = require('../internals/try-to-string');\n\nvar TypeError = global.TypeError;\n\n// `Assert: IsCallable(argument) is true`\nmodule.exports = function (argument) {\n  if (isCallable(argument)) return argument;\n  throw TypeError(tryToString(argument) + ' is not a function');\n};\n","var global = require('../internals/global');\n\nvar String = global.String;\n\nmodule.exports = function (argument) {\n  try {\n    return String(argument);\n  } catch (error) {\n    return 'Object';\n  }\n};\n","var global = require('../internals/global');\nvar call = require('../internals/function-call');\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\n\nvar TypeError = global.TypeError;\n\n// `OrdinaryToPrimitive` abstract operation\n// https://tc39.es/ecma262/#sec-ordinarytoprimitive\nmodule.exports = function (input, pref) {\n  var fn, val;\n  if (pref === 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;\n  if (isCallable(fn = input.valueOf) && !isObject(val = call(fn, input))) return val;\n  if (pref !== 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;\n  throw TypeError(\"Can't convert object to primitive value\");\n};\n","var global = require('../internals/global');\nvar shared = require('../internals/shared');\nvar hasOwn = require('../internals/has-own-property');\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 symbolFor = Symbol && Symbol['for'];\nvar createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol : Symbol && Symbol.withoutSetter || uid;\n\nmodule.exports = function (name) {\n  if (!hasOwn(WellKnownSymbolsStore, name) || !(NATIVE_SYMBOL || typeof WellKnownSymbolsStore[name] == 'string')) {\n    var description = 'Symbol.' + name;\n    if (NATIVE_SYMBOL && hasOwn(Symbol, name)) {\n      WellKnownSymbolsStore[name] = Symbol[name];\n    } else if (USE_SYMBOL_AS_UID && symbolFor) {\n      WellKnownSymbolsStore[name] = symbolFor(description);\n    } else {\n      WellKnownSymbolsStore[name] = createWellKnownSymbol(description);\n    }\n  } return WellKnownSymbolsStore[name];\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.19.3',\n  mode: IS_PURE ? 'pure' : 'global',\n  copyright: '© 2021 Denis Pushkarev (zloirock.ru)'\n});\n","module.exports = false;\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 global = require('../internals/global');\n\n// eslint-disable-next-line es/no-object-defineproperty -- safe\nvar defineProperty = Object.defineProperty;\n\nmodule.exports = function (key, value) {\n  try {\n    defineProperty(global, key, { value: value, configurable: true, writable: true });\n  } catch (error) {\n    global[key] = value;\n  } return value;\n};\n","var uncurryThis = require('../internals/function-uncurry-this');\nvar toObject = require('../internals/to-object');\n\nvar hasOwnProperty = uncurryThis({}.hasOwnProperty);\n\n// `HasOwnProperty` abstract operation\n// https://tc39.es/ecma262/#sec-hasownproperty\nmodule.exports = Object.hasOwn || function hasOwn(it, key) {\n  return hasOwnProperty(toObject(it), key);\n};\n","var global = require('../internals/global');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nvar Object = global.Object;\n\n// `ToObject` abstract operation\n// https://tc39.es/ecma262/#sec-toobject\nmodule.exports = function (argument) {\n  return Object(requireObjectCoercible(argument));\n};\n","var uncurryThis = require('../internals/function-uncurry-this');\n\nvar id = 0;\nvar postfix = Math.random();\nvar toString = uncurryThis(1.0.toString);\n\nmodule.exports = function (key) {\n  return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString(++id + postfix, 36);\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  // eslint-disable-next-line es/no-object-defineproperty -- requied for testing\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 global = require('../internals/global');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar IE8_DOM_DEFINE = require('../internals/ie8-dom-define');\nvar anObject = require('../internals/an-object');\nvar toPropertyKey = require('../internals/to-property-key');\n\nvar TypeError = global.TypeError;\n// eslint-disable-next-line es/no-object-defineproperty -- safe\nvar $defineProperty = Object.defineProperty;\n\n// `Object.defineProperty` method\n// https://tc39.es/ecma262/#sec-object.defineproperty\nexports.f = DESCRIPTORS ? $defineProperty : function defineProperty(O, P, Attributes) {\n  anObject(O);\n  P = toPropertyKey(P);\n  anObject(Attributes);\n  if (IE8_DOM_DEFINE) try {\n    return $defineProperty(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 global = require('../internals/global');\nvar isObject = require('../internals/is-object');\n\nvar String = global.String;\nvar TypeError = global.TypeError;\n\n// `Assert: Type(argument) is Object`\nmodule.exports = function (argument) {\n  if (isObject(argument)) return argument;\n  throw TypeError(String(argument) + ' is not an object');\n};\n","var global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\nvar hasOwn = require('../internals/has-own-property');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar setGlobal = require('../internals/set-global');\nvar inspectSource = require('../internals/inspect-source');\nvar InternalStateModule = require('../internals/internal-state');\nvar CONFIGURABLE_FUNCTION_NAME = require('../internals/function-name').CONFIGURABLE;\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  var name = options && options.name !== undefined ? options.name : key;\n  var state;\n  if (isCallable(value)) {\n    if (String(name).slice(0, 7) === 'Symbol(') {\n      name = '[' + String(name).replace(/^Symbol\\(([^)]*)\\)/, '$1') + ']';\n    }\n    if (!hasOwn(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) {\n      createNonEnumerableProperty(value, 'name', name);\n    }\n    state = enforceInternalState(value);\n    if (!state.source) {\n      state.source = TEMPLATE.join(typeof name == 'string' ? name : '');\n    }\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 isCallable(this) && getInternalState(this).source || inspectSource(this);\n});\n","var uncurryThis = require('../internals/function-uncurry-this');\nvar isCallable = require('../internals/is-callable');\nvar store = require('../internals/shared-store');\n\nvar functionToString = uncurryThis(Function.toString);\n\n// this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper\nif (!isCallable(store.inspectSource)) {\n  store.inspectSource = function (it) {\n    return functionToString(it);\n  };\n}\n\nmodule.exports = store.inspectSource;\n","var NATIVE_WEAK_MAP = require('../internals/native-weak-map');\nvar global = require('../internals/global');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar isObject = require('../internals/is-object');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar hasOwn = require('../internals/has-own-property');\nvar shared = require('../internals/shared-store');\nvar sharedKey = require('../internals/shared-key');\nvar hiddenKeys = require('../internals/hidden-keys');\n\nvar OBJECT_ALREADY_INITIALIZED = 'Object already initialized';\nvar TypeError = global.TypeError;\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 || shared.state) {\n  var store = shared.state || (shared.state = new WeakMap());\n  var wmget = uncurryThis(store.get);\n  var wmhas = uncurryThis(store.has);\n  var wmset = uncurryThis(store.set);\n  set = function (it, metadata) {\n    if (wmhas(store, it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);\n    metadata.facade = it;\n    wmset(store, it, metadata);\n    return metadata;\n  };\n  get = function (it) {\n    return wmget(store, it) || {};\n  };\n  has = function (it) {\n    return wmhas(store, it);\n  };\n} else {\n  var STATE = sharedKey('state');\n  hiddenKeys[STATE] = true;\n  set = function (it, metadata) {\n    if (hasOwn(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);\n    metadata.facade = it;\n    createNonEnumerableProperty(it, STATE, metadata);\n    return metadata;\n  };\n  get = function (it) {\n    return hasOwn(it, STATE) ? it[STATE] : {};\n  };\n  has = function (it) {\n    return hasOwn(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 isCallable = require('../internals/is-callable');\nvar inspectSource = require('../internals/inspect-source');\n\nvar WeakMap = global.WeakMap;\n\nmodule.exports = isCallable(WeakMap) && /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","module.exports = {};\n","var DESCRIPTORS = require('../internals/descriptors');\nvar hasOwn = require('../internals/has-own-property');\n\nvar FunctionPrototype = Function.prototype;\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor;\n\nvar EXISTS = hasOwn(FunctionPrototype, 'name');\n// additional protection from minified / mangled / dropped function names\nvar PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';\nvar CONFIGURABLE = EXISTS && (!DESCRIPTORS || (DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable));\n\nmodule.exports = {\n  EXISTS: EXISTS,\n  PROPER: PROPER,\n  CONFIGURABLE: CONFIGURABLE\n};\n","var hasOwn = require('../internals/has-own-property');\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 (!hasOwn(target, key)) defineProperty(target, key, getOwnPropertyDescriptor(source, key));\n  }\n};\n","var getBuiltIn = require('../internals/get-built-in');\nvar uncurryThis = require('../internals/function-uncurry-this');\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\nvar concat = uncurryThis([].concat);\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 ? concat(keys, getOwnPropertySymbols(it)) : keys;\n};\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.es/ecma262/#sec-object.getownpropertynames\n// eslint-disable-next-line es/no-object-getownpropertynames -- safe\nexports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {\n  return internalObjectKeys(O, hiddenKeys);\n};\n","var uncurryThis = require('../internals/function-uncurry-this');\nvar hasOwn = require('../internals/has-own-property');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar indexOf = require('../internals/array-includes').indexOf;\nvar hiddenKeys = require('../internals/hidden-keys');\n\nvar push = uncurryThis([].push);\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) !hasOwn(hiddenKeys, key) && hasOwn(O, key) && push(result, key);\n  // Don't enum bug & hidden keys\n  while (names.length > i) if (hasOwn(O, key = names[i++])) {\n    ~indexOf(result, key) || push(result, key);\n  }\n  return result;\n};\n","var toIndexedObject = require('../internals/to-indexed-object');\nvar toAbsoluteIndex = require('../internals/to-absolute-index');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\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 = lengthOfArrayLike(O);\n    var index = toAbsoluteIndex(fromIndex, length);\n    var value;\n    // Array#includes uses SameValueZero equality algorithm\n    // eslint-disable-next-line no-self-compare -- NaN check\n    if (IS_INCLUDES && el != el) while (length > index) {\n      value = O[index++];\n      // eslint-disable-next-line no-self-compare -- NaN check\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.es/ecma262/#sec-array.prototype.includes\n  includes: createMethod(true),\n  // `Array.prototype.indexOf` method\n  // https://tc39.es/ecma262/#sec-array.prototype.indexof\n  indexOf: createMethod(false)\n};\n","var toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\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 = toIntegerOrInfinity(index);\n  return integer < 0 ? max(integer + length, 0) : min(integer, length);\n};\n","var ceil = Math.ceil;\nvar floor = Math.floor;\n\n// `ToIntegerOrInfinity` abstract operation\n// https://tc39.es/ecma262/#sec-tointegerorinfinity\nmodule.exports = function (argument) {\n  var number = +argument;\n  // eslint-disable-next-line no-self-compare -- safe\n  return number !== number || number === 0 ? 0 : (number > 0 ? floor : ceil)(number);\n};\n","var toLength = require('../internals/to-length');\n\n// `LengthOfArrayLike` abstract operation\n// https://tc39.es/ecma262/#sec-lengthofarraylike\nmodule.exports = function (obj) {\n  return toLength(obj.length);\n};\n","var toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\n\nvar min = Math.min;\n\n// `ToLength` abstract operation\n// https://tc39.es/ecma262/#sec-tolength\nmodule.exports = function (argument) {\n  return argument > 0 ? min(toIntegerOrInfinity(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991\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","// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe\nexports.f = Object.getOwnPropertySymbols;\n","var fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\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    : isCallable(detection) ? 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","/*!\n* DOMMatrix v0.0.24 (https://thednp.github.io/DOMMatrix/)\n* Copyright 2021 © thednp\n* Licensed under MIT (https://github.com/thednp/DOMMatrix/blob/master/LICENSE)\n*/\n(function (global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n  typeof define === 'function' && define.amd ? define(factory) :\n  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.CSSMatrix = factory());\n})(this, (function () { 'use strict';\n\n  // DOMMatrix Static methods\n  // * `fromFloat64Array` and `fromFloat32Array are not implemented;\n  // * `fromArray` is a more simple implementation, should also accept Float[32/64]Array;\n  // * `fromMatrix` load values from another CSSMatrix/DOMMatrix instance or JSON object;\n  // * `fromString` parses and loads values from any valid CSS transform string (TransformList).\n\n  /**\n   * Creates a new mutable `CSSMatrix` instance given an array of 16/6 floating point values.\n   * This static method invalidates arrays that contain non-number elements.\n   *\n   * If the array has six values, the result is a 2D matrix; if the array has 16 values,\n   * the result is a 3D matrix. Otherwise, a TypeError exception is thrown.\n   *\n   * @param {number[]} array an `Array` to feed values from.\n   * @return {CSSMatrix} the resulted matrix.\n   */\n  function fromArray(array) {\n    var m = new CSSMatrix();\n    var a = Array.from(array);\n\n    if (!a.every(function (n) { return !Number.isNaN(n); })) {\n      throw TypeError((\"CSSMatrix: \\\"\" + array + \"\\\" must only have numbers.\"));\n    }\n    if (a.length === 16) {\n      var m11 = a[0];\n      var m12 = a[1];\n      var m13 = a[2];\n      var m14 = a[3];\n      var m21 = a[4];\n      var m22 = a[5];\n      var m23 = a[6];\n      var m24 = a[7];\n      var m31 = a[8];\n      var m32 = a[9];\n      var m33 = a[10];\n      var m34 = a[11];\n      var m41 = a[12];\n      var m42 = a[13];\n      var m43 = a[14];\n      var m44 = a[15];\n\n      m.m11 = m11;\n      m.a = m11;\n\n      m.m21 = m21;\n      m.c = m21;\n\n      m.m31 = m31;\n\n      m.m41 = m41;\n      m.e = m41;\n\n      m.m12 = m12;\n      m.b = m12;\n\n      m.m22 = m22;\n      m.d = m22;\n\n      m.m32 = m32;\n\n      m.m42 = m42;\n      m.f = m42;\n\n      m.m13 = m13;\n      m.m23 = m23;\n      m.m33 = m33;\n      m.m43 = m43;\n      m.m14 = m14;\n      m.m24 = m24;\n      m.m34 = m34;\n      m.m44 = m44;\n    } else if (a.length === 6) {\n      var M11 = a[0];\n      var M12 = a[1];\n      var M21 = a[2];\n      var M22 = a[3];\n      var M41 = a[4];\n      var M42 = a[5];\n\n      m.m11 = M11;\n      m.a = M11;\n\n      m.m12 = M12;\n      m.b = M12;\n\n      m.m21 = M21;\n      m.c = M21;\n\n      m.m22 = M22;\n      m.d = M22;\n\n      m.m41 = M41;\n      m.e = M41;\n\n      m.m42 = M42;\n      m.f = M42;\n    } else {\n      throw new TypeError('CSSMatrix: expecting an Array of 6/16 values.');\n    }\n    return m;\n  }\n\n  /**\n   * Creates a new mutable `CSSMatrix` instance given an existing matrix or a\n   * `DOMMatrix` instance which provides the values for its properties.\n   *\n   * @param {CSSMatrix | DOMMatrix | CSSMatrix.JSONMatrix} m the source matrix to feed values from.\n   * @return {CSSMatrix} the resulted matrix.\n   */\n  function fromMatrix(m) {\n    var keys = Object.keys(new CSSMatrix());\n    if (typeof m === 'object' && keys.every(function (k) { return k in m; })) {\n      return fromArray(\n        [m.m11, m.m12, m.m13, m.m14,\n          m.m21, m.m22, m.m23, m.m24,\n          m.m31, m.m32, m.m33, m.m34,\n          m.m41, m.m42, m.m43, m.m44]\n      );\n    }\n    throw TypeError((\"CSSMatrix: \\\"\" + m + \"\\\" is not a DOMMatrix / CSSMatrix / JSON compatible object.\"));\n  }\n\n  /**\n   * Creates a new mutable `CSSMatrix` given any valid CSS transform string,\n   * or what we call `TransformList`:\n   *\n   * * `matrix(a, b, c, d, e, f)` - valid matrix() transform function\n   * * `matrix3d(m11, m12, m13, ...m44)` - valid matrix3d() transform function\n   * * `translate(tx, ty) rotateX(alpha)` - any valid transform function(s)\n   *\n   * @copyright thednp © 2021\n   *\n   * @param {string} source valid CSS transform string syntax.\n   * @return {CSSMatrix} the resulted matrix.\n   */\n  function fromString(source) {\n    if (typeof source !== 'string') {\n      throw TypeError((\"CSSMatrix: \\\"\" + source + \"\\\" is not a string.\"));\n    }\n    var str = String(source).replace(/\\s/g, '');\n    var m = new CSSMatrix();\n    var invalidStringError = \"CSSMatrix: invalid transform string \\\"\" + source + \"\\\"\";\n\n    // const px = ['perspective'];\n    // const length = ['translate', 'translate3d', 'translateX', 'translateY', 'translateZ'];\n    // const deg = ['rotate', 'rotate3d', 'rotateX', 'rotateY', 'rotateZ', 'skew', 'skewX', 'skewY'];\n    // const abs = ['scale', 'scale3d', 'matrix', 'matrix3d'];\n    // const transformFunctions = px.concat(length, deg, abs);\n\n    str.split(')').filter(function (f) { return f; }).forEach(function (tf) {\n      var ref = tf.split('(');\n      var prop = ref[0];\n      var value = ref[1];\n\n      // invalidate empty string\n      if (!value) { throw TypeError(invalidStringError); }\n\n      var components = value.split(',')\n        .map(function (n) { return (n.includes('rad') ? parseFloat(n) * (180 / Math.PI) : parseFloat(n)); });\n\n      var x = components[0];\n      var y = components[1];\n      var z = components[2];\n      var a = components[3];\n      var xyz = [x, y, z];\n      var xyza = [x, y, z, a];\n\n      // single number value expected\n      if (prop === 'perspective' && x && [y, z].every(function (n) { return n === undefined; })) {\n        m.m34 = -1 / x;\n      // 6/16 number values expected\n      } else if (prop.includes('matrix') && [6, 16].includes(components.length)\n        && components.every(function (n) { return !Number.isNaN(+n); })) {\n        var values = components.map(function (n) { return (Math.abs(n) < 1e-6 ? 0 : n); });\n        m = m.multiply(fromArray(values));\n      // 3 values expected\n      } else if (prop === 'translate3d' && xyz.every(function (n) { return !Number.isNaN(+n); })) {\n        m = m.translate(x, y, z);\n      // single/double number value(s) expected\n      } else if (prop === 'translate' && x && z === undefined) {\n        m = m.translate(x, y || 0, 0);\n      // all 4 values expected\n      } else if (prop === 'rotate3d' && xyza.every(function (n) { return !Number.isNaN(+n); }) && a) {\n        m = m.rotateAxisAngle(x, y, z, a);\n      // single value expected\n      } else if (prop === 'rotate' && x && [y, z].every(function (n) { return n === undefined; })) {\n        m = m.rotate(0, 0, x);\n      // 4 values expected\n      } else if (prop === 'scale3d' && xyz.every(function (n) { return !Number.isNaN(+n); }) && xyz.some(function (n) { return n !== 1; })) {\n        m = m.scale(x, y, z);\n      // single value expected\n      } else if (prop === 'scale' && !Number.isNaN(x) && x !== 1 && z === undefined) {\n        var nosy = Number.isNaN(+y);\n        var sy = nosy ? x : y;\n        m = m.scale(x, sy, 1);\n      // single/double value expected\n      } else if (prop === 'skew' && x && z === undefined) {\n        m = m.skewX(x);\n        m = y ? m.skewY(y) : m;\n      } else if (/[XYZ]/.test(prop) && x && [y, z].every(function (n) { return n === undefined; }) // a single value expected\n        && ['translate', 'rotate', 'scale', 'skew'].some(function (p) { return prop.includes(p); })) {\n        if (['skewX', 'skewY'].includes(prop)) {\n          // @ts-ignore unfortunately\n          m = m[prop](x);\n        } else {\n          var fn = prop.replace(/[XYZ]/, '');\n          var axis = prop.replace(fn, '');\n          var idx = ['X', 'Y', 'Z'].indexOf(axis);\n          var axeValues = [\n            idx === 0 ? x : 0,\n            idx === 1 ? x : 0,\n            idx === 2 ? x : 0];\n          // @ts-ignore unfortunately\n          m = m[fn].apply(m, axeValues);\n        }\n      } else {\n        throw TypeError(invalidStringError);\n      }\n    });\n\n    return m;\n  }\n\n  // Transform Functions\n  // https://www.w3.org/TR/css-transforms-1/#transform-functions\n\n  /**\n   * Creates a new `CSSMatrix` for the translation matrix and returns it.\n   * This method is equivalent to the CSS `translate3d()` function.\n   *\n   * https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/translate3d\n   *\n   * @param {number} x the `x-axis` position.\n   * @param {number} y the `y-axis` position.\n   * @param {number} z the `z-axis` position.\n   * @return {CSSMatrix} the resulted matrix.\n   */\n  function Translate(x, y, z) {\n    var m = new CSSMatrix();\n    m.m41 = x;\n    m.e = x;\n    m.m42 = y;\n    m.f = y;\n    m.m43 = z;\n    return m;\n  }\n\n  /**\n   * Creates a new `CSSMatrix` for the rotation matrix and returns it.\n   *\n   * http://en.wikipedia.org/wiki/Rotation_matrix\n   *\n   * @param {number} rx the `x-axis` rotation.\n   * @param {number} ry the `y-axis` rotation.\n   * @param {number} rz the `z-axis` rotation.\n   * @return {CSSMatrix} the resulted matrix.\n   */\n  function Rotate(rx, ry, rz) {\n    var m = new CSSMatrix();\n    var degToRad = Math.PI / 180;\n    var radX = rx * degToRad;\n    var radY = ry * degToRad;\n    var radZ = rz * degToRad;\n\n    // minus sin() because of right-handed system\n    var cosx = Math.cos(radX);\n    var sinx = -Math.sin(radX);\n    var cosy = Math.cos(radY);\n    var siny = -Math.sin(radY);\n    var cosz = Math.cos(radZ);\n    var sinz = -Math.sin(radZ);\n\n    var m11 = cosy * cosz;\n    var m12 = -cosy * sinz;\n\n    m.m11 = m11;\n    m.a = m11;\n\n    m.m12 = m12;\n    m.b = m12;\n\n    m.m13 = siny;\n\n    var m21 = sinx * siny * cosz + cosx * sinz;\n    m.m21 = m21;\n    m.c = m21;\n\n    var m22 = cosx * cosz - sinx * siny * sinz;\n    m.m22 = m22;\n    m.d = m22;\n\n    m.m23 = -sinx * cosy;\n\n    m.m31 = sinx * sinz - cosx * siny * cosz;\n    m.m32 = sinx * cosz + cosx * siny * sinz;\n    m.m33 = cosx * cosy;\n\n    return m;\n  }\n\n  /**\n   * Creates a new `CSSMatrix` for the rotation matrix and returns it.\n   * This method is equivalent to the CSS `rotate3d()` function.\n   *\n   * https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/rotate3d\n   *\n   * @param {number} x the `x-axis` vector length.\n   * @param {number} y the `y-axis` vector length.\n   * @param {number} z the `z-axis` vector length.\n   * @param {number} alpha the value in degrees of the rotation.\n   * @return {CSSMatrix} the resulted matrix.\n   */\n  function RotateAxisAngle(x, y, z, alpha) {\n    var m = new CSSMatrix();\n    var angle = alpha * (Math.PI / 360);\n    var sinA = Math.sin(angle);\n    var cosA = Math.cos(angle);\n    var sinA2 = sinA * sinA;\n    var length = Math.sqrt(x * x + y * y + z * z);\n    var X = x;\n    var Y = y;\n    var Z = z;\n\n    if (length === 0) {\n      // bad vector length, use something reasonable\n      X = 0;\n      Y = 0;\n      Z = 1;\n    } else {\n      X /= length;\n      Y /= length;\n      Z /= length;\n    }\n\n    var x2 = X * X;\n    var y2 = Y * Y;\n    var z2 = Z * Z;\n\n    var m11 = 1 - 2 * (y2 + z2) * sinA2;\n    m.m11 = m11;\n    m.a = m11;\n\n    var m12 = 2 * (X * Y * sinA2 + Z * sinA * cosA);\n    m.m12 = m12;\n    m.b = m12;\n\n    m.m13 = 2 * (X * Z * sinA2 - Y * sinA * cosA);\n\n    var m21 = 2 * (Y * X * sinA2 - Z * sinA * cosA);\n    m.m21 = m21;\n    m.c = m21;\n\n    var m22 = 1 - 2 * (z2 + x2) * sinA2;\n    m.m22 = m22;\n    m.d = m22;\n\n    m.m23 = 2 * (Y * Z * sinA2 + X * sinA * cosA);\n    m.m31 = 2 * (Z * X * sinA2 + Y * sinA * cosA);\n    m.m32 = 2 * (Z * Y * sinA2 - X * sinA * cosA);\n    m.m33 = 1 - 2 * (x2 + y2) * sinA2;\n\n    return m;\n  }\n\n  /**\n   * Creates a new `CSSMatrix` for the scale matrix and returns it.\n   * This method is equivalent to the CSS `scale3d()` function, except it doesn't\n   * accept {x, y, z} transform origin parameters.\n   *\n   * https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/scale3d\n   *\n   * @param {number} x the `x-axis` scale.\n   * @param {number} y the `y-axis` scale.\n   * @param {number} z the `z-axis` scale.\n   * @return {CSSMatrix} the resulted matrix.\n   */\n  function Scale(x, y, z) {\n    var m = new CSSMatrix();\n    m.m11 = x;\n    m.a = x;\n\n    m.m22 = y;\n    m.d = y;\n\n    m.m33 = z;\n    return m;\n  }\n\n  /**\n   * Creates a new `CSSMatrix` for the shear of the `x-axis` rotation matrix and\n   * returns it. This method is equivalent to the CSS `skewX()` function.\n   *\n   * https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/skewX\n   *\n   * @param {number} angle the angle in degrees.\n   * @return {CSSMatrix} the resulted matrix.\n   */\n  function SkewX(angle) {\n    var m = new CSSMatrix();\n    var radA = (angle * Math.PI) / 180;\n    var t = Math.tan(radA);\n    m.m21 = t;\n    m.c = t;\n    return m;\n  }\n\n  /**\n   * Creates a new `CSSMatrix` for the shear of the `y-axis` rotation matrix and\n   * returns it. This method is equivalent to the CSS `skewY()` function.\n   *\n   * https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/skewY\n   *\n   * @param {number} angle the angle in degrees.\n   * @return {CSSMatrix} the resulted matrix.\n   */\n  function SkewY(angle) {\n    var m = new CSSMatrix();\n    var radA = (angle * Math.PI) / 180;\n    var t = Math.tan(radA);\n    m.m12 = t;\n    m.b = t;\n    return m;\n  }\n\n  /**\n   * Creates a new `CSSMatrix` resulted from the multiplication of two matrixes\n   * and returns it. Both matrixes are not changed.\n   *\n   * @param {CSSMatrix} m1 the first matrix.\n   * @param {CSSMatrix} m2 the second matrix.\n   * @return {CSSMatrix} the resulted matrix.\n   */\n  function Multiply(m1, m2) {\n    var m11 = m2.m11 * m1.m11 + m2.m12 * m1.m21 + m2.m13 * m1.m31 + m2.m14 * m1.m41;\n    var m12 = m2.m11 * m1.m12 + m2.m12 * m1.m22 + m2.m13 * m1.m32 + m2.m14 * m1.m42;\n    var m13 = m2.m11 * m1.m13 + m2.m12 * m1.m23 + m2.m13 * m1.m33 + m2.m14 * m1.m43;\n    var m14 = m2.m11 * m1.m14 + m2.m12 * m1.m24 + m2.m13 * m1.m34 + m2.m14 * m1.m44;\n\n    var m21 = m2.m21 * m1.m11 + m2.m22 * m1.m21 + m2.m23 * m1.m31 + m2.m24 * m1.m41;\n    var m22 = m2.m21 * m1.m12 + m2.m22 * m1.m22 + m2.m23 * m1.m32 + m2.m24 * m1.m42;\n    var m23 = m2.m21 * m1.m13 + m2.m22 * m1.m23 + m2.m23 * m1.m33 + m2.m24 * m1.m43;\n    var m24 = m2.m21 * m1.m14 + m2.m22 * m1.m24 + m2.m23 * m1.m34 + m2.m24 * m1.m44;\n\n    var m31 = m2.m31 * m1.m11 + m2.m32 * m1.m21 + m2.m33 * m1.m31 + m2.m34 * m1.m41;\n    var m32 = m2.m31 * m1.m12 + m2.m32 * m1.m22 + m2.m33 * m1.m32 + m2.m34 * m1.m42;\n    var m33 = m2.m31 * m1.m13 + m2.m32 * m1.m23 + m2.m33 * m1.m33 + m2.m34 * m1.m43;\n    var m34 = m2.m31 * m1.m14 + m2.m32 * m1.m24 + m2.m33 * m1.m34 + m2.m34 * m1.m44;\n\n    var m41 = m2.m41 * m1.m11 + m2.m42 * m1.m21 + m2.m43 * m1.m31 + m2.m44 * m1.m41;\n    var m42 = m2.m41 * m1.m12 + m2.m42 * m1.m22 + m2.m43 * m1.m32 + m2.m44 * m1.m42;\n    var m43 = m2.m41 * m1.m13 + m2.m42 * m1.m23 + m2.m43 * m1.m33 + m2.m44 * m1.m43;\n    var m44 = m2.m41 * m1.m14 + m2.m42 * m1.m24 + m2.m43 * m1.m34 + m2.m44 * m1.m44;\n\n    return fromArray(\n      [m11, m12, m13, m14,\n        m21, m22, m23, m24,\n        m31, m32, m33, m34,\n        m41, m42, m43, m44]\n    );\n  }\n\n  /**\n   * Creates and returns a new `DOMMatrix` compatible instance\n   * with equivalent instance.\n   * @class CSSMatrix\n   *\n   * @author thednp <https://github.com/thednp/DOMMatrix/>\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMMatrix\n   */\n\n  var CSSMatrix = function CSSMatrix() {\n    var args = [], len = arguments.length;\n    while ( len-- ) args[ len ] = arguments[ len ];\n\n    var m = this;\n    // array 6\n    m.a = 1; m.b = 0;\n    m.c = 0; m.d = 1;\n    m.e = 0; m.f = 0;\n    // array 16\n    m.m11 = 1; m.m12 = 0; m.m13 = 0; m.m14 = 0;\n    m.m21 = 0; m.m22 = 1; m.m23 = 0; m.m24 = 0;\n    m.m31 = 0; m.m32 = 0; m.m33 = 1; m.m34 = 0;\n    m.m41 = 0; m.m42 = 0; m.m43 = 0; m.m44 = 1;\n\n    if (args && args.length) {\n      var ARGS = [16, 6].some(function (l) { return l === args.length; }) ? args : args[0];\n\n      return m.setMatrixValue(ARGS);\n    }\n    return m;\n  };\n\n  var prototypeAccessors = { isIdentity: { configurable: true },is2D: { configurable: true } };\n\n  /**\n   * Sets a new `Boolean` flag value for `this.isIdentity` matrix property.\n   *\n   * @param {boolean} value sets a new flag for this property\n   */\n  prototypeAccessors.isIdentity.set = function (value) {\n    this.isIdentity = value;\n  };\n\n  /**\n   * A `Boolean` whose value is `true` if the matrix is the identity matrix. The identity\n   * matrix is one in which every value is 0 except those on the main diagonal from top-left\n   * to bottom-right corner (in other words, where the offsets in each direction are equal).\n   *\n   * @return {boolean} the current property value\n   */\n  prototypeAccessors.isIdentity.get = function () {\n    var m = this;\n    return (m.m11 === 1 && m.m12 === 0 && m.m13 === 0 && m.m14 === 0\n            && m.m21 === 0 && m.m22 === 1 && m.m23 === 0 && m.m24 === 0\n            && m.m31 === 0 && m.m32 === 0 && m.m33 === 1 && m.m34 === 0\n            && m.m41 === 0 && m.m42 === 0 && m.m43 === 0 && m.m44 === 1);\n  };\n\n  /**\n   * A `Boolean` flag whose value is `true` if the matrix was initialized as a 2D matrix\n   * and `false` if the matrix is 3D.\n   *\n   * @return {boolean} the current property value\n   */\n  prototypeAccessors.is2D.get = function () {\n    var m = this;\n    return (m.m31 === 0 && m.m32 === 0 && m.m33 === 1 && m.m34 === 0 && m.m43 === 0 && m.m44 === 1);\n  };\n\n  /**\n   * Sets a new `Boolean` flag value for `this.is2D` matrix property.\n   *\n   * @param {boolean} value sets a new flag for this property\n   */\n  prototypeAccessors.is2D.set = function (value) {\n    this.is2D = value;\n  };\n\n  /**\n   * The `setMatrixValue` method replaces the existing matrix with one computed\n   * in the browser. EG: `matrix(1,0.25,-0.25,1,0,0)`\n   *\n   * The method accepts any *Array* values, the result of\n   * `DOMMatrix` instance method `toFloat64Array()` / `toFloat32Array()` calls\n   *or `CSSMatrix` instance method `toArray()`.\n   *\n   * This method expects valid *matrix()* / *matrix3d()* string values, as well\n   * as other transform functions like *translateX(10px)*.\n   *\n   * @param {string | number[] | CSSMatrix | DOMMatrix} source\n   * @return {CSSMatrix} the matrix instance\n   */\n  CSSMatrix.prototype.setMatrixValue = function setMatrixValue (source) {\n    var m = this;\n\n    // [Arguments list | Array] come here\n    if ([Array, Float64Array, Float32Array].some(function (a) { return source instanceof a; })) {\n      return fromArray(source);\n    }\n    // CSS transform string source - TransformList\n    if (typeof source === 'string' && source.length && source !== 'none') {\n      return fromString(source);\n    }\n    // new CSSMatrix(CSSMatrix | DOMMatrix | JSON)\n    if (typeof source === 'object') {\n      return fromMatrix(source);\n    }\n    return m;\n  };\n\n  /**\n   * Returns an *Array* containing elements which comprise the matrix.\n   * The method can return either the 16 elements or the 6 elements\n   * depending on the value of the `is2D` property.\n   *\n   * @return {number[]} an *Array* representation of the matrix\n   */\n  CSSMatrix.prototype.toArray = function toArray () {\n    var m = this;\n    var pow = (Math.pow( 10, 6 ));\n    var result;\n\n    if (m.is2D) {\n      result = [m.a, m.b, m.c, m.d, m.e, m.f];\n    } else {\n      result = [m.m11, m.m12, m.m13, m.m14,\n        m.m21, m.m22, m.m23, m.m24,\n        m.m31, m.m32, m.m33, m.m34,\n        m.m41, m.m42, m.m43, m.m44];\n    }\n    // clean up the numbers\n    // eslint-disable-next-line -- no-bitwise\n    return result.map(function (n) { return (Math.abs(n) < 1e-6 ? 0 : ((n * pow) >> 0) / pow); });\n  };\n\n  /**\n   * Creates and returns a string representation of the matrix in `CSS` matrix syntax,\n   * using the appropriate `CSS` matrix notation.\n   *\n   * matrix3d *matrix3d(m11, m12, m13, m14, m21, ...)*\n   * matrix *matrix(a, b, c, d, e, f)*\n   *\n   * @return {string} a string representation of the matrix\n   */\n  CSSMatrix.prototype.toString = function toString () {\n    var m = this;\n    var values = m.toArray();\n    var type = m.is2D ? 'matrix' : 'matrix3d';\n    return (type + \"(\" + values + \")\");\n  };\n\n  /**\n   * Returns a JSON representation of the `CSSMatrix` instance, a standard *Object*\n   * that includes `{a,b,c,d,e,f}` and `{m11,m12,m13,..m44}` properties as well\n   * as the `is2D` & `isIdentity` properties.\n   *\n   * The result can also be used as a second parameter for the `fromMatrix` static method\n   * to load values into another matrix instance.\n   *\n   * @return {CSSMatrix.JSONMatrix} an *Object* with all matrix values.\n   */\n  CSSMatrix.prototype.toJSON = function toJSON () {\n    var m = this;\n    var is2D = m.is2D;\n      var isIdentity = m.isIdentity;\n    return Object.assign({}, m, {is2D: is2D, isIdentity: isIdentity});\n  };\n\n  /**\n   * The Multiply method returns a new CSSMatrix which is the result of this\n   * matrix multiplied by the passed matrix, with the passed matrix to the right.\n   * This matrix is not modified.\n   *\n   * @param {CSSMatrix | DOMMatrix | CSSMatrix.JSONMatrix} m2 CSSMatrix\n   * @return {CSSMatrix} The resulted matrix.\n   */\n  CSSMatrix.prototype.multiply = function multiply (m2) {\n    return Multiply(this, m2);\n  };\n\n  /**\n   * The translate method returns a new matrix which is this matrix post\n   * multiplied by a translation matrix containing the passed values. If the z\n   * component is undefined, a 0 value is used in its place. This matrix is not\n   * modified.\n   *\n   * @param {number} x X component of the translation value.\n   * @param {number=} y Y component of the translation value.\n   * @param {number=} z Z component of the translation value.\n   * @return {CSSMatrix} The resulted matrix\n   */\n  CSSMatrix.prototype.translate = function translate (x, y, z) {\n    var X = x;\n    var Y = y;\n    var Z = z;\n    if (Z === undefined) { Z = 0; }\n    if (Y === undefined) { Y = 0; }\n    return Multiply(this, Translate(X, Y, Z));\n  };\n\n  /**\n   * The scale method returns a new matrix which is this matrix post multiplied by\n   * a scale matrix containing the passed values. If the z component is undefined,\n   * a 1 value is used in its place. If the y component is undefined, the x\n   * component value is used in its place. This matrix is not modified.\n   *\n   * @param {number} x The X component of the scale value.\n   * @param {number=} y The Y component of the scale value.\n   * @param {number=} z The Z component of the scale value.\n   * @return {CSSMatrix} The resulted matrix\n   */\n  CSSMatrix.prototype.scale = function scale (x, y, z) {\n    var X = x;\n    var Y = y;\n    var Z = z;\n    if (Y === undefined) { Y = x; }\n    if (Z === undefined) { Z = 1; } // Z must be 1 if undefined\n\n    return Multiply(this, Scale(X, Y, Z));\n  };\n\n  /**\n   * The rotate method returns a new matrix which is this matrix post multiplied\n   * by each of 3 rotation matrices about the major axes, first X, then Y, then Z.\n   * If the y and z components are undefined, the x value is used to rotate the\n   * object about the z axis, as though the vector (0,0,x) were passed. All\n   * rotation values are in degrees. This matrix is not modified.\n   *\n   * @param {number} rx The X component of the rotation, or Z if Y and Z are null.\n   * @param {number=} ry The (optional) Y component of the rotation value.\n   * @param {number=} rz The (optional) Z component of the rotation value.\n   * @return {CSSMatrix} The resulted matrix\n   */\n  CSSMatrix.prototype.rotate = function rotate (rx, ry, rz) {\n    var RX = rx;\n    var RY = ry;\n    var RZ = rz;\n    if (RY === undefined) { RY = 0; }\n    if (RZ === undefined) { RZ = RX; RX = 0; }\n    return Multiply(this, Rotate(RX, RY, RZ));\n  };\n\n  /**\n   * The rotateAxisAngle method returns a new matrix which is this matrix post\n   * multiplied by a rotation matrix with the given axis and `angle`. The right-hand\n   * rule is used to determine the direction of rotation. All rotation values are\n   * in degrees. This matrix is not modified.\n   *\n   * @param {number} x The X component of the axis vector.\n   * @param {number} y The Y component of the axis vector.\n   * @param {number} z The Z component of the axis vector.\n   * @param {number} angle The angle of rotation about the axis vector, in degrees.\n   * @return {CSSMatrix} The resulted matrix\n   */\n  CSSMatrix.prototype.rotateAxisAngle = function rotateAxisAngle (x, y, z, angle) {\n    if ([x, y, z, angle].some(function (n) { return Number.isNaN(n); })) {\n      throw new TypeError('CSSMatrix: expecting 4 values');\n    }\n    return Multiply(this, RotateAxisAngle(x, y, z, angle));\n  };\n\n  /**\n   * Specifies a skew transformation along the `x-axis` by the given angle.\n   * This matrix is not modified.\n   *\n   * @param {number} angle The angle amount in degrees to skew.\n   * @return {CSSMatrix} The resulted matrix\n   */\n  CSSMatrix.prototype.skewX = function skewX (angle) {\n    return Multiply(this, SkewX(angle));\n  };\n\n  /**\n   * Specifies a skew transformation along the `y-axis` by the given angle.\n   * This matrix is not modified.\n   *\n   * @param {number} angle The angle amount in degrees to skew.\n   * @return {CSSMatrix} The resulted matrix\n   */\n  CSSMatrix.prototype.skewY = function skewY (angle) {\n    return Multiply(this, SkewY(angle));\n  };\n\n  /**\n   * Transforms a specified point using the matrix, returning a new\n   * Tuple *Object* comprising of the transformed point.\n   * Neither the matrix nor the original point are altered.\n   *\n   * The method is equivalent with `transformPoint()` method\n   * of the `DOMMatrix` constructor.\n   *\n   * @copyright thednp © 2021\n   *\n   * @param {CSSMatrix.PointTuple | DOMPoint} v Tuple or DOMPoint\n   * @return {CSSMatrix.PointTuple} the resulting Tuple\n   */\n  CSSMatrix.prototype.transformPoint = function transformPoint (v) {\n    var M = this;\n    var m = Translate(v.x, v.y, v.z);\n\n    m.m44 = v.w || 1;\n    m = M.multiply(m);\n\n    return {\n      x: m.m41,\n      y: m.m42,\n      z: m.m43,\n      w: m.m44,\n    };\n  };\n\n  /**\n   * Transforms a specified vector using the matrix, returning a new\n   * {x,y,z,w} Tuple *Object* comprising the transformed vector.\n   * Neither the matrix nor the original vector are altered.\n   *\n   * @param {CSSMatrix.PointTuple} t Tuple with `{x,y,z,w}` components\n   * @return {CSSMatrix.PointTuple} the resulting Tuple\n   */\n  CSSMatrix.prototype.transform = function transform (t) {\n    var m = this;\n    var x = m.m11 * t.x + m.m12 * t.y + m.m13 * t.z + m.m14 * t.w;\n    var y = m.m21 * t.x + m.m22 * t.y + m.m23 * t.z + m.m24 * t.w;\n    var z = m.m31 * t.x + m.m32 * t.y + m.m33 * t.z + m.m34 * t.w;\n    var w = m.m41 * t.x + m.m42 * t.y + m.m43 * t.z + m.m44 * t.w;\n\n    return {\n      x: x / w,\n      y: y / w,\n      z: z / w,\n      w: w,\n    };\n  };\n\n  Object.defineProperties( CSSMatrix.prototype, prototypeAccessors );\n\n  // Add Transform Functions to CSSMatrix object\n  // without creating a TypeScript namespace.\n  Object.assign(CSSMatrix, {\n    Translate: Translate,\n    Rotate: Rotate,\n    RotateAxisAngle: RotateAxisAngle,\n    Scale: Scale,\n    SkewX: SkewX,\n    SkewY: SkewY,\n    Multiply: Multiply,\n    fromArray: fromArray,\n    fromMatrix: fromMatrix,\n    fromString: fromString,\n  });\n\n  var version = \"0.0.24\";\n\n  // @ts-ignore\n\n  /**\n   * A global namespace for library version.\n   * @type {string}\n   */\n  var Version = version;\n\n  Object.assign(CSSMatrix, { Version: Version });\n\n  return CSSMatrix;\n\n}));\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.es/ecma262/#sec-array.prototype.entries\n// `Array.prototype.keys` method\n// https://tc39.es/ecma262/#sec-array.prototype.keys\n// `Array.prototype.values` method\n// https://tc39.es/ecma262/#sec-array.prototype.values\n// `Array.prototype[@@iterator]` method\n// https://tc39.es/ecma262/#sec-array.prototype-@@iterator\n// `CreateArrayIterator` internal method\n// https://tc39.es/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.es/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.es/ecma262/#sec-createunmappedargumentsobject\n// https://tc39.es/ecma262/#sec-createmappedargumentsobject\nIterators.Arguments = Iterators.Array;\n\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\naddToUnscopables('keys');\naddToUnscopables('values');\naddToUnscopables('entries');\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.es/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","/* global ActiveXObject -- old IE, WSH */\nvar 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    activeXDocument = new ActiveXObject('htmlfile');\n  } catch (error) { /* ignore */ }\n  NullProtoObject = typeof document != 'undefined'\n    ? document.domain && activeXDocument\n      ? NullProtoObjectViaActiveX(activeXDocument) // old IE\n      : NullProtoObjectViaIFrame()\n    : NullProtoObjectViaActiveX(activeXDocument); // WSH\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.es/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 toIndexedObject = require('../internals/to-indexed-object');\nvar objectKeys = require('../internals/object-keys');\n\n// `Object.defineProperties` method\n// https://tc39.es/ecma262/#sec-object.defineproperties\n// eslint-disable-next-line es/no-object-defineproperties -- safe\nmodule.exports = DESCRIPTORS ? Object.defineProperties : function defineProperties(O, Properties) {\n  anObject(O);\n  var props = toIndexedObject(Properties);\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++], props[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.es/ecma262/#sec-object.keys\n// eslint-disable-next-line es/no-object-keys -- safe\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","module.exports = {};\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar IS_PURE = require('../internals/is-pure');\nvar FunctionName = require('../internals/function-name');\nvar isCallable = require('../internals/is-callable');\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 Iterators = require('../internals/iterators');\nvar IteratorsCore = require('../internals/iterators-core');\n\nvar PROPER_FUNCTION_NAME = FunctionName.PROPER;\nvar CONFIGURABLE_FUNCTION_NAME = FunctionName.CONFIGURABLE;\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 (CurrentIteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) {\n      if (!IS_PURE && getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) {\n        if (setPrototypeOf) {\n          setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype);\n        } else if (!isCallable(CurrentIteratorPrototype[ITERATOR])) {\n          redefine(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.prototype.{ values, @@iterator }.name in V8 / FF\n  if (PROPER_FUNCTION_NAME && DEFAULT == VALUES && nativeIterator && nativeIterator.name !== VALUES) {\n    if (!IS_PURE && CONFIGURABLE_FUNCTION_NAME) {\n      createNonEnumerableProperty(IterablePrototype, 'name', VALUES);\n    } else {\n      INCORRECT_VALUES_NAME = true;\n      defaultIterator = function values() { return call(nativeIterator, this); };\n    }\n  }\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  // define iterator\n  if ((!IS_PURE || FORCED) && IterablePrototype[ITERATOR] !== defaultIterator) {\n    redefine(IterablePrototype, ITERATOR, defaultIterator, { name: DEFAULT });\n  }\n  Iterators[NAME] = defaultIterator;\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, ENUMERABLE_NEXT) {\n  var TO_STRING_TAG = NAME + ' Iterator';\n  IteratorConstructor.prototype = create(IteratorPrototype, { next: createPropertyDescriptor(+!ENUMERABLE_NEXT, next) });\n  setToStringTag(IteratorConstructor, TO_STRING_TAG, false, true);\n  Iterators[TO_STRING_TAG] = returnThis;\n  return IteratorConstructor;\n};\n","'use strict';\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\nvar create = require('../internals/object-create');\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar redefine = require('../internals/redefine');\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\n// `%IteratorPrototype%` object\n// https://tc39.es/ecma262/#sec-%iteratorprototype%-object\nvar IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator;\n\n/* eslint-disable es/no-array-prototype-keys -- safe */\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\nvar NEW_ITERATOR_PROTOTYPE = IteratorPrototype == undefined || fails(function () {\n  var test = {};\n  // FF44- legacy iterators case\n  return IteratorPrototype[ITERATOR].call(test) !== test;\n});\n\nif (NEW_ITERATOR_PROTOTYPE) IteratorPrototype = {};\nelse if (IS_PURE) IteratorPrototype = create(IteratorPrototype);\n\n// `%IteratorPrototype%[@@iterator]()` method\n// https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator\nif (!isCallable(IteratorPrototype[ITERATOR])) {\n  redefine(IteratorPrototype, ITERATOR, function () {\n    return this;\n  });\n}\n\nmodule.exports = {\n  IteratorPrototype: IteratorPrototype,\n  BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS\n};\n","var global = require('../internals/global');\nvar hasOwn = require('../internals/has-own-property');\nvar isCallable = require('../internals/is-callable');\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 Object = global.Object;\nvar ObjectPrototype = Object.prototype;\n\n// `Object.getPrototypeOf` method\n// https://tc39.es/ecma262/#sec-object.getprototypeof\nmodule.exports = CORRECT_PROTOTYPE_GETTER ? Object.getPrototypeOf : function (O) {\n  var object = toObject(O);\n  if (hasOwn(object, IE_PROTO)) return object[IE_PROTO];\n  var constructor = object.constructor;\n  if (isCallable(constructor) && object instanceof constructor) {\n    return constructor.prototype;\n  } return object instanceof Object ? ObjectPrototype : null;\n};\n","var fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n  function F() { /* empty */ }\n  F.prototype.constructor = null;\n  // eslint-disable-next-line es/no-object-getprototypeof -- required for testing\n  return Object.getPrototypeOf(new F()) !== F.prototype;\n});\n","var defineProperty = require('../internals/object-define-property').f;\nvar hasOwn = require('../internals/has-own-property');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\n\nmodule.exports = function (it, TAG, STATIC) {\n  if (it && !hasOwn(it = STATIC ? it : it.prototype, TO_STRING_TAG)) {\n    defineProperty(it, TO_STRING_TAG, { configurable: true, value: TAG });\n  }\n};\n","/* eslint-disable no-proto -- safe */\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar anObject = require('../internals/an-object');\nvar aPossiblePrototype = require('../internals/a-possible-prototype');\n\n// `Object.setPrototypeOf` method\n// https://tc39.es/ecma262/#sec-object.setprototypeof\n// Works with __proto__ only. Old v8 can't work with null proto objects.\n// eslint-disable-next-line es/no-object-setprototypeof -- safe\nmodule.exports = Object.setPrototypeOf || ('__proto__' in {} ? function () {\n  var CORRECT_SETTER = false;\n  var test = {};\n  var setter;\n  try {\n    // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\n    setter = uncurryThis(Object.getOwnPropertyDescriptor(Object.prototype, '__proto__').set);\n    setter(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(O, proto);\n    else O.__proto__ = proto;\n    return O;\n  };\n}() : undefined);\n","var global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\n\nvar String = global.String;\nvar TypeError = global.TypeError;\n\nmodule.exports = function (argument) {\n  if (typeof argument == 'object' || isCallable(argument)) return argument;\n  throw TypeError(\"Can't set \" + String(argument) + ' as a prototype');\n};\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    }, { AS_ENTRIES: true });\n    return obj;\n  }\n});\n","var global = require('../internals/global');\nvar bind = require('../internals/function-bind-context');\nvar call = require('../internals/function-call');\nvar anObject = require('../internals/an-object');\nvar tryToString = require('../internals/try-to-string');\nvar isArrayIteratorMethod = require('../internals/is-array-iterator-method');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\nvar getIterator = require('../internals/get-iterator');\nvar getIteratorMethod = require('../internals/get-iterator-method');\nvar iteratorClose = require('../internals/iterator-close');\n\nvar TypeError = global.TypeError;\n\nvar Result = function (stopped, result) {\n  this.stopped = stopped;\n  this.result = result;\n};\n\nvar ResultPrototype = Result.prototype;\n\nmodule.exports = function (iterable, unboundFunction, options) {\n  var that = options && options.that;\n  var AS_ENTRIES = !!(options && options.AS_ENTRIES);\n  var IS_ITERATOR = !!(options && options.IS_ITERATOR);\n  var INTERRUPTED = !!(options && options.INTERRUPTED);\n  var fn = bind(unboundFunction, that);\n  var iterator, iterFn, index, length, result, next, step;\n\n  var stop = function (condition) {\n    if (iterator) iteratorClose(iterator, 'normal', condition);\n    return new Result(true, condition);\n  };\n\n  var callFn = function (value) {\n    if (AS_ENTRIES) {\n      anObject(value);\n      return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);\n    } return INTERRUPTED ? fn(value, stop) : fn(value);\n  };\n\n  if (IS_ITERATOR) {\n    iterator = iterable;\n  } else {\n    iterFn = getIteratorMethod(iterable);\n    if (!iterFn) throw TypeError(tryToString(iterable) + ' is not iterable');\n    // optimisation for array iterators\n    if (isArrayIteratorMethod(iterFn)) {\n      for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) {\n        result = callFn(iterable[index]);\n        if (result && isPrototypeOf(ResultPrototype, result)) return result;\n      } return new Result(false);\n    }\n    iterator = getIterator(iterable, iterFn);\n  }\n\n  next = iterator.next;\n  while (!(step = call(next, iterator)).done) {\n    try {\n      result = callFn(step.value);\n    } catch (error) {\n      iteratorClose(iterator, 'throw', error);\n    }\n    if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result;\n  } return new Result(false);\n};\n","var uncurryThis = require('../internals/function-uncurry-this');\nvar aCallable = require('../internals/a-callable');\n\nvar bind = uncurryThis(uncurryThis.bind);\n\n// optional / simple context binding\nmodule.exports = function (fn, that) {\n  aCallable(fn);\n  return that === undefined ? fn : bind ? bind(fn, that) : function (/* ...args */) {\n    return fn.apply(that, arguments);\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","var global = require('../internals/global');\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar anObject = require('../internals/an-object');\nvar tryToString = require('../internals/try-to-string');\nvar getIteratorMethod = require('../internals/get-iterator-method');\n\nvar TypeError = global.TypeError;\n\nmodule.exports = function (argument, usingIterator) {\n  var iteratorMethod = arguments.length < 2 ? getIteratorMethod(argument) : usingIterator;\n  if (aCallable(iteratorMethod)) return anObject(call(iteratorMethod, argument));\n  throw TypeError(tryToString(argument) + ' is not iterable');\n};\n","var classof = require('../internals/classof');\nvar getMethod = require('../internals/get-method');\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 getMethod(it, ITERATOR)\n    || getMethod(it, '@@iterator')\n    || Iterators[classof(it)];\n};\n","var global = require('../internals/global');\nvar TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar isCallable = require('../internals/is-callable');\nvar classofRaw = require('../internals/classof-raw');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\nvar Object = global.Object;\n\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' && isCallable(O.callee) ? '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 call = require('../internals/function-call');\nvar anObject = require('../internals/an-object');\nvar getMethod = require('../internals/get-method');\n\nmodule.exports = function (iterator, kind, value) {\n  var innerResult, innerError;\n  anObject(iterator);\n  try {\n    innerResult = getMethod(iterator, 'return');\n    if (!innerResult) {\n      if (kind === 'throw') throw value;\n      return value;\n    }\n    innerResult = call(innerResult, iterator);\n  } catch (error) {\n    innerError = true;\n    innerResult = error;\n  }\n  if (kind === 'throw') throw value;\n  if (innerError) throw innerResult;\n  anObject(innerResult);\n  return value;\n};\n","'use strict';\nvar toPropertyKey = require('../internals/to-property-key');\nvar definePropertyModule = require('../internals/object-define-property');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\nmodule.exports = function (object, key, value) {\n  var propertyKey = toPropertyKey(key);\n  if (propertyKey in object) definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value));\n  else object[propertyKey] = value;\n};\n","var global = require('../internals/global');\n\nmodule.exports = global;\n","require('../../modules/es.aggregate-error');\nrequire('../../modules/es.array.iterator');\nrequire('../../modules/es.object.to-string');\nrequire('../../modules/es.promise');\nrequire('../../modules/es.promise.all-settled');\nrequire('../../modules/es.promise.any');\nrequire('../../modules/es.promise.finally');\nrequire('../../modules/es.string.iterator');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Promise;\n","'use strict';\nvar $ = require('../internals/export');\nvar global = require('../internals/global');\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\nvar copyConstructorProperties = require('../internals/copy-constructor-properties');\nvar create = require('../internals/object-create');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar clearErrorStack = require('../internals/clear-error-stack');\nvar installErrorCause = require('../internals/install-error-cause');\nvar iterate = require('../internals/iterate');\nvar normalizeStringArgument = require('../internals/normalize-string-argument');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar ERROR_STACK_INSTALLABLE = require('../internals/error-stack-installable');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\nvar Error = global.Error;\nvar push = [].push;\n\nvar $AggregateError = function AggregateError(errors, message /* , options */) {\n  var options = arguments.length > 2 ? arguments[2] : undefined;\n  var isInstance = isPrototypeOf(AggregateErrorPrototype, this);\n  var that;\n  if (setPrototypeOf) {\n    that = setPrototypeOf(new Error(undefined), isInstance ? getPrototypeOf(this) : AggregateErrorPrototype);\n  } else {\n    that = isInstance ? this : create(AggregateErrorPrototype);\n    createNonEnumerableProperty(that, TO_STRING_TAG, 'Error');\n  }\n  createNonEnumerableProperty(that, 'message', normalizeStringArgument(message, ''));\n  if (ERROR_STACK_INSTALLABLE) createNonEnumerableProperty(that, 'stack', clearErrorStack(that.stack, 1));\n  installErrorCause(that, options);\n  var errorsArray = [];\n  iterate(errors, push, { that: errorsArray });\n  createNonEnumerableProperty(that, 'errors', errorsArray);\n  return that;\n};\n\nif (setPrototypeOf) setPrototypeOf($AggregateError, Error);\nelse copyConstructorProperties($AggregateError, Error);\n\nvar AggregateErrorPrototype = $AggregateError.prototype = create(Error.prototype, {\n  constructor: createPropertyDescriptor(1, $AggregateError),\n  message: createPropertyDescriptor(1, ''),\n  name: createPropertyDescriptor(1, 'AggregateError')\n});\n\n// `AggregateError` constructor\n// https://tc39.es/ecma262/#sec-aggregate-error-constructor\n$({ global: true }, {\n  AggregateError: $AggregateError\n});\n","var uncurryThis = require('../internals/function-uncurry-this');\nvar arraySlice = require('../internals/array-slice-simple');\n\nvar replace = uncurryThis(''.replace);\nvar split = uncurryThis(''.split);\nvar join = uncurryThis([].join);\n\nvar TEST = (function (arg) { return String(Error(arg).stack); })('zxcasd');\nvar V8_OR_CHAKRA_STACK_ENTRY = /\\n\\s*at [^:]*:[^\\n]*/;\nvar IS_V8_OR_CHAKRA_STACK = V8_OR_CHAKRA_STACK_ENTRY.test(TEST);\nvar IS_FIREFOX_OR_SAFARI_STACK = /@[^\\n]*\\n/.test(TEST) && !/zxcasd/.test(TEST);\n\nmodule.exports = function (stack, dropEntries) {\n  if (typeof stack != 'string') return stack;\n  if (IS_V8_OR_CHAKRA_STACK) {\n    while (dropEntries--) stack = replace(stack, V8_OR_CHAKRA_STACK_ENTRY, '');\n  } else if (IS_FIREFOX_OR_SAFARI_STACK) {\n    return join(arraySlice(split(stack, '\\n'), dropEntries), '\\n');\n  } return stack;\n};\n","var global = require('../internals/global');\nvar toAbsoluteIndex = require('../internals/to-absolute-index');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar createProperty = require('../internals/create-property');\n\nvar Array = global.Array;\nvar max = Math.max;\n\nmodule.exports = function (O, start, end) {\n  var length = lengthOfArrayLike(O);\n  var k = toAbsoluteIndex(start, length);\n  var fin = toAbsoluteIndex(end === undefined ? length : end, length);\n  var result = Array(max(fin - k, 0));\n  for (var n = 0; k < fin; k++, n++) createProperty(result, n, O[k]);\n  result.length = n;\n  return result;\n};\n","var isObject = require('../internals/is-object');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\n\n// `InstallErrorCause` abstract operation\n// https://tc39.es/proposal-error-cause/#sec-errorobjects-install-error-cause\nmodule.exports = function (O, options) {\n  if (isObject(options) && 'cause' in options) {\n    createNonEnumerableProperty(O, 'cause', options.cause);\n  }\n};\n","var toString = require('../internals/to-string');\n\nmodule.exports = function (argument, $default) {\n  return argument === undefined ? arguments.length < 2 ? '' : $default : toString(argument);\n};\n","var global = require('../internals/global');\nvar classof = require('../internals/classof');\n\nvar String = global.String;\n\nmodule.exports = function (argument) {\n  if (classof(argument) === 'Symbol') throw TypeError('Cannot convert a Symbol value to a string');\n  return String(argument);\n};\n","var fails = require('../internals/fails');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\nmodule.exports = !fails(function () {\n  var error = Error('a');\n  if (!('stack' in error)) return true;\n  // eslint-disable-next-line es/no-object-defineproperty -- safe\n  Object.defineProperty(error, 'stack', createPropertyDescriptor(1, 7));\n  return error.stack !== 7;\n});\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.es/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.es/ecma262/#sec-object.prototype.tostring\nmodule.exports = TO_STRING_TAG_SUPPORT ? {}.toString : function toString() {\n  return '[object ' + classof(this) + ']';\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 call = require('../internals/function-call');\nvar NativePromise = require('../internals/native-promise-constructor');\nvar redefine = require('../internals/redefine');\nvar redefineAll = require('../internals/redefine-all');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar setSpecies = require('../internals/set-species');\nvar aCallable = require('../internals/a-callable');\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\nvar anInstance = require('../internals/an-instance');\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 IS_BROWSER = require('../internals/engine-is-browser');\nvar IS_NODE = require('../internals/engine-is-node');\nvar V8_VERSION = require('../internals/engine-v8-version');\n\nvar SPECIES = wellKnownSymbol('species');\nvar PROMISE = 'Promise';\n\nvar getInternalState = InternalStateModule.getterFor(PROMISE);\nvar setInternalState = InternalStateModule.set;\nvar getInternalPromiseState = InternalStateModule.getterFor(PROMISE);\nvar NativePromisePrototype = NativePromise && NativePromise.prototype;\nvar PromiseConstructor = NativePromise;\nvar PromisePrototype = NativePromisePrototype;\nvar TypeError = global.TypeError;\nvar document = global.document;\nvar process = global.process;\nvar newPromiseCapability = newPromiseCapabilityModule.f;\nvar newGenericPromiseCapability = newPromiseCapability;\n\nvar DISPATCH_EVENT = !!(document && document.createEvent && global.dispatchEvent);\nvar NATIVE_REJECTION_EVENT = isCallable(global.PromiseRejectionEvent);\nvar UNHANDLED_REJECTION = 'unhandledrejection';\nvar REJECTION_HANDLED = 'rejectionhandled';\nvar PENDING = 0;\nvar FULFILLED = 1;\nvar REJECTED = 2;\nvar HANDLED = 1;\nvar UNHANDLED = 2;\nvar SUBCLASSING = false;\n\nvar Internal, OwnPromiseCapability, PromiseWrapper, nativeThen;\n\nvar FORCED = isForced(PROMISE, function () {\n  var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(PromiseConstructor);\n  var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(PromiseConstructor);\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 (!GLOBAL_CORE_JS_PROMISE && V8_VERSION === 66) return true;\n  // We need Promise#finally in the pure version for preventing prototype pollution\n  if (IS_PURE && !PromisePrototype['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(PROMISE_CONSTRUCTOR_SOURCE)) return false;\n  // Detect correctness of subclassing with @@species support\n  var promise = new PromiseConstructor(function (resolve) { resolve(1); });\n  var FakePromise = function (exec) {\n    exec(function () { /* empty */ }, function () { /* empty */ });\n  };\n  var constructor = promise.constructor = {};\n  constructor[SPECIES] = FakePromise;\n  SUBCLASSING = promise.then(function () { /* empty */ }) instanceof FakePromise;\n  if (!SUBCLASSING) return true;\n  // Unhandled rejections tracking support, NodeJS Promise without it fails @@species test\n  return !GLOBAL_CORE_JS_PROMISE && IS_BROWSER && !NATIVE_REJECTION_EVENT;\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) && isCallable(then = it.then) ? then : false;\n};\n\nvar notify = function (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(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            call(then, 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(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 (!NATIVE_REJECTION_EVENT && (handler = global['on' + name])) handler(event);\n  else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason);\n};\n\nvar onUnhandled = function (state) {\n  call(task, global, function () {\n    var promise = state.facade;\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 (state) {\n  call(task, global, function () {\n    var promise = state.facade;\n    if (IS_NODE) {\n      process.emit('rejectionHandled', promise);\n    } else dispatchEvent(REJECTION_HANDLED, promise, state.value);\n  });\n};\n\nvar bind = function (fn, state, unwrap) {\n  return function (value) {\n    fn(state, value, unwrap);\n  };\n};\n\nvar internalReject = function (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(state, true);\n};\n\nvar internalResolve = function (state, value, unwrap) {\n  if (state.done) return;\n  state.done = true;\n  if (unwrap) state = unwrap;\n  try {\n    if (state.facade === 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          call(then, value,\n            bind(internalResolve, wrapper, state),\n            bind(internalReject, wrapper, state)\n          );\n        } catch (error) {\n          internalReject(wrapper, error, state);\n        }\n      });\n    } else {\n      state.value = value;\n      state.state = FULFILLED;\n      notify(state, false);\n    }\n  } catch (error) {\n    internalReject({ 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, PromisePrototype);\n    aCallable(executor);\n    call(Internal, this);\n    var state = getInternalState(this);\n    try {\n      executor(bind(internalResolve, state), bind(internalReject, state));\n    } catch (error) {\n      internalReject(state, error);\n    }\n  };\n  PromisePrototype = PromiseConstructor.prototype;\n  // eslint-disable-next-line no-unused-vars -- required for `.length`\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(PromisePrototype, {\n    // `Promise.prototype.then` method\n    // https://tc39.es/ecma262/#sec-promise.prototype.then\n    then: function then(onFulfilled, onRejected) {\n      var state = getInternalPromiseState(this);\n      var reactions = state.reactions;\n      var reaction = newPromiseCapability(speciesConstructor(this, PromiseConstructor));\n      reaction.ok = isCallable(onFulfilled) ? onFulfilled : true;\n      reaction.fail = isCallable(onRejected) && onRejected;\n      reaction.domain = IS_NODE ? process.domain : undefined;\n      state.parent = true;\n      reactions[reactions.length] = reaction;\n      if (state.state != PENDING) notify(state, false);\n      return reaction.promise;\n    },\n    // `Promise.prototype.catch` method\n    // https://tc39.es/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, state);\n    this.reject = bind(internalReject, 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 && isCallable(NativePromise) && NativePromisePrototype !== Object.prototype) {\n    nativeThen = NativePromisePrototype.then;\n\n    if (!SUBCLASSING) {\n      // make `Promise#then` return a polyfilled `Promise` for native promise-based APIs\n      redefine(NativePromisePrototype, 'then', function then(onFulfilled, onRejected) {\n        var that = this;\n        return new PromiseConstructor(function (resolve, reject) {\n          call(nativeThen, that, resolve, reject);\n        }).then(onFulfilled, onRejected);\n      // https://github.com/zloirock/core-js/issues/640\n      }, { unsafe: true });\n\n      // makes sure that native promise-based APIs `Promise#catch` properly works with patched `Promise#then`\n      redefine(NativePromisePrototype, 'catch', PromisePrototype['catch'], { unsafe: true });\n    }\n\n    // make `.constructor === Promise` work for native promise-based APIs\n    try {\n      delete NativePromisePrototype.constructor;\n    } catch (error) { /* empty */ }\n\n    // make `instanceof Promise` work for native promise-based APIs\n    if (setPrototypeOf) {\n      setPrototypeOf(NativePromisePrototype, PromisePrototype);\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.es/ecma262/#sec-promise.reject\n  reject: function reject(r) {\n    var capability = newPromiseCapability(this);\n    call(capability.reject, 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.es/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.es/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 = aCallable(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        remaining++;\n        call($promiseResolve, 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.es/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 = aCallable(C.resolve);\n      iterate(iterable, function (promise) {\n        call($promiseResolve, 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","var global = require('../internals/global');\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\n\nvar TypeError = global.TypeError;\n\nmodule.exports = function (it, Prototype) {\n  if (isPrototypeOf(Prototype, it)) return it;\n  throw TypeError('Incorrect invocation');\n};\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 es/no-array-from, no-throw-literal -- required for testing\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","var anObject = require('../internals/an-object');\nvar aConstructor = require('../internals/a-constructor');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar SPECIES = wellKnownSymbol('species');\n\n// `SpeciesConstructor` abstract operation\n// https://tc39.es/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 : aConstructor(S);\n};\n","var global = require('../internals/global');\nvar isConstructor = require('../internals/is-constructor');\nvar tryToString = require('../internals/try-to-string');\n\nvar TypeError = global.TypeError;\n\n// `Assert: IsConstructor(argument) is true`\nmodule.exports = function (argument) {\n  if (isConstructor(argument)) return argument;\n  throw TypeError(tryToString(argument) + ' is not a constructor');\n};\n","var uncurryThis = require('../internals/function-uncurry-this');\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\nvar classof = require('../internals/classof');\nvar getBuiltIn = require('../internals/get-built-in');\nvar inspectSource = require('../internals/inspect-source');\n\nvar noop = function () { /* empty */ };\nvar empty = [];\nvar construct = getBuiltIn('Reflect', 'construct');\nvar constructorRegExp = /^\\s*(?:class|function)\\b/;\nvar exec = uncurryThis(constructorRegExp.exec);\nvar INCORRECT_TO_STRING = !constructorRegExp.exec(noop);\n\nvar isConstructorModern = function (argument) {\n  if (!isCallable(argument)) return false;\n  try {\n    construct(noop, empty, argument);\n    return true;\n  } catch (error) {\n    return false;\n  }\n};\n\nvar isConstructorLegacy = function (argument) {\n  if (!isCallable(argument)) return false;\n  switch (classof(argument)) {\n    case 'AsyncFunction':\n    case 'GeneratorFunction':\n    case 'AsyncGeneratorFunction': return false;\n    // we can't check .prototype since constructors produced by .bind haven't it\n  } return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource(argument));\n};\n\n// `IsConstructor` abstract operation\n// https://tc39.es/ecma262/#sec-isconstructor\nmodule.exports = !construct || fails(function () {\n  var called;\n  return isConstructorModern(isConstructorModern.call)\n    || !isConstructorModern(Object)\n    || !isConstructorModern(function () { called = true; })\n    || called;\n}) ? isConstructorLegacy : isConstructorModern;\n","var global = require('../internals/global');\nvar apply = require('../internals/function-apply');\nvar bind = require('../internals/function-bind-context');\nvar isCallable = require('../internals/is-callable');\nvar hasOwn = require('../internals/has-own-property');\nvar fails = require('../internals/fails');\nvar html = require('../internals/html');\nvar arraySlice = require('../internals/array-slice');\nvar createElement = require('../internals/document-create-element');\nvar IS_IOS = require('../internals/engine-is-ios');\nvar IS_NODE = require('../internals/engine-is-node');\n\nvar set = global.setImmediate;\nvar clear = global.clearImmediate;\nvar process = global.process;\nvar Dispatch = global.Dispatch;\nvar Function = global.Function;\nvar MessageChannel = global.MessageChannel;\nvar String = global.String;\nvar counter = 0;\nvar queue = {};\nvar ONREADYSTATECHANGE = 'onreadystatechange';\nvar location, defer, channel, port;\n\ntry {\n  // Deno throws a ReferenceError on `location` access without `--location` flag\n  location = global.location;\n} catch (error) { /* empty */ }\n\nvar run = function (id) {\n  if (hasOwn(queue, 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(String(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 = arraySlice(arguments, 1);\n    queue[++counter] = function () {\n      apply(isCallable(fn) ? fn : Function(fn), 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 (IS_NODE) {\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);\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    isCallable(global.postMessage) &&\n    !global.importScripts &&\n    location && location.protocol !== 'file:' &&\n    !fails(post)\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 FunctionPrototype = Function.prototype;\nvar apply = FunctionPrototype.apply;\nvar bind = FunctionPrototype.bind;\nvar call = FunctionPrototype.call;\n\n// eslint-disable-next-line es/no-reflect -- safe\nmodule.exports = typeof Reflect == 'object' && Reflect.apply || (bind ? call.bind(apply) : function () {\n  return call.apply(apply, arguments);\n});\n","var uncurryThis = require('../internals/function-uncurry-this');\n\nmodule.exports = uncurryThis([].slice);\n","var userAgent = require('../internals/engine-user-agent');\n\nmodule.exports = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent);\n","var classof = require('../internals/classof-raw');\nvar global = require('../internals/global');\n\nmodule.exports = classof(global.process) == 'process';\n","var global = require('../internals/global');\nvar bind = require('../internals/function-bind-context');\nvar getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;\nvar macrotask = require('../internals/task').set;\nvar IS_IOS = require('../internals/engine-is-ios');\nvar IS_IOS_PEBBLE = require('../internals/engine-is-ios-pebble');\nvar IS_WEBOS_WEBKIT = require('../internals/engine-is-webos-webkit');\nvar IS_NODE = require('../internals/engine-is-node');\n\nvar MutationObserver = global.MutationObserver || global.WebKitMutationObserver;\nvar document = global.document;\nvar process = global.process;\nvar Promise = global.Promise;\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  // browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339\n  // also except WebOS Webkit https://github.com/zloirock/core-js/issues/898\n  if (!IS_IOS && !IS_NODE && !IS_WEBOS_WEBKIT && MutationObserver && document) {\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 (!IS_IOS_PEBBLE && Promise && Promise.resolve) {\n    // Promise.resolve without an argument throws an error in LG WebOS 2\n    promise = Promise.resolve(undefined);\n    // workaround of WebKit ~ iOS Safari 10.1 bug\n    promise.constructor = Promise;\n    then = bind(promise.then, promise);\n    notify = function () {\n      then(flush);\n    };\n  // Node.js without promises\n  } else if (IS_NODE) {\n    notify = function () {\n      process.nextTick(flush);\n    };\n  // for other environments - macrotask based on:\n  // - setImmediate\n  // - MessageChannel\n  // - window.postMessag\n  // - onreadystatechange\n  // - setTimeout\n  } else {\n    // strange IE + webpack dev server bug - use .bind(global)\n    macrotask = bind(macrotask, global);\n    notify = function () {\n      macrotask(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 userAgent = require('../internals/engine-user-agent');\nvar global = require('../internals/global');\n\nmodule.exports = /ipad|iphone|ipod/i.test(userAgent) && global.Pebble !== undefined;\n","var userAgent = require('../internals/engine-user-agent');\n\nmodule.exports = /web0s(?!.*chrome)/i.test(userAgent);\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 aCallable = require('../internals/a-callable');\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 = aCallable(resolve);\n  this.reject = aCallable(reject);\n};\n\n// `NewPromiseCapability` abstract operation\n// https://tc39.es/ecma262/#sec-newpromisecapability\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","module.exports = typeof window == 'object';\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar perform = require('../internals/perform');\nvar iterate = require('../internals/iterate');\n\n// `Promise.allSettled` method\n// https://tc39.es/ecma262/#sec-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 = aCallable(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        remaining++;\n        call(promiseResolve, 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 (error) {\n          if (alreadyCalled) return;\n          alreadyCalled = true;\n          values[index] = { status: 'rejected', reason: error };\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 aCallable = require('../internals/a-callable');\nvar getBuiltIn = require('../internals/get-built-in');\nvar call = require('../internals/function-call');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar perform = require('../internals/perform');\nvar iterate = require('../internals/iterate');\n\nvar PROMISE_ANY_ERROR = 'No one promise resolved';\n\n// `Promise.any` method\n// https://tc39.es/ecma262/#sec-promise.any\n$({ target: 'Promise', stat: true }, {\n  any: function any(iterable) {\n    var C = this;\n    var AggregateError = getBuiltIn('AggregateError');\n    var capability = newPromiseCapabilityModule.f(C);\n    var resolve = capability.resolve;\n    var reject = capability.reject;\n    var result = perform(function () {\n      var promiseResolve = aCallable(C.resolve);\n      var errors = [];\n      var counter = 0;\n      var remaining = 1;\n      var alreadyResolved = false;\n      iterate(iterable, function (promise) {\n        var index = counter++;\n        var alreadyRejected = false;\n        remaining++;\n        call(promiseResolve, C, promise).then(function (value) {\n          if (alreadyRejected || alreadyResolved) return;\n          alreadyResolved = true;\n          resolve(value);\n        }, function (error) {\n          if (alreadyRejected || alreadyResolved) return;\n          alreadyRejected = true;\n          errors[index] = error;\n          --remaining || reject(new AggregateError(errors, PROMISE_ANY_ERROR));\n        });\n      });\n      --remaining || reject(new AggregateError(errors, PROMISE_ANY_ERROR));\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 isCallable = require('../internals/is-callable');\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.es/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 = isCallable(onFinally);\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// makes sure that native promise-based APIs `Promise#finally` properly works with patched `Promise#then`\nif (!IS_PURE && isCallable(NativePromise)) {\n  var method = getBuiltIn('Promise').prototype['finally'];\n  if (NativePromise.prototype['finally'] !== method) {\n    redefine(NativePromise.prototype, 'finally', method, { unsafe: true });\n  }\n}\n","'use strict';\nvar charAt = require('../internals/string-multibyte').charAt;\nvar toString = require('../internals/to-string');\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.es/ecma262/#sec-string.prototype-@@iterator\ndefineIterator(String, 'String', function (iterated) {\n  setInternalState(this, {\n    type: STRING_ITERATOR,\n    string: toString(iterated),\n    index: 0\n  });\n// `%StringIteratorPrototype%.next` method\n// https://tc39.es/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 uncurryThis = require('../internals/function-uncurry-this');\nvar toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\nvar toString = require('../internals/to-string');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nvar charAt = uncurryThis(''.charAt);\nvar charCodeAt = uncurryThis(''.charCodeAt);\nvar stringSlice = uncurryThis(''.slice);\n\nvar createMethod = function (CONVERT_TO_STRING) {\n  return function ($this, pos) {\n    var S = toString(requireObjectCoercible($this));\n    var position = toIntegerOrInfinity(pos);\n    var size = S.length;\n    var first, second;\n    if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined;\n    first = charCodeAt(S, position);\n    return first < 0xD800 || first > 0xDBFF || position + 1 === size\n      || (second = charCodeAt(S, position + 1)) < 0xDC00 || second > 0xDFFF\n        ? CONVERT_TO_STRING\n          ? charAt(S, position)\n          : first\n        : CONVERT_TO_STRING\n          ? stringSlice(S, position, position + 2)\n          : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n  };\n};\n\nmodule.exports = {\n  // `String.prototype.codePointAt` method\n  // https://tc39.es/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","/**\n * web-streams-polyfill v3.2.0\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 = typeof globalThis !== 'undefined' ? globalThis : 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        return undefined;\n    }\n    function getGlobals() {\n        if (typeof self !== 'undefined') {\n            return self;\n        }\n        else if (typeof window !== 'undefined') {\n            return window;\n        }\n        else if (typeof global !== 'undefined') {\n            return global;\n        }\n        return undefined;\n    }\n    var globals = getGlobals();\n\n    function typeIsObject(x) {\n        return (typeof x === 'object' && x !== null) || typeof x === 'function';\n    }\n    var rethrowAssertionErrorRejection = noop;\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    var queueMicrotask = (function () {\n        var globalQueueMicrotask = globals && globals.queueMicrotask;\n        if (typeof globalQueueMicrotask === 'function') {\n            return globalQueueMicrotask;\n        }\n        var resolvedPromise = promiseResolvedWith(undefined);\n        return function (fn) { return PerformPromiseThen(resolvedPromise, fn); };\n    })();\n    function reflectCall(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 promiseCall(F, V, args) {\n        try {\n            return promiseResolvedWith(reflectCall(F, V, args));\n        }\n        catch (value) {\n            return promiseRejectedWith(value);\n        }\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: false,\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 ReadableStreamReaderGenericInitialize(reader, stream) {\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        if (reader._closedPromise_reject === undefined) {\n            return;\n        }\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        if (reader._closedPromise_resolve === undefined) {\n            return;\n        }\n        reader._closedPromise_resolve(undefined);\n        reader._closedPromise_resolve = undefined;\n        reader._closedPromise_reject = undefined;\n    }\n\n    var AbortSteps = SymbolPolyfill('[[AbortSteps]]');\n    var ErrorSteps = SymbolPolyfill('[[ErrorSteps]]');\n    var CancelSteps = SymbolPolyfill('[[CancelSteps]]');\n    var PullSteps = SymbolPolyfill('[[PullSteps]]');\n\n    /// <reference lib=\"es2015.core\" />\n    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isFinite#Polyfill\n    var NumberIsFinite = Number.isFinite || function (x) {\n        return typeof x === 'number' && isFinite(x);\n    };\n\n    /// <reference lib=\"es2015.core\" />\n    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc#Polyfill\n    var MathTrunc = Math.trunc || function (v) {\n        return v < 0 ? Math.ceil(v) : Math.floor(v);\n    };\n\n    // https://heycam.github.io/webidl/#idl-dictionaries\n    function isDictionary(x) {\n        return typeof x === 'object' || typeof x === 'function';\n    }\n    function assertDictionary(obj, context) {\n        if (obj !== undefined && !isDictionary(obj)) {\n            throw new TypeError(context + \" is not an object.\");\n        }\n    }\n    // https://heycam.github.io/webidl/#idl-callback-functions\n    function assertFunction(x, context) {\n        if (typeof x !== 'function') {\n            throw new TypeError(context + \" is not a function.\");\n        }\n    }\n    // https://heycam.github.io/webidl/#idl-object\n    function isObject(x) {\n        return (typeof x === 'object' && x !== null) || typeof x === 'function';\n    }\n    function assertObject(x, context) {\n        if (!isObject(x)) {\n            throw new TypeError(context + \" is not an object.\");\n        }\n    }\n    function assertRequiredArgument(x, position, context) {\n        if (x === undefined) {\n            throw new TypeError(\"Parameter \" + position + \" is required in '\" + context + \"'.\");\n        }\n    }\n    function assertRequiredField(x, field, context) {\n        if (x === undefined) {\n            throw new TypeError(field + \" is required in '\" + context + \"'.\");\n        }\n    }\n    // https://heycam.github.io/webidl/#idl-unrestricted-double\n    function convertUnrestrictedDouble(value) {\n        return Number(value);\n    }\n    function censorNegativeZero(x) {\n        return x === 0 ? 0 : x;\n    }\n    function integerPart(x) {\n        return censorNegativeZero(MathTrunc(x));\n    }\n    // https://heycam.github.io/webidl/#idl-unsigned-long-long\n    function convertUnsignedLongLongWithEnforceRange(value, context) {\n        var lowerBound = 0;\n        var upperBound = Number.MAX_SAFE_INTEGER;\n        var x = Number(value);\n        x = censorNegativeZero(x);\n        if (!NumberIsFinite(x)) {\n            throw new TypeError(context + \" is not a finite number\");\n        }\n        x = integerPart(x);\n        if (x < lowerBound || x > upperBound) {\n            throw new TypeError(context + \" is outside the accepted range of \" + lowerBound + \" to \" + upperBound + \", inclusive\");\n        }\n        if (!NumberIsFinite(x) || x === 0) {\n            return 0;\n        }\n        // TODO Use BigInt if supported?\n        // let xBigInt = BigInt(integerPart(x));\n        // xBigInt = BigInt.asUintN(64, xBigInt);\n        // return Number(xBigInt);\n        return x;\n    }\n\n    function assertReadableStream(x, context) {\n        if (!IsReadableStream(x)) {\n            throw new TypeError(context + \" is not a ReadableStream.\");\n        }\n    }\n\n    // Abstract operations for the ReadableStream.\n    function AcquireReadableStreamDefaultReader(stream) {\n        return new ReadableStreamDefaultReader(stream);\n    }\n    // ReadableStream API exposed for controllers.\n    function ReadableStreamAddReadRequest(stream, readRequest) {\n        stream._reader._readRequests.push(readRequest);\n    }\n    function ReadableStreamFulfillReadRequest(stream, chunk, done) {\n        var reader = stream._reader;\n        var readRequest = reader._readRequests.shift();\n        if (done) {\n            readRequest._closeSteps();\n        }\n        else {\n            readRequest._chunkSteps(chunk);\n        }\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    /**\n     * A default reader vended by a {@link ReadableStream}.\n     *\n     * @public\n     */\n    var ReadableStreamDefaultReader = /** @class */ (function () {\n        function ReadableStreamDefaultReader(stream) {\n            assertRequiredArgument(stream, 1, 'ReadableStreamDefaultReader');\n            assertReadableStream(stream, 'First parameter');\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._readRequests = new SimpleQueue();\n        }\n        Object.defineProperty(ReadableStreamDefaultReader.prototype, \"closed\", {\n            /**\n             * Returns a promise that will be fulfilled when the stream becomes closed,\n             * or rejected if the stream ever errors or the reader's lock is released before the stream finishes closing.\n             */\n            get: function () {\n                if (!IsReadableStreamDefaultReader(this)) {\n                    return promiseRejectedWith(defaultReaderBrandCheckException('closed'));\n                }\n                return this._closedPromise;\n            },\n            enumerable: false,\n            configurable: true\n        });\n        /**\n         * If the reader is active, behaves the same as {@link ReadableStream.cancel | stream.cancel(reason)}.\n         */\n        ReadableStreamDefaultReader.prototype.cancel = function (reason) {\n            if (reason === void 0) { reason = undefined; }\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        /**\n         * Returns a promise that allows access to the next chunk from the stream's internal queue, if available.\n         *\n         * If reading a chunk causes the queue to become empty, more data will be pulled from the underlying source.\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            var resolvePromise;\n            var rejectPromise;\n            var promise = newPromise(function (resolve, reject) {\n                resolvePromise = resolve;\n                rejectPromise = reject;\n            });\n            var readRequest = {\n                _chunkSteps: function (chunk) { return resolvePromise({ value: chunk, done: false }); },\n                _closeSteps: function () { return resolvePromise({ value: undefined, done: true }); },\n                _errorSteps: function (e) { return rejectPromise(e); }\n            };\n            ReadableStreamDefaultReaderRead(this, readRequest);\n            return promise;\n        };\n        /**\n         * Releases the reader's lock on the corresponding stream. After the lock is released, the reader is no longer active.\n         * If the associated stream is errored when the lock is released, the reader will appear errored in the same way\n         * from now on; otherwise, the reader will appear closed.\n         *\n         * A reader's lock cannot be released while it still has a pending read request, i.e., if a promise returned by\n         * the reader's {@link ReadableStreamDefaultReader.read | read()} method has not yet been settled. Attempting to\n         * do so will throw a `TypeError` and leave the reader locked to the stream.\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    Object.defineProperties(ReadableStreamDefaultReader.prototype, {\n        cancel: { enumerable: true },\n        read: { enumerable: true },\n        releaseLock: { enumerable: true },\n        closed: { enumerable: true }\n    });\n    if (typeof SymbolPolyfill.toStringTag === 'symbol') {\n        Object.defineProperty(ReadableStreamDefaultReader.prototype, SymbolPolyfill.toStringTag, {\n            value: 'ReadableStreamDefaultReader',\n            configurable: true\n        });\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 x instanceof ReadableStreamDefaultReader;\n    }\n    function ReadableStreamDefaultReaderRead(reader, readRequest) {\n        var stream = reader._ownerReadableStream;\n        stream._disturbed = true;\n        if (stream._state === 'closed') {\n            readRequest._closeSteps();\n        }\n        else if (stream._state === 'errored') {\n            readRequest._errorSteps(stream._storedError);\n        }\n        else {\n            stream._readableStreamController[PullSteps](readRequest);\n        }\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 ReadableStreamAsyncIteratorImpl = /** @class */ (function () {\n        function ReadableStreamAsyncIteratorImpl(reader, preventCancel) {\n            this._ongoingPromise = undefined;\n            this._isFinished = false;\n            this._reader = reader;\n            this._preventCancel = preventCancel;\n        }\n        ReadableStreamAsyncIteratorImpl.prototype.next = function () {\n            var _this = this;\n            var nextSteps = function () { return _this._nextSteps(); };\n            this._ongoingPromise = this._ongoingPromise ?\n                transformPromiseWith(this._ongoingPromise, nextSteps, nextSteps) :\n                nextSteps();\n            return this._ongoingPromise;\n        };\n        ReadableStreamAsyncIteratorImpl.prototype.return = function (value) {\n            var _this = this;\n            var returnSteps = function () { return _this._returnSteps(value); };\n            return this._ongoingPromise ?\n                transformPromiseWith(this._ongoingPromise, returnSteps, returnSteps) :\n                returnSteps();\n        };\n        ReadableStreamAsyncIteratorImpl.prototype._nextSteps = function () {\n            var _this = this;\n            if (this._isFinished) {\n                return Promise.resolve({ value: undefined, done: true });\n            }\n            var reader = this._reader;\n            if (reader._ownerReadableStream === undefined) {\n                return promiseRejectedWith(readerLockException('iterate'));\n            }\n            var resolvePromise;\n            var rejectPromise;\n            var promise = newPromise(function (resolve, reject) {\n                resolvePromise = resolve;\n                rejectPromise = reject;\n            });\n            var readRequest = {\n                _chunkSteps: function (chunk) {\n                    _this._ongoingPromise = undefined;\n                    // This needs to be delayed by one microtask, otherwise we stop pulling too early which breaks a test.\n                    // FIXME Is this a bug in the specification, or in the test?\n                    queueMicrotask(function () { return resolvePromise({ value: chunk, done: false }); });\n                },\n                _closeSteps: function () {\n                    _this._ongoingPromise = undefined;\n                    _this._isFinished = true;\n                    ReadableStreamReaderGenericRelease(reader);\n                    resolvePromise({ value: undefined, done: true });\n                },\n                _errorSteps: function (reason) {\n                    _this._ongoingPromise = undefined;\n                    _this._isFinished = true;\n                    ReadableStreamReaderGenericRelease(reader);\n                    rejectPromise(reason);\n                }\n            };\n            ReadableStreamDefaultReaderRead(reader, readRequest);\n            return promise;\n        };\n        ReadableStreamAsyncIteratorImpl.prototype._returnSteps = function (value) {\n            if (this._isFinished) {\n                return Promise.resolve({ value: value, done: true });\n            }\n            this._isFinished = true;\n            var reader = this._reader;\n            if (reader._ownerReadableStream === undefined) {\n                return promiseRejectedWith(readerLockException('finish iterating'));\n            }\n            if (!this._preventCancel) {\n                var result = ReadableStreamReaderGenericCancel(reader, value);\n                ReadableStreamReaderGenericRelease(reader);\n                return transformPromiseWith(result, function () { return ({ value: value, done: true }); });\n            }\n            ReadableStreamReaderGenericRelease(reader);\n            return promiseResolvedWith({ value: value, done: true });\n        };\n        return ReadableStreamAsyncIteratorImpl;\n    }());\n    var ReadableStreamAsyncIteratorPrototype = {\n        next: function () {\n            if (!IsReadableStreamAsyncIterator(this)) {\n                return promiseRejectedWith(streamAsyncIteratorBrandCheckException('next'));\n            }\n            return this._asyncIteratorImpl.next();\n        },\n        return: function (value) {\n            if (!IsReadableStreamAsyncIterator(this)) {\n                return promiseRejectedWith(streamAsyncIteratorBrandCheckException('return'));\n            }\n            return this._asyncIteratorImpl.return(value);\n        }\n    };\n    if (AsyncIteratorPrototype !== undefined) {\n        Object.setPrototypeOf(ReadableStreamAsyncIteratorPrototype, AsyncIteratorPrototype);\n    }\n    // Abstract operations for the ReadableStream.\n    function AcquireReadableStreamAsyncIterator(stream, preventCancel) {\n        var reader = AcquireReadableStreamDefaultReader(stream);\n        var impl = new ReadableStreamAsyncIteratorImpl(reader, preventCancel);\n        var iterator = Object.create(ReadableStreamAsyncIteratorPrototype);\n        iterator._asyncIteratorImpl = impl;\n        return iterator;\n    }\n    function IsReadableStreamAsyncIterator(x) {\n        if (!typeIsObject(x)) {\n            return false;\n        }\n        if (!Object.prototype.hasOwnProperty.call(x, '_asyncIteratorImpl')) {\n            return false;\n        }\n        try {\n            // noinspection SuspiciousTypeOfGuard\n            return x._asyncIteratorImpl instanceof\n                ReadableStreamAsyncIteratorImpl;\n        }\n        catch (_a) {\n            return false;\n        }\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    /// <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    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 CopyDataBlockBytes(dest, destOffset, src, srcOffset, n) {\n        new Uint8Array(dest).set(new Uint8Array(src, srcOffset, n), destOffset);\n    }\n    // Not implemented correctly\n    function TransferArrayBuffer(O) {\n        return O;\n    }\n    // Not implemented correctly\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    function IsDetachedBuffer(O) {\n        return false;\n    }\n    function ArrayBufferSlice(buffer, begin, end) {\n        // ArrayBuffer.prototype.slice is not available on IE10\n        // https://www.caniuse.com/mdn-javascript_builtins_arraybuffer_slice\n        if (buffer.slice) {\n            return buffer.slice(begin, end);\n        }\n        var length = end - begin;\n        var slice = new ArrayBuffer(length);\n        CopyDataBlockBytes(slice, 0, buffer, begin, length);\n        return slice;\n    }\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 CloneAsUint8Array(O) {\n        var buffer = ArrayBufferSlice(O.buffer, O.byteOffset, O.byteOffset + O.byteLength);\n        return new Uint8Array(buffer);\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        if (!IsNonNegativeNumber(size) || size === Infinity) {\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    /**\n     * A pull-into request in a {@link ReadableByteStreamController}.\n     *\n     * @public\n     */\n    var ReadableStreamBYOBRequest = /** @class */ (function () {\n        function ReadableStreamBYOBRequest() {\n            throw new TypeError('Illegal constructor');\n        }\n        Object.defineProperty(ReadableStreamBYOBRequest.prototype, \"view\", {\n            /**\n             * Returns the view for writing in to, or `null` if the BYOB request has already been responded to.\n             */\n            get: function () {\n                if (!IsReadableStreamBYOBRequest(this)) {\n                    throw byobRequestBrandCheckException('view');\n                }\n                return this._view;\n            },\n            enumerable: false,\n            configurable: true\n        });\n        ReadableStreamBYOBRequest.prototype.respond = function (bytesWritten) {\n            if (!IsReadableStreamBYOBRequest(this)) {\n                throw byobRequestBrandCheckException('respond');\n            }\n            assertRequiredArgument(bytesWritten, 1, 'respond');\n            bytesWritten = convertUnsignedLongLongWithEnforceRange(bytesWritten, 'First parameter');\n            if (this._associatedReadableByteStreamController === undefined) {\n                throw new TypeError('This BYOB request has been invalidated');\n            }\n            if (IsDetachedBuffer(this._view.buffer)) ;\n            ReadableByteStreamControllerRespond(this._associatedReadableByteStreamController, bytesWritten);\n        };\n        ReadableStreamBYOBRequest.prototype.respondWithNewView = function (view) {\n            if (!IsReadableStreamBYOBRequest(this)) {\n                throw byobRequestBrandCheckException('respondWithNewView');\n            }\n            assertRequiredArgument(view, 1, 'respondWithNewView');\n            if (!ArrayBuffer.isView(view)) {\n                throw new TypeError('You can only respond with array buffer views');\n            }\n            if (this._associatedReadableByteStreamController === undefined) {\n                throw new TypeError('This BYOB request has been invalidated');\n            }\n            if (IsDetachedBuffer(view.buffer)) ;\n            ReadableByteStreamControllerRespondWithNewView(this._associatedReadableByteStreamController, view);\n        };\n        return ReadableStreamBYOBRequest;\n    }());\n    Object.defineProperties(ReadableStreamBYOBRequest.prototype, {\n        respond: { enumerable: true },\n        respondWithNewView: { enumerable: true },\n        view: { enumerable: true }\n    });\n    if (typeof SymbolPolyfill.toStringTag === 'symbol') {\n        Object.defineProperty(ReadableStreamBYOBRequest.prototype, SymbolPolyfill.toStringTag, {\n            value: 'ReadableStreamBYOBRequest',\n            configurable: true\n        });\n    }\n    /**\n     * Allows control of a {@link ReadableStream | readable byte stream}'s state and internal queue.\n     *\n     * @public\n     */\n    var ReadableByteStreamController = /** @class */ (function () {\n        function ReadableByteStreamController() {\n            throw new TypeError('Illegal constructor');\n        }\n        Object.defineProperty(ReadableByteStreamController.prototype, \"byobRequest\", {\n            /**\n             * Returns the current BYOB pull request, or `null` if there isn't one.\n             */\n            get: function () {\n                if (!IsReadableByteStreamController(this)) {\n                    throw byteStreamControllerBrandCheckException('byobRequest');\n                }\n                return ReadableByteStreamControllerGetBYOBRequest(this);\n            },\n            enumerable: false,\n            configurable: true\n        });\n        Object.defineProperty(ReadableByteStreamController.prototype, \"desiredSize\", {\n            /**\n             * Returns the desired size to fill the controlled stream's internal queue. It can be negative, if the queue is\n             * over-full. An underlying byte source ought to use this information to determine when and how to apply backpressure.\n             */\n            get: function () {\n                if (!IsReadableByteStreamController(this)) {\n                    throw byteStreamControllerBrandCheckException('desiredSize');\n                }\n                return ReadableByteStreamControllerGetDesiredSize(this);\n            },\n            enumerable: false,\n            configurable: true\n        });\n        /**\n         * Closes the controlled readable stream. Consumers will still be able to read any previously-enqueued chunks from\n         * the stream, but once those are read, the stream will become closed.\n         */\n        ReadableByteStreamController.prototype.close = function () {\n            if (!IsReadableByteStreamController(this)) {\n                throw byteStreamControllerBrandCheckException('close');\n            }\n            if (this._closeRequested) {\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)) {\n                throw byteStreamControllerBrandCheckException('enqueue');\n            }\n            assertRequiredArgument(chunk, 1, 'enqueue');\n            if (!ArrayBuffer.isView(chunk)) {\n                throw new TypeError('chunk must be an array buffer view');\n            }\n            if (chunk.byteLength === 0) {\n                throw new TypeError('chunk must have non-zero byteLength');\n            }\n            if (chunk.buffer.byteLength === 0) {\n                throw new TypeError(\"chunk's buffer must have non-zero byteLength\");\n            }\n            if (this._closeRequested) {\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            ReadableByteStreamControllerEnqueue(this, chunk);\n        };\n        /**\n         * Errors the controlled readable stream, making all future interactions with it fail with the given error `e`.\n         */\n        ReadableByteStreamController.prototype.error = function (e) {\n            if (e === void 0) { e = undefined; }\n            if (!IsReadableByteStreamController(this)) {\n                throw byteStreamControllerBrandCheckException('error');\n            }\n            ReadableByteStreamControllerError(this, e);\n        };\n        /** @internal */\n        ReadableByteStreamController.prototype[CancelSteps] = function (reason) {\n            ReadableByteStreamControllerClearPendingPullIntos(this);\n            ResetQueue(this);\n            var result = this._cancelAlgorithm(reason);\n            ReadableByteStreamControllerClearAlgorithms(this);\n            return result;\n        };\n        /** @internal */\n        ReadableByteStreamController.prototype[PullSteps] = function (readRequest) {\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 = new Uint8Array(entry.buffer, entry.byteOffset, entry.byteLength);\n                readRequest._chunkSteps(view);\n                return;\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                    readRequest._errorSteps(bufferE);\n                    return;\n                }\n                var pullIntoDescriptor = {\n                    buffer: buffer,\n                    bufferByteLength: autoAllocateChunkSize,\n                    byteOffset: 0,\n                    byteLength: autoAllocateChunkSize,\n                    bytesFilled: 0,\n                    elementSize: 1,\n                    viewConstructor: Uint8Array,\n                    readerType: 'default'\n                };\n                this._pendingPullIntos.push(pullIntoDescriptor);\n            }\n            ReadableStreamAddReadRequest(stream, readRequest);\n            ReadableByteStreamControllerCallPullIfNeeded(this);\n        };\n        return ReadableByteStreamController;\n    }());\n    Object.defineProperties(ReadableByteStreamController.prototype, {\n        close: { enumerable: true },\n        enqueue: { enumerable: true },\n        error: { enumerable: true },\n        byobRequest: { enumerable: true },\n        desiredSize: { enumerable: true }\n    });\n    if (typeof SymbolPolyfill.toStringTag === 'symbol') {\n        Object.defineProperty(ReadableByteStreamController.prototype, SymbolPolyfill.toStringTag, {\n            value: 'ReadableByteStreamController',\n            configurable: true\n        });\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 x instanceof ReadableByteStreamController;\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 x instanceof ReadableStreamBYOBRequest;\n    }\n    function ReadableByteStreamControllerCallPullIfNeeded(controller) {\n        var shouldPull = ReadableByteStreamControllerShouldCallPull(controller);\n        if (!shouldPull) {\n            return;\n        }\n        if (controller._pulling) {\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) {\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.viewConstructor(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            CopyDataBlockBytes(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        pullIntoDescriptor.bytesFilled += size;\n    }\n    function ReadableByteStreamControllerHandleQueueDrain(controller) {\n        if (controller._queueTotalSize === 0 && controller._closeRequested) {\n            ReadableByteStreamControllerClearAlgorithms(controller);\n            ReadableStreamClose(controller._controlledReadableByteStream);\n        }\n        else {\n            ReadableByteStreamControllerCallPullIfNeeded(controller);\n        }\n    }\n    function ReadableByteStreamControllerInvalidateBYOBRequest(controller) {\n        if (controller._byobRequest === null) {\n            return;\n        }\n        controller._byobRequest._associatedReadableByteStreamController = undefined;\n        controller._byobRequest._view = null;\n        controller._byobRequest = null;\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)) {\n                ReadableByteStreamControllerShiftPendingPullInto(controller);\n                ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadableByteStream, pullIntoDescriptor);\n            }\n        }\n    }\n    function ReadableByteStreamControllerPullInto(controller, view, readIntoRequest) {\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        // try {\n        var buffer = TransferArrayBuffer(view.buffer);\n        // } catch (e) {\n        //   readIntoRequest._errorSteps(e);\n        //   return;\n        // }\n        var pullIntoDescriptor = {\n            buffer: buffer,\n            bufferByteLength: buffer.byteLength,\n            byteOffset: view.byteOffset,\n            byteLength: view.byteLength,\n            bytesFilled: 0,\n            elementSize: elementSize,\n            viewConstructor: 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            ReadableStreamAddReadIntoRequest(stream, readIntoRequest);\n            return;\n        }\n        if (stream._state === 'closed') {\n            var emptyView = new ctor(pullIntoDescriptor.buffer, pullIntoDescriptor.byteOffset, 0);\n            readIntoRequest._closeSteps(emptyView);\n            return;\n        }\n        if (controller._queueTotalSize > 0) {\n            if (ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor)) {\n                var filledView = ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor);\n                ReadableByteStreamControllerHandleQueueDrain(controller);\n                readIntoRequest._chunkSteps(filledView);\n                return;\n            }\n            if (controller._closeRequested) {\n                var e = new TypeError('Insufficient bytes to fill elements in the given buffer');\n                ReadableByteStreamControllerError(controller, e);\n                readIntoRequest._errorSteps(e);\n                return;\n            }\n        }\n        controller._pendingPullIntos.push(pullIntoDescriptor);\n        ReadableStreamAddReadIntoRequest(stream, readIntoRequest);\n        ReadableByteStreamControllerCallPullIfNeeded(controller);\n    }\n    function ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor) {\n        var stream = controller._controlledReadableByteStream;\n        if (ReadableStreamHasBYOBReader(stream)) {\n            while (ReadableStreamGetNumReadIntoRequests(stream) > 0) {\n                var pullIntoDescriptor = ReadableByteStreamControllerShiftPendingPullInto(controller);\n                ReadableByteStreamControllerCommitPullIntoDescriptor(stream, pullIntoDescriptor);\n            }\n        }\n    }\n    function ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, pullIntoDescriptor) {\n        ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesWritten, pullIntoDescriptor);\n        if (pullIntoDescriptor.bytesFilled < pullIntoDescriptor.elementSize) {\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 = ArrayBufferSlice(pullIntoDescriptor.buffer, end - remainderSize, end);\n            ReadableByteStreamControllerEnqueueChunkToQueue(controller, remainder, 0, remainder.byteLength);\n        }\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        ReadableByteStreamControllerInvalidateBYOBRequest(controller);\n        var state = controller._controlledReadableByteStream._state;\n        if (state === 'closed') {\n            ReadableByteStreamControllerRespondInClosedState(controller);\n        }\n        else {\n            ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, firstDescriptor);\n        }\n        ReadableByteStreamControllerCallPullIfNeeded(controller);\n    }\n    function ReadableByteStreamControllerShiftPendingPullInto(controller) {\n        var descriptor = controller._pendingPullIntos.shift();\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) {\n            return false;\n        }\n        if (!controller._started) {\n            return false;\n        }\n        if (ReadableStreamHasDefaultReader(stream) && ReadableStreamGetNumReadRequests(stream) > 0) {\n            return true;\n        }\n        if (ReadableStreamHasBYOBReader(stream) && 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._closeRequested || stream._state !== 'readable') {\n            return;\n        }\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        if (controller._closeRequested || stream._state !== 'readable') {\n            return;\n        }\n        var buffer = chunk.buffer;\n        var byteOffset = chunk.byteOffset;\n        var byteLength = chunk.byteLength;\n        var transferredBuffer = TransferArrayBuffer(buffer);\n        if (controller._pendingPullIntos.length > 0) {\n            var firstPendingPullInto = controller._pendingPullIntos.peek();\n            if (IsDetachedBuffer(firstPendingPullInto.buffer)) ;\n            firstPendingPullInto.buffer = TransferArrayBuffer(firstPendingPullInto.buffer);\n        }\n        ReadableByteStreamControllerInvalidateBYOBRequest(controller);\n        if (ReadableStreamHasDefaultReader(stream)) {\n            if (ReadableStreamGetNumReadRequests(stream) === 0) {\n                ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);\n            }\n            else {\n                if (controller._pendingPullIntos.length > 0) {\n                    ReadableByteStreamControllerShiftPendingPullInto(controller);\n                }\n                var transferredView = new Uint8Array(transferredBuffer, byteOffset, byteLength);\n                ReadableStreamFulfillReadRequest(stream, transferredView, false);\n            }\n        }\n        else if (ReadableStreamHasBYOBReader(stream)) {\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 ReadableByteStreamControllerGetBYOBRequest(controller) {\n        if (controller._byobRequest === null && controller._pendingPullIntos.length > 0) {\n            var firstDescriptor = controller._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, controller, view);\n            controller._byobRequest = byobRequest;\n        }\n        return controller._byobRequest;\n    }\n    function ReadableByteStreamControllerGetDesiredSize(controller) {\n        var state = controller._controlledReadableByteStream._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        var firstDescriptor = controller._pendingPullIntos.peek();\n        var state = controller._controlledReadableByteStream._state;\n        if (state === 'closed') {\n            if (bytesWritten !== 0) {\n                throw new TypeError('bytesWritten must be 0 when calling respond() on a closed stream');\n            }\n        }\n        else {\n            if (bytesWritten === 0) {\n                throw new TypeError('bytesWritten must be greater than 0 when calling respond() on a readable stream');\n            }\n            if (firstDescriptor.bytesFilled + bytesWritten > firstDescriptor.byteLength) {\n                throw new RangeError('bytesWritten out of range');\n            }\n        }\n        firstDescriptor.buffer = TransferArrayBuffer(firstDescriptor.buffer);\n        ReadableByteStreamControllerRespondInternal(controller, bytesWritten);\n    }\n    function ReadableByteStreamControllerRespondWithNewView(controller, view) {\n        var firstDescriptor = controller._pendingPullIntos.peek();\n        var state = controller._controlledReadableByteStream._state;\n        if (state === 'closed') {\n            if (view.byteLength !== 0) {\n                throw new TypeError('The view\\'s length must be 0 when calling respondWithNewView() on a closed stream');\n            }\n        }\n        else {\n            if (view.byteLength === 0) {\n                throw new TypeError('The view\\'s length must be greater than 0 when calling respondWithNewView() on a readable stream');\n            }\n        }\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.bufferByteLength !== view.buffer.byteLength) {\n            throw new RangeError('The buffer of view has different capacity than byobRequest');\n        }\n        if (firstDescriptor.bytesFilled + view.byteLength > firstDescriptor.byteLength) {\n            throw new RangeError('The region specified by view is larger than byobRequest');\n        }\n        var viewByteLength = view.byteLength;\n        firstDescriptor.buffer = TransferArrayBuffer(view.buffer);\n        ReadableByteStreamControllerRespondInternal(controller, viewByteLength);\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 = null;\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 = 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        var startAlgorithm = function () { return undefined; };\n        var pullAlgorithm = function () { return promiseResolvedWith(undefined); };\n        var cancelAlgorithm = function () { return promiseResolvedWith(undefined); };\n        if (underlyingByteSource.start !== undefined) {\n            startAlgorithm = function () { return underlyingByteSource.start(controller); };\n        }\n        if (underlyingByteSource.pull !== undefined) {\n            pullAlgorithm = function () { return underlyingByteSource.pull(controller); };\n        }\n        if (underlyingByteSource.cancel !== undefined) {\n            cancelAlgorithm = function (reason) { return underlyingByteSource.cancel(reason); };\n        }\n        var autoAllocateChunkSize = underlyingByteSource.autoAllocateChunkSize;\n        if (autoAllocateChunkSize === 0) {\n            throw new TypeError('autoAllocateChunkSize must be greater than 0');\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) {\n        return new ReadableStreamBYOBReader(stream);\n    }\n    // ReadableStream API exposed for controllers.\n    function ReadableStreamAddReadIntoRequest(stream, readIntoRequest) {\n        stream._reader._readIntoRequests.push(readIntoRequest);\n    }\n    function ReadableStreamFulfillReadIntoRequest(stream, chunk, done) {\n        var reader = stream._reader;\n        var readIntoRequest = reader._readIntoRequests.shift();\n        if (done) {\n            readIntoRequest._closeSteps(chunk);\n        }\n        else {\n            readIntoRequest._chunkSteps(chunk);\n        }\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    /**\n     * A BYOB reader vended by a {@link ReadableStream}.\n     *\n     * @public\n     */\n    var ReadableStreamBYOBReader = /** @class */ (function () {\n        function ReadableStreamBYOBReader(stream) {\n            assertRequiredArgument(stream, 1, 'ReadableStreamBYOBReader');\n            assertReadableStream(stream, 'First parameter');\n            if (IsReadableStreamLocked(stream)) {\n                throw new TypeError('This stream has already been locked for exclusive reading by another reader');\n            }\n            if (!IsReadableByteStreamController(stream._readableStreamController)) {\n                throw new TypeError('Cannot construct a ReadableStreamBYOBReader for a stream not constructed with a byte ' +\n                    'source');\n            }\n            ReadableStreamReaderGenericInitialize(this, stream);\n            this._readIntoRequests = new SimpleQueue();\n        }\n        Object.defineProperty(ReadableStreamBYOBReader.prototype, \"closed\", {\n            /**\n             * Returns a promise that will be fulfilled when the stream becomes closed, or rejected if the stream ever errors or\n             * the reader's lock is released before the stream finishes closing.\n             */\n            get: function () {\n                if (!IsReadableStreamBYOBReader(this)) {\n                    return promiseRejectedWith(byobReaderBrandCheckException('closed'));\n                }\n                return this._closedPromise;\n            },\n            enumerable: false,\n            configurable: true\n        });\n        /**\n         * If the reader is active, behaves the same as {@link ReadableStream.cancel | stream.cancel(reason)}.\n         */\n        ReadableStreamBYOBReader.prototype.cancel = function (reason) {\n            if (reason === void 0) { reason = undefined; }\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        /**\n         * Attempts to reads bytes into view, and returns a promise resolved with the result.\n         *\n         * If reading a chunk causes the queue to become empty, more data will be pulled from the underlying source.\n         */\n        ReadableStreamBYOBReader.prototype.read = function (view) {\n            if (!IsReadableStreamBYOBReader(this)) {\n                return promiseRejectedWith(byobReaderBrandCheckException('read'));\n            }\n            if (!ArrayBuffer.isView(view)) {\n                return promiseRejectedWith(new TypeError('view must be an array buffer view'));\n            }\n            if (view.byteLength === 0) {\n                return promiseRejectedWith(new TypeError('view must have non-zero byteLength'));\n            }\n            if (view.buffer.byteLength === 0) {\n                return promiseRejectedWith(new TypeError(\"view's buffer must have non-zero byteLength\"));\n            }\n            if (IsDetachedBuffer(view.buffer)) ;\n            if (this._ownerReadableStream === undefined) {\n                return promiseRejectedWith(readerLockException('read from'));\n            }\n            var resolvePromise;\n            var rejectPromise;\n            var promise = newPromise(function (resolve, reject) {\n                resolvePromise = resolve;\n                rejectPromise = reject;\n            });\n            var readIntoRequest = {\n                _chunkSteps: function (chunk) { return resolvePromise({ value: chunk, done: false }); },\n                _closeSteps: function (chunk) { return resolvePromise({ value: chunk, done: true }); },\n                _errorSteps: function (e) { return rejectPromise(e); }\n            };\n            ReadableStreamBYOBReaderRead(this, view, readIntoRequest);\n            return promise;\n        };\n        /**\n         * Releases the reader's lock on the corresponding stream. After the lock is released, the reader is no longer active.\n         * If the associated stream is errored when the lock is released, the reader will appear errored in the same way\n         * from now on; otherwise, the reader will appear closed.\n         *\n         * A reader's lock cannot be released while it still has a pending read request, i.e., if a promise returned by\n         * the reader's {@link ReadableStreamBYOBReader.read | read()} method has not yet been settled. Attempting to\n         * do so will throw a `TypeError` and leave the reader locked to the stream.\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    Object.defineProperties(ReadableStreamBYOBReader.prototype, {\n        cancel: { enumerable: true },\n        read: { enumerable: true },\n        releaseLock: { enumerable: true },\n        closed: { enumerable: true }\n    });\n    if (typeof SymbolPolyfill.toStringTag === 'symbol') {\n        Object.defineProperty(ReadableStreamBYOBReader.prototype, SymbolPolyfill.toStringTag, {\n            value: 'ReadableStreamBYOBReader',\n            configurable: true\n        });\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 x instanceof ReadableStreamBYOBReader;\n    }\n    function ReadableStreamBYOBReaderRead(reader, view, readIntoRequest) {\n        var stream = reader._ownerReadableStream;\n        stream._disturbed = true;\n        if (stream._state === 'errored') {\n            readIntoRequest._errorSteps(stream._storedError);\n        }\n        else {\n            ReadableByteStreamControllerPullInto(stream._readableStreamController, view, readIntoRequest);\n        }\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    function ExtractHighWaterMark(strategy, defaultHWM) {\n        var highWaterMark = strategy.highWaterMark;\n        if (highWaterMark === undefined) {\n            return defaultHWM;\n        }\n        if (NumberIsNaN(highWaterMark) || highWaterMark < 0) {\n            throw new RangeError('Invalid highWaterMark');\n        }\n        return highWaterMark;\n    }\n    function ExtractSizeAlgorithm(strategy) {\n        var size = strategy.size;\n        if (!size) {\n            return function () { return 1; };\n        }\n        return size;\n    }\n\n    function convertQueuingStrategy(init, context) {\n        assertDictionary(init, context);\n        var highWaterMark = init === null || init === void 0 ? void 0 : init.highWaterMark;\n        var size = init === null || init === void 0 ? void 0 : init.size;\n        return {\n            highWaterMark: highWaterMark === undefined ? undefined : convertUnrestrictedDouble(highWaterMark),\n            size: size === undefined ? undefined : convertQueuingStrategySize(size, context + \" has member 'size' that\")\n        };\n    }\n    function convertQueuingStrategySize(fn, context) {\n        assertFunction(fn, context);\n        return function (chunk) { return convertUnrestrictedDouble(fn(chunk)); };\n    }\n\n    function convertUnderlyingSink(original, context) {\n        assertDictionary(original, context);\n        var abort = original === null || original === void 0 ? void 0 : original.abort;\n        var close = original === null || original === void 0 ? void 0 : original.close;\n        var start = original === null || original === void 0 ? void 0 : original.start;\n        var type = original === null || original === void 0 ? void 0 : original.type;\n        var write = original === null || original === void 0 ? void 0 : original.write;\n        return {\n            abort: abort === undefined ?\n                undefined :\n                convertUnderlyingSinkAbortCallback(abort, original, context + \" has member 'abort' that\"),\n            close: close === undefined ?\n                undefined :\n                convertUnderlyingSinkCloseCallback(close, original, context + \" has member 'close' that\"),\n            start: start === undefined ?\n                undefined :\n                convertUnderlyingSinkStartCallback(start, original, context + \" has member 'start' that\"),\n            write: write === undefined ?\n                undefined :\n                convertUnderlyingSinkWriteCallback(write, original, context + \" has member 'write' that\"),\n            type: type\n        };\n    }\n    function convertUnderlyingSinkAbortCallback(fn, original, context) {\n        assertFunction(fn, context);\n        return function (reason) { return promiseCall(fn, original, [reason]); };\n    }\n    function convertUnderlyingSinkCloseCallback(fn, original, context) {\n        assertFunction(fn, context);\n        return function () { return promiseCall(fn, original, []); };\n    }\n    function convertUnderlyingSinkStartCallback(fn, original, context) {\n        assertFunction(fn, context);\n        return function (controller) { return reflectCall(fn, original, [controller]); };\n    }\n    function convertUnderlyingSinkWriteCallback(fn, original, context) {\n        assertFunction(fn, context);\n        return function (chunk, controller) { return promiseCall(fn, original, [chunk, controller]); };\n    }\n\n    function assertWritableStream(x, context) {\n        if (!IsWritableStream(x)) {\n            throw new TypeError(context + \" is not a WritableStream.\");\n        }\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    var supportsAbortController = typeof AbortController === 'function';\n    /**\n     * Construct a new AbortController, if supported by the platform.\n     *\n     * @internal\n     */\n    function createAbortController() {\n        if (supportsAbortController) {\n            return new AbortController();\n        }\n        return undefined;\n    }\n\n    /**\n     * A writable stream represents a destination for data, into which you can write.\n     *\n     * @public\n     */\n    var WritableStream = /** @class */ (function () {\n        function WritableStream(rawUnderlyingSink, rawStrategy) {\n            if (rawUnderlyingSink === void 0) { rawUnderlyingSink = {}; }\n            if (rawStrategy === void 0) { rawStrategy = {}; }\n            if (rawUnderlyingSink === undefined) {\n                rawUnderlyingSink = null;\n            }\n            else {\n                assertObject(rawUnderlyingSink, 'First parameter');\n            }\n            var strategy = convertQueuingStrategy(rawStrategy, 'Second parameter');\n            var underlyingSink = convertUnderlyingSink(rawUnderlyingSink, 'First parameter');\n            InitializeWritableStream(this);\n            var type = underlyingSink.type;\n            if (type !== undefined) {\n                throw new RangeError('Invalid type is specified');\n            }\n            var sizeAlgorithm = ExtractSizeAlgorithm(strategy);\n            var highWaterMark = ExtractHighWaterMark(strategy, 1);\n            SetUpWritableStreamDefaultControllerFromUnderlyingSink(this, underlyingSink, highWaterMark, sizeAlgorithm);\n        }\n        Object.defineProperty(WritableStream.prototype, \"locked\", {\n            /**\n             * Returns whether or not the writable stream is locked to a writer.\n             */\n            get: function () {\n                if (!IsWritableStream(this)) {\n                    throw streamBrandCheckException$2('locked');\n                }\n                return IsWritableStreamLocked(this);\n            },\n            enumerable: false,\n            configurable: true\n        });\n        /**\n         * Aborts the stream, signaling that the producer can no longer successfully write to the stream and it is to be\n         * immediately moved to an errored state, with any queued-up writes discarded. This will also execute any abort\n         * mechanism of the underlying sink.\n         *\n         * The returned promise will fulfill if the stream shuts down successfully, or reject if the underlying sink signaled\n         * that there was an error doing so. Additionally, it will reject with a `TypeError` (without attempting to cancel\n         * the stream) if the stream is currently locked.\n         */\n        WritableStream.prototype.abort = function (reason) {\n            if (reason === void 0) { reason = undefined; }\n            if (!IsWritableStream(this)) {\n                return promiseRejectedWith(streamBrandCheckException$2('abort'));\n            }\n            if (IsWritableStreamLocked(this)) {\n                return promiseRejectedWith(new TypeError('Cannot abort a stream that already has a writer'));\n            }\n            return WritableStreamAbort(this, reason);\n        };\n        /**\n         * Closes the stream. The underlying sink will finish processing any previously-written chunks, before invoking its\n         * close behavior. During this time any further attempts to write will fail (without erroring the stream).\n         *\n         * The method returns a promise that will fulfill if all remaining chunks are successfully written and the stream\n         * successfully closes, or rejects if an error is encountered during this process. Additionally, it will reject with\n         * a `TypeError` (without attempting to cancel the stream) if the stream is currently locked.\n         */\n        WritableStream.prototype.close = function () {\n            if (!IsWritableStream(this)) {\n                return promiseRejectedWith(streamBrandCheckException$2('close'));\n            }\n            if (IsWritableStreamLocked(this)) {\n                return promiseRejectedWith(new TypeError('Cannot close a stream that already has a writer'));\n            }\n            if (WritableStreamCloseQueuedOrInFlight(this)) {\n                return promiseRejectedWith(new TypeError('Cannot close an already-closing stream'));\n            }\n            return WritableStreamClose(this);\n        };\n        /**\n         * Creates a {@link WritableStreamDefaultWriter | writer} and locks the stream to the new writer. While the stream\n         * is locked, no other writer can be acquired until this one is released.\n         *\n         * This functionality is especially useful for creating abstractions that desire the ability to write to a stream\n         * without interruption or interleaving. By getting a writer for the stream, you can ensure nobody else can write at\n         * the same time, which would cause the resulting written data to be unpredictable and probably useless.\n         */\n        WritableStream.prototype.getWriter = function () {\n            if (!IsWritableStream(this)) {\n                throw streamBrandCheckException$2('getWriter');\n            }\n            return AcquireWritableStreamDefaultWriter(this);\n        };\n        return WritableStream;\n    }());\n    Object.defineProperties(WritableStream.prototype, {\n        abort: { enumerable: true },\n        close: { enumerable: true },\n        getWriter: { enumerable: true },\n        locked: { enumerable: true }\n    });\n    if (typeof SymbolPolyfill.toStringTag === 'symbol') {\n        Object.defineProperty(WritableStream.prototype, SymbolPolyfill.toStringTag, {\n            value: 'WritableStream',\n            configurable: true\n        });\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 x instanceof WritableStream;\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 _a;\n        if (stream._state === 'closed' || stream._state === 'errored') {\n            return promiseResolvedWith(undefined);\n        }\n        stream._writableStreamController._abortReason = reason;\n        (_a = stream._writableStreamController._abortController) === null || _a === void 0 ? void 0 : _a.abort();\n        // TypeScript narrows the type of `stream._state` down to 'writable' | 'erroring',\n        // but it doesn't know that signaling abort runs author code that might have changed the state.\n        // Widen the type again by casting to WritableStreamState.\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) {\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 && 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) && controller._started) {\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) {\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) {\n                defaultWriterReadyPromiseReset(writer);\n            }\n            else {\n                defaultWriterReadyPromiseResolve(writer);\n            }\n        }\n        stream._backpressure = backpressure;\n    }\n    /**\n     * A default writer vended by a {@link WritableStream}.\n     *\n     * @public\n     */\n    var WritableStreamDefaultWriter = /** @class */ (function () {\n        function WritableStreamDefaultWriter(stream) {\n            assertRequiredArgument(stream, 1, 'WritableStreamDefaultWriter');\n            assertWritableStream(stream, 'First parameter');\n            if (IsWritableStreamLocked(stream)) {\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) && stream._backpressure) {\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            /**\n             * Returns a promise that will be fulfilled when the stream becomes closed, or rejected if the stream ever errors or\n             * the writer’s lock is released before the stream finishes closing.\n             */\n            get: function () {\n                if (!IsWritableStreamDefaultWriter(this)) {\n                    return promiseRejectedWith(defaultWriterBrandCheckException('closed'));\n                }\n                return this._closedPromise;\n            },\n            enumerable: false,\n            configurable: true\n        });\n        Object.defineProperty(WritableStreamDefaultWriter.prototype, \"desiredSize\", {\n            /**\n             * Returns the desired size to fill the stream’s internal queue. It can be negative, if the queue is over-full.\n             * A producer can use this information to determine the right amount of data to write.\n             *\n             * It will be `null` if the stream cannot be successfully written to (due to either being errored, or having an abort\n             * queued up). It will return zero if the stream is closed. And the getter will throw an exception if invoked when\n             * the writer’s lock is released.\n             */\n            get: function () {\n                if (!IsWritableStreamDefaultWriter(this)) {\n                    throw defaultWriterBrandCheckException('desiredSize');\n                }\n                if (this._ownerWritableStream === undefined) {\n                    throw defaultWriterLockException('desiredSize');\n                }\n                return WritableStreamDefaultWriterGetDesiredSize(this);\n            },\n            enumerable: false,\n            configurable: true\n        });\n        Object.defineProperty(WritableStreamDefaultWriter.prototype, \"ready\", {\n            /**\n             * Returns a promise that will be fulfilled when the desired size to fill the stream’s internal queue transitions\n             * from non-positive to positive, signaling that it is no longer applying backpressure. Once the desired size dips\n             * back to zero or below, the getter will return a new promise that stays pending until the next transition.\n             *\n             * If the stream becomes errored or aborted, or the writer’s lock is released, the returned promise will become\n             * rejected.\n             */\n            get: function () {\n                if (!IsWritableStreamDefaultWriter(this)) {\n                    return promiseRejectedWith(defaultWriterBrandCheckException('ready'));\n                }\n                return this._readyPromise;\n            },\n            enumerable: false,\n            configurable: true\n        });\n        /**\n         * If the reader is active, behaves the same as {@link WritableStream.abort | stream.abort(reason)}.\n         */\n        WritableStreamDefaultWriter.prototype.abort = function (reason) {\n            if (reason === void 0) { reason = undefined; }\n            if (!IsWritableStreamDefaultWriter(this)) {\n                return promiseRejectedWith(defaultWriterBrandCheckException('abort'));\n            }\n            if (this._ownerWritableStream === undefined) {\n                return promiseRejectedWith(defaultWriterLockException('abort'));\n            }\n            return WritableStreamDefaultWriterAbort(this, reason);\n        };\n        /**\n         * If the reader is active, behaves the same as {@link WritableStream.close | stream.close()}.\n         */\n        WritableStreamDefaultWriter.prototype.close = function () {\n            if (!IsWritableStreamDefaultWriter(this)) {\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)) {\n                return promiseRejectedWith(new TypeError('Cannot close an already-closing stream'));\n            }\n            return WritableStreamDefaultWriterClose(this);\n        };\n        /**\n         * Releases the writer’s lock on the corresponding stream. After the lock is released, the writer is no longer active.\n         * If the associated stream is errored when the lock is released, the writer will appear errored in the same way from\n         * now on; otherwise, the writer will appear closed.\n         *\n         * Note that the lock can still be released even if some ongoing writes have not yet finished (i.e. even if the\n         * promises returned from previous calls to {@link WritableStreamDefaultWriter.write | write()} have not yet settled).\n         * It’s not necessary to hold the lock on the writer for the duration of the write; the lock instead simply prevents\n         * other producers from writing in an interleaved manner.\n         */\n        WritableStreamDefaultWriter.prototype.releaseLock = function () {\n            if (!IsWritableStreamDefaultWriter(this)) {\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 (chunk === void 0) { chunk = undefined; }\n            if (!IsWritableStreamDefaultWriter(this)) {\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    Object.defineProperties(WritableStreamDefaultWriter.prototype, {\n        abort: { enumerable: true },\n        close: { enumerable: true },\n        releaseLock: { enumerable: true },\n        write: { enumerable: true },\n        closed: { enumerable: true },\n        desiredSize: { enumerable: true },\n        ready: { enumerable: true }\n    });\n    if (typeof SymbolPolyfill.toStringTag === 'symbol') {\n        Object.defineProperty(WritableStreamDefaultWriter.prototype, SymbolPolyfill.toStringTag, {\n            value: 'WritableStreamDefaultWriter',\n            configurable: true\n        });\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 x instanceof WritableStreamDefaultWriter;\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) || 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) || 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 closeSentinel = {};\n    /**\n     * Allows control of a {@link WritableStream | writable stream}'s state and internal queue.\n     *\n     * @public\n     */\n    var WritableStreamDefaultController = /** @class */ (function () {\n        function WritableStreamDefaultController() {\n            throw new TypeError('Illegal constructor');\n        }\n        Object.defineProperty(WritableStreamDefaultController.prototype, \"abortReason\", {\n            /**\n             * The reason which was passed to `WritableStream.abort(reason)` when the stream was aborted.\n             *\n             * @deprecated\n             *  This property has been removed from the specification, see https://github.com/whatwg/streams/pull/1177.\n             *  Use {@link WritableStreamDefaultController.signal}'s `reason` instead.\n             */\n            get: function () {\n                if (!IsWritableStreamDefaultController(this)) {\n                    throw defaultControllerBrandCheckException$2('abortReason');\n                }\n                return this._abortReason;\n            },\n            enumerable: false,\n            configurable: true\n        });\n        Object.defineProperty(WritableStreamDefaultController.prototype, \"signal\", {\n            /**\n             * An `AbortSignal` that can be used to abort the pending write or close operation when the stream is aborted.\n             */\n            get: function () {\n                if (!IsWritableStreamDefaultController(this)) {\n                    throw defaultControllerBrandCheckException$2('signal');\n                }\n                if (this._abortController === undefined) {\n                    // Older browsers or older Node versions may not support `AbortController` or `AbortSignal`.\n                    // We don't want to bundle and ship an `AbortController` polyfill together with our polyfill,\n                    // so instead we only implement support for `signal` if we find a global `AbortController` constructor.\n                    throw new TypeError('WritableStreamDefaultController.prototype.signal is not supported');\n                }\n                return this._abortController.signal;\n            },\n            enumerable: false,\n            configurable: true\n        });\n        /**\n         * Closes the controlled writable stream, making all future interactions with it fail with the given error `e`.\n         *\n         * This method is rarely used, since usually it suffices to return a rejected promise from one of the underlying\n         * sink's methods. However, it can be useful for suddenly shutting down a stream in response to an event outside the\n         * normal lifecycle of interactions with the underlying sink.\n         */\n        WritableStreamDefaultController.prototype.error = function (e) {\n            if (e === void 0) { e = undefined; }\n            if (!IsWritableStreamDefaultController(this)) {\n                throw defaultControllerBrandCheckException$2('error');\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    Object.defineProperties(WritableStreamDefaultController.prototype, {\n        abortReason: { enumerable: true },\n        signal: { enumerable: true },\n        error: { enumerable: true }\n    });\n    if (typeof SymbolPolyfill.toStringTag === 'symbol') {\n        Object.defineProperty(WritableStreamDefaultController.prototype, SymbolPolyfill.toStringTag, {\n            value: 'WritableStreamDefaultController',\n            configurable: true\n        });\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 x instanceof WritableStreamDefaultController;\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._abortReason = undefined;\n        controller._abortController = createAbortController();\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        var startAlgorithm = function () { return undefined; };\n        var writeAlgorithm = function () { return promiseResolvedWith(undefined); };\n        var closeAlgorithm = function () { return promiseResolvedWith(undefined); };\n        var abortAlgorithm = function () { return promiseResolvedWith(undefined); };\n        if (underlyingSink.start !== undefined) {\n            startAlgorithm = function () { return underlyingSink.start(controller); };\n        }\n        if (underlyingSink.write !== undefined) {\n            writeAlgorithm = function (chunk) { return underlyingSink.write(chunk, controller); };\n        }\n        if (underlyingSink.close !== undefined) {\n            closeAlgorithm = function () { return underlyingSink.close(); };\n        }\n        if (underlyingSink.abort !== undefined) {\n            abortAlgorithm = function (reason) { return underlyingSink.abort(reason); };\n        }\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, closeSentinel, 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        try {\n            EnqueueValueWithSize(controller, chunk, chunkSize);\n        }\n        catch (enqueueE) {\n            WritableStreamDefaultControllerErrorIfNeeded(controller, enqueueE);\n            return;\n        }\n        var stream = controller._controlledWritableStream;\n        if (!WritableStreamCloseQueuedOrInFlight(stream) && 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) {\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 value = PeekQueueValue(controller);\n        if (value === closeSentinel) {\n            WritableStreamDefaultControllerProcessClose(controller);\n        }\n        else {\n            WritableStreamDefaultControllerProcessWrite(controller, value);\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) && 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$2(name) {\n        return new TypeError(\"WritableStream.prototype.\" + name + \" can only be used on a WritableStream\");\n    }\n    // Helper functions for the WritableStreamDefaultController.\n    function defaultControllerBrandCheckException$2(name) {\n        return new TypeError(\"WritableStreamDefaultController.prototype.\" + name + \" can only be used on a WritableStreamDefaultController\");\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        if (writer._closedPromise_reject === undefined) {\n            return;\n        }\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        if (writer._closedPromise_resolve === undefined) {\n            return;\n        }\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        if (writer._readyPromise_reject === undefined) {\n            return;\n        }\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        if (writer._readyPromise_resolve === undefined) {\n            return;\n        }\n        writer._readyPromise_resolve(undefined);\n        writer._readyPromise_resolve = undefined;\n        writer._readyPromise_reject = undefined;\n        writer._readyPromiseState = 'fulfilled';\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        // eslint-disable-next-line no-shadow\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    // eslint-disable-next-line no-redeclare\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) {\n                        actions.push(function () {\n                            if (dest._state === 'writable') {\n                                return WritableStreamAbort(dest, error);\n                            }\n                            return promiseResolvedWith(undefined);\n                        });\n                    }\n                    if (!preventCancel) {\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) {\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) {\n                    return promiseResolvedWith(true);\n                }\n                return PerformPromiseThen(writer._readyPromise, function () {\n                    return newPromise(function (resolveRead, rejectRead) {\n                        ReadableStreamDefaultReaderRead(reader, {\n                            _chunkSteps: function (chunk) {\n                                currentWrite = PerformPromiseThen(WritableStreamDefaultWriterWrite(writer, chunk), undefined, noop);\n                                resolveRead(false);\n                            },\n                            _closeSteps: function () { return resolveRead(true); },\n                            _errorSteps: rejectRead\n                        });\n                    });\n                });\n            }\n            // Errors must be propagated forward\n            isOrBecomesErrored(source, reader._closedPromise, function (storedError) {\n                if (!preventAbort) {\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) {\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) {\n                    shutdownWithAction(function () { return WritableStreamDefaultWriterCloseWithErrorPropagation(writer); });\n                }\n                else {\n                    shutdown();\n                }\n            });\n            // Closing must be propagated backward\n            if (WritableStreamCloseQueuedOrInFlight(dest) || 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) {\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) {\n                    return;\n                }\n                shuttingDown = true;\n                if (dest._state === 'writable' && !WritableStreamCloseQueuedOrInFlight(dest)) {\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) {\n                    return;\n                }\n                shuttingDown = true;\n                if (dest._state === 'writable' && !WritableStreamCloseQueuedOrInFlight(dest)) {\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    /**\n     * Allows control of a {@link ReadableStream | readable stream}'s state and internal queue.\n     *\n     * @public\n     */\n    var ReadableStreamDefaultController = /** @class */ (function () {\n        function ReadableStreamDefaultController() {\n            throw new TypeError('Illegal constructor');\n        }\n        Object.defineProperty(ReadableStreamDefaultController.prototype, \"desiredSize\", {\n            /**\n             * Returns the desired size to fill the controlled stream's internal queue. It can be negative, if the queue is\n             * over-full. An underlying source ought to use this information to determine when and how to apply backpressure.\n             */\n            get: function () {\n                if (!IsReadableStreamDefaultController(this)) {\n                    throw defaultControllerBrandCheckException$1('desiredSize');\n                }\n                return ReadableStreamDefaultControllerGetDesiredSize(this);\n            },\n            enumerable: false,\n            configurable: true\n        });\n        /**\n         * Closes the controlled readable stream. Consumers will still be able to read any previously-enqueued chunks from\n         * the stream, but once those are read, the stream will become closed.\n         */\n        ReadableStreamDefaultController.prototype.close = function () {\n            if (!IsReadableStreamDefaultController(this)) {\n                throw defaultControllerBrandCheckException$1('close');\n            }\n            if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(this)) {\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 (chunk === void 0) { chunk = undefined; }\n            if (!IsReadableStreamDefaultController(this)) {\n                throw defaultControllerBrandCheckException$1('enqueue');\n            }\n            if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(this)) {\n                throw new TypeError('The stream is not in a state that permits enqueue');\n            }\n            return ReadableStreamDefaultControllerEnqueue(this, chunk);\n        };\n        /**\n         * Errors the controlled readable stream, making all future interactions with it fail with the given error `e`.\n         */\n        ReadableStreamDefaultController.prototype.error = function (e) {\n            if (e === void 0) { e = undefined; }\n            if (!IsReadableStreamDefaultController(this)) {\n                throw defaultControllerBrandCheckException$1('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 (readRequest) {\n            var stream = this._controlledReadableStream;\n            if (this._queue.length > 0) {\n                var chunk = DequeueValue(this);\n                if (this._closeRequested && this._queue.length === 0) {\n                    ReadableStreamDefaultControllerClearAlgorithms(this);\n                    ReadableStreamClose(stream);\n                }\n                else {\n                    ReadableStreamDefaultControllerCallPullIfNeeded(this);\n                }\n                readRequest._chunkSteps(chunk);\n            }\n            else {\n                ReadableStreamAddReadRequest(stream, readRequest);\n                ReadableStreamDefaultControllerCallPullIfNeeded(this);\n            }\n        };\n        return ReadableStreamDefaultController;\n    }());\n    Object.defineProperties(ReadableStreamDefaultController.prototype, {\n        close: { enumerable: true },\n        enqueue: { enumerable: true },\n        error: { enumerable: true },\n        desiredSize: { enumerable: true }\n    });\n    if (typeof SymbolPolyfill.toStringTag === 'symbol') {\n        Object.defineProperty(ReadableStreamDefaultController.prototype, SymbolPolyfill.toStringTag, {\n            value: 'ReadableStreamDefaultController',\n            configurable: true\n        });\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 x instanceof ReadableStreamDefaultController;\n    }\n    function ReadableStreamDefaultControllerCallPullIfNeeded(controller) {\n        var shouldPull = ReadableStreamDefaultControllerShouldCallPull(controller);\n        if (!shouldPull) {\n            return;\n        }\n        if (controller._pulling) {\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) {\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)) {\n            return false;\n        }\n        if (!controller._started) {\n            return false;\n        }\n        if (IsReadableStreamLocked(stream) && 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        if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(controller)) {\n            return;\n        }\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        if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(controller)) {\n            return;\n        }\n        var stream = controller._controlledReadableStream;\n        if (IsReadableStreamLocked(stream) && 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 state = controller._controlledReadableStream._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)) {\n            return false;\n        }\n        return true;\n    }\n    function ReadableStreamDefaultControllerCanCloseOrEnqueue(controller) {\n        var state = controller._controlledReadableStream._state;\n        if (!controller._closeRequested && 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        var startAlgorithm = function () { return undefined; };\n        var pullAlgorithm = function () { return promiseResolvedWith(undefined); };\n        var cancelAlgorithm = function () { return promiseResolvedWith(undefined); };\n        if (underlyingSource.start !== undefined) {\n            startAlgorithm = function () { return underlyingSource.start(controller); };\n        }\n        if (underlyingSource.pull !== undefined) {\n            pullAlgorithm = function () { return underlyingSource.pull(controller); };\n        }\n        if (underlyingSource.cancel !== undefined) {\n            cancelAlgorithm = function (reason) { return underlyingSource.cancel(reason); };\n        }\n        SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm);\n    }\n    // Helper functions for the ReadableStreamDefaultController.\n    function defaultControllerBrandCheckException$1(name) {\n        return new TypeError(\"ReadableStreamDefaultController.prototype.\" + name + \" can only be used on a ReadableStreamDefaultController\");\n    }\n\n    function ReadableStreamTee(stream, cloneForBranch2) {\n        if (IsReadableByteStreamController(stream._readableStreamController)) {\n            return ReadableByteStreamTee(stream);\n        }\n        return ReadableStreamDefaultTee(stream);\n    }\n    function ReadableStreamDefaultTee(stream, cloneForBranch2) {\n        var reader = AcquireReadableStreamDefaultReader(stream);\n        var reading = false;\n        var readAgain = 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) {\n                readAgain = true;\n                return promiseResolvedWith(undefined);\n            }\n            reading = true;\n            var readRequest = {\n                _chunkSteps: function (chunk) {\n                    // This needs to be delayed a microtask because it takes at least a microtask to detect errors (using\n                    // reader._closedPromise below), and we want errors in stream to error both branches immediately. We cannot let\n                    // successful synchronously-available reads get ahead of asynchronously-available errors.\n                    queueMicrotask(function () {\n                        readAgain = false;\n                        var chunk1 = chunk;\n                        var chunk2 = chunk;\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 && cloneForBranch2) {\n                        //   chunk2 = StructuredDeserialize(StructuredSerialize(chunk2));\n                        // }\n                        if (!canceled1) {\n                            ReadableStreamDefaultControllerEnqueue(branch1._readableStreamController, chunk1);\n                        }\n                        if (!canceled2) {\n                            ReadableStreamDefaultControllerEnqueue(branch2._readableStreamController, chunk2);\n                        }\n                        reading = false;\n                        if (readAgain) {\n                            pullAlgorithm();\n                        }\n                    });\n                },\n                _closeSteps: function () {\n                    reading = false;\n                    if (!canceled1) {\n                        ReadableStreamDefaultControllerClose(branch1._readableStreamController);\n                    }\n                    if (!canceled2) {\n                        ReadableStreamDefaultControllerClose(branch2._readableStreamController);\n                    }\n                    if (!canceled1 || !canceled2) {\n                        resolveCancelPromise(undefined);\n                    }\n                },\n                _errorSteps: function () {\n                    reading = false;\n                }\n            };\n            ReadableStreamDefaultReaderRead(reader, readRequest);\n            return promiseResolvedWith(undefined);\n        }\n        function cancel1Algorithm(reason) {\n            canceled1 = true;\n            reason1 = reason;\n            if (canceled2) {\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) {\n                var compositeReason = CreateArrayFromList([reason1, reason2]);\n                var cancelResult = ReadableStreamCancel(stream, compositeReason);\n                resolveCancelPromise(cancelResult);\n            }\n            return cancelPromise;\n        }\n        function startAlgorithm() {\n            // do nothing\n        }\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            if (!canceled1 || !canceled2) {\n                resolveCancelPromise(undefined);\n            }\n        });\n        return [branch1, branch2];\n    }\n    function ReadableByteStreamTee(stream) {\n        var reader = AcquireReadableStreamDefaultReader(stream);\n        var reading = false;\n        var readAgainForBranch1 = false;\n        var readAgainForBranch2 = 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 forwardReaderError(thisReader) {\n            uponRejection(thisReader._closedPromise, function (r) {\n                if (thisReader !== reader) {\n                    return;\n                }\n                ReadableByteStreamControllerError(branch1._readableStreamController, r);\n                ReadableByteStreamControllerError(branch2._readableStreamController, r);\n                if (!canceled1 || !canceled2) {\n                    resolveCancelPromise(undefined);\n                }\n            });\n        }\n        function pullWithDefaultReader() {\n            if (IsReadableStreamBYOBReader(reader)) {\n                ReadableStreamReaderGenericRelease(reader);\n                reader = AcquireReadableStreamDefaultReader(stream);\n                forwardReaderError(reader);\n            }\n            var readRequest = {\n                _chunkSteps: function (chunk) {\n                    // This needs to be delayed a microtask because it takes at least a microtask to detect errors (using\n                    // reader._closedPromise below), and we want errors in stream to error both branches immediately. We cannot let\n                    // successful synchronously-available reads get ahead of asynchronously-available errors.\n                    queueMicrotask(function () {\n                        readAgainForBranch1 = false;\n                        readAgainForBranch2 = false;\n                        var chunk1 = chunk;\n                        var chunk2 = chunk;\n                        if (!canceled1 && !canceled2) {\n                            try {\n                                chunk2 = CloneAsUint8Array(chunk);\n                            }\n                            catch (cloneE) {\n                                ReadableByteStreamControllerError(branch1._readableStreamController, cloneE);\n                                ReadableByteStreamControllerError(branch2._readableStreamController, cloneE);\n                                resolveCancelPromise(ReadableStreamCancel(stream, cloneE));\n                                return;\n                            }\n                        }\n                        if (!canceled1) {\n                            ReadableByteStreamControllerEnqueue(branch1._readableStreamController, chunk1);\n                        }\n                        if (!canceled2) {\n                            ReadableByteStreamControllerEnqueue(branch2._readableStreamController, chunk2);\n                        }\n                        reading = false;\n                        if (readAgainForBranch1) {\n                            pull1Algorithm();\n                        }\n                        else if (readAgainForBranch2) {\n                            pull2Algorithm();\n                        }\n                    });\n                },\n                _closeSteps: function () {\n                    reading = false;\n                    if (!canceled1) {\n                        ReadableByteStreamControllerClose(branch1._readableStreamController);\n                    }\n                    if (!canceled2) {\n                        ReadableByteStreamControllerClose(branch2._readableStreamController);\n                    }\n                    if (branch1._readableStreamController._pendingPullIntos.length > 0) {\n                        ReadableByteStreamControllerRespond(branch1._readableStreamController, 0);\n                    }\n                    if (branch2._readableStreamController._pendingPullIntos.length > 0) {\n                        ReadableByteStreamControllerRespond(branch2._readableStreamController, 0);\n                    }\n                    if (!canceled1 || !canceled2) {\n                        resolveCancelPromise(undefined);\n                    }\n                },\n                _errorSteps: function () {\n                    reading = false;\n                }\n            };\n            ReadableStreamDefaultReaderRead(reader, readRequest);\n        }\n        function pullWithBYOBReader(view, forBranch2) {\n            if (IsReadableStreamDefaultReader(reader)) {\n                ReadableStreamReaderGenericRelease(reader);\n                reader = AcquireReadableStreamBYOBReader(stream);\n                forwardReaderError(reader);\n            }\n            var byobBranch = forBranch2 ? branch2 : branch1;\n            var otherBranch = forBranch2 ? branch1 : branch2;\n            var readIntoRequest = {\n                _chunkSteps: function (chunk) {\n                    // This needs to be delayed a microtask because it takes at least a microtask to detect errors (using\n                    // reader._closedPromise below), and we want errors in stream to error both branches immediately. We cannot let\n                    // successful synchronously-available reads get ahead of asynchronously-available errors.\n                    queueMicrotask(function () {\n                        readAgainForBranch1 = false;\n                        readAgainForBranch2 = false;\n                        var byobCanceled = forBranch2 ? canceled2 : canceled1;\n                        var otherCanceled = forBranch2 ? canceled1 : canceled2;\n                        if (!otherCanceled) {\n                            var clonedChunk = void 0;\n                            try {\n                                clonedChunk = CloneAsUint8Array(chunk);\n                            }\n                            catch (cloneE) {\n                                ReadableByteStreamControllerError(byobBranch._readableStreamController, cloneE);\n                                ReadableByteStreamControllerError(otherBranch._readableStreamController, cloneE);\n                                resolveCancelPromise(ReadableStreamCancel(stream, cloneE));\n                                return;\n                            }\n                            if (!byobCanceled) {\n                                ReadableByteStreamControllerRespondWithNewView(byobBranch._readableStreamController, chunk);\n                            }\n                            ReadableByteStreamControllerEnqueue(otherBranch._readableStreamController, clonedChunk);\n                        }\n                        else if (!byobCanceled) {\n                            ReadableByteStreamControllerRespondWithNewView(byobBranch._readableStreamController, chunk);\n                        }\n                        reading = false;\n                        if (readAgainForBranch1) {\n                            pull1Algorithm();\n                        }\n                        else if (readAgainForBranch2) {\n                            pull2Algorithm();\n                        }\n                    });\n                },\n                _closeSteps: function (chunk) {\n                    reading = false;\n                    var byobCanceled = forBranch2 ? canceled2 : canceled1;\n                    var otherCanceled = forBranch2 ? canceled1 : canceled2;\n                    if (!byobCanceled) {\n                        ReadableByteStreamControllerClose(byobBranch._readableStreamController);\n                    }\n                    if (!otherCanceled) {\n                        ReadableByteStreamControllerClose(otherBranch._readableStreamController);\n                    }\n                    if (chunk !== undefined) {\n                        if (!byobCanceled) {\n                            ReadableByteStreamControllerRespondWithNewView(byobBranch._readableStreamController, chunk);\n                        }\n                        if (!otherCanceled && otherBranch._readableStreamController._pendingPullIntos.length > 0) {\n                            ReadableByteStreamControllerRespond(otherBranch._readableStreamController, 0);\n                        }\n                    }\n                    if (!byobCanceled || !otherCanceled) {\n                        resolveCancelPromise(undefined);\n                    }\n                },\n                _errorSteps: function () {\n                    reading = false;\n                }\n            };\n            ReadableStreamBYOBReaderRead(reader, view, readIntoRequest);\n        }\n        function pull1Algorithm() {\n            if (reading) {\n                readAgainForBranch1 = true;\n                return promiseResolvedWith(undefined);\n            }\n            reading = true;\n            var byobRequest = ReadableByteStreamControllerGetBYOBRequest(branch1._readableStreamController);\n            if (byobRequest === null) {\n                pullWithDefaultReader();\n            }\n            else {\n                pullWithBYOBReader(byobRequest._view, false);\n            }\n            return promiseResolvedWith(undefined);\n        }\n        function pull2Algorithm() {\n            if (reading) {\n                readAgainForBranch2 = true;\n                return promiseResolvedWith(undefined);\n            }\n            reading = true;\n            var byobRequest = ReadableByteStreamControllerGetBYOBRequest(branch2._readableStreamController);\n            if (byobRequest === null) {\n                pullWithDefaultReader();\n            }\n            else {\n                pullWithBYOBReader(byobRequest._view, true);\n            }\n            return promiseResolvedWith(undefined);\n        }\n        function cancel1Algorithm(reason) {\n            canceled1 = true;\n            reason1 = reason;\n            if (canceled2) {\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) {\n                var compositeReason = CreateArrayFromList([reason1, reason2]);\n                var cancelResult = ReadableStreamCancel(stream, compositeReason);\n                resolveCancelPromise(cancelResult);\n            }\n            return cancelPromise;\n        }\n        function startAlgorithm() {\n            return;\n        }\n        branch1 = CreateReadableByteStream(startAlgorithm, pull1Algorithm, cancel1Algorithm);\n        branch2 = CreateReadableByteStream(startAlgorithm, pull2Algorithm, cancel2Algorithm);\n        forwardReaderError(reader);\n        return [branch1, branch2];\n    }\n\n    function convertUnderlyingDefaultOrByteSource(source, context) {\n        assertDictionary(source, context);\n        var original = source;\n        var autoAllocateChunkSize = original === null || original === void 0 ? void 0 : original.autoAllocateChunkSize;\n        var cancel = original === null || original === void 0 ? void 0 : original.cancel;\n        var pull = original === null || original === void 0 ? void 0 : original.pull;\n        var start = original === null || original === void 0 ? void 0 : original.start;\n        var type = original === null || original === void 0 ? void 0 : original.type;\n        return {\n            autoAllocateChunkSize: autoAllocateChunkSize === undefined ?\n                undefined :\n                convertUnsignedLongLongWithEnforceRange(autoAllocateChunkSize, context + \" has member 'autoAllocateChunkSize' that\"),\n            cancel: cancel === undefined ?\n                undefined :\n                convertUnderlyingSourceCancelCallback(cancel, original, context + \" has member 'cancel' that\"),\n            pull: pull === undefined ?\n                undefined :\n                convertUnderlyingSourcePullCallback(pull, original, context + \" has member 'pull' that\"),\n            start: start === undefined ?\n                undefined :\n                convertUnderlyingSourceStartCallback(start, original, context + \" has member 'start' that\"),\n            type: type === undefined ? undefined : convertReadableStreamType(type, context + \" has member 'type' that\")\n        };\n    }\n    function convertUnderlyingSourceCancelCallback(fn, original, context) {\n        assertFunction(fn, context);\n        return function (reason) { return promiseCall(fn, original, [reason]); };\n    }\n    function convertUnderlyingSourcePullCallback(fn, original, context) {\n        assertFunction(fn, context);\n        return function (controller) { return promiseCall(fn, original, [controller]); };\n    }\n    function convertUnderlyingSourceStartCallback(fn, original, context) {\n        assertFunction(fn, context);\n        return function (controller) { return reflectCall(fn, original, [controller]); };\n    }\n    function convertReadableStreamType(type, context) {\n        type = \"\" + type;\n        if (type !== 'bytes') {\n            throw new TypeError(context + \" '\" + type + \"' is not a valid enumeration value for ReadableStreamType\");\n        }\n        return type;\n    }\n\n    function convertReaderOptions(options, context) {\n        assertDictionary(options, context);\n        var mode = options === null || options === void 0 ? void 0 : options.mode;\n        return {\n            mode: mode === undefined ? undefined : convertReadableStreamReaderMode(mode, context + \" has member 'mode' that\")\n        };\n    }\n    function convertReadableStreamReaderMode(mode, context) {\n        mode = \"\" + mode;\n        if (mode !== 'byob') {\n            throw new TypeError(context + \" '\" + mode + \"' is not a valid enumeration value for ReadableStreamReaderMode\");\n        }\n        return mode;\n    }\n\n    function convertIteratorOptions(options, context) {\n        assertDictionary(options, context);\n        var preventCancel = options === null || options === void 0 ? void 0 : options.preventCancel;\n        return { preventCancel: Boolean(preventCancel) };\n    }\n\n    function convertPipeOptions(options, context) {\n        assertDictionary(options, context);\n        var preventAbort = options === null || options === void 0 ? void 0 : options.preventAbort;\n        var preventCancel = options === null || options === void 0 ? void 0 : options.preventCancel;\n        var preventClose = options === null || options === void 0 ? void 0 : options.preventClose;\n        var signal = options === null || options === void 0 ? void 0 : options.signal;\n        if (signal !== undefined) {\n            assertAbortSignal(signal, context + \" has member 'signal' that\");\n        }\n        return {\n            preventAbort: Boolean(preventAbort),\n            preventCancel: Boolean(preventCancel),\n            preventClose: Boolean(preventClose),\n            signal: signal\n        };\n    }\n    function assertAbortSignal(signal, context) {\n        if (!isAbortSignal(signal)) {\n            throw new TypeError(context + \" is not an AbortSignal.\");\n        }\n    }\n\n    function convertReadableWritablePair(pair, context) {\n        assertDictionary(pair, context);\n        var readable = pair === null || pair === void 0 ? void 0 : pair.readable;\n        assertRequiredField(readable, 'readable', 'ReadableWritablePair');\n        assertReadableStream(readable, context + \" has member 'readable' that\");\n        var writable = pair === null || pair === void 0 ? void 0 : pair.writable;\n        assertRequiredField(writable, 'writable', 'ReadableWritablePair');\n        assertWritableStream(writable, context + \" has member 'writable' that\");\n        return { readable: readable, writable: writable };\n    }\n\n    /**\n     * A readable stream represents a source of data, from which you can read.\n     *\n     * @public\n     */\n    var ReadableStream = /** @class */ (function () {\n        function ReadableStream(rawUnderlyingSource, rawStrategy) {\n            if (rawUnderlyingSource === void 0) { rawUnderlyingSource = {}; }\n            if (rawStrategy === void 0) { rawStrategy = {}; }\n            if (rawUnderlyingSource === undefined) {\n                rawUnderlyingSource = null;\n            }\n            else {\n                assertObject(rawUnderlyingSource, 'First parameter');\n            }\n            var strategy = convertQueuingStrategy(rawStrategy, 'Second parameter');\n            var underlyingSource = convertUnderlyingDefaultOrByteSource(rawUnderlyingSource, 'First parameter');\n            InitializeReadableStream(this);\n            if (underlyingSource.type === 'bytes') {\n                if (strategy.size !== undefined) {\n                    throw new RangeError('The strategy for a byte stream cannot have a size function');\n                }\n                var highWaterMark = ExtractHighWaterMark(strategy, 0);\n                SetUpReadableByteStreamControllerFromUnderlyingSource(this, underlyingSource, highWaterMark);\n            }\n            else {\n                var sizeAlgorithm = ExtractSizeAlgorithm(strategy);\n                var highWaterMark = ExtractHighWaterMark(strategy, 1);\n                SetUpReadableStreamDefaultControllerFromUnderlyingSource(this, underlyingSource, highWaterMark, sizeAlgorithm);\n            }\n        }\n        Object.defineProperty(ReadableStream.prototype, \"locked\", {\n            /**\n             * Whether or not the readable stream is locked to a {@link ReadableStreamDefaultReader | reader}.\n             */\n            get: function () {\n                if (!IsReadableStream(this)) {\n                    throw streamBrandCheckException$1('locked');\n                }\n                return IsReadableStreamLocked(this);\n            },\n            enumerable: false,\n            configurable: true\n        });\n        /**\n         * Cancels the stream, signaling a loss of interest in the stream by a consumer.\n         *\n         * The supplied `reason` argument will be given to the underlying source's {@link UnderlyingSource.cancel | cancel()}\n         * method, which might or might not use it.\n         */\n        ReadableStream.prototype.cancel = function (reason) {\n            if (reason === void 0) { reason = undefined; }\n            if (!IsReadableStream(this)) {\n                return promiseRejectedWith(streamBrandCheckException$1('cancel'));\n            }\n            if (IsReadableStreamLocked(this)) {\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 (rawOptions) {\n            if (rawOptions === void 0) { rawOptions = undefined; }\n            if (!IsReadableStream(this)) {\n                throw streamBrandCheckException$1('getReader');\n            }\n            var options = convertReaderOptions(rawOptions, 'First parameter');\n            if (options.mode === undefined) {\n                return AcquireReadableStreamDefaultReader(this);\n            }\n            return AcquireReadableStreamBYOBReader(this);\n        };\n        ReadableStream.prototype.pipeThrough = function (rawTransform, rawOptions) {\n            if (rawOptions === void 0) { rawOptions = {}; }\n            if (!IsReadableStream(this)) {\n                throw streamBrandCheckException$1('pipeThrough');\n            }\n            assertRequiredArgument(rawTransform, 1, 'pipeThrough');\n            var transform = convertReadableWritablePair(rawTransform, 'First parameter');\n            var options = convertPipeOptions(rawOptions, 'Second parameter');\n            if (IsReadableStreamLocked(this)) {\n                throw new TypeError('ReadableStream.prototype.pipeThrough cannot be used on a locked ReadableStream');\n            }\n            if (IsWritableStreamLocked(transform.writable)) {\n                throw new TypeError('ReadableStream.prototype.pipeThrough cannot be used on a locked WritableStream');\n            }\n            var promise = ReadableStreamPipeTo(this, transform.writable, options.preventClose, options.preventAbort, options.preventCancel, options.signal);\n            setPromiseIsHandledToTrue(promise);\n            return transform.readable;\n        };\n        ReadableStream.prototype.pipeTo = function (destination, rawOptions) {\n            if (rawOptions === void 0) { rawOptions = {}; }\n            if (!IsReadableStream(this)) {\n                return promiseRejectedWith(streamBrandCheckException$1('pipeTo'));\n            }\n            if (destination === undefined) {\n                return promiseRejectedWith(\"Parameter 1 is required in 'pipeTo'.\");\n            }\n            if (!IsWritableStream(destination)) {\n                return promiseRejectedWith(new TypeError(\"ReadableStream.prototype.pipeTo's first argument must be a WritableStream\"));\n            }\n            var options;\n            try {\n                options = convertPipeOptions(rawOptions, 'Second parameter');\n            }\n            catch (e) {\n                return promiseRejectedWith(e);\n            }\n            if (IsReadableStreamLocked(this)) {\n                return promiseRejectedWith(new TypeError('ReadableStream.prototype.pipeTo cannot be used on a locked ReadableStream'));\n            }\n            if (IsWritableStreamLocked(destination)) {\n                return promiseRejectedWith(new TypeError('ReadableStream.prototype.pipeTo cannot be used on a locked WritableStream'));\n            }\n            return ReadableStreamPipeTo(this, destination, options.preventClose, options.preventAbort, options.preventCancel, options.signal);\n        };\n        /**\n         * Tees this readable stream, returning a two-element array containing the two resulting branches as\n         * new {@link ReadableStream} instances.\n         *\n         * Teeing a stream will lock it, preventing any other consumer from acquiring a reader.\n         * To cancel the stream, cancel both of the resulting branches; a composite cancellation reason will then be\n         * propagated to the stream's underlying source.\n         *\n         * Note that the chunks seen in each branch will be the same object. If the chunks are not immutable,\n         * this could allow interference between the two branches.\n         */\n        ReadableStream.prototype.tee = function () {\n            if (!IsReadableStream(this)) {\n                throw streamBrandCheckException$1('tee');\n            }\n            var branches = ReadableStreamTee(this);\n            return CreateArrayFromList(branches);\n        };\n        ReadableStream.prototype.values = function (rawOptions) {\n            if (rawOptions === void 0) { rawOptions = undefined; }\n            if (!IsReadableStream(this)) {\n                throw streamBrandCheckException$1('values');\n            }\n            var options = convertIteratorOptions(rawOptions, 'First parameter');\n            return AcquireReadableStreamAsyncIterator(this, options.preventCancel);\n        };\n        return ReadableStream;\n    }());\n    Object.defineProperties(ReadableStream.prototype, {\n        cancel: { enumerable: true },\n        getReader: { enumerable: true },\n        pipeThrough: { enumerable: true },\n        pipeTo: { enumerable: true },\n        tee: { enumerable: true },\n        values: { enumerable: true },\n        locked: { enumerable: true }\n    });\n    if (typeof SymbolPolyfill.toStringTag === 'symbol') {\n        Object.defineProperty(ReadableStream.prototype, SymbolPolyfill.toStringTag, {\n            value: 'ReadableStream',\n            configurable: true\n        });\n    }\n    if (typeof SymbolPolyfill.asyncIterator === 'symbol') {\n        Object.defineProperty(ReadableStream.prototype, SymbolPolyfill.asyncIterator, {\n            value: ReadableStream.prototype.values,\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    // Throws if and only if startAlgorithm throws.\n    function CreateReadableByteStream(startAlgorithm, pullAlgorithm, cancelAlgorithm) {\n        var stream = Object.create(ReadableStream.prototype);\n        InitializeReadableStream(stream);\n        var controller = Object.create(ReadableByteStreamController.prototype);\n        SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, 0, undefined);\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 x instanceof ReadableStream;\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 reader = stream._reader;\n        if (reader !== undefined && IsReadableStreamBYOBReader(reader)) {\n            reader._readIntoRequests.forEach(function (readIntoRequest) {\n                readIntoRequest._closeSteps(undefined);\n            });\n            reader._readIntoRequests = new SimpleQueue();\n        }\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        defaultReaderClosedPromiseResolve(reader);\n        if (IsReadableStreamDefaultReader(reader)) {\n            reader._readRequests.forEach(function (readRequest) {\n                readRequest._closeSteps();\n            });\n            reader._readRequests = new SimpleQueue();\n        }\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        defaultReaderClosedPromiseReject(reader, e);\n        if (IsReadableStreamDefaultReader(reader)) {\n            reader._readRequests.forEach(function (readRequest) {\n                readRequest._errorSteps(e);\n            });\n            reader._readRequests = new SimpleQueue();\n        }\n        else {\n            reader._readIntoRequests.forEach(function (readIntoRequest) {\n                readIntoRequest._errorSteps(e);\n            });\n            reader._readIntoRequests = new SimpleQueue();\n        }\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    function convertQueuingStrategyInit(init, context) {\n        assertDictionary(init, context);\n        var highWaterMark = init === null || init === void 0 ? void 0 : init.highWaterMark;\n        assertRequiredField(highWaterMark, 'highWaterMark', 'QueuingStrategyInit');\n        return {\n            highWaterMark: convertUnrestrictedDouble(highWaterMark)\n        };\n    }\n\n    // The size function must not have a prototype property nor be a constructor\n    var byteLengthSizeFunction = function (chunk) {\n        return chunk.byteLength;\n    };\n    Object.defineProperty(byteLengthSizeFunction, 'name', {\n        value: 'size',\n        configurable: true\n    });\n    /**\n     * A queuing strategy that counts the number of bytes in each chunk.\n     *\n     * @public\n     */\n    var ByteLengthQueuingStrategy = /** @class */ (function () {\n        function ByteLengthQueuingStrategy(options) {\n            assertRequiredArgument(options, 1, 'ByteLengthQueuingStrategy');\n            options = convertQueuingStrategyInit(options, 'First parameter');\n            this._byteLengthQueuingStrategyHighWaterMark = options.highWaterMark;\n        }\n        Object.defineProperty(ByteLengthQueuingStrategy.prototype, \"highWaterMark\", {\n            /**\n             * Returns the high water mark provided to the constructor.\n             */\n            get: function () {\n                if (!IsByteLengthQueuingStrategy(this)) {\n                    throw byteLengthBrandCheckException('highWaterMark');\n                }\n                return this._byteLengthQueuingStrategyHighWaterMark;\n            },\n            enumerable: false,\n            configurable: true\n        });\n        Object.defineProperty(ByteLengthQueuingStrategy.prototype, \"size\", {\n            /**\n             * Measures the size of `chunk` by returning the value of its `byteLength` property.\n             */\n            get: function () {\n                if (!IsByteLengthQueuingStrategy(this)) {\n                    throw byteLengthBrandCheckException('size');\n                }\n                return byteLengthSizeFunction;\n            },\n            enumerable: false,\n            configurable: true\n        });\n        return ByteLengthQueuingStrategy;\n    }());\n    Object.defineProperties(ByteLengthQueuingStrategy.prototype, {\n        highWaterMark: { enumerable: true },\n        size: { enumerable: true }\n    });\n    if (typeof SymbolPolyfill.toStringTag === 'symbol') {\n        Object.defineProperty(ByteLengthQueuingStrategy.prototype, SymbolPolyfill.toStringTag, {\n            value: 'ByteLengthQueuingStrategy',\n            configurable: true\n        });\n    }\n    // Helper functions for the ByteLengthQueuingStrategy.\n    function byteLengthBrandCheckException(name) {\n        return new TypeError(\"ByteLengthQueuingStrategy.prototype.\" + name + \" can only be used on a ByteLengthQueuingStrategy\");\n    }\n    function IsByteLengthQueuingStrategy(x) {\n        if (!typeIsObject(x)) {\n            return false;\n        }\n        if (!Object.prototype.hasOwnProperty.call(x, '_byteLengthQueuingStrategyHighWaterMark')) {\n            return false;\n        }\n        return x instanceof ByteLengthQueuingStrategy;\n    }\n\n    // The size function must not have a prototype property nor be a constructor\n    var countSizeFunction = function () {\n        return 1;\n    };\n    Object.defineProperty(countSizeFunction, 'name', {\n        value: 'size',\n        configurable: true\n    });\n    /**\n     * A queuing strategy that counts the number of chunks.\n     *\n     * @public\n     */\n    var CountQueuingStrategy = /** @class */ (function () {\n        function CountQueuingStrategy(options) {\n            assertRequiredArgument(options, 1, 'CountQueuingStrategy');\n            options = convertQueuingStrategyInit(options, 'First parameter');\n            this._countQueuingStrategyHighWaterMark = options.highWaterMark;\n        }\n        Object.defineProperty(CountQueuingStrategy.prototype, \"highWaterMark\", {\n            /**\n             * Returns the high water mark provided to the constructor.\n             */\n            get: function () {\n                if (!IsCountQueuingStrategy(this)) {\n                    throw countBrandCheckException('highWaterMark');\n                }\n                return this._countQueuingStrategyHighWaterMark;\n            },\n            enumerable: false,\n            configurable: true\n        });\n        Object.defineProperty(CountQueuingStrategy.prototype, \"size\", {\n            /**\n             * Measures the size of `chunk` by always returning 1.\n             * This ensures that the total queue size is a count of the number of chunks in the queue.\n             */\n            get: function () {\n                if (!IsCountQueuingStrategy(this)) {\n                    throw countBrandCheckException('size');\n                }\n                return countSizeFunction;\n            },\n            enumerable: false,\n            configurable: true\n        });\n        return CountQueuingStrategy;\n    }());\n    Object.defineProperties(CountQueuingStrategy.prototype, {\n        highWaterMark: { enumerable: true },\n        size: { enumerable: true }\n    });\n    if (typeof SymbolPolyfill.toStringTag === 'symbol') {\n        Object.defineProperty(CountQueuingStrategy.prototype, SymbolPolyfill.toStringTag, {\n            value: 'CountQueuingStrategy',\n            configurable: true\n        });\n    }\n    // Helper functions for the CountQueuingStrategy.\n    function countBrandCheckException(name) {\n        return new TypeError(\"CountQueuingStrategy.prototype.\" + name + \" can only be used on a CountQueuingStrategy\");\n    }\n    function IsCountQueuingStrategy(x) {\n        if (!typeIsObject(x)) {\n            return false;\n        }\n        if (!Object.prototype.hasOwnProperty.call(x, '_countQueuingStrategyHighWaterMark')) {\n            return false;\n        }\n        return x instanceof CountQueuingStrategy;\n    }\n\n    function convertTransformer(original, context) {\n        assertDictionary(original, context);\n        var flush = original === null || original === void 0 ? void 0 : original.flush;\n        var readableType = original === null || original === void 0 ? void 0 : original.readableType;\n        var start = original === null || original === void 0 ? void 0 : original.start;\n        var transform = original === null || original === void 0 ? void 0 : original.transform;\n        var writableType = original === null || original === void 0 ? void 0 : original.writableType;\n        return {\n            flush: flush === undefined ?\n                undefined :\n                convertTransformerFlushCallback(flush, original, context + \" has member 'flush' that\"),\n            readableType: readableType,\n            start: start === undefined ?\n                undefined :\n                convertTransformerStartCallback(start, original, context + \" has member 'start' that\"),\n            transform: transform === undefined ?\n                undefined :\n                convertTransformerTransformCallback(transform, original, context + \" has member 'transform' that\"),\n            writableType: writableType\n        };\n    }\n    function convertTransformerFlushCallback(fn, original, context) {\n        assertFunction(fn, context);\n        return function (controller) { return promiseCall(fn, original, [controller]); };\n    }\n    function convertTransformerStartCallback(fn, original, context) {\n        assertFunction(fn, context);\n        return function (controller) { return reflectCall(fn, original, [controller]); };\n    }\n    function convertTransformerTransformCallback(fn, original, context) {\n        assertFunction(fn, context);\n        return function (chunk, controller) { return promiseCall(fn, original, [chunk, controller]); };\n    }\n\n    // Class TransformStream\n    /**\n     * A transform stream consists of a pair of streams: a {@link WritableStream | writable stream},\n     * known as its writable side, and a {@link ReadableStream | readable stream}, known as its readable side.\n     * In a manner specific to the transform stream in question, writes to the writable side result in new data being\n     * made available for reading from the readable side.\n     *\n     * @public\n     */\n    var TransformStream = /** @class */ (function () {\n        function TransformStream(rawTransformer, rawWritableStrategy, rawReadableStrategy) {\n            if (rawTransformer === void 0) { rawTransformer = {}; }\n            if (rawWritableStrategy === void 0) { rawWritableStrategy = {}; }\n            if (rawReadableStrategy === void 0) { rawReadableStrategy = {}; }\n            if (rawTransformer === undefined) {\n                rawTransformer = null;\n            }\n            var writableStrategy = convertQueuingStrategy(rawWritableStrategy, 'Second parameter');\n            var readableStrategy = convertQueuingStrategy(rawReadableStrategy, 'Third parameter');\n            var transformer = convertTransformer(rawTransformer, 'First parameter');\n            if (transformer.readableType !== undefined) {\n                throw new RangeError('Invalid readableType specified');\n            }\n            if (transformer.writableType !== undefined) {\n                throw new RangeError('Invalid writableType specified');\n            }\n            var readableHighWaterMark = ExtractHighWaterMark(readableStrategy, 0);\n            var readableSizeAlgorithm = ExtractSizeAlgorithm(readableStrategy);\n            var writableHighWaterMark = ExtractHighWaterMark(writableStrategy, 1);\n            var writableSizeAlgorithm = ExtractSizeAlgorithm(writableStrategy);\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            if (transformer.start !== undefined) {\n                startPromise_resolve(transformer.start(this._transformStreamController));\n            }\n            else {\n                startPromise_resolve(undefined);\n            }\n        }\n        Object.defineProperty(TransformStream.prototype, \"readable\", {\n            /**\n             * The readable side of the transform stream.\n             */\n            get: function () {\n                if (!IsTransformStream(this)) {\n                    throw streamBrandCheckException('readable');\n                }\n                return this._readable;\n            },\n            enumerable: false,\n            configurable: true\n        });\n        Object.defineProperty(TransformStream.prototype, \"writable\", {\n            /**\n             * The writable side of the transform stream.\n             */\n            get: function () {\n                if (!IsTransformStream(this)) {\n                    throw streamBrandCheckException('writable');\n                }\n                return this._writable;\n            },\n            enumerable: false,\n            configurable: true\n        });\n        return TransformStream;\n    }());\n    Object.defineProperties(TransformStream.prototype, {\n        readable: { enumerable: true },\n        writable: { enumerable: true }\n    });\n    if (typeof SymbolPolyfill.toStringTag === 'symbol') {\n        Object.defineProperty(TransformStream.prototype, SymbolPolyfill.toStringTag, {\n            value: 'TransformStream',\n            configurable: true\n        });\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        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 x instanceof TransformStream;\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) {\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    // Class TransformStreamDefaultController\n    /**\n     * Allows control of the {@link ReadableStream} and {@link WritableStream} of the associated {@link TransformStream}.\n     *\n     * @public\n     */\n    var TransformStreamDefaultController = /** @class */ (function () {\n        function TransformStreamDefaultController() {\n            throw new TypeError('Illegal constructor');\n        }\n        Object.defineProperty(TransformStreamDefaultController.prototype, \"desiredSize\", {\n            /**\n             * Returns the desired size to fill the readable side’s internal queue. It can be negative, if the queue is over-full.\n             */\n            get: function () {\n                if (!IsTransformStreamDefaultController(this)) {\n                    throw defaultControllerBrandCheckException('desiredSize');\n                }\n                var readableController = this._controlledTransformStream._readable._readableStreamController;\n                return ReadableStreamDefaultControllerGetDesiredSize(readableController);\n            },\n            enumerable: false,\n            configurable: true\n        });\n        TransformStreamDefaultController.prototype.enqueue = function (chunk) {\n            if (chunk === void 0) { chunk = undefined; }\n            if (!IsTransformStreamDefaultController(this)) {\n                throw defaultControllerBrandCheckException('enqueue');\n            }\n            TransformStreamDefaultControllerEnqueue(this, chunk);\n        };\n        /**\n         * Errors both the readable side and the writable side of the controlled transform stream, making all future\n         * interactions with it fail with the given error `e`. Any chunks queued for transformation will be discarded.\n         */\n        TransformStreamDefaultController.prototype.error = function (reason) {\n            if (reason === void 0) { reason = undefined; }\n            if (!IsTransformStreamDefaultController(this)) {\n                throw defaultControllerBrandCheckException('error');\n            }\n            TransformStreamDefaultControllerError(this, reason);\n        };\n        /**\n         * Closes the readable side and errors the writable side of the controlled transform stream. This is useful when the\n         * transformer only needs to consume a portion of the chunks written to the writable side.\n         */\n        TransformStreamDefaultController.prototype.terminate = function () {\n            if (!IsTransformStreamDefaultController(this)) {\n                throw defaultControllerBrandCheckException('terminate');\n            }\n            TransformStreamDefaultControllerTerminate(this);\n        };\n        return TransformStreamDefaultController;\n    }());\n    Object.defineProperties(TransformStreamDefaultController.prototype, {\n        enqueue: { enumerable: true },\n        error: { enumerable: true },\n        terminate: { enumerable: true },\n        desiredSize: { enumerable: true }\n    });\n    if (typeof SymbolPolyfill.toStringTag === 'symbol') {\n        Object.defineProperty(TransformStreamDefaultController.prototype, SymbolPolyfill.toStringTag, {\n            value: 'TransformStreamDefaultController',\n            configurable: true\n        });\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 x instanceof TransformStreamDefaultController;\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 flushAlgorithm = function () { return promiseResolvedWith(undefined); };\n        if (transformer.transform !== undefined) {\n            transformAlgorithm = function (chunk) { return transformer.transform(chunk, controller); };\n        }\n        if (transformer.flush !== undefined) {\n            flushAlgorithm = function () { return transformer.flush(controller); };\n        }\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)) {\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        ReadableStreamDefaultControllerClose(readableController);\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) {\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            ReadableStreamDefaultControllerClose(readable._readableStreamController);\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(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(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.ReadableByteStreamController = ReadableByteStreamController;\n    exports.ReadableStream = ReadableStream;\n    exports.ReadableStreamBYOBReader = ReadableStreamBYOBReader;\n    exports.ReadableStreamBYOBRequest = ReadableStreamBYOBRequest;\n    exports.ReadableStreamDefaultController = ReadableStreamDefaultController;\n    exports.ReadableStreamDefaultReader = ReadableStreamDefaultReader;\n    exports.TransformStream = TransformStream;\n    exports.TransformStreamDefaultController = TransformStreamDefaultController;\n    exports.WritableStream = WritableStream;\n    exports.WritableStreamDefaultController = WritableStreamDefaultController;\n    exports.WritableStreamDefaultWriter = WritableStreamDefaultWriter;\n\n    Object.defineProperty(exports, '__esModule', { value: true });\n\n})));\n//# sourceMappingURL=ponyfill.js.map\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 { CMapCompressionType, unreachable } from \"../shared/util.js\";\n\nclass BaseCanvasFactory {\n  constructor() {\n    if (this.constructor === BaseCanvasFactory) {\n      unreachable(\"Cannot initialize BaseCanvasFactory.\");\n    }\n  }\n\n  create(width, height) {\n    if (width <= 0 || height <= 0) {\n      throw new Error(\"Invalid canvas size\");\n    }\n    const canvas = this._createCanvas(width, height);\n    return {\n      canvas,\n      context: canvas.getContext(\"2d\"),\n    };\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  /**\n   * @private\n   */\n  _createCanvas(width, height) {\n    unreachable(\"Abstract method `_createCanvas` called.\");\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 BaseStandardFontDataFactory {\n  constructor({ baseUrl = null }) {\n    if (this.constructor === BaseStandardFontDataFactory) {\n      unreachable(\"Cannot initialize BaseStandardFontDataFactory.\");\n    }\n    this.baseUrl = baseUrl;\n  }\n\n  async fetch({ filename }) {\n    if (!this.baseUrl) {\n      throw new Error(\n        'The standard font \"baseUrl\" parameter must be specified, ensure that ' +\n          'the \"standardFontDataUrl\" API parameter is provided.'\n      );\n    }\n    if (!filename) {\n      throw new Error(\"Font filename must be specified.\");\n    }\n    const url = `${this.baseUrl}${filename}`;\n\n    return this._fetchData(url).catch(reason => {\n      throw new Error(`Unable to load font data at: ${url}`);\n    });\n  }\n\n  /**\n   * @private\n   */\n  _fetchData(url) {\n    unreachable(\"Abstract method `_fetchData` called.\");\n  }\n}\n\nclass BaseSVGFactory {\n  constructor() {\n    if (this.constructor === BaseSVGFactory) {\n      unreachable(\"Cannot initialize BaseSVGFactory.\");\n    }\n  }\n\n  create(width, height) {\n    if (width <= 0 || height <= 0) {\n      throw new Error(\"Invalid SVG dimensions\");\n    }\n    const svg = this._createSVG(\"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    if (typeof type !== \"string\") {\n      throw new Error(\"Invalid SVG element type\");\n    }\n    return this._createSVG(type);\n  }\n\n  /**\n   * @private\n   */\n  _createSVG(type) {\n    unreachable(\"Abstract method `_createSVG` called.\");\n  }\n}\n\nexport {\n  BaseCanvasFactory,\n  BaseCMapReaderFactory,\n  BaseStandardFontDataFactory,\n  BaseSVGFactory,\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\n/**\n * @module pdfjsLib\n */\n\nimport {\n  AbortException,\n  AnnotationMode,\n  assert,\n  createPromiseCapability,\n  getVerbosityLevel,\n  info,\n  InvalidPDFException,\n  isArrayBuffer,\n  isSameOrigin,\n  MissingPDFException,\n  PasswordException,\n  RenderingIntentFlag,\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  DOMStandardFontDataFactory,\n  isDataScheme,\n  loadScript,\n  PageViewport,\n  RenderingCancelledException,\n  StatTimer,\n} from \"./display_utils.js\";\nimport { FontFaceObject, FontLoader } from \"./font_loader.js\";\nimport {\n  NodeCanvasFactory,\n  NodeCMapReaderFactory,\n  NodeStandardFontDataFactory,\n} from \"./node_utils.js\";\nimport { AnnotationStorage } from \"./annotation_storage.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 { XfaText } from \"./xfa_text.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;\nconst DefaultStandardFontDataFactory =\n  (typeof PDFJSDev === \"undefined\" || PDFJSDev.test(\"GENERIC\")) && isNodeJS\n    ? NodeStandardFontDataFactory\n    : DOMStandardFontDataFactory;\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 * @typedef {Object} RefProxy\n * @property {number} num\n * @property {number} gen\n */\n\n/**\n * Document initialization / loading parameters object.\n *\n * @typedef {Object} DocumentInitParameters\n * @property {string|URL} [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} [useSystemFonts] - When `true`, fonts that aren't\n *   embedded in the PDF document will fallback to a system font.\n *   The default value is `true` in web environments and `false` in Node.js;\n *   unless `disableFontFace === true` in which case this defaults to `false`\n *   regardless of the environment (to prevent completely broken fonts).\n * @property {string} [standardFontDataUrl] - The URL where the standard font\n *   files are located. Include the trailing slash.\n * @property {Object} [StandardFontDataFactory] - The factory that will be used\n *   when reading the standard font files. Providing a custom factory is useful\n *   for environments without Fetch API or `XMLHttpRequest` support, such as\n *   Node.js. The default value is {DOMStandardFontDataFactory}.\n * @property {boolean} [useWorkerFetch] - Enable using the Fetch API in the\n *   worker-thread when reading CMap and standard font files. When `true`,\n *   the `CMapReaderFactory` and `StandardFontDataFactory` options are ignored.\n *   The default value is `true` in web environments and `false` in Node.js.\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 the Font Loading API or `@font-face` rules.\n *   If disabled, fonts will be rendered using a built-in font renderer that\n *   constructs the glyphs with primitive path commands.\n *   The default value is `false` in web environments and `true` in Node.js.\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 {boolean} [enableXfa] - Render Xfa forms if any.\n *   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 * 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|URL|TypedArray|PDFDataRangeTransport|DocumentInitParameters}\n *   src - Can be a URL where a PDF file is located, a typed array (Uint8Array)\n *         already populated with data, or a parameter object.\n * @returns {PDFDocumentLoadingTask}\n */\nfunction getDocument(src) {\n  const task = new PDFDocumentLoadingTask();\n\n  let source;\n  if (typeof src === \"string\" || src instanceof URL) {\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 string, URL, Uint8Array, or 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    const value = source[key];\n\n    switch (key) {\n      case \"url\":\n        if (typeof window !== \"undefined\") {\n          try {\n            // The full path is required in the 'url' field.\n            params[key] = new URL(value, window.location).href;\n            continue;\n          } catch (ex) {\n            warn(`Cannot create valid URL: \"${ex}\".`);\n          }\n        } else if (typeof value === \"string\" || value instanceof URL) {\n          params[key] = value.toString(); // Support Node.js environments.\n          continue;\n        }\n        throw new Error(\n          \"Invalid PDF url data: \" +\n            \"either string or URL-object is expected in the url property.\"\n        );\n      case \"range\":\n        rangeTransport = value;\n        continue;\n      case \"worker\":\n        worker = value;\n        continue;\n      case \"data\":\n        // Converting string or array-like data to Uint8Array.\n        if (\n          typeof PDFJSDev !== \"undefined\" &&\n          PDFJSDev.test(\"GENERIC\") &&\n          isNodeJS &&\n          typeof Buffer !== \"undefined\" && // eslint-disable-line no-undef\n          value instanceof Buffer // eslint-disable-line no-undef\n        ) {\n          params[key] = new Uint8Array(value);\n        } else if (value instanceof Uint8Array) {\n          break; // Use the data as-is when it's already a Uint8Array.\n        } else if (typeof value === \"string\") {\n          params[key] = stringToBytes(value);\n        } else if (\n          typeof value === \"object\" &&\n          value !== null &&\n          !isNaN(value.length)\n        ) {\n          params[key] = new Uint8Array(value);\n        } else if (isArrayBuffer(value)) {\n          params[key] = new Uint8Array(value);\n        } else {\n          throw new Error(\n            \"Invalid PDF binary data: either typed array, \" +\n              \"string, or array-like object is expected in the data property.\"\n          );\n        }\n        continue;\n    }\n    params[key] = value;\n  }\n\n  params.rangeChunkSize = params.rangeChunkSize || DEFAULT_RANGE_CHUNK_SIZE;\n  params.CMapReaderFactory =\n    params.CMapReaderFactory || DefaultCMapReaderFactory;\n  params.StandardFontDataFactory =\n    params.StandardFontDataFactory || DefaultStandardFontDataFactory;\n  params.ignoreErrors = params.stopAtErrors !== true;\n  params.fontExtraProperties = params.fontExtraProperties === true;\n  params.pdfBug = params.pdfBug === true;\n  params.enableXfa = params.enableXfa === true;\n\n  if (\n    typeof params.docBaseUrl !== \"string\" ||\n    isDataScheme(params.docBaseUrl)\n  ) {\n    // Ignore \"data:\"-URLs, since they can't be used to recover valid absolute\n    // URLs anyway. We want to avoid sending them to the worker-thread, since\n    // they contain the *entire* PDF document and can thus be arbitrarily long.\n    params.docBaseUrl = null;\n  }\n  if (!Number.isInteger(params.maxImageSize)) {\n    params.maxImageSize = -1;\n  }\n  if (typeof params.useWorkerFetch !== \"boolean\") {\n    params.useWorkerFetch =\n      params.CMapReaderFactory === DOMCMapReaderFactory &&\n      params.StandardFontDataFactory === DOMStandardFontDataFactory;\n  }\n  if (typeof params.isEvalSupported !== \"boolean\") {\n    params.isEvalSupported = true;\n  }\n  if (typeof params.disableFontFace !== \"boolean\") {\n    params.disableFontFace =\n      (typeof PDFJSDev === \"undefined\" || PDFJSDev.test(\"GENERIC\")) && isNodeJS;\n  }\n  if (typeof params.useSystemFonts !== \"boolean\") {\n    params.useSystemFonts =\n      !(\n        (typeof PDFJSDev === \"undefined\" || PDFJSDev.test(\"GENERIC\")) &&\n        isNodeJS\n      ) && !params.disableFontFace;\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              contentDispositionFilename: params.contentDispositionFilename,\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          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<string>} A promise that is resolved when the worker ID of\n *   the `MessageHandler` is known.\n * @private\n */\nasync function _fetchDocument(worker, source, pdfDataRangeTransport, docId) {\n  if (worker.destroyed) {\n    throw 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    source.contentDispositionFilename =\n      pdfDataRangeTransport.contentDispositionFilename;\n  }\n  const workerId = await worker.messageHandler.sendWithPromise(\n    \"GetDocRequest\",\n    {\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      docBaseUrl: source.docBaseUrl,\n      ignoreErrors: source.ignoreErrors,\n      isEvalSupported: source.isEvalSupported,\n      fontExtraProperties: source.fontExtraProperties,\n      enableXfa: source.enableXfa,\n      useSystemFonts: source.useSystemFonts,\n      cMapUrl: source.useWorkerFetch ? source.cMapUrl : null,\n      standardFontDataUrl: source.useWorkerFetch\n        ? source.standardFontDataUrl\n        : null,\n    }\n  );\n\n  if (worker.destroyed) {\n    throw new Error(\"Worker was destroyed\");\n  }\n  return workerId;\n}\n\n/**\n * @typedef {Object} OnProgressParameters\n * @property {number} loaded - Currently loaded number of bytes.\n * @property {number} total - Total number of bytes in the PDF file.\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 */\nclass PDFDocumentLoadingTask {\n  static get idCounters() {\n    return shadow(this, \"idCounters\", { doc: 0 });\n  }\n\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${PDFDocumentLoadingTask.idCounters.doc++}`;\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).\n     * The callback receives an {@link OnProgressParameters} argument.\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   * Abort all network requests and destroy the worker.\n   * @returns {Promise<void>} A promise that is resolved when destruction is\n   *   completed.\n   */\n  async destroy() {\n    this.destroyed = true;\n    await this._transport?.destroy();\n\n    this._transport = null;\n    if (this._worker) {\n      this._worker.destroy();\n      this._worker = null;\n    }\n  }\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   * @param {string} [contentDispositionFilename]\n   */\n  constructor(\n    length,\n    initialData,\n    progressiveDone = false,\n    contentDispositionFilename = null\n  ) {\n    this.length = length;\n    this.initialData = initialData;\n    this.progressiveDone = progressiveDone;\n    this.contentDispositionFilename = contentDispositionFilename;\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    if (typeof PDFJSDev === \"undefined\" || PDFJSDev.test(\"GENERIC\")) {\n      Object.defineProperty(this, \"fingerprint\", {\n        get() {\n          deprecated(\n            \"`PDFDocumentProxy.fingerprint`, \" +\n              \"please use `PDFDocumentProxy.fingerprints` instead.\"\n          );\n          return this.fingerprints[0];\n        },\n      });\n\n      Object.defineProperty(this, \"getStats\", {\n        value: async () => {\n          deprecated(\n            \"`PDFDocumentProxy.getStats`, \" +\n              \"please use the `PDFDocumentProxy.stats`-getter instead.\"\n          );\n          return this.stats || { streamTypes: {}, fontTypes: {} };\n        },\n      });\n    }\n  }\n\n  /**\n   * @type {AnnotationStorage} Storage for annotation data in forms.\n   */\n  get annotationStorage() {\n    return this._transport.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 {Array<string, string|null>} A (not guaranteed to be) unique ID to\n   *   identify the PDF document.\n   *   NOTE: The first element will always be defined for all PDF documents,\n   *   whereas the second element is only defined for *modified* PDF documents.\n   */\n  get fingerprints() {\n    return this._pdfInfo.fingerprints;\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   * @type {PDFDocumentStats | null} The current statistics about document\n   *   structures, or `null` when no statistics exists.\n   */\n  get stats() {\n    return this._transport.stats;\n  }\n\n  /**\n   * @type {boolean} True if only XFA form.\n   */\n  get isPureXfa() {\n    return !!this._transport._htmlForXfa;\n  }\n\n  /**\n   * NOTE: This is (mostly) intended to support printing of XFA forms.\n   *\n   * @type {Object | null} An object representing a HTML tree structure\n   *   to render the XFA, or `null` when no XFA form exists.\n   */\n  get allXfaHtml() {\n    return this._transport._htmlForXfa;\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 {RefProxy} ref - The page reference.\n   * @returns {Promise<number>} A promise that is resolved with the page index,\n   *   starting from zero, that is associated with the 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> | null>} A promise that is resolved with all\n   *   information of the given named destination, or `null` when the named\n   *   destination is not present in the PDF file.\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   * @returns {Promise<Object | null>} A promise that is resolved with\n   *   an {Object} with the JavaScript actions:\n   *     - from the name tree (like getJavaScript);\n   *     - from A or AA entries in the catalog dictionary.\n   *   , or `null` if no JavaScript exists.\n   */\n  getJSActions() {\n    return this._transport.getDocJSActions();\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   * @typedef {Object} MarkInfo\n   * Properties correspond to Table 321 of the PDF 32000-1:2008 spec.\n   * @property {boolean} Marked\n   * @property {boolean} UserProperties\n   * @property {boolean} Suspects\n   */\n\n  /**\n   * @returns {Promise<MarkInfo | null>} A promise that is resolved with\n   *   a {MarkInfo} object that contains the MarkInfo flags for the PDF\n   *   document, or `null` when no MarkInfo values are present in the PDF file.\n   */\n  getMarkInfo() {\n    return this._transport.getMarkInfo();\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   * 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   * @param {boolean} [keepLoadedFonts] - Let fonts remain attached to the DOM.\n   *   NOTE: This will increase persistent memory usage, hence don't use this\n   *   option unless absolutely necessary. The default value is `false`.\n   * @returns {Promise} A promise that is resolved when clean-up has finished.\n   */\n  cleanup(keepLoadedFonts = false) {\n    return this._transport.startCleanup(keepLoadedFonts || this.isPureXfa);\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 needed in the viewer.\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   * @returns {Promise<Uint8Array>} A promise that is resolved with a\n   *   {Uint8Array} containing the full data of the saved document.\n   */\n  saveDocument() {\n    if (\n      (typeof PDFJSDev === \"undefined\" || PDFJSDev.test(\"GENERIC\")) &&\n      this._transport.annotationStorage.size <= 0\n    ) {\n      deprecated(\n        \"saveDocument called while `annotationStorage` is empty, \" +\n          \"please use the getData-method instead.\"\n      );\n    }\n    return this._transport.saveDocument();\n  }\n\n  /**\n   * @returns {Promise<Object<string, Array<Object>> | null>} A promise that is\n   *   resolved with an {Object} containing /AcroForm field data for the JS\n   *   sandbox, or `null` when no field data is present in the PDF file.\n   */\n  getFieldObjects() {\n    return this._transport.getFieldObjects();\n  }\n\n  /**\n   * @returns {Promise<boolean>} A promise that is resolved with `true`\n   *   if some /AcroForm fields have JavaScript actions.\n   */\n  hasJSActions() {\n    return this._transport.hasJSActions();\n  }\n\n  /**\n   * @returns {Promise<Array<string> | null>} A promise that is resolved with an\n   *   {Array<string>} containing IDs of annotations that have a calculation\n   *   action, or `null` when no such annotations are present in the PDF file.\n   */\n  getCalculationOrderIds() {\n    return this._transport.getCalculationOrderIds();\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 * @property {boolean} [includeMarkedContent] - When true include marked\n *   content items in the items array of TextContent. The default is `false`.\n */\n\n/**\n * Page text content.\n *\n * @typedef {Object} TextContent\n * @property {Array<TextItem | TextMarkedContent>} items - Array of\n *   {@link TextItem} and {@link TextMarkedContent} objects. TextMarkedContent\n *   items are included when includeMarkedContent is true.\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 * @property {boolean} hasEOL - Indicating if the text content is followed by a\n *   line-break.\n */\n\n/**\n * Page text marked content part.\n *\n * @typedef {Object} TextMarkedContent\n * @property {string} type - Either 'beginMarkedContent',\n *   'beginMarkedContentProps', or 'endMarkedContent'.\n * @property {string} id - The marked content identifier. Only used for type\n *   'beginMarkedContentProps'.\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 are fetched,\n *   can be 'display' (viewable annotations), 'print' (printable annotations),\n *   or 'any' (all annotations). The default value is 'display'.\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', 'print',\n *   or 'any'. The default value is 'display'.\n * @property {number} [annotationMode] Controls which annotations are rendered\n *   onto the canvas, for annotations with appearance-data; the values from\n *   {@link AnnotationMode} should be used. The following values are supported:\n *    - `AnnotationMode.DISABLE`, which disables all annotations.\n *    - `AnnotationMode.ENABLE`, which includes all possible annotations (thus\n *      it also depends on the `intent`-option, see above).\n *    - `AnnotationMode.ENABLE_FORMS`, which excludes annotations that contain\n *      interactive form elements (those will be rendered in the display layer).\n *    - `AnnotationMode.ENABLE_STORAGE`, which includes all possible annotations\n *      (as above) but where interactive form elements are updated with data\n *      from the {@link AnnotationStorage}-instance; useful e.g. for printing.\n *   The default value is `AnnotationMode.ENABLE`.\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 {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 * @property {Map<string, HTMLCanvasElement>} [annotationCanvasMap] - Map some\n *   annotation ids with canvases used to render them.\n */\n\n/**\n * Page getOperatorList parameters.\n *\n * @typedef {Object} GetOperatorListParameters\n * @property {string} [intent] - Rendering intent, can be 'display', 'print',\n *   or 'any'. The default value is 'display'.\n * @property {number} [annotationMode] Controls which annotations are included\n *   in the operatorList, for annotations with appearance-data; the values from\n *   {@link AnnotationMode} should be used. The following values are supported:\n *    - `AnnotationMode.DISABLE`, which disables all annotations.\n *    - `AnnotationMode.ENABLE`, which includes all possible annotations (thus\n *      it also depends on the `intent`-option, see above).\n *    - `AnnotationMode.ENABLE_FORMS`, which excludes annotations that contain\n *      interactive form elements (those will be rendered in the display layer).\n *    - `AnnotationMode.ENABLE_STORAGE`, which includes all possible annotations\n *      (as above) but where interactive form elements are updated with data\n *      from the {@link AnnotationStorage}-instance; useful e.g. for printing.\n *   The default value is `AnnotationMode.ENABLE`.\n */\n\n/**\n * Structure tree node. The root node will have a role \"Root\".\n *\n * @typedef {Object} StructTreeNode\n * @property {Array<StructTreeNode | StructTreeContent>} children - Array of\n *   {@link StructTreeNode} and {@link StructTreeContent} objects.\n * @property {string} role - element's role, already mapped if a role map exists\n * in the PDF.\n */\n\n/**\n * Structure tree content.\n *\n * @typedef {Object} StructTreeContent\n * @property {string} type - either \"content\" for page and stream structure\n *   elements or \"object\" for object references.\n * @property {string} id - unique id that will map to the text layer.\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._annotationPromises = 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 {RefProxy | null} The reference that points to this page.\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 = \"display\" } = {}) {\n    const intentArgs = this._transport.getRenderingIntent(intent);\n\n    let promise = this._annotationPromises.get(intentArgs.cacheKey);\n    if (!promise) {\n      promise = this._transport.getAnnotations(\n        this._pageIndex,\n        intentArgs.renderingIntent\n      );\n      this._annotationPromises.set(intentArgs.cacheKey, promise);\n\n      if (typeof PDFJSDev === \"undefined\" || PDFJSDev.test(\"GENERIC\")) {\n        promise = promise.then(annotations => {\n          for (const annotation of annotations) {\n            if (annotation.titleObj !== undefined) {\n              Object.defineProperty(annotation, \"title\", {\n                get() {\n                  deprecated(\n                    \"`title`-property on annotation, please use `titleObj` instead.\"\n                  );\n                  return annotation.titleObj.str;\n                },\n              });\n            }\n            if (annotation.contentsObj !== undefined) {\n              Object.defineProperty(annotation, \"contents\", {\n                get() {\n                  deprecated(\n                    \"`contents`-property on annotation, please use `contentsObj` instead.\"\n                  );\n                  return annotation.contentsObj.str;\n                },\n              });\n            }\n          }\n          return annotations;\n        });\n      }\n    }\n    return promise;\n  }\n\n  /**\n   * @returns {Promise<Object>} A promise that is resolved with an\n   *   {Object} with JS actions.\n   */\n  getJSActions() {\n    return (this._jsActionsPromise ||= this._transport.getPageJSActions(\n      this._pageIndex\n    ));\n  }\n\n  /**\n   * @returns {Promise<Object | null>} A promise that is resolved with\n   *   an {Object} with a fake DOM object (a tree structure where elements\n   *   are {Object} with a name, attributes (class, style, ...), value and\n   *   children, very similar to a HTML DOM tree), or `null` if no XFA exists.\n   */\n  async getXfa() {\n    return this._transport._htmlForXfa?.children[this._pageIndex] || null;\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    annotationMode = AnnotationMode.ENABLE,\n    transform = null,\n    imageLayer = null,\n    canvasFactory = null,\n    background = null,\n    optionalContentConfigPromise = null,\n    annotationCanvasMap = null,\n  }) {\n    if (typeof PDFJSDev !== \"undefined\" && PDFJSDev.test(\"GENERIC\")) {\n      if (arguments[0]?.renderInteractiveForms !== undefined) {\n        deprecated(\n          \"render no longer accepts the `renderInteractiveForms`-option, \" +\n            \"please use the `annotationMode`-option instead.\"\n        );\n        if (\n          arguments[0].renderInteractiveForms === true &&\n          annotationMode === AnnotationMode.ENABLE\n        ) {\n          annotationMode = AnnotationMode.ENABLE_FORMS;\n        }\n      }\n      if (arguments[0]?.includeAnnotationStorage !== undefined) {\n        deprecated(\n          \"render no longer accepts the `includeAnnotationStorage`-option, \" +\n            \"please use the `annotationMode`-option instead.\"\n        );\n        if (\n          arguments[0].includeAnnotationStorage === true &&\n          annotationMode === AnnotationMode.ENABLE\n        ) {\n          annotationMode = AnnotationMode.ENABLE_STORAGE;\n        }\n      }\n    }\n\n    if (this._stats) {\n      this._stats.time(\"Overall\");\n    }\n\n    const intentArgs = this._transport.getRenderingIntent(\n      intent,\n      annotationMode\n    );\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(intentArgs.cacheKey);\n    if (!intentState) {\n      intentState = Object.create(null);\n      this._intentStates.set(intentArgs.cacheKey, 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 intentPrint = !!(\n      intentArgs.renderingIntent & RenderingIntentFlag.PRINT\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(intentArgs);\n    }\n\n    const complete = error => {\n      intentState.renderTasks.delete(internalRenderTask);\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 || intentPrint) {\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 instanceof Error ? error : new Error(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      annotationCanvasMap,\n      operatorList: intentState.operatorList,\n      pageIndex: this._pageIndex,\n      canvasFactory: canvasFactoryInstance,\n      useRequestAnimationFrame: !intentPrint,\n      pdfBug: this._pdfBug,\n    });\n\n    (intentState.renderTasks ||= new Set()).add(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   * @param {GetOperatorListParameters} params - Page getOperatorList\n   *   parameters.\n   * @returns {Promise<PDFOperatorList>} A promise resolved with an\n   *   {@link PDFOperatorList} object that represents the page's operator list.\n   */\n  getOperatorList({\n    intent = \"display\",\n    annotationMode = AnnotationMode.ENABLE,\n  } = {}) {\n    function operatorListChanged() {\n      if (intentState.operatorList.lastChunk) {\n        intentState.opListReadCapability.resolve(intentState.operatorList);\n\n        intentState.renderTasks.delete(opListTask);\n      }\n    }\n\n    const intentArgs = this._transport.getRenderingIntent(\n      intent,\n      annotationMode,\n      /* isOpList = */ true\n    );\n    let intentState = this._intentStates.get(intentArgs.cacheKey);\n    if (!intentState) {\n      intentState = Object.create(null);\n      this._intentStates.set(intentArgs.cacheKey, 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 ||= new Set()).add(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(intentArgs);\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    includeMarkedContent = 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        includeMarkedContent: includeMarkedContent === 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    if (this._transport._htmlForXfa) {\n      // TODO: We need to revisit this once the XFA foreground patch lands and\n      // only do this for non-foreground XFA.\n      return this.getXfa().then(xfa => {\n        return XfaText.textContent(xfa);\n      });\n    }\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   * @returns {Promise<StructTreeNode>} A promise that is resolved with a\n   *   {@link StructTreeNode} object that represents the page's structure tree,\n   *   or `null` when no structure tree is present for the current page.\n   */\n  getStructTree() {\n    return (this._structTreePromise ||= this._transport.getStructTree(\n      this._pageIndex\n    ));\n  }\n\n  /**\n   * Destroys the page object.\n   * @private\n   */\n  _destroy() {\n    this.destroyed = true;\n\n    const waitOn = [];\n    for (const intentState of this._intentStates.values()) {\n      this._abortOperatorList({\n        intentState,\n        reason: new Error(\"Page was destroyed.\"),\n        force: true,\n      });\n\n      if (intentState.opListReadCapability) {\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._annotationPromises.clear();\n    this._jsActionsPromise = null;\n    this._structTreePromise = 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.size > 0 || !operatorList.lastChunk) {\n        return false;\n      }\n    }\n\n    this._intentStates.clear();\n    this.objs.clear();\n    this._annotationPromises.clear();\n    this._jsActionsPromise = null;\n    this._structTreePromise = 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, cacheKey) {\n    const intentState = this._intentStates.get(cacheKey);\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 (const internalRenderTask of intentState.renderTasks) {\n      internalRenderTask.operatorListChanged();\n    }\n\n    if (operatorListChunk.lastChunk) {\n      this._tryCleanup();\n    }\n  }\n\n  /**\n   * @private\n   */\n  _pumpOperatorList({ renderingIntent, cacheKey }) {\n    if (\n      typeof PDFJSDev === \"undefined\" ||\n      PDFJSDev.test(\"!PRODUCTION || TESTING\")\n    ) {\n      assert(\n        Number.isInteger(renderingIntent) && renderingIntent > 0,\n        '_pumpOperatorList: Expected valid \"renderingIntent\" argument.'\n      );\n    }\n\n    const readableStream = this._transport.messageHandler.sendWithStream(\n      \"GetOperatorList\",\n      {\n        pageIndex: this._pageIndex,\n        intent: renderingIntent,\n        cacheKey,\n        annotationStorage:\n          renderingIntent & RenderingIntentFlag.ANNOTATIONS_STORAGE\n            ? this._transport.annotationStorage.serializable\n            : null,\n      }\n    );\n    const reader = readableStream.getReader();\n\n    const intentState = this._intentStates.get(cacheKey);\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 (const internalRenderTask of intentState.renderTasks) {\n              internalRenderTask.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    if (\n      typeof PDFJSDev === \"undefined\" ||\n      PDFJSDev.test(\"!PRODUCTION || TESTING\")\n    ) {\n      assert(\n        reason instanceof Error,\n        '_abortOperatorList: Expected valid \"reason\" argument.'\n      );\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.size > 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\n      .cancel(new AbortException(reason.message))\n      .catch(() => {\n        // Avoid \"Uncaught promise\" messages in the console.\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 [curCacheKey, curIntentState] of this._intentStates) {\n      if (curIntentState === intentState) {\n        this._intentStates.delete(curCacheKey);\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() {\n    this._listeners = [];\n    this._deferred = Promise.resolve();\n  }\n\n  postMessage(obj, transfers) {\n    function cloneValue(object) {\n      if (\n        (typeof PDFJSDev !== \"undefined\" && PDFJSDev.test(\"MOZCENTRAL\")) ||\n        globalThis.structuredClone\n      ) {\n        return globalThis.structuredClone(object, transfers);\n      }\n\n      // Trying to perform a structured clone close to the spec, including\n      // transfers.\n      function fallbackCloneValue(value) {\n        if (\n          typeof value === \"function\" ||\n          typeof value === \"symbol\" ||\n          value instanceof URL\n        ) {\n          throw new Error(\n            `LoopbackPort.postMessage - cannot clone: ${value?.toString()}`\n          );\n        }\n\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          if (transfers?.includes(buffer)) {\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        if (value instanceof Map) {\n          result = new Map();\n          cloned.set(value, result); // Adding to cache now for cyclic references.\n          for (const [key, val] of value) {\n            result.set(key, fallbackCloneValue(val));\n          }\n          return result;\n        }\n        if (value instanceof Set) {\n          result = new Set();\n          cloned.set(value, result); // Adding to cache now for cyclic references.\n          for (const val of value) {\n            result.add(fallbackCloneValue(val));\n          }\n          return result;\n        }\n        result = Array.isArray(value) ? [] : Object.create(null);\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\" && !value.hasOwnProperty?.(i)) {\n            continue;\n          }\n          result[i] = fallbackCloneValue(desc.value);\n        }\n        return result;\n      }\n\n      const cloned = new WeakMap();\n      return fallbackCloneValue(object);\n    }\n\n    const event = { data: cloneValue(obj) };\n\n    this._deferred.then(() => {\n      for (const listener of this._listeners) {\n        listener.call(this, event);\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;\n *   the constants from {@link VerbosityLevel} should be used.\n */\n\nconst PDFWorkerUtil = {\n  isWorkerDisabled: false,\n  fallbackWorkerSrc: null,\n  fakeWorkerId: 0,\n};\nif (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    PDFWorkerUtil.isWorkerDisabled = true;\n\n    PDFWorkerUtil.fallbackWorkerSrc = PDFJSDev.test(\"LIB\")\n      ? \"../pdf.worker.js\"\n      : \"./pdf.worker.js\";\n  } else if (typeof document === \"object\") {\n    const pdfjsFilePath = document?.currentScript?.src;\n    if (pdfjsFilePath) {\n      PDFWorkerUtil.fallbackWorkerSrc = pdfjsFilePath.replace(\n        /(\\.(?:min\\.)?js)(\\?.*)?$/i,\n        \".worker$1$2\"\n      );\n    }\n  }\n\n  PDFWorkerUtil.createCDNWrapper = function (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/**\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 * @param {PDFWorkerParameters} params - The worker initialization parameters.\n */\nclass PDFWorker {\n  static get _workerPorts() {\n    return shadow(this, \"_workerPorts\", new WeakMap());\n  }\n\n  constructor({\n    name = null,\n    port = null,\n    verbosity = getVerbosityLevel(),\n  } = {}) {\n    if (port && PDFWorker._workerPorts.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.verbosity = verbosity;\n\n    this._readyCapability = createPromiseCapability();\n    this._port = null;\n    this._webWorker = null;\n    this._messageHandler = null;\n\n    if (port) {\n      PDFWorker._workerPorts.set(port, this);\n      this._initializeFromPort(port);\n      return;\n    }\n    this._initialize();\n  }\n\n  /**\n   * Promise for worker initialization completion.\n   * @type {Promise<void>}\n   */\n  get promise() {\n    return this._readyCapability.promise;\n  }\n\n  /**\n   * The current `workerPort`, when it exists.\n   * @type {Worker}\n   */\n  get port() {\n    return this._port;\n  }\n\n  /**\n   * The current MessageHandler-instance.\n   * @type {MessageHandler}\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 should already be initialized\n      // and ready to accept 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      !PDFWorkerUtil.isWorkerDisabled &&\n      !PDFWorker._mainThreadWorkerMessageHandler\n    ) {\n      let workerSrc = PDFWorker.workerSrc;\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 = PDFWorkerUtil.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            this._messageHandler = messageHandler;\n            this._port = worker;\n            this._webWorker = worker;\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([255]);\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 the worker to initialize. We will try to send\n        // the \"test\" message immediately, and once the \"ready\" message arrives.\n        // The worker shall process only the first received \"test\" message.\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 (!PDFWorkerUtil.isWorkerDisabled) {\n      warn(\"Setting up fake worker.\");\n      PDFWorkerUtil.isWorkerDisabled = true;\n    }\n\n    PDFWorker._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${PDFWorkerUtil.fakeWorkerId++}`;\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    PDFWorker._workerPorts.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 parameters.\n   */\n  static fromPort(params) {\n    if (!params?.port) {\n      throw new Error(\"PDFWorker.fromPort - invalid method signature.\");\n    }\n    if (this._workerPorts.has(params.port)) {\n      return this._workerPorts.get(params.port);\n    }\n    return new PDFWorker(params);\n  }\n\n  /**\n   * The current `workerSrc`, when it exists.\n   * @type {string}\n   */\n  static get workerSrc() {\n    if (GlobalWorkerOptions.workerSrc) {\n      return GlobalWorkerOptions.workerSrc;\n    }\n    if (PDFWorkerUtil.fallbackWorkerSrc !== null) {\n      if (!isNodeJS) {\n        deprecated('No \"GlobalWorkerOptions.workerSrc\" specified.');\n      }\n      return PDFWorkerUtil.fallbackWorkerSrc;\n    }\n    throw new Error('No \"GlobalWorkerOptions.workerSrc\" specified.');\n  }\n\n  static get _mainThreadWorkerMessageHandler() {\n    try {\n      return globalThis.pdfjsWorker?.WorkerMessageHandler || null;\n    } catch (ex) {\n      return null;\n    }\n  }\n\n  // Loads worker code into the main-thread.\n  static get _setupFakeWorkerGlobal() {\n    const loader = async () => {\n      const mainWorkerMessageHandler = this._mainThreadWorkerMessageHandler;\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        const worker = await 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\")(this.workerSrc);\n        return worker.WorkerMessageHandler;\n      }\n      await loadScript(this.workerSrc);\n      return window.pdfjsWorker.WorkerMessageHandler;\n    };\n\n    return shadow(this, \"_setupFakeWorkerGlobal\", loader());\n  }\n}\nif (typeof PDFJSDev !== \"undefined\" && PDFJSDev.test(\"GENERIC\")) {\n  PDFWorker.getWorkerSrc = function () {\n    deprecated(\n      \"`PDFWorker.getWorkerSrc()`, please use `PDFWorker.workerSrc` instead.\"\n    );\n    return this.workerSrc;\n  };\n}\n\n/**\n * For internal use only.\n * @ignore\n */\nclass WorkerTransport {\n  #docStats = null;\n\n  #pageCache = new Map();\n\n  #pagePromises = new Map();\n\n  #metadataPromise = null;\n\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      styleElement: params.styleElement,\n    });\n    this._params = params;\n\n    if (!params.useWorkerFetch) {\n      this.CMapReaderFactory = new params.CMapReaderFactory({\n        baseUrl: params.cMapUrl,\n        isCompressed: params.cMapPacked,\n      });\n      this.StandardFontDataFactory = new params.StandardFontDataFactory({\n        baseUrl: params.standardFontDataUrl,\n      });\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    this.downloadInfoCapability = createPromiseCapability();\n\n    this.setupMessageHandler();\n  }\n\n  get annotationStorage() {\n    return shadow(this, \"annotationStorage\", new AnnotationStorage());\n  }\n\n  get stats() {\n    return this.#docStats;\n  }\n\n  getRenderingIntent(\n    intent,\n    annotationMode = AnnotationMode.ENABLE,\n    isOpList = false\n  ) {\n    let renderingIntent = RenderingIntentFlag.DISPLAY; // Default value.\n    let lastModified = \"\";\n\n    switch (intent) {\n      case \"any\":\n        renderingIntent = RenderingIntentFlag.ANY;\n        break;\n      case \"display\":\n        break;\n      case \"print\":\n        renderingIntent = RenderingIntentFlag.PRINT;\n        break;\n      default:\n        warn(`getRenderingIntent - invalid intent: ${intent}`);\n    }\n\n    switch (annotationMode) {\n      case AnnotationMode.DISABLE:\n        renderingIntent += RenderingIntentFlag.ANNOTATIONS_DISABLE;\n        break;\n      case AnnotationMode.ENABLE:\n        break;\n      case AnnotationMode.ENABLE_FORMS:\n        renderingIntent += RenderingIntentFlag.ANNOTATIONS_FORMS;\n        break;\n      case AnnotationMode.ENABLE_STORAGE:\n        renderingIntent += RenderingIntentFlag.ANNOTATIONS_STORAGE;\n\n        lastModified = this.annotationStorage.lastModified;\n        break;\n      default:\n        warn(`getRenderingIntent - invalid annotationMode: ${annotationMode}`);\n    }\n\n    if (isOpList) {\n      renderingIntent += RenderingIntentFlag.OPLIST;\n    }\n\n    return {\n      renderingIntent,\n      cacheKey: `${renderingIntent}_${lastModified}`,\n    };\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    for (const page of this.#pageCache.values()) {\n      waitOn.push(page._destroy());\n    }\n    this.#pageCache.clear();\n    this.#pagePromises.clear();\n    // Allow `AnnotationStorage`-related clean-up when destroying the document.\n    if (this.hasOwnProperty(\"annotationStorage\")) {\n      this.annotationStorage.resetModified();\n    }\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\n    Promise.all(waitOn).then(() => {\n      this.commonObjs.clear();\n      this.fontLoader.clear();\n      this.#metadataPromise = null;\n      this._getFieldObjectsPromise = null;\n      this._hasJSActionsPromise = null;\n\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) {\n            loadingTask.onProgress?.(this._lastProgress);\n          }\n          fullReader.onProgress = evt => {\n            loadingTask.onProgress?.({\n              loaded: evt.loaded,\n              total: evt.total,\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      this._htmlForXfa = pdfInfo.htmlForXfa;\n      delete pdfInfo.htmlForXfa;\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        default:\n          unreachable(\"DocException - expected a valid Error.\");\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      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.get(data.pageIndex);\n      page._startRenderPage(data.transparency, data.cacheKey);\n    });\n\n    messageHandler.on(\"commonobj\", ([id, type, exportedData]) => {\n      if (this.destroyed) {\n        return; // Ignore any pending requests if the worker was terminated.\n      }\n\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 (params.pdfBug && globalThis.FontInspector?.enabled) {\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\", ([id, pageIndex, type, imageData]) => {\n      if (this.destroyed) {\n        // Ignore any pending requests if the worker was terminated.\n        return;\n      }\n\n      const pageProxy = this.#pageCache.get(pageIndex);\n      if (pageProxy.objs.has(id)) {\n        return;\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 (imageData?.data?.length > MAX_IMAGE_SIZE_TO_STORE) {\n            pageProxy.cleanupAfterRender = true;\n          }\n          break;\n        case \"Pattern\":\n          pageProxy.objs.resolve(id, imageData);\n          break;\n        default:\n          throw new Error(`Got unknown object type ${type}`);\n      }\n    });\n\n    messageHandler.on(\"DocProgress\", data => {\n      if (this.destroyed) {\n        return; // Ignore any pending requests if the worker was terminated.\n      }\n      loadingTask.onProgress?.({\n        loaded: data.loaded,\n        total: data.total,\n      });\n    });\n\n    messageHandler.on(\"DocStats\", data => {\n      if (this.destroyed) {\n        return; // Ignore any pending requests if the worker was terminated.\n      }\n      // Ensure that a `PDFDocumentProxy.stats` call-site cannot accidentally\n      // modify this internal data.\n      this.#docStats = Object.freeze({\n        streamTypes: Object.freeze(data.streamTypes),\n        fontTypes: Object.freeze(data.fontTypes),\n      });\n    });\n\n    messageHandler.on(\n      \"UnsupportedFeature\",\n      this._onUnsupportedFeature.bind(this)\n    );\n\n    messageHandler.on(\"FetchBuiltInCMap\", data => {\n      if (this.destroyed) {\n        return Promise.reject(new Error(\"Worker was destroyed.\"));\n      }\n      if (!this.CMapReaderFactory) {\n        return Promise.reject(\n          new Error(\n            \"CMapReaderFactory not initialized, see the `useWorkerFetch` parameter.\"\n          )\n        );\n      }\n      return this.CMapReaderFactory.fetch(data);\n    });\n\n    messageHandler.on(\"FetchStandardFontData\", data => {\n      if (this.destroyed) {\n        return Promise.reject(new Error(\"Worker was destroyed.\"));\n      }\n      if (!this.StandardFontDataFactory) {\n        return Promise.reject(\n          new Error(\n            \"StandardFontDataFactory not initialized, see the `useWorkerFetch` parameter.\"\n          )\n        );\n      }\n      return this.StandardFontDataFactory.fetch(data);\n    });\n  }\n\n  _onUnsupportedFeature({ featureId }) {\n    if (this.destroyed) {\n      return; // Ignore any pending requests if the worker was terminated.\n    }\n    this.loadingTask.onUnsupportedFeature?.(featureId);\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      cachedPromise = this.#pagePromises.get(pageIndex);\n    if (cachedPromise) {\n      return cachedPromise;\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.set(pageIndex, page);\n        return page;\n      });\n    this.#pagePromises.set(pageIndex, promise);\n    return promise;\n  }\n\n  getPageIndex(ref) {\n    return this.messageHandler.sendWithPromise(\"GetPageIndex\", {\n      ref,\n    });\n  }\n\n  getAnnotations(pageIndex, intent) {\n    return this.messageHandler.sendWithPromise(\"GetAnnotations\", {\n      pageIndex,\n      intent,\n    });\n  }\n\n  saveDocument() {\n    return this.messageHandler\n      .sendWithPromise(\"SaveDocument\", {\n        isPureXfa: !!this._htmlForXfa,\n        numPages: this._numPages,\n        annotationStorage: this.annotationStorage.serializable,\n        filename: this._fullReader?.filename ?? null,\n      })\n      .finally(() => {\n        this.annotationStorage.resetModified();\n      });\n  }\n\n  getFieldObjects() {\n    return (this._getFieldObjectsPromise ||=\n      this.messageHandler.sendWithPromise(\"GetFieldObjects\", null));\n  }\n\n  hasJSActions() {\n    return (this._hasJSActionsPromise ||= this.messageHandler.sendWithPromise(\n      \"HasJSActions\",\n      null\n    ));\n  }\n\n  getCalculationOrderIds() {\n    return this.messageHandler.sendWithPromise(\"GetCalculationOrderIds\", null);\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  getDocJSActions() {\n    return this.messageHandler.sendWithPromise(\"GetDocJSActions\", null);\n  }\n\n  getPageJSActions(pageIndex) {\n    return this.messageHandler.sendWithPromise(\"GetPageJSActions\", {\n      pageIndex,\n    });\n  }\n\n  getStructTree(pageIndex) {\n    return this.messageHandler.sendWithPromise(\"GetStructTree\", {\n      pageIndex,\n    });\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.#metadataPromise ||= 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?.filename ?? null,\n          contentLength: this._fullReader?.contentLength ?? null,\n        };\n      }));\n  }\n\n  getMarkInfo() {\n    return this.messageHandler.sendWithPromise(\"GetMarkInfo\", null);\n  }\n\n  async startCleanup(keepLoadedFonts = false) {\n    await this.messageHandler.sendWithPromise(\"Cleanup\", null);\n\n    if (this.destroyed) {\n      return; // No need to manually clean-up when destruction has started.\n    }\n    for (const page of this.#pageCache.values()) {\n      const cleanupSuccessful = page.cleanup();\n\n      if (!cleanupSuccessful) {\n        throw new Error(\n          `startCleanup: Page ${page.pageNumber} is currently rendering.`\n        );\n      }\n    }\n    this.commonObjs.clear();\n    if (!keepLoadedFonts) {\n      this.fontLoader.clear();\n    }\n    this.#metadataPromise = null;\n    this._getFieldObjectsPromise = null;\n    this._hasJSActionsPromise = null;\n  }\n\n  get loadingParams() {\n    const params = this._params;\n    return shadow(this, \"loadingParams\", {\n      disableAutoFetch: params.disableAutoFetch,\n      enableXfa: params.enableXfa,\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?.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 */\nclass InternalRenderTask {\n  static get canvasInUse() {\n    return shadow(this, \"canvasInUse\", new WeakSet());\n  }\n\n  constructor({\n    callback,\n    params,\n    objs,\n    commonObjs,\n    annotationCanvasMap,\n    operatorList,\n    pageIndex,\n    canvasFactory,\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.annotationCanvasMap = annotationCanvasMap;\n    this.operatorListIdx = null;\n    this.operatorList = operatorList;\n    this._pageIndex = pageIndex;\n    this.canvasFactory = canvasFactory;\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._cancelBound = this.cancel.bind(this);\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 (InternalRenderTask.canvasInUse.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      InternalRenderTask.canvasInUse.add(this._canvas);\n    }\n\n    if (this._pdfBug && globalThis.StepperManager?.enabled) {\n      this.stepper = globalThis.StepperManager.create(this._pageIndex);\n      this.stepper.init(this.operatorList);\n      this.stepper.nextBreakPoint = this.stepper.getNextBreakPoint();\n    }\n    const { canvasContext, viewport, transform, imageLayer, background } =\n      this.params;\n\n    this.gfx = new CanvasGraphics(\n      canvasContext,\n      this.commonObjs,\n      this.objs,\n      this.canvasFactory,\n      imageLayer,\n      optionalContentConfig,\n      this.annotationCanvasMap\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      InternalRenderTask.canvasInUse.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._cancelBound);\n      });\n    } else {\n      Promise.resolve().then(this._nextBound).catch(this._cancelBound);\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          InternalRenderTask.canvasInUse.delete(this._canvas);\n        }\n        this.callback();\n      }\n    }\n  }\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  build,\n  DefaultCanvasFactory,\n  DefaultCMapReaderFactory,\n  DefaultStandardFontDataFactory,\n  getDocument,\n  LoopbackPort,\n  PDFDataRangeTransport,\n  PDFDocumentLoadingTask,\n  PDFDocumentProxy,\n  PDFPageProxy,\n  PDFWorker,\n  RenderTask,\n  setPDFNetworkStreamFactory,\n  version,\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    // For testing only.\n    styleElement = null,\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 =\n      typeof PDFJSDev === \"undefined\" || PDFJSDev.test(\"!PRODUCTION || TESTING\")\n        ? styleElement\n        : 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    const styleSheet = styleElement.sheet;\n    styleSheet.insertRule(rule, styleSheet.cssRules.length);\n  }\n\n  clear() {\n    for (const nativeFontFace of this.nativeFontFaces) {\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 hasFonts = !!this._document?.fonts;\n    if (\n      typeof PDFJSDev === \"undefined\" ||\n      PDFJSDev.test(\"!PRODUCTION || TESTING\")\n    ) {\n      return shadow(\n        this,\n        \"isFontLoadingAPISupported\",\n        hasFonts && !this.styleElement\n      );\n    }\n    return shadow(this, \"isFontLoadingAPISupported\", hasFonts);\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?.[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 (const font of fonts) {\n        names.push(font.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 (const name of names) {\n        const span = this._document.createElement(\"span\");\n        span.textContent = \"Hi\";\n        span.style.fontFamily = name;\n        div.appendChild(span);\n      }\n      this._document.body.appendChild(div);\n\n      isFontReady(loadTestFontId, () => {\n        div.remove();\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,\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    let nativeFontFace;\n    if (!this.cssFontInfo) {\n      nativeFontFace = new FontFace(this.loadedName, this.data, {});\n    } else {\n      const css = {\n        weight: this.cssFontInfo.fontWeight,\n      };\n      if (this.cssFontInfo.italicAngle) {\n        css.style = `oblique ${this.cssFontInfo.italicAngle}deg`;\n      }\n      nativeFontFace = new FontFace(\n        this.cssFontInfo.fontFamily,\n        this.data,\n        css\n      );\n    }\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(this.data);\n    // Add the @font-face rule to the document.\n    const url = `url(data:${this.mimetype};base64,${btoa(data)});`;\n    let rule;\n    if (!this.cssFontInfo) {\n      rule = `@font-face {font-family:\"${this.loadedName}\";src:${url}}`;\n    } else {\n      let css = `font-weight: ${this.cssFontInfo.fontWeight};`;\n      if (this.cssFontInfo.italicAngle) {\n        css += `font-style: oblique ${this.cssFontInfo.italicAngle}deg;`;\n      }\n      rule = `@font-face {font-family:\"${this.cssFontInfo.fontFamily}\";${css}src:${url}}`;\n    }\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;\n    try {\n      cmds = objs.get(this.loadedName + \"_path_\" + character);\n    } catch (ex) {\n      if (!this.ignoreErrors) {\n        throw ex;\n      }\n      this._onUnsupportedFeature({\n        featureId: UNSUPPORTED_FEATURES.errorFontGetPath,\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      const jsBuf = [];\n      for (const current of cmds) {\n        const args = current.args !== undefined ? current.args.join(\",\") : \"\";\n        jsBuf.push(\"c.\", current.cmd, \"(\", args, \");\\n\");\n      }\n      // eslint-disable-next-line no-new-func\n      return (this.compiledGlyphs[character] = new Function(\n        \"c\",\n        \"size\",\n        jsBuf.join(\"\")\n      ));\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 (const current of cmds) {\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\nimport {\n  BaseCanvasFactory,\n  BaseCMapReaderFactory,\n  BaseStandardFontDataFactory,\n} from \"./base_factory.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\nlet NodeStandardFontDataFactory = class {\n  constructor() {\n    unreachable(\"Not implemented: NodeStandardFontDataFactory\");\n  }\n};\n\nif ((typeof PDFJSDev === \"undefined\" || PDFJSDev.test(\"GENERIC\")) && isNodeJS) {\n  const fetchData = function (url) {\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(new Uint8Array(data));\n      });\n    });\n  };\n\n  NodeCanvasFactory = class extends BaseCanvasFactory {\n    _createCanvas(width, height) {\n      const Canvas = __non_webpack_require__(\"canvas\");\n      return Canvas.createCanvas(width, height);\n    }\n  };\n\n  NodeCMapReaderFactory = class extends BaseCMapReaderFactory {\n    _fetchData(url, compressionType) {\n      return fetchData(url).then(data => {\n        return { cMapData: data, compressionType };\n      });\n    }\n  };\n\n  NodeStandardFontDataFactory = class extends BaseStandardFontDataFactory {\n    _fetchData(url) {\n      return fetchData(url);\n    }\n  };\n}\n\nexport {\n  NodeCanvasFactory,\n  NodeCMapReaderFactory,\n  NodeStandardFontDataFactory,\n};\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\nimport { objectFromMap } from \"../shared/util.js\";\n\n/**\n * Key/value storage for annotation data in forms.\n */\nclass AnnotationStorage {\n  constructor() {\n    this._storage = new Map();\n    this._timeStamp = Date.now();\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 effects.\n    this.onSetModified = null;\n    this.onResetModified = null;\n  }\n\n  /**\n   * Get the value for a given key if it exists, or return the default value.\n   *\n   * @public\n   * @memberof AnnotationStorage\n   * @param {string} key\n   * @param {Object} defaultValue\n   * @returns {Object}\n   */\n  getValue(key, defaultValue) {\n    const value = this._storage.get(key);\n    if (value === undefined) {\n      return defaultValue;\n    }\n\n    return Object.assign(defaultValue, value);\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    const obj = this._storage.get(key);\n    let modified = false;\n    if (obj !== undefined) {\n      for (const [entry, val] of Object.entries(value)) {\n        if (obj[entry] !== val) {\n          modified = true;\n          obj[entry] = val;\n        }\n      }\n    } else {\n      modified = true;\n      this._storage.set(key, value);\n    }\n    if (modified) {\n      this._timeStamp = Date.now();\n      this._setModified();\n    }\n  }\n\n  getAll() {\n    return this._storage.size > 0 ? objectFromMap(this._storage) : null;\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  /**\n   * PLEASE NOTE: Only intended for usage within the API itself.\n   * @ignore\n   */\n  get serializable() {\n    return this._storage.size > 0 ? this._storage : null;\n  }\n\n  /**\n   * PLEASE NOTE: Only intended for usage within the API itself.\n   * @ignore\n   */\n  get lastModified() {\n    return this._timeStamp.toString();\n  }\n}\n\nexport { AnnotationStorage };\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 {\n  getShadingPattern,\n  PathType,\n  TilingPattern,\n} from \"./pattern_helper.js\";\nimport { PixelsPerInch } from \"./display_utils.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// Minimal font size that would be used during canvas fillText operations.\nconst MIN_FONT_SIZE = 16;\n// Maximum font size that would be used during canvas fillText operations.\nconst MAX_FONT_SIZE = 100;\nconst MAX_GROUP_SIZE = 4096;\n\n// Defines the time the `executeOperatorList`-method is going to be executing\n// before it stops and shedules a continue of execution.\nconst EXECUTION_TIME = 15; // ms\n// Defines the number of steps before checking the execution time.\nconst EXECUTION_STEPS = 10;\n\nconst COMPILE_TYPE3_GLYPHS = true;\nconst MAX_SIZE_TO_COMPILE = 1000;\n\nconst FULL_CHUNK_HEIGHT = 16;\n\n// Because of https://bugs.chromium.org/p/chromium/issues/detail?id=1170396\n// some curves aren't rendered correctly.\n// Multiplying lineWidth by this factor should help to have \"correct\"\n// rendering with no artifacts.\n// Once the bug is fixed upstream, we can remove this constant and its use.\nconst LINEWIDTH_SCALE_FACTOR = 1.000001;\n\n/**\n * Overrides certain methods on a 2d ctx so that when they are called they\n * will also call the same method on the destCtx. The methods that are\n * overridden are all the transformation state modifiers, path creation, and\n * save/restore. We only forward these specific methods because they are the\n * only state modifiers that we cannot copy over when we switch contexts.\n *\n * To remove mirroring call `ctx._removeMirroring()`.\n *\n * @param {Object} ctx - The 2d canvas context that will duplicate its calls on\n *   the destCtx.\n * @param {Object} destCtx - The 2d canvas context that will receive the\n *   forwarded calls.\n */\nfunction mirrorContextOperations(ctx, destCtx) {\n  if (ctx._removeMirroring) {\n    throw new Error(\"Context is already forwarding operations.\");\n  }\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  ctx.__originalResetTransform = ctx.resetTransform;\n  ctx.__originalClip = ctx.clip;\n  ctx.__originalMoveTo = ctx.moveTo;\n  ctx.__originalLineTo = ctx.lineTo;\n  ctx.__originalBezierCurveTo = ctx.bezierCurveTo;\n  ctx.__originalRect = ctx.rect;\n  ctx.__originalClosePath = ctx.closePath;\n  ctx.__originalBeginPath = ctx.beginPath;\n\n  ctx._removeMirroring = () => {\n    ctx.save = ctx.__originalSave;\n    ctx.restore = ctx.__originalRestore;\n    ctx.rotate = ctx.__originalRotate;\n    ctx.scale = ctx.__originalScale;\n    ctx.translate = ctx.__originalTranslate;\n    ctx.transform = ctx.__originalTransform;\n    ctx.setTransform = ctx.__originalSetTransform;\n    ctx.resetTransform = ctx.__originalResetTransform;\n\n    ctx.clip = ctx.__originalClip;\n    ctx.moveTo = ctx.__originalMoveTo;\n    ctx.lineTo = ctx.__originalLineTo;\n    ctx.bezierCurveTo = ctx.__originalBezierCurveTo;\n    ctx.rect = ctx.__originalRect;\n    ctx.closePath = ctx.__originalClosePath;\n    ctx.beginPath = ctx.__originalBeginPath;\n    delete ctx._removeMirroring;\n  };\n\n  ctx.save = function ctxSave() {\n    destCtx.save();\n    this.__originalSave();\n  };\n\n  ctx.restore = function ctxRestore() {\n    destCtx.restore();\n    this.__originalRestore();\n  };\n\n  ctx.translate = function ctxTranslate(x, y) {\n    destCtx.translate(x, y);\n    this.__originalTranslate(x, y);\n  };\n\n  ctx.scale = function ctxScale(x, y) {\n    destCtx.scale(x, y);\n    this.__originalScale(x, y);\n  };\n\n  ctx.transform = function ctxTransform(a, b, c, d, e, f) {\n    destCtx.transform(a, b, c, d, e, f);\n    this.__originalTransform(a, b, c, d, e, f);\n  };\n\n  ctx.setTransform = function ctxSetTransform(a, b, c, d, e, f) {\n    destCtx.setTransform(a, b, c, d, e, f);\n    this.__originalSetTransform(a, b, c, d, e, f);\n  };\n\n  ctx.resetTransform = function ctxResetTransform() {\n    destCtx.resetTransform();\n    this.__originalResetTransform();\n  };\n\n  ctx.rotate = function ctxRotate(angle) {\n    destCtx.rotate(angle);\n    this.__originalRotate(angle);\n  };\n\n  ctx.clip = function ctxRotate(rule) {\n    destCtx.clip(rule);\n    this.__originalClip(rule);\n  };\n\n  ctx.moveTo = function (x, y) {\n    destCtx.moveTo(x, y);\n    this.__originalMoveTo(x, y);\n  };\n\n  ctx.lineTo = function (x, y) {\n    destCtx.lineTo(x, y);\n    this.__originalLineTo(x, y);\n  };\n\n  ctx.bezierCurveTo = function (cp1x, cp1y, cp2x, cp2y, x, y) {\n    destCtx.bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y);\n    this.__originalBezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y);\n  };\n\n  ctx.rect = function (x, y, width, height) {\n    destCtx.rect(x, y, width, height);\n    this.__originalRect(x, y, width, height);\n  };\n\n  ctx.closePath = function () {\n    destCtx.closePath();\n    this.__originalClosePath();\n  };\n\n  ctx.beginPath = function () {\n    destCtx.beginPath();\n    this.__originalBeginPath();\n  };\n}\n\nfunction addContextCurrentTransform(ctx) {\n  // If the context doesn't expose a `mozCurrentTransform`, add a JS based one.\n  if (ctx.mozCurrentTransform) {\n    return;\n  }\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  ctx._originalResetTransform = ctx.resetTransform;\n\n  ctx._transformMatrix = ctx._transformMatrix || [1, 0, 0, 1, 0, 0];\n  ctx._transformStack = [];\n\n  try {\n    // The call to getOwnPropertyDescriptor throws an exception in Node.js:\n    // \"TypeError: Method lineWidth called on incompatible receiver\n    //  #<CanvasRenderingContext2D>\".\n    const desc = Object.getOwnPropertyDescriptor(\n      Object.getPrototypeOf(ctx),\n      \"lineWidth\"\n    );\n\n    ctx._setLineWidth = desc.set;\n    ctx._getLineWidth = desc.get;\n\n    Object.defineProperty(ctx, \"lineWidth\", {\n      set: function setLineWidth(width) {\n        this._setLineWidth(width * LINEWIDTH_SCALE_FACTOR);\n      },\n      get: function getLineWidth() {\n        return this._getLineWidth();\n      },\n    });\n  } catch (_) {}\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      const [a, b, c, d, e, f] = this._transformMatrix;\n      const ad_bc = a * d - b * c;\n      const 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    const 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    const 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    const 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    const m = this._transformMatrix;\n    m[0] *= x;\n    m[1] *= x;\n    m[2] *= y;\n    m[3] *= y;\n\n    this._originalScale(x, y);\n  };\n\n  ctx.transform = function ctxTransform(a, b, c, d, e, f) {\n    const 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.resetTransform = function ctxResetTransform() {\n    this._transformMatrix = [1, 0, 0, 1, 0, 0];\n\n    ctx._originalResetTransform();\n  };\n\n  ctx.rotate = function ctxRotate(angle) {\n    const cosValue = Math.cos(angle);\n    const sinValue = Math.sin(angle);\n\n    const 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\nclass CachedCanvases {\n  constructor(canvasFactory) {\n    this.canvasFactory = canvasFactory;\n    this.cache = Object.create(null);\n  }\n\n  getCanvas(id, width, height, trackTransform) {\n    let 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\n  clear() {\n    for (const id in this.cache) {\n      const canvasEntry = this.cache[id];\n      this.canvasFactory.destroy(canvasEntry);\n      delete this.cache[id];\n    }\n  }\n}\n\nfunction compileType3Glyph(imgData) {\n  const POINT_TO_PROCESS_LIMIT = 1000;\n  const POINT_TYPES = new Uint8Array([\n    0, 2, 4, 0, 1, 0, 5, 4, 8, 10, 0, 8, 0, 2, 1, 0,\n  ]);\n\n  const width = imgData.width,\n    height = imgData.height,\n    width1 = width + 1;\n  let i, ii, j, j0;\n  const points = new Uint8Array(width1 * (height + 1));\n\n  // decodes bit-packed mask data\n  const lineSize = (width + 7) & ~7,\n    data0 = imgData.data;\n  const data = new Uint8Array(lineSize * height);\n  let pos = 0;\n  for (i = 0, ii = data0.length; i < ii; i++) {\n    const elem = data0[i];\n    let mask = 128;\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  let 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    let 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  const steps = new Int32Array([0, width1, -1, 0, -width1, 0, 0, 0, 1]);\n  const outlines = [];\n  for (i = 0; count && i <= height; i++) {\n    let p = i * width1;\n    const end = p + width;\n    while (p < end && !points[p]) {\n      p++;\n    }\n    if (p === end) {\n      continue;\n    }\n    const coords = [p % width1, i];\n\n    const p0 = p;\n    let type = points[p];\n    do {\n      const step = steps[type];\n      do {\n        p += step;\n      } while (!points[p]);\n\n      const 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, (p / width1) | 0);\n\n      if (!points[p]) {\n        --count;\n      }\n    } while (p0 !== p);\n    outlines.push(coords);\n    --i;\n  }\n\n  const 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      const 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\nclass CanvasExtraState {\n  constructor(width, height) {\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.transferMaps = null;\n\n    this.startNewPathAndClipBox([0, 0, width, height]);\n  }\n\n  clone() {\n    const clone = Object.create(this);\n    clone.clipBox = this.clipBox.slice();\n    return clone;\n  }\n\n  setCurrentPoint(x, y) {\n    this.x = x;\n    this.y = y;\n  }\n\n  updatePathMinMax(transform, x, y) {\n    [x, y] = Util.applyTransform([x, y], transform);\n    this.minX = Math.min(this.minX, x);\n    this.minY = Math.min(this.minY, y);\n    this.maxX = Math.max(this.maxX, x);\n    this.maxY = Math.max(this.maxY, y);\n  }\n\n  updateCurvePathMinMax(transform, x0, y0, x1, y1, x2, y2, x3, y3) {\n    const box = Util.bezierBoundingBox(x0, y0, x1, y1, x2, y2, x3, y3);\n    this.updatePathMinMax(transform, box[0], box[1]);\n    this.updatePathMinMax(transform, box[2], box[3]);\n  }\n\n  getPathBoundingBox(pathType = PathType.FILL, transform = null) {\n    const box = [this.minX, this.minY, this.maxX, this.maxY];\n    if (pathType === PathType.STROKE) {\n      if (!transform) {\n        unreachable(\"Stroke bounding box must include transform.\");\n      }\n      // Stroked paths can be outside of the path bounding box by 1/2 the line\n      // width.\n      const scale = Util.singularValueDecompose2dScale(transform);\n      const xStrokePad = (scale[0] * this.lineWidth) / 2;\n      const yStrokePad = (scale[1] * this.lineWidth) / 2;\n      box[0] -= xStrokePad;\n      box[1] -= yStrokePad;\n      box[2] += xStrokePad;\n      box[3] += yStrokePad;\n    }\n    return box;\n  }\n\n  updateClipFromPath() {\n    const intersect = Util.intersect(this.clipBox, this.getPathBoundingBox());\n    this.startNewPathAndClipBox(intersect || [0, 0, 0, 0]);\n  }\n\n  startNewPathAndClipBox(box) {\n    this.clipBox = box;\n    this.minX = Infinity;\n    this.minY = Infinity;\n    this.maxX = 0;\n    this.maxY = 0;\n  }\n\n  getClippedPathBoundingBox(pathType = PathType.FILL, transform = null) {\n    return Util.intersect(\n      this.clipBox,\n      this.getPathBoundingBox(pathType, transform)\n    );\n  }\n}\n\nfunction 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  const height = imgData.height,\n    width = imgData.width;\n  const partialChunkHeight = height % FULL_CHUNK_HEIGHT;\n  const fullChunks = (height - partialChunkHeight) / FULL_CHUNK_HEIGHT;\n  const totalChunks = partialChunkHeight === 0 ? fullChunks : fullChunks + 1;\n\n  const chunkImgData = ctx.createImageData(width, FULL_CHUNK_HEIGHT);\n  let srcPos = 0,\n    destPos;\n  const src = imgData.data;\n  const dest = chunkImgData.data;\n  let 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    const srcLength = src.byteLength;\n    const dest32 = new Uint32Array(dest.buffer, 0, dest.byteLength >> 2);\n    const dest32DataLength = dest32.length;\n    const fullSrcDiff = (width + 7) >> 3;\n    let white = 0xffffffff;\n    let 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 = i < fullChunks ? FULL_CHUNK_HEIGHT : partialChunkHeight;\n      destPos = 0;\n      for (j = 0; j < thisChunkHeight; j++) {\n        const srcDiff = srcLength - srcPos;\n        let k = 0;\n        const kEnd = srcDiff > fullSrcDiff ? width : srcDiff * 8 - 7;\n        const kEndUnrolled = kEnd & ~7;\n        let mask = 0;\n        let 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\nfunction putBinaryImageMask(ctx, imgData) {\n  const height = imgData.height,\n    width = imgData.width;\n  const partialChunkHeight = height % FULL_CHUNK_HEIGHT;\n  const fullChunks = (height - partialChunkHeight) / FULL_CHUNK_HEIGHT;\n  const totalChunks = partialChunkHeight === 0 ? fullChunks : fullChunks + 1;\n\n  const chunkImgData = ctx.createImageData(width, FULL_CHUNK_HEIGHT);\n  let srcPos = 0;\n  const src = imgData.data;\n  const dest = chunkImgData.data;\n\n  for (let i = 0; i < totalChunks; i++) {\n    const 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    let destPos = 3; // alpha component offset\n    for (let j = 0; j < thisChunkHeight; j++) {\n      let elem,\n        mask = 0;\n      for (let k = 0; k < width; k++) {\n        if (!mask) {\n          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\nfunction copyCtxState(sourceCtx, destCtx) {\n  const properties = [\n    \"strokeStyle\",\n    \"fillStyle\",\n    \"fillRule\",\n    \"globalAlpha\",\n    \"lineWidth\",\n    \"lineCap\",\n    \"lineJoin\",\n    \"miterLimit\",\n    \"globalCompositeOperation\",\n    \"font\",\n  ];\n  for (let i = 0, ii = properties.length; i < ii; i++) {\n    const 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\nfunction 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\nfunction composeSMaskBackdrop(bytes, r0, g0, b0) {\n  const length = bytes.length;\n  for (let i = 3; i < length; i += 4) {\n    const 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      const 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\nfunction composeSMaskAlpha(maskData, layerData, transferMap) {\n  const length = maskData.length;\n  const scale = 1 / 255;\n  for (let i = 3; i < length; i += 4) {\n    const alpha = transferMap ? transferMap[maskData[i]] : maskData[i];\n    layerData[i] = (layerData[i] * alpha * scale) | 0;\n  }\n}\n\nfunction composeSMaskLuminosity(maskData, layerData, transferMap) {\n  const length = maskData.length;\n  for (let i = 3; i < length; i += 4) {\n    const 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\nfunction genericComposeSMask(\n  maskCtx,\n  layerCtx,\n  width,\n  height,\n  subtype,\n  backdrop,\n  transferMap,\n  layerOffsetX,\n  layerOffsetY,\n  maskOffsetX,\n  maskOffsetY\n) {\n  const hasBackdrop = !!backdrop;\n  const r0 = hasBackdrop ? backdrop[0] : 0;\n  const g0 = hasBackdrop ? backdrop[1] : 0;\n  const b0 = hasBackdrop ? backdrop[2] : 0;\n\n  let composeFn;\n  if (subtype === \"Luminosity\") {\n    composeFn = composeSMaskLuminosity;\n  } else {\n    composeFn = composeSMaskAlpha;\n  }\n\n  // processing image in chunks to save memory\n  const PIXELS_TO_PROCESS = 1048576;\n  const chunkSize = Math.min(height, Math.ceil(PIXELS_TO_PROCESS / width));\n  for (let row = 0; row < height; row += chunkSize) {\n    const chunkHeight = Math.min(chunkSize, height - row);\n    const maskData = maskCtx.getImageData(\n      layerOffsetX - maskOffsetX,\n      row + (layerOffsetY - maskOffsetY),\n      width,\n      chunkHeight\n    );\n    const layerData = layerCtx.getImageData(\n      layerOffsetX,\n      row + layerOffsetY,\n      width,\n      chunkHeight\n    );\n\n    if (hasBackdrop) {\n      composeSMaskBackdrop(maskData.data, r0, g0, b0);\n    }\n    composeFn(maskData.data, layerData.data, transferMap);\n\n    layerCtx.putImageData(layerData, layerOffsetX, row + layerOffsetY);\n  }\n}\n\nfunction composeSMask(ctx, smask, layerCtx, layerBox) {\n  const layerOffsetX = layerBox[0];\n  const layerOffsetY = layerBox[1];\n  const layerWidth = layerBox[2] - layerOffsetX;\n  const layerHeight = layerBox[3] - layerOffsetY;\n  if (layerWidth === 0 || layerHeight === 0) {\n    return;\n  }\n  genericComposeSMask(\n    smask.context,\n    layerCtx,\n    layerWidth,\n    layerHeight,\n    smask.subtype,\n    smask.backdrop,\n    smask.transferMap,\n    layerOffsetX,\n    layerOffsetY,\n    smask.offsetX,\n    smask.offsetY\n  );\n  ctx.save();\n  ctx.globalAlpha = 1;\n  ctx.globalCompositeOperation = \"source-over\";\n  ctx.setTransform(1, 0, 0, 1, 0, 0);\n  ctx.drawImage(layerCtx.canvas, 0, 0);\n  ctx.restore();\n}\n\nfunction getImageSmoothingEnabled(transform, interpolate) {\n  const scale = Util.singularValueDecompose2dScale(transform);\n  // Round to a 32bit float so that `<=` check below will pass for numbers that\n  // are very close, but not exactly the same 64bit floats.\n  scale[0] = Math.fround(scale[0]);\n  scale[1] = Math.fround(scale[1]);\n  const actualScale = Math.fround(\n    (globalThis.devicePixelRatio || 1) * PixelsPerInch.PDF_TO_CSS_UNITS\n  );\n  if (interpolate !== undefined) {\n    // If the value is explicitly set use it.\n    return interpolate;\n  } else if (scale[0] <= actualScale || scale[1] <= actualScale) {\n    // Smooth when downscaling.\n    return true;\n  }\n  // Don't smooth when upscaling.\n  return false;\n}\n\nconst LINE_CAP_STYLES = [\"butt\", \"round\", \"square\"];\nconst LINE_JOIN_STYLES = [\"miter\", \"round\", \"bevel\"];\nconst NORMAL_CLIP = {};\nconst EO_CLIP = {};\n\nclass CanvasGraphics {\n  constructor(\n    canvasCtx,\n    commonObjs,\n    objs,\n    canvasFactory,\n    imageLayer,\n    optionalContentConfig,\n    annotationCanvasMap\n  ) {\n    this.ctx = canvasCtx;\n    this.current = new CanvasExtraState(\n      this.ctx.canvas.width,\n      this.ctx.canvas.height\n    );\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.imageLayer = imageLayer;\n    this.groupStack = [];\n    this.processingType3 = null;\n    // Patterns are painted relative to the initial page/form transform, see\n    // PDF 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.suspendedCtx = null;\n    this.contentVisible = true;\n    this.markedContentStack = [];\n    this.optionalContentConfig = optionalContentConfig;\n    this.cachedCanvases = new CachedCanvases(this.canvasFactory);\n    this.cachedPatterns = new Map();\n    this.annotationCanvasMap = annotationCanvasMap;\n    this.viewportScale = 1;\n    this.outputScaleX = 1;\n    this.outputScaleY = 1;\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  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    const width = this.ctx.canvas.width;\n    const 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      const 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(this.ctx, this.compositeCtx.mozCurrentTransform);\n    }\n\n    this.ctx.save();\n    resetCtxToDefault(this.ctx);\n    if (transform) {\n      this.ctx.transform.apply(this.ctx, transform);\n      this.outputScaleX = transform[0];\n      this.outputScaleY = transform[0];\n    }\n    this.ctx.transform.apply(this.ctx, viewport.transform);\n    this.viewportScale = viewport.scale;\n\n    this.baseTransform = this.ctx.mozCurrentTransform.slice();\n    this._combinedScaleFactor = Math.hypot(\n      this.baseTransform[0],\n      this.baseTransform[2]\n    );\n\n    if (this.imageLayer) {\n      this.imageLayer.beginLayout();\n    }\n  }\n\n  executeOperatorList(\n    operatorList,\n    executionStartIdx,\n    continueCallback,\n    stepper\n  ) {\n    const argsArray = operatorList.argsArray;\n    const fnArray = operatorList.fnArray;\n    let i = executionStartIdx || 0;\n    const argsArrayLen = argsArray.length;\n\n    // Sometimes the OperatorList to execute is empty.\n    if (argsArrayLen === i) {\n      return i;\n    }\n\n    const chunkOperations =\n      argsArrayLen - i > EXECUTION_STEPS &&\n      typeof continueCallback === \"function\";\n    const endTime = chunkOperations ? Date.now() + EXECUTION_TIME : 0;\n    let steps = 0;\n\n    const commonObjs = this.commonObjs;\n    const objs = this.objs;\n    let 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() {\n    // Finishing all opened operations such as SMask group painting.\n    while (this.stateStack.length || this.current.activeSMask !== null) {\n      this.restore();\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.cachedPatterns.clear();\n\n    if (this.imageLayer) {\n      this.imageLayer.endLayout();\n    }\n  }\n\n  _scaleImage(img, inverseTransform) {\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    const width = img.width;\n    const height = img.height;\n    let widthScale = Math.max(\n      Math.hypot(inverseTransform[0], inverseTransform[1]),\n      1\n    );\n    let heightScale = Math.max(\n      Math.hypot(inverseTransform[2], inverseTransform[3]),\n      1\n    );\n\n    let paintWidth = width,\n      paintHeight = height;\n    let tmpCanvasId = \"prescale1\";\n    let tmpCanvas, tmpCtx;\n    while (\n      (widthScale > 2 && paintWidth > 1) ||\n      (heightScale > 2 && paintHeight > 1)\n    ) {\n      let 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        img,\n        0,\n        0,\n        paintWidth,\n        paintHeight,\n        0,\n        0,\n        newWidth,\n        newHeight\n      );\n      img = tmpCanvas.canvas;\n      paintWidth = newWidth;\n      paintHeight = newHeight;\n      tmpCanvasId = tmpCanvasId === \"prescale1\" ? \"prescale2\" : \"prescale1\";\n    }\n    return {\n      img,\n      paintWidth,\n      paintHeight,\n    };\n  }\n\n  _createMaskCanvas(img) {\n    const ctx = this.ctx;\n    const width = img.width,\n      height = img.height;\n    const fillColor = this.current.fillColor;\n    const isPatternFill = this.current.patternFill;\n    const maskCanvas = this.cachedCanvases.getCanvas(\n      \"maskCanvas\",\n      width,\n      height\n    );\n    const maskCtx = maskCanvas.context;\n    putBinaryImageMask(maskCtx, img);\n\n    // Create the mask canvas at the size it will be drawn at and also set\n    // its transform to match the current transform so if there are any\n    // patterns applied they will be applied relative to the correct\n    // transform.\n    const objToCanvas = ctx.mozCurrentTransform;\n    let maskToCanvas = Util.transform(objToCanvas, [\n      1 / width,\n      0,\n      0,\n      -1 / height,\n      0,\n      0,\n    ]);\n    maskToCanvas = Util.transform(maskToCanvas, [1, 0, 0, 1, 0, -height]);\n    const cord1 = Util.applyTransform([0, 0], maskToCanvas);\n    const cord2 = Util.applyTransform([width, height], maskToCanvas);\n    const rect = Util.normalizeRect([cord1[0], cord1[1], cord2[0], cord2[1]]);\n    const drawnWidth = Math.ceil(rect[2] - rect[0]);\n    const drawnHeight = Math.ceil(rect[3] - rect[1]);\n    const fillCanvas = this.cachedCanvases.getCanvas(\n      \"fillCanvas\",\n      drawnWidth,\n      drawnHeight,\n      true\n    );\n    const fillCtx = fillCanvas.context;\n    // The offset will be the top-left cordinate mask.\n    const offsetX = Math.min(cord1[0], cord2[0]);\n    const offsetY = Math.min(cord1[1], cord2[1]);\n    fillCtx.translate(-offsetX, -offsetY);\n    fillCtx.transform.apply(fillCtx, maskToCanvas);\n    // Pre-scale if needed to improve image smoothing.\n    const scaled = this._scaleImage(\n      maskCanvas.canvas,\n      fillCtx.mozCurrentTransformInverse\n    );\n    fillCtx.imageSmoothingEnabled = getImageSmoothingEnabled(\n      fillCtx.mozCurrentTransform,\n      img.interpolate\n    );\n    fillCtx.drawImage(\n      scaled.img,\n      0,\n      0,\n      scaled.img.width,\n      scaled.img.height,\n      0,\n      0,\n      width,\n      height\n    );\n    fillCtx.globalCompositeOperation = \"source-in\";\n\n    const inverse = Util.transform(fillCtx.mozCurrentTransformInverse, [\n      1,\n      0,\n      0,\n      1,\n      -offsetX,\n      -offsetY,\n    ]);\n    fillCtx.fillStyle = isPatternFill\n      ? fillColor.getPattern(ctx, this, inverse, PathType.FILL)\n      : fillColor;\n\n    fillCtx.fillRect(0, 0, width, height);\n\n    // Round the offsets to avoid drawing fractional pixels.\n    return {\n      canvas: fillCanvas.canvas,\n      offsetX: Math.round(offsetX),\n      offsetY: Math.round(offsetY),\n    };\n  }\n\n  // Graphics state\n  setLineWidth(width) {\n    this.current.lineWidth = width;\n    this.ctx.lineWidth = width;\n  }\n\n  setLineCap(style) {\n    this.ctx.lineCap = LINE_CAP_STYLES[style];\n  }\n\n  setLineJoin(style) {\n    this.ctx.lineJoin = LINE_JOIN_STYLES[style];\n  }\n\n  setMiterLimit(limit) {\n    this.ctx.miterLimit = limit;\n  }\n\n  setDash(dashArray, dashPhase) {\n    const ctx = this.ctx;\n    if (ctx.setLineDash !== undefined) {\n      ctx.setLineDash(dashArray);\n      ctx.lineDashOffset = dashPhase;\n    }\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 (let i = 0, ii = states.length; i < ii; i++) {\n      const state = states[i];\n      const key = state[0];\n      const 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          this.current.activeSMask = value ? this.tempSMask : null;\n          this.tempSMask = null;\n          this.checkSMaskState();\n          break;\n        case \"TR\":\n          this.current.transferMaps = value;\n      }\n    }\n  }\n\n  checkSMaskState() {\n    const inSMaskMode = !!this.suspendedCtx;\n    if (this.current.activeSMask && !inSMaskMode) {\n      this.beginSMaskMode();\n    } else if (!this.current.activeSMask && inSMaskMode) {\n      this.endSMaskMode();\n    }\n    // Else, the state is okay and nothing needs to be done.\n  }\n\n  /**\n   * Soft mask mode takes the current main drawing canvas and replaces it with\n   * a temporary canvas. Any drawing operations that happen on the temporary\n   * canvas need to be composed with the main canvas that was suspended (see\n   * `compose()`). The temporary canvas also duplicates many of its operations\n   * on the suspended canvas to keep them in sync, so that when the soft mask\n   * mode ends any clipping paths or transformations will still be active and in\n   * the right order on the canvas' graphics state stack.\n   */\n  beginSMaskMode() {\n    if (this.suspendedCtx) {\n      throw new Error(\"beginSMaskMode called while already in smask mode\");\n    }\n    const drawnWidth = this.ctx.canvas.width;\n    const drawnHeight = this.ctx.canvas.height;\n    const cacheId = \"smaskGroupAt\" + this.groupLevel;\n    const scratchCanvas = this.cachedCanvases.getCanvas(\n      cacheId,\n      drawnWidth,\n      drawnHeight,\n      true\n    );\n    this.suspendedCtx = this.ctx;\n    this.ctx = scratchCanvas.context;\n    const ctx = this.ctx;\n    ctx.setTransform.apply(ctx, this.suspendedCtx.mozCurrentTransform);\n    copyCtxState(this.suspendedCtx, ctx);\n    mirrorContextOperations(ctx, this.suspendedCtx);\n\n    this.setGState([\n      [\"BM\", \"source-over\"],\n      [\"ca\", 1],\n      [\"CA\", 1],\n    ]);\n  }\n\n  endSMaskMode() {\n    if (!this.suspendedCtx) {\n      throw new Error(\"endSMaskMode called while not in smask mode\");\n    }\n    // The soft mask is done, now restore the suspended canvas as the main\n    // drawing canvas.\n    this.ctx._removeMirroring();\n    copyCtxState(this.ctx, this.suspendedCtx);\n    this.ctx = this.suspendedCtx;\n\n    this.current.activeSMask = null;\n    this.suspendedCtx = null;\n  }\n\n  compose(dirtyBox) {\n    if (!this.current.activeSMask) {\n      return;\n    }\n\n    if (!dirtyBox) {\n      dirtyBox = [0, 0, this.ctx.canvas.width, this.ctx.canvas.height];\n    } else {\n      dirtyBox[0] = Math.floor(dirtyBox[0]);\n      dirtyBox[1] = Math.floor(dirtyBox[1]);\n      dirtyBox[2] = Math.ceil(dirtyBox[2]);\n      dirtyBox[3] = Math.ceil(dirtyBox[3]);\n    }\n    const smask = this.current.activeSMask;\n    const suspendedCtx = this.suspendedCtx;\n\n    composeSMask(suspendedCtx, smask, this.ctx, dirtyBox);\n    // Whatever was drawn has been moved to the suspended canvas, now clear it\n    // out of the current canvas.\n    this.ctx.save();\n    this.ctx.setTransform(1, 0, 0, 1, 0, 0);\n    this.ctx.clearRect(0, 0, this.ctx.canvas.width, this.ctx.canvas.height);\n    this.ctx.restore();\n  }\n\n  save() {\n    this.ctx.save();\n    const old = this.current;\n    this.stateStack.push(old);\n    this.current = old.clone();\n  }\n\n  restore() {\n    if (this.stateStack.length === 0 && this.current.activeSMask) {\n      this.endSMaskMode();\n    }\n\n    if (this.stateStack.length !== 0) {\n      this.current = this.stateStack.pop();\n      this.ctx.restore();\n      this.checkSMaskState();\n\n      // Ensure that the clipping path is reset (fixes issue6413.pdf).\n      this.pendingClip = null;\n\n      this._cachedGetSinglePixelWidth = null;\n    }\n  }\n\n  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(ops, args) {\n    const ctx = this.ctx;\n    const current = this.current;\n    let x = current.x,\n      y = current.y;\n    let startX, startY;\n    for (let 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          const width = args[j++];\n          const height = args[j++];\n\n          const xw = x + width;\n          const yh = y + height;\n          ctx.moveTo(x, y);\n          if (width === 0 || height === 0) {\n            ctx.lineTo(xw, yh);\n          } else {\n            ctx.lineTo(xw, y);\n            ctx.lineTo(xw, yh);\n            ctx.lineTo(x, yh);\n          }\n          current.updatePathMinMax(ctx.mozCurrentTransform, x, y);\n          current.updatePathMinMax(ctx.mozCurrentTransform, xw, yh);\n          ctx.closePath();\n          break;\n        case OPS.moveTo:\n          x = args[j++];\n          y = args[j++];\n          ctx.moveTo(x, y);\n          current.updatePathMinMax(ctx.mozCurrentTransform, x, y);\n          break;\n        case OPS.lineTo:\n          x = args[j++];\n          y = args[j++];\n          ctx.lineTo(x, y);\n          current.updatePathMinMax(ctx.mozCurrentTransform, x, y);\n          break;\n        case OPS.curveTo:\n          startX = x;\n          startY = y;\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          current.updateCurvePathMinMax(\n            ctx.mozCurrentTransform,\n            startX,\n            startY,\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          startX = x;\n          startY = y;\n          ctx.bezierCurveTo(\n            x,\n            y,\n            args[j],\n            args[j + 1],\n            args[j + 2],\n            args[j + 3]\n          );\n          current.updateCurvePathMinMax(\n            ctx.mozCurrentTransform,\n            startX,\n            startY,\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          startX = x;\n          startY = y;\n          x = args[j + 2];\n          y = args[j + 3];\n          ctx.bezierCurveTo(args[j], args[j + 1], x, y, x, y);\n          current.updateCurvePathMinMax(\n            ctx.mozCurrentTransform,\n            startX,\n            startY,\n            args[j],\n            args[j + 1],\n            x,\n            y,\n            x,\n            y\n          );\n          j += 4;\n          break;\n        case OPS.closePath:\n          ctx.closePath();\n          break;\n      }\n    }\n    current.setCurrentPoint(x, y);\n  }\n\n  closePath() {\n    this.ctx.closePath();\n  }\n\n  stroke(consumePath) {\n    consumePath = typeof consumePath !== \"undefined\" ? consumePath : true;\n    const ctx = this.ctx;\n    const 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 (typeof strokeColor === \"object\" && strokeColor?.getPattern) {\n        const lineWidth = this.getSinglePixelWidth();\n        ctx.save();\n        ctx.strokeStyle = strokeColor.getPattern(\n          ctx,\n          this,\n          ctx.mozCurrentTransformInverse,\n          PathType.STROKE\n        );\n        // Prevent drawing too thin lines by enforcing a minimum line width.\n        ctx.lineWidth = Math.max(lineWidth, this.current.lineWidth);\n        ctx.stroke();\n        ctx.restore();\n      } else {\n        const lineWidth = this.getSinglePixelWidth();\n        if (lineWidth < 0 && -lineWidth >= this.current.lineWidth) {\n          // The current transform will transform a square pixel into a\n          // parallelogram where both heights are lower than 1 and not equal.\n          ctx.save();\n          ctx.resetTransform();\n          ctx.lineWidth = Math.round(this._combinedScaleFactor);\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(lineWidth, this.current.lineWidth);\n          ctx.stroke();\n        }\n      }\n    }\n    if (consumePath) {\n      this.consumePath(this.current.getClippedPathBoundingBox());\n    }\n    // Restore the global alpha to the fill alpha\n    ctx.globalAlpha = this.current.fillAlpha;\n  }\n\n  closeStroke() {\n    this.closePath();\n    this.stroke();\n  }\n\n  fill(consumePath) {\n    consumePath = typeof consumePath !== \"undefined\" ? consumePath : true;\n    const ctx = this.ctx;\n    const fillColor = this.current.fillColor;\n    const isPatternFill = this.current.patternFill;\n    let needRestore = false;\n\n    if (isPatternFill) {\n      ctx.save();\n      ctx.fillStyle = fillColor.getPattern(\n        ctx,\n        this,\n        ctx.mozCurrentTransformInverse,\n        PathType.FILL\n      );\n      needRestore = true;\n    }\n\n    const intersect = this.current.getClippedPathBoundingBox();\n    if (this.contentVisible && intersect !== null) {\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(intersect);\n    }\n  }\n\n  eoFill() {\n    this.pendingEOFill = true;\n    this.fill();\n  }\n\n  fillStroke() {\n    this.fill(false);\n    this.stroke(false);\n\n    this.consumePath();\n  }\n\n  eoFillStroke() {\n    this.pendingEOFill = true;\n    this.fillStroke();\n  }\n\n  closeFillStroke() {\n    this.closePath();\n    this.fillStroke();\n  }\n\n  closeEOFillStroke() {\n    this.pendingEOFill = true;\n    this.closePath();\n    this.fillStroke();\n  }\n\n  endPath() {\n    this.consumePath();\n  }\n\n  // Clipping\n  clip() {\n    this.pendingClip = NORMAL_CLIP;\n  }\n\n  eoClip() {\n    this.pendingClip = EO_CLIP;\n  }\n\n  // Text\n  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\n  endText() {\n    const paths = this.pendingTextPaths;\n    const ctx = this.ctx;\n    if (paths === undefined) {\n      ctx.beginPath();\n      return;\n    }\n\n    ctx.save();\n    ctx.beginPath();\n    for (let i = 0; i < paths.length; i++) {\n      const 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\n  setCharSpacing(spacing) {\n    this.current.charSpacing = spacing;\n  }\n\n  setWordSpacing(spacing) {\n    this.current.wordSpacing = spacing;\n  }\n\n  setHScale(scale) {\n    this.current.textHScale = scale / 100;\n  }\n\n  setLeading(leading) {\n    this.current.leading = -leading;\n  }\n\n  setFont(fontRefName, size) {\n    const fontObj = this.commonObjs.get(fontRefName);\n    const current = this.current;\n\n    if (!fontObj) {\n      throw new Error(`Can't find font for ${fontRefName}`);\n    }\n    current.fontMatrix = fontObj.fontMatrix || 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    const 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    const italic = fontObj.italic ? \"italic\" : \"normal\";\n    const 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\n  setTextRenderingMode(mode) {\n    this.current.textRenderingMode = mode;\n  }\n\n  setTextRise(rise) {\n    this.current.textRise = rise;\n  }\n\n  moveText(x, y) {\n    this.current.x = this.current.lineX += x;\n    this.current.y = this.current.lineY += y;\n  }\n\n  setLeadingMoveText(x, y) {\n    this.setLeading(-y);\n    this.moveText(x, y);\n  }\n\n  setTextMatrix(a, b, c, d, e, f) {\n    this.current.textMatrix = [a, b, c, d, e, f];\n    this.current.textMatrixScale = Math.hypot(a, b);\n\n    this.current.x = this.current.lineX = 0;\n    this.current.y = this.current.lineY = 0;\n  }\n\n  nextLine() {\n    this.moveText(0, this.current.leading);\n  }\n\n  paintChar(character, x, y, patternTransform, resetLineWidthToOne) {\n    const ctx = this.ctx;\n    const current = this.current;\n    const font = current.font;\n    const textRenderingMode = current.textRenderingMode;\n    const fontSize = current.fontSize / current.fontSizeScale;\n    const fillStrokeMode =\n      textRenderingMode & TextRenderingMode.FILL_STROKE_MASK;\n    const isAddToPathSet = !!(\n      textRenderingMode & TextRenderingMode.ADD_TO_PATH_FLAG\n    );\n    const patternFill = current.patternFill && !font.missingFile;\n\n    let 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        if (resetLineWidthToOne) {\n          ctx.resetTransform();\n          ctx.lineWidth = Math.round(this._combinedScaleFactor);\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        if (resetLineWidthToOne) {\n          ctx.save();\n          ctx.moveTo(x, y);\n          ctx.resetTransform();\n          ctx.lineWidth = Math.round(this._combinedScaleFactor);\n          ctx.strokeText(character, 0, 0);\n          ctx.restore();\n        } else {\n          ctx.strokeText(character, x, y);\n        }\n      }\n    }\n\n    if (isAddToPathSet) {\n      const 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    const data = ctx.getImageData(0, 0, 10, 10).data;\n    let enabled = false;\n    for (let 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(glyphs) {\n    const current = this.current;\n    const font = current.font;\n    if (font.isType3Font) {\n      return this.showType3Text(glyphs);\n    }\n\n    const fontSize = current.fontSize;\n    if (fontSize === 0) {\n      return undefined;\n    }\n\n    const ctx = this.ctx;\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 glyphsLength = glyphs.length;\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    const simpleFillText =\n      current.textRenderingMode === TextRenderingMode.FILL &&\n      !font.disableFontFace &&\n      !current.patternFill;\n\n    ctx.save();\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    let patternTransform;\n    if (current.patternFill) {\n      ctx.save();\n      const pattern = current.fillColor.getPattern(\n        ctx,\n        this,\n        ctx.mozCurrentTransformInverse,\n        PathType.FILL\n      );\n      patternTransform = ctx.mozCurrentTransform;\n      ctx.restore();\n      ctx.fillStyle = pattern;\n    }\n\n    let lineWidth = current.lineWidth;\n    let resetLineWidthToOne = false;\n    const scale = current.textMatrixScale;\n    if (scale === 0 || lineWidth === 0) {\n      const 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();\n        resetLineWidthToOne = lineWidth < 0;\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    let x = 0,\n      i;\n    for (i = 0; i < glyphsLength; ++i) {\n      const glyph = glyphs[i];\n      if (isNum(glyph)) {\n        x += (spacingDir * glyph * fontSize) / 1000;\n        continue;\n      }\n\n      let restoreNeeded = false;\n      const spacing = (glyph.isSpace ? wordSpacing : 0) + charSpacing;\n      const character = glyph.fontChar;\n      const accent = glyph.accent;\n      let scaledX, scaledY;\n      let width = glyph.width;\n      if (vertical) {\n        const vmetric = glyph.vmetric || defaultVMetrics;\n        const vx =\n          -(glyph.vmetric ? vmetric[1] : width * 0.5) * 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 (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        const measuredWidth =\n          ((ctx.measureText(character).width * 1000) / fontSize) *\n          fontSizeScale;\n        if (width < measuredWidth && this.isFontSubpixelAAEnabled) {\n          const 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(\n            character,\n            scaledX,\n            scaledY,\n            patternTransform,\n            resetLineWidthToOne\n          );\n          if (accent) {\n            const scaledAccentX =\n              scaledX + (fontSize * accent.offset.x) / fontSizeScale;\n            const scaledAccentY =\n              scaledY - (fontSize * accent.offset.y) / fontSizeScale;\n            this.paintChar(\n              accent.fontChar,\n              scaledAccentX,\n              scaledAccentY,\n              patternTransform,\n              resetLineWidthToOne\n            );\n          }\n        }\n      }\n\n      let 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    this.compose();\n    return undefined;\n  }\n\n  showType3Text(glyphs) {\n    // Type3 fonts - each glyph is a \"mini-PDF\"\n    const ctx = this.ctx;\n    const current = this.current;\n    const font = current.font;\n    const fontSize = current.fontSize;\n    const fontDirection = current.fontDirection;\n    const spacingDir = font.vertical ? 1 : -1;\n    const charSpacing = current.charSpacing;\n    const wordSpacing = current.wordSpacing;\n    const textHScale = current.textHScale * fontDirection;\n    const fontMatrix = current.fontMatrix || FONT_IDENTITY_MATRIX;\n    const glyphsLength = glyphs.length;\n    const isTextInvisible =\n      current.textRenderingMode === TextRenderingMode.INVISIBLE;\n    let 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      const spacing = (glyph.isSpace ? wordSpacing : 0) + charSpacing;\n      const 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      const 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(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\n  setCharWidthAndBounds(xWidth, yWidth, llx, lly, urx, ury) {\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(IR) {\n    let pattern;\n    if (IR[0] === \"TilingPattern\") {\n      const color = IR[1];\n      const baseTransform =\n        this.baseTransform || this.ctx.mozCurrentTransform.slice();\n      const canvasGraphicsFactory = {\n        createCanvasGraphics: ctx => {\n          return new CanvasGraphics(\n            ctx,\n            this.commonObjs,\n            this.objs,\n            this.canvasFactory\n          );\n        },\n      };\n      pattern = new TilingPattern(\n        IR,\n        color,\n        this.ctx,\n        canvasGraphicsFactory,\n        baseTransform\n      );\n    } else {\n      pattern = this._getPattern(IR[1], IR[2]);\n    }\n    return pattern;\n  }\n\n  setStrokeColorN() {\n    this.current.strokeColor = this.getColorN_Pattern(arguments);\n  }\n\n  setFillColorN() {\n    this.current.fillColor = this.getColorN_Pattern(arguments);\n    this.current.patternFill = true;\n  }\n\n  setStrokeRGBColor(r, g, b) {\n    const color = Util.makeHexColor(r, g, b);\n    this.ctx.strokeStyle = color;\n    this.current.strokeColor = color;\n  }\n\n  setFillRGBColor(r, g, b) {\n    const color = Util.makeHexColor(r, g, b);\n    this.ctx.fillStyle = color;\n    this.current.fillColor = color;\n    this.current.patternFill = false;\n  }\n\n  _getPattern(objId, matrix = null) {\n    let pattern;\n    if (this.cachedPatterns.has(objId)) {\n      pattern = this.cachedPatterns.get(objId);\n    } else {\n      pattern = getShadingPattern(this.objs.get(objId));\n      this.cachedPatterns.set(objId, pattern);\n    }\n    if (matrix) {\n      pattern.matrix = matrix;\n    }\n    return pattern;\n  }\n\n  shadingFill(objId) {\n    if (!this.contentVisible) {\n      return;\n    }\n    const ctx = this.ctx;\n\n    this.save();\n    const pattern = this._getPattern(objId);\n    ctx.fillStyle = pattern.getPattern(\n      ctx,\n      this,\n      ctx.mozCurrentTransformInverse,\n      PathType.SHADING\n    );\n\n    const inv = ctx.mozCurrentTransformInverse;\n    if (inv) {\n      const canvas = ctx.canvas;\n      const width = canvas.width;\n      const height = canvas.height;\n\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\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      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.compose(this.current.getClippedPathBoundingBox());\n    this.restore();\n  }\n\n  // Images\n  beginInlineImage() {\n    unreachable(\"Should not call beginInlineImage\");\n  }\n\n  beginImageData() {\n    unreachable(\"Should not call beginImageData\");\n  }\n\n  paintFormXObjectBegin(matrix, bbox) {\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      const width = bbox[2] - bbox[0];\n      const height = bbox[3] - bbox[1];\n      this.ctx.rect(bbox[0], bbox[1], width, height);\n      this.current.updatePathMinMax(\n        this.ctx.mozCurrentTransform,\n        bbox[0],\n        bbox[1]\n      );\n      this.current.updatePathMinMax(\n        this.ctx.mozCurrentTransform,\n        bbox[2],\n        bbox[3]\n      );\n      this.clip();\n      this.endPath();\n    }\n  }\n\n  paintFormXObjectEnd() {\n    if (!this.contentVisible) {\n      return;\n    }\n    this.restore();\n    this.baseTransform = this.baseTransformStack.pop();\n  }\n\n  beginGroup(group) {\n    if (!this.contentVisible) {\n      return;\n    }\n\n    this.save();\n    // If there's an active soft mask we don't want it enabled for the group, so\n    // clear it out. The mask and suspended canvas will be restored in endGroup.\n    const suspendedCtx = this.suspendedCtx;\n    if (this.current.activeSMask) {\n      this.suspendedCtx = null;\n      this.current.activeSMask = null;\n    }\n\n    const 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    const 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    let bounds = Util.getAxialAlignedBoundingBox(\n      group.bbox,\n      currentCtx.mozCurrentTransform\n    );\n    // Clip the bounding box to the current canvas.\n    const 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    const offsetX = Math.floor(bounds[0]);\n    const offsetY = Math.floor(bounds[1]);\n    let drawnWidth = Math.max(Math.ceil(bounds[2]) - offsetX, 1);\n    let drawnHeight = Math.max(Math.ceil(bounds[3]) - offsetY, 1);\n    let 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    this.current.startNewPathAndClipBox([0, 0, drawnWidth, drawnHeight]);\n\n    let 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    const scratchCanvas = this.cachedCanvases.getCanvas(\n      cacheId,\n      drawnWidth,\n      drawnHeight,\n      true\n    );\n    const 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      currentCtx.save();\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({\n      ctx: currentCtx,\n      suspendedCtx,\n    });\n    this.groupLevel++;\n  }\n\n  endGroup(group) {\n    if (!this.contentVisible) {\n      return;\n    }\n    this.groupLevel--;\n    const groupCtx = this.ctx;\n    const { ctx, suspendedCtx } = this.groupStack.pop();\n    this.ctx = ctx;\n    // Turn off image smoothing to avoid sub pixel interpolation which can\n    // look kind of blurry for some pdfs.\n    this.ctx.imageSmoothingEnabled = false;\n\n    if (suspendedCtx) {\n      this.suspendedCtx = suspendedCtx;\n    }\n\n    if (group.smask) {\n      this.tempSMask = this.smaskStack.pop();\n      this.restore();\n    } else {\n      this.ctx.restore();\n      const currentMtx = this.ctx.mozCurrentTransform;\n      this.restore();\n      this.ctx.save();\n      this.ctx.setTransform.apply(this.ctx, currentMtx);\n      const dirtyBox = Util.getAxialAlignedBoundingBox(\n        [0, 0, groupCtx.canvas.width, groupCtx.canvas.height],\n        currentMtx\n      );\n      this.ctx.drawImage(groupCtx.canvas, 0, 0);\n      this.ctx.restore();\n      this.compose(dirtyBox);\n    }\n  }\n\n  beginAnnotations() {\n    this.save();\n    if (this.baseTransform) {\n      this.ctx.setTransform.apply(this.ctx, this.baseTransform);\n    }\n  }\n\n  endAnnotations() {\n    this.restore();\n  }\n\n  beginAnnotation(id, rect, transform, matrix, hasOwnCanvas) {\n    this.save();\n\n    if (Array.isArray(rect) && rect.length === 4) {\n      const width = rect[2] - rect[0];\n      const height = rect[3] - rect[1];\n\n      if (hasOwnCanvas && this.annotationCanvasMap) {\n        transform = transform.slice();\n        transform[4] -= rect[0];\n        transform[5] -= rect[1];\n\n        rect = rect.slice();\n        rect[0] = rect[1] = 0;\n        rect[2] = width;\n        rect[3] = height;\n\n        const [scaleX, scaleY] = Util.singularValueDecompose2dScale(\n          this.ctx.mozCurrentTransform\n        );\n        const { viewportScale } = this;\n        const canvasWidth = Math.ceil(\n          width * this.outputScaleX * viewportScale\n        );\n        const canvasHeight = Math.ceil(\n          height * this.outputScaleY * viewportScale\n        );\n\n        this.annotationCanvas = this.canvasFactory.create(\n          canvasWidth,\n          canvasHeight\n        );\n        const { canvas, context } = this.annotationCanvas;\n        canvas.style.width = `calc(${width}px * var(--viewport-scale-factor))`;\n        canvas.style.height = `calc(${height}px * var(--viewport-scale-factor))`;\n        this.annotationCanvasMap.set(id, canvas);\n        this.annotationCanvas.savedCtx = this.ctx;\n        this.ctx = context;\n        this.ctx.setTransform(scaleX, 0, 0, -scaleY, 0, height * scaleY);\n        addContextCurrentTransform(this.ctx);\n\n        resetCtxToDefault(this.ctx);\n      } else {\n        resetCtxToDefault(this.ctx);\n\n        this.ctx.rect(rect[0], rect[1], width, height);\n        this.clip();\n        this.endPath();\n      }\n    }\n\n    this.current = new CanvasExtraState(\n      this.ctx.canvas.width,\n      this.ctx.canvas.height\n    );\n\n    this.transform.apply(this, transform);\n    this.transform.apply(this, matrix);\n  }\n\n  endAnnotation() {\n    if (this.annotationCanvas) {\n      this.ctx = this.annotationCanvas.savedCtx;\n      delete this.annotationCanvas.savedCtx;\n      delete this.annotationCanvas;\n    }\n    this.restore();\n  }\n\n  paintImageMaskXObject(img) {\n    if (!this.contentVisible) {\n      return;\n    }\n    const ctx = this.ctx;\n    const width = img.width,\n      height = img.height;\n\n    const 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?.compiled) {\n      glyph.compiled(ctx);\n      return;\n    }\n    const mask = this._createMaskCanvas(img);\n    const maskCanvas = mask.canvas;\n\n    ctx.save();\n    // The mask is drawn with the transform applied. Reset the current\n    // transform to draw to the identity.\n    ctx.setTransform(1, 0, 0, 1, 0, 0);\n    ctx.drawImage(maskCanvas, mask.offsetX, mask.offsetY);\n    ctx.restore();\n    this.compose();\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    const ctx = this.ctx;\n    ctx.save();\n    const currentTransform = ctx.mozCurrentTransform;\n    ctx.transform(scaleX, skewX, skewY, scaleY, 0, 0);\n    const mask = this._createMaskCanvas(imgData);\n\n    ctx.setTransform(1, 0, 0, 1, 0, 0);\n    for (let i = 0, ii = positions.length; i < ii; i += 2) {\n      const trans = Util.transform(currentTransform, [\n        scaleX,\n        skewX,\n        skewY,\n        scaleY,\n        positions[i],\n        positions[i + 1],\n      ]);\n\n      const [x, y] = Util.applyTransform([0, 0], trans);\n      ctx.drawImage(mask.canvas, x, y);\n    }\n    ctx.restore();\n    this.compose();\n  }\n\n  paintImageMaskXObjectGroup(images) {\n    if (!this.contentVisible) {\n      return;\n    }\n    const ctx = this.ctx;\n\n    const fillColor = this.current.fillColor;\n    const isPatternFill = this.current.patternFill;\n    for (let i = 0, ii = images.length; i < ii; i++) {\n      const image = images[i];\n      const width = image.width,\n        height = image.height;\n\n      const maskCanvas = this.cachedCanvases.getCanvas(\n        \"maskCanvas\",\n        width,\n        height\n      );\n      const 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(\n            maskCtx,\n            this,\n            ctx.mozCurrentTransformInverse,\n            PathType.FILL\n          )\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    this.compose();\n  }\n\n  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(objId, scaleX, scaleY, positions) {\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    const width = imgData.width;\n    const height = imgData.height;\n    const map = [];\n    for (let 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(imgData) {\n    if (!this.contentVisible) {\n      return;\n    }\n    const width = imgData.width;\n    const height = imgData.height;\n    const ctx = this.ctx;\n\n    this.save();\n    // scale the image to the unit square\n    ctx.scale(1 / width, -1 / height);\n\n    let imgToPaint;\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      const tmpCanvas = this.cachedCanvases.getCanvas(\n        \"inlineImage\",\n        width,\n        height\n      );\n      const tmpCtx = tmpCanvas.context;\n      putBinaryImageData(tmpCtx, imgData, this.current.transferMaps);\n      imgToPaint = tmpCanvas.canvas;\n    }\n\n    const scaled = this._scaleImage(imgToPaint, ctx.mozCurrentTransformInverse);\n    ctx.imageSmoothingEnabled = getImageSmoothingEnabled(\n      ctx.mozCurrentTransform,\n      imgData.interpolate\n    );\n    ctx.drawImage(\n      scaled.img,\n      0,\n      0,\n      scaled.paintWidth,\n      scaled.paintHeight,\n      0,\n      -height,\n      width,\n      height\n    );\n\n    if (this.imageLayer) {\n      const position = this.getCanvasPosition(0, -height);\n      this.imageLayer.appendImage({\n        imgData,\n        left: position[0],\n        top: position[1],\n        width: width / ctx.mozCurrentTransformInverse[0],\n        height: height / ctx.mozCurrentTransformInverse[3],\n      });\n    }\n    this.compose();\n    this.restore();\n  }\n\n  paintInlineImageXObjectGroup(imgData, map) {\n    if (!this.contentVisible) {\n      return;\n    }\n    const ctx = this.ctx;\n    const w = imgData.width;\n    const h = imgData.height;\n\n    const tmpCanvas = this.cachedCanvases.getCanvas(\"inlineImage\", w, h);\n    const tmpCtx = tmpCanvas.context;\n    putBinaryImageData(tmpCtx, imgData, this.current.transferMaps);\n\n    for (let i = 0, ii = map.length; i < ii; i++) {\n      const 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        const 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    this.compose();\n  }\n\n  paintSolidColorImageMask() {\n    if (!this.contentVisible) {\n      return;\n    }\n    this.ctx.fillRect(0, 0, 1, 1);\n    this.compose();\n  }\n\n  // Marked content\n\n  markPoint(tag) {\n    // TODO Marked content.\n  }\n\n  markPointProps(tag, properties) {\n    // TODO Marked content.\n  }\n\n  beginMarkedContent(tag) {\n    this.markedContentStack.push({\n      visible: true,\n    });\n  }\n\n  beginMarkedContentProps(tag, properties) {\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\n  endMarkedContent() {\n    this.markedContentStack.pop();\n    this.contentVisible = this.isContentVisible();\n  }\n\n  // Compatibility\n\n  beginCompat() {\n    // TODO ignore undefined operators (should we do that anyway?)\n  }\n\n  endCompat() {\n    // TODO stop ignoring undefined operators\n  }\n\n  // Helper functions\n\n  consumePath(clipBox) {\n    if (this.pendingClip) {\n      this.current.updateClipFromPath();\n    }\n    if (!this.pendingClip) {\n      this.compose(clipBox);\n    }\n    const 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    this.current.startNewPathAndClipBox(this.current.clipBox);\n    ctx.beginPath();\n  }\n\n  getSinglePixelWidth() {\n    if (this._cachedGetSinglePixelWidth === null) {\n      // If transform is [a b] then a pixel (square) is transformed\n      //                 [c d]\n      // into a parallelogram: its area is the abs value of the determinant.\n      // This parallelogram has 2 heights:\n      //  - Area / |col_1|;\n      //  - Area / |col_2|.\n      // so in order to get a height of at least 1, pixel height\n      // must be computed as followed:\n      //  h = max(sqrt(a² + c²) / |det(M)|, sqrt(b² + d²) / |det(M)|).\n      // This is equivalent to:\n      //  h = max(|line_1_inv(M)|, |line_2_inv(M)|)\n      const m = this.ctx.mozCurrentTransform;\n\n      const absDet = Math.abs(m[0] * m[3] - m[2] * m[1]);\n      const sqNorm1 = m[0] ** 2 + m[2] ** 2;\n      const sqNorm2 = m[1] ** 2 + m[3] ** 2;\n      const pixelHeight = Math.sqrt(Math.max(sqNorm1, sqNorm2)) / absDet;\n      if (sqNorm1 !== sqNorm2 && this._combinedScaleFactor * pixelHeight > 1) {\n        // The parallelogram isn't a square and at least one height\n        // is lower than 1 so the resulting line width must be 1\n        // but it cannot be achieved with one scale: when scaling a pixel\n        // we'll get a rectangle (see issue #12295).\n        // For example with matrix [0.001 0, 0, 100], a pixel is transformed\n        // in a rectangle 0.001x100. If we just scale by 1000 (to have a 1)\n        // then we'll get a rectangle 1x1e5 which is wrong.\n        // In this case, we must reset the transform, set linewidth to 1\n        // and then stroke.\n        this._cachedGetSinglePixelWidth = -(\n          this._combinedScaleFactor * pixelHeight\n        );\n      } else if (absDet > Number.EPSILON) {\n        this._cachedGetSinglePixelWidth = pixelHeight;\n      } else {\n        // Matrix is non-invertible.\n        this._cachedGetSinglePixelWidth = 1;\n      }\n    }\n\n    return this._cachedGetSinglePixelWidth;\n  }\n\n  getCanvasPosition(x, y) {\n    const 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() {\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\nfor (const op in OPS) {\n  if (CanvasGraphics.prototype[op] !== undefined) {\n    CanvasGraphics.prototype[OPS[op]] = CanvasGraphics.prototype[op];\n  }\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 {\n  FormatError,\n  info,\n  shadow,\n  unreachable,\n  Util,\n  warn,\n} from \"../shared/util.js\";\n\nconst PathType = {\n  FILL: \"Fill\",\n  STROKE: \"Stroke\",\n  SHADING: \"Shading\",\n};\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\nclass BaseShadingPattern {\n  constructor() {\n    if (this.constructor === BaseShadingPattern) {\n      unreachable(\"Cannot initialize BaseShadingPattern.\");\n    }\n  }\n\n  getPattern() {\n    unreachable(\"Abstract method `getPattern` called.\");\n  }\n}\n\nclass RadialAxialShadingPattern extends BaseShadingPattern {\n  constructor(IR) {\n    super();\n    this._type = IR[1];\n    this._bbox = IR[2];\n    this._colorStops = IR[3];\n    this._p0 = IR[4];\n    this._p1 = IR[5];\n    this._r0 = IR[6];\n    this._r1 = IR[7];\n    this.matrix = null;\n  }\n\n  _createGradient(ctx) {\n    let grad;\n    if (this._type === \"axial\") {\n      grad = ctx.createLinearGradient(\n        this._p0[0],\n        this._p0[1],\n        this._p1[0],\n        this._p1[1]\n      );\n    } else if (this._type === \"radial\") {\n      grad = ctx.createRadialGradient(\n        this._p0[0],\n        this._p0[1],\n        this._r0,\n        this._p1[0],\n        this._p1[1],\n        this._r1\n      );\n    }\n\n    for (const colorStop of this._colorStops) {\n      grad.addColorStop(colorStop[0], colorStop[1]);\n    }\n    return grad;\n  }\n\n  getPattern(ctx, owner, inverse, pathType) {\n    let pattern;\n    if (pathType === PathType.STROKE || pathType === PathType.FILL) {\n      const ownerBBox = owner.current.getClippedPathBoundingBox(\n        pathType,\n        ctx.mozCurrentTransform\n      ) || [0, 0, 0, 0];\n      // Create a canvas that is only as big as the current path. This doesn't\n      // allow us to cache the pattern, but it generally creates much smaller\n      // canvases and saves memory use. See bug 1722807 for an example.\n      const width = Math.ceil(ownerBBox[2] - ownerBBox[0]) || 1;\n      const height = Math.ceil(ownerBBox[3] - ownerBBox[1]) || 1;\n\n      const tmpCanvas = owner.cachedCanvases.getCanvas(\n        \"pattern\",\n        width,\n        height,\n        true\n      );\n\n      const tmpCtx = tmpCanvas.context;\n      tmpCtx.clearRect(0, 0, tmpCtx.canvas.width, tmpCtx.canvas.height);\n      tmpCtx.beginPath();\n      tmpCtx.rect(0, 0, tmpCtx.canvas.width, tmpCtx.canvas.height);\n      // Non shading fill patterns are positioned relative to the base transform\n      // (usually the page's initial transform), but we may have created a\n      // smaller canvas based on the path, so we must account for the shift.\n      tmpCtx.translate(-ownerBBox[0], -ownerBBox[1]);\n      inverse = Util.transform(inverse, [\n        1,\n        0,\n        0,\n        1,\n        ownerBBox[0],\n        ownerBBox[1],\n      ]);\n\n      tmpCtx.transform.apply(tmpCtx, owner.baseTransform);\n      if (this.matrix) {\n        tmpCtx.transform.apply(tmpCtx, this.matrix);\n      }\n      applyBoundingBox(tmpCtx, this._bbox);\n\n      tmpCtx.fillStyle = this._createGradient(tmpCtx);\n      tmpCtx.fill();\n\n      pattern = ctx.createPattern(tmpCanvas.canvas, \"no-repeat\");\n      const domMatrix = new DOMMatrix(inverse);\n      try {\n        pattern.setTransform(domMatrix);\n      } catch (ex) {\n        // Avoid rendering breaking completely in Firefox 78 ESR,\n        // and in Node.js (see issue 13724).\n        warn(`RadialAxialShadingPattern.getPattern: \"${ex?.message}\".`);\n      }\n    } else {\n      // Shading fills are applied relative to the current matrix which is also\n      // how canvas gradients work, so there's no need to do anything special\n      // here.\n      applyBoundingBox(ctx, this._bbox);\n      pattern = this._createGradient(ctx);\n    }\n    return pattern;\n  }\n}\n\nfunction drawTriangle(data, context, p1, p2, p3, c1, c2, c3) {\n  // Very basic Gouraud-shaded triangle rasterization algorithm.\n  const coords = context.coords,\n    colors = context.colors;\n  const bytes = data.data,\n    rowSize = data.width * 4;\n  let 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  const x1 = (coords[p1] + context.offsetX) * context.scaleX;\n  const y1 = (coords[p1 + 1] + context.offsetY) * context.scaleY;\n  const x2 = (coords[p2] + context.offsetX) * context.scaleX;\n  const y2 = (coords[p2 + 1] + context.offsetY) * context.scaleY;\n  const x3 = (coords[p3] + context.offsetX) * context.scaleX;\n  const y3 = (coords[p3 + 1] + context.offsetY) * context.scaleY;\n  if (y1 >= y3) {\n    return;\n  }\n  const c1r = colors[c1],\n    c1g = colors[c1 + 1],\n    c1b = colors[c1 + 2];\n  const c2r = colors[c2],\n    c2g = colors[c2 + 1],\n    c2b = colors[c2 + 2];\n  const c3r = colors[c3],\n    c3g = colors[c3 + 1],\n    c3b = colors[c3 + 2];\n\n  const minY = Math.round(y1),\n    maxY = Math.round(y3);\n  let xa, car, cag, cab;\n  let xb, cbr, cbg, cbb;\n  for (let y = minY; y <= maxY; y++) {\n    if (y < y2) {\n      let k;\n      if (y < y1) {\n        k = 0;\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    const x1_ = Math.round(Math.min(xa, xb));\n    const x2_ = Math.round(Math.max(xa, xb));\n    let j = rowSize * y + x1_ * 4;\n    for (let 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\nfunction drawFigure(data, figure, context) {\n  const ps = figure.coords;\n  const cs = figure.colors;\n  let i, ii;\n  switch (figure.type) {\n    case \"lattice\":\n      const verticesPerRow = figure.verticesPerRow;\n      const rows = Math.floor(ps.length / verticesPerRow) - 1;\n      const cols = verticesPerRow - 1;\n      for (i = 0; i < rows; i++) {\n        let q = i * verticesPerRow;\n        for (let 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\nclass MeshShadingPattern extends BaseShadingPattern {\n  constructor(IR) {\n    super();\n    this._coords = IR[2];\n    this._colors = IR[3];\n    this._figures = IR[4];\n    this._bounds = IR[5];\n    this._bbox = IR[7];\n    this._background = IR[8];\n    this.matrix = null;\n  }\n\n  _createMeshCanvas(combinedScale, backgroundColor, cachedCanvases) {\n    // we will increase scale on some weird factor to let antialiasing take\n    // care of \"rough\" edges\n    const EXPECTED_SCALE = 1.1;\n    // MAX_PATTERN_SIZE is used to avoid OOM situation.\n    const 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    const BORDER_SIZE = 2;\n\n    const offsetX = Math.floor(this._bounds[0]);\n    const offsetY = Math.floor(this._bounds[1]);\n    const boundsWidth = Math.ceil(this._bounds[2]) - offsetX;\n    const boundsHeight = Math.ceil(this._bounds[3]) - offsetY;\n\n    const width = Math.min(\n      Math.ceil(Math.abs(boundsWidth * combinedScale[0] * EXPECTED_SCALE)),\n      MAX_PATTERN_SIZE\n    );\n    const height = Math.min(\n      Math.ceil(Math.abs(boundsHeight * combinedScale[1] * EXPECTED_SCALE)),\n      MAX_PATTERN_SIZE\n    );\n    const scaleX = boundsWidth / width;\n    const scaleY = boundsHeight / height;\n\n    const context = {\n      coords: this._coords,\n      colors: this._colors,\n      offsetX: -offsetX,\n      offsetY: -offsetY,\n      scaleX: 1 / scaleX,\n      scaleY: 1 / scaleY,\n    };\n\n    const paddedWidth = width + BORDER_SIZE * 2;\n    const paddedHeight = height + BORDER_SIZE * 2;\n\n    const tmpCanvas = cachedCanvases.getCanvas(\n      \"mesh\",\n      paddedWidth,\n      paddedHeight,\n      false\n    );\n    const tmpCtx = tmpCanvas.context;\n\n    const data = tmpCtx.createImageData(width, height);\n    if (backgroundColor) {\n      const bytes = data.data;\n      for (let 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 (const figure of this._figures) {\n      drawFigure(data, figure, context);\n    }\n    tmpCtx.putImageData(data, BORDER_SIZE, BORDER_SIZE);\n    const canvas = tmpCanvas.canvas;\n\n    return {\n      canvas,\n      offsetX: offsetX - BORDER_SIZE * scaleX,\n      offsetY: offsetY - BORDER_SIZE * scaleY,\n      scaleX,\n      scaleY,\n    };\n  }\n\n  getPattern(ctx, owner, inverse, pathType) {\n    applyBoundingBox(ctx, this._bbox);\n    let scale;\n    if (pathType === PathType.SHADING) {\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 (this.matrix) {\n        const matrixScale = Util.singularValueDecompose2dScale(this.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    const temporaryPatternCanvas = this._createMeshCanvas(\n      scale,\n      pathType === PathType.SHADING ? null : this._background,\n      owner.cachedCanvases\n    );\n\n    if (pathType !== PathType.SHADING) {\n      ctx.setTransform.apply(ctx, owner.baseTransform);\n      if (this.matrix) {\n        ctx.transform.apply(ctx, this.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\nclass DummyShadingPattern extends BaseShadingPattern {\n  getPattern() {\n    return \"hotpink\";\n  }\n}\n\nfunction getShadingPattern(IR) {\n  switch (IR[0]) {\n    case \"RadialAxial\":\n      return new RadialAxialShadingPattern(IR);\n    case \"Mesh\":\n      return new MeshShadingPattern(IR);\n    case \"Dummy\":\n      return new DummyShadingPattern();\n  }\n  throw new Error(`Unknown IR type: ${IR[0]}`);\n}\n\nconst PaintType = {\n  COLORED: 1,\n  UNCOLORED: 2,\n};\n\nclass TilingPattern {\n  // 10in @ 300dpi shall be enough.\n  static get MAX_PATTERN_SIZE() {\n    return shadow(this, \"MAX_PATTERN_SIZE\", 3000);\n  }\n\n  constructor(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.ctx = ctx;\n    this.canvasGraphicsFactory = canvasGraphicsFactory;\n    this.baseTransform = baseTransform;\n  }\n\n  createPatternCanvas(owner) {\n    const operatorList = this.operatorList;\n    const bbox = this.bbox;\n    const xstep = this.xstep;\n    const ystep = this.ystep;\n    const paintType = this.paintType;\n    const tilingType = this.tilingType;\n    const color = this.color;\n    const 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    const 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    const matrixScale = Util.singularValueDecompose2dScale(this.matrix);\n    const curMatrixScale = Util.singularValueDecompose2dScale(\n      this.baseTransform\n    );\n    const 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    const dimx = this.getSizeAndScale(\n      xstep,\n      this.ctx.canvas.width,\n      combinedScale[0]\n    );\n    const dimy = this.getSizeAndScale(\n      ystep,\n      this.ctx.canvas.height,\n      combinedScale[1]\n    );\n\n    const tmpCanvas = owner.cachedCanvases.getCanvas(\n      \"pattern\",\n      dimx.size,\n      dimy.size,\n      true\n    );\n    const tmpCtx = tmpCanvas.context;\n    const graphics = canvasGraphicsFactory.createCanvasGraphics(tmpCtx);\n    graphics.groupLevel = owner.groupLevel;\n\n    this.setFillAndStrokeStyleToContext(graphics, paintType, color);\n\n    let adjustedX0 = x0;\n    let adjustedY0 = y0;\n    let adjustedX1 = x1;\n    let adjustedY1 = y1;\n    // Some bounding boxes have negative x0/y0 cordinates which will cause the\n    // some of the drawing to be off of the canvas. To avoid this shift the\n    // bounding box over.\n    if (x0 < 0) {\n      adjustedX0 = 0;\n      adjustedX1 += Math.abs(x0);\n    }\n    if (y0 < 0) {\n      adjustedY0 = 0;\n      adjustedY1 += Math.abs(y0);\n    }\n    tmpCtx.translate(-(dimx.scale * adjustedX0), -(dimy.scale * adjustedY0));\n    graphics.transform(dimx.scale, 0, 0, dimy.scale, 0, 0);\n\n    this.clipBbox(graphics, adjustedX0, adjustedY0, adjustedX1, adjustedY1);\n\n    graphics.baseTransform = graphics.ctx.mozCurrentTransform.slice();\n\n    graphics.executeOperatorList(operatorList);\n\n    graphics.endDrawing();\n\n    return {\n      canvas: tmpCanvas.canvas,\n      scaleX: dimx.scale,\n      scaleY: dimy.scale,\n      offsetX: adjustedX0,\n      offsetY: adjustedY0,\n    };\n  }\n\n  getSizeAndScale(step, realOutputSize, scale) {\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    const maxSize = Math.max(TilingPattern.MAX_PATTERN_SIZE, realOutputSize);\n    let 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(graphics, x0, y0, x1, y1) {\n    const bboxWidth = x1 - x0;\n    const bboxHeight = y1 - y0;\n    graphics.ctx.rect(x0, y0, bboxWidth, bboxHeight);\n    graphics.clip();\n    graphics.endPath();\n  }\n\n  setFillAndStrokeStyleToContext(graphics, paintType, color) {\n    const context = graphics.ctx,\n      current = graphics.current;\n    switch (paintType) {\n      case PaintType.COLORED:\n        const 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        const cssColor = Util.makeHexColor(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(ctx, owner, inverse, pathType) {\n    // PDF spec 8.7.2 NOTE 1: pattern's matrix is relative to initial matrix.\n    let matrix = inverse;\n    if (pathType !== PathType.SHADING) {\n      matrix = Util.transform(matrix, owner.baseTransform);\n      if (this.matrix) {\n        matrix = Util.transform(matrix, this.matrix);\n      }\n    }\n\n    const temporaryPatternCanvas = this.createPatternCanvas(owner);\n\n    let domMatrix = new DOMMatrix(matrix);\n    // Rescale and so that the ctx.createPattern call generates a pattern with\n    // the desired size.\n    domMatrix = domMatrix.translate(\n      temporaryPatternCanvas.offsetX,\n      temporaryPatternCanvas.offsetY\n    );\n    domMatrix = domMatrix.scale(\n      1 / temporaryPatternCanvas.scaleX,\n      1 / temporaryPatternCanvas.scaleY\n    );\n\n    const pattern = ctx.createPattern(temporaryPatternCanvas.canvas, \"repeat\");\n    try {\n      pattern.setTransform(domMatrix);\n    } catch (ex) {\n      // Avoid rendering breaking completely in Firefox 78 ESR,\n      // and in Node.js (see issue 13724).\n      warn(`TilingPattern.getPattern: \"${ex?.message}\".`);\n    }\n    return pattern;\n  }\n}\n\nexport { getShadingPattern, PathType, 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\nimport {\n  AbortException,\n  assert,\n  createPromiseCapability,\n  MissingPDFException,\n  PasswordException,\n  UnexpectedResponseException,\n  UnknownErrorException,\n  warn,\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    !(\n      reason instanceof Error ||\n      (typeof reason === \"object\" && reason !== null)\n    )\n  ) {\n    if (\n      typeof PDFJSDev === \"undefined\" ||\n      PDFJSDev.test(\"!PRODUCTION || TESTING\")\n    ) {\n      throw new Error(\n        'wrapReason: Expected \"reason\" to be a (possibly cloned) Error.'\n      );\n    }\n    warn('wrapReason: Expected \"reason\" to be a (possibly cloned) Error.');\n    return reason;\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 \"PasswordException\":\n      return new PasswordException(reason.message, reason.code);\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.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\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.comObj.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.comObj.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      sourceName = this.sourceName,\n      targetName = this.targetName,\n      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          comObj.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 streamId = data.streamId,\n      sourceName = this.sourceName,\n      targetName = data.sourceName,\n      comObj = this.comObj;\n    const self = this,\n      action = this.actionHandler[data.action];\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        comObj.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\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      sourceName = this.sourceName,\n      targetName = data.sourceName,\n      comObj = this.comObj;\n    const streamController = this.streamControllers[streamId],\n      streamSink = this.streamSinks[streamId];\n\n    switch (data.stream) {\n      case StreamKind.START_COMPLETE:\n        if (data.success) {\n          streamController.startCall.resolve();\n        } else {\n          streamController.startCall.reject(wrapReason(data.reason));\n        }\n        break;\n      case StreamKind.PULL_COMPLETE:\n        if (data.success) {\n          streamController.pullCall.resolve();\n        } else {\n          streamController.pullCall.reject(wrapReason(data.reason));\n        }\n        break;\n      case StreamKind.PULL:\n        // Ignore any pull after close is called.\n        if (!streamSink) {\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, so when it changes\n        // from negative to positive, set ready property as resolved promise.\n        if (streamSink.desiredSize <= 0 && data.desiredSize > 0) {\n          streamSink.sinkCapability.resolve();\n        }\n        // Reset desiredSize property of sink on every pull.\n        streamSink.desiredSize = data.desiredSize;\n\n        new Promise(function (resolve) {\n          resolve(streamSink.onPull && streamSink.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(streamController, \"enqueue should have stream controller\");\n        if (streamController.isClosed) {\n          break;\n        }\n        streamController.controller.enqueue(data.chunk);\n        break;\n      case StreamKind.CLOSE:\n        assert(streamController, \"close should have stream controller\");\n        if (streamController.isClosed) {\n          break;\n        }\n        streamController.isClosed = true;\n        streamController.controller.close();\n        this._deleteStreamController(streamController, streamId);\n        break;\n      case StreamKind.ERROR:\n        assert(streamController, \"error should have stream controller\");\n        streamController.controller.error(wrapReason(data.reason));\n        this._deleteStreamController(streamController, streamId);\n        break;\n      case StreamKind.CANCEL_COMPLETE:\n        if (data.success) {\n          streamController.cancelCall.resolve();\n        } else {\n          streamController.cancelCall.reject(wrapReason(data.reason));\n        }\n        this._deleteStreamController(streamController, streamId);\n        break;\n      case StreamKind.CANCEL:\n        if (!streamSink) {\n          break;\n        }\n\n        new Promise(function (resolve) {\n          resolve(\n            streamSink.onCancel && streamSink.onCancel(wrapReason(data.reason))\n          );\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        streamSink.sinkCapability.reject(wrapReason(data.reason));\n        streamSink.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(streamController, 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      streamController.startCall && streamController.startCall.promise,\n      streamController.pullCall && streamController.pullCall.promise,\n      streamController.cancelCall && streamController.cancelCall.promise,\n    ]);\n    delete this.streamControllers[streamId];\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 { objectFromMap } from \"../shared/util.js\";\n\nclass Metadata {\n  #metadataMap;\n\n  #data;\n\n  constructor({ parsedData, rawData }) {\n    this.#metadataMap = parsedData;\n    this.#data = rawData;\n  }\n\n  getRaw() {\n    return this.#data;\n  }\n\n  get(name) {\n    return this.#metadataMap.get(name) ?? null;\n  }\n\n  getAll() {\n    return objectFromMap(this.#metadataMap);\n  }\n\n  has(name) {\n    return this.#metadataMap.has(name);\n  }\n}\n\nexport { Metadata };\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 { objectFromMap, 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  _evaluateVisibilityExpression(array) {\n    const length = array.length;\n    if (length < 2) {\n      return true;\n    }\n    const operator = array[0];\n    for (let i = 1; i < length; i++) {\n      const element = array[i];\n      let state;\n      if (Array.isArray(element)) {\n        state = this._evaluateVisibilityExpression(element);\n      } else if (this._groups.has(element)) {\n        state = this._groups.get(element).visible;\n      } else {\n        warn(`Optional content group not found: ${element}`);\n        return true;\n      }\n      switch (operator) {\n        case \"And\":\n          if (!state) {\n            return false;\n          }\n          break;\n        case \"Or\":\n          if (state) {\n            return true;\n          }\n          break;\n        case \"Not\":\n          return !state;\n        default:\n          return true;\n      }\n    }\n    return operator === \"And\";\n  }\n\n  isVisible(group) {\n    if (this._groups.size === 0) {\n      return true;\n    }\n    if (!group) {\n      warn(\"Optional content group not defined.\");\n      return true;\n    }\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.\n      if (group.expression) {\n        return this._evaluateVisibilityExpression(group.expression);\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    return this._groups.size > 0 ? objectFromMap(this._groups) : null;\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\nimport { assert, createPromiseCapability } from \"../shared/util.js\";\nimport { isPdfFile } from \"./display_utils.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    this._contentDispositionFilename =\n      params.contentDispositionFilename || null;\n\n    const initialData = params.initialData;\n    if (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?._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?.onProgress) {\n        firstReader.onProgress({ loaded: evt.loaded });\n      }\n    } else {\n      const fullReader = this._fullRequestReader;\n      if (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      this._contentDispositionFilename\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    for (const reader of this._rangeReaders.slice(0)) {\n      reader.cancel(reason);\n    }\n    this._pdfDataRangeTransport.abort();\n  }\n}\n\n/** @implements {IPDFStreamReader} */\nclass PDFDataTransportStreamReader {\n  constructor(\n    stream,\n    queuedChunks,\n    progressiveDone = false,\n    contentDispositionFilename = null\n  ) {\n    this._stream = stream;\n    this._done = progressiveDone || false;\n    this._filename = isPdfFile(contentDispositionFilename)\n      ? contentDispositionFilename\n      : 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    for (const requestCapability of this._requests) {\n      requestCapability.resolve({ value: undefined, done: true });\n    }\n    this._requests.length = 0;\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      for (const requestCapability of this._requests) {\n        requestCapability.resolve({ value: undefined, done: true });\n      }\n      this._requests.length = 0;\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    for (const requestCapability of this._requests) {\n      requestCapability.resolve({ value: undefined, done: true });\n    }\n    this._requests.length = 0;\n    this._stream._removeRangeReader(this);\n  }\n}\n\nexport { PDFDataTransportStream };\n","/* Copyright 2021 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\nclass XfaText {\n  /**\n   * Walk an XFA tree and create an array of text nodes that is compatible\n   * with a regular PDFs TextContent. Currently, only TextItem.str is supported,\n   * all other fields and styles haven't been implemented.\n   *\n   * @param {Object} xfa - An XFA fake DOM object.\n   *\n   * @returns {TextContent}\n   */\n  static textContent(xfa) {\n    const items = [];\n    const output = {\n      items,\n      styles: Object.create(null),\n    };\n    function walk(node) {\n      if (!node) {\n        return;\n      }\n      let str = null;\n      const name = node.name;\n      if (name === \"#text\") {\n        str = node.value;\n      } else if (!XfaText.shouldBuildText(name)) {\n        return;\n      } else if (node?.attributes?.textContent) {\n        str = node.attributes.textContent;\n      } else if (node.value) {\n        str = node.value;\n      }\n      if (str !== null) {\n        items.push({\n          str,\n        });\n      }\n      if (!node.children) {\n        return;\n      }\n      for (const child of node.children) {\n        walk(child);\n      }\n    }\n    walk(xfa);\n    return output;\n  }\n\n  /**\n   * @param {string} name - DOM node name. (lower case)\n   *\n   * @returns {boolean} true if the DOM node should have a corresponding text\n   * node.\n   */\n  static shouldBuildText(name) {\n    return !(\n      name === \"textarea\" ||\n      name === \"input\" ||\n      name === \"option\" ||\n      name === \"select\"\n    );\n  }\n}\n\nexport { XfaText };\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\n/** @typedef {import(\"./api\").PDFPageProxy} PDFPageProxy */\n/** @typedef {import(\"./display_utils\").PageViewport} PageViewport */\n/** @typedef {import(\"./interfaces\").IDownloadManager} IDownloadManager */\n/** @typedef {import(\"../../web/interfaces\").IPDFLinkService} IPDFLinkService */\n\nimport {\n  AnnotationBorderStyleType,\n  AnnotationType,\n  assert,\n  shadow,\n  stringToPDFString,\n  unreachable,\n  Util,\n  warn,\n} from \"../shared/util.js\";\nimport {\n  DOMSVGFactory,\n  getFilenameFromUrl,\n  PDFDateString,\n} from \"./display_utils.js\";\nimport { AnnotationStorage } from \"./annotation_storage.js\";\nimport { ColorConverters } from \"../shared/scripting_utils.js\";\nimport { XfaLayer } from \"./xfa_layer.js\";\n\nconst DEFAULT_TAB_INDEX = 1000;\nconst GetElementsByNameSet = new WeakSet();\n\n/**\n * @typedef {Object} AnnotationElementParameters\n * @property {Object} data\n * @property {HTMLDivElement} layer\n * @property {PDFPageProxy} page\n * @property {PageViewport} viewport\n * @property {IPDFLinkService} linkService\n * @property {IDownloadManager} downloadManager\n * @property {AnnotationStorage} [annotationStorage]\n * @property {string} [imageResourcesPath] - Path for image resources, mainly\n *   for annotation icons. Include trailing slash.\n * @property {boolean} renderForms\n * @property {Object} svgFactory\n * @property {boolean} [enableScripting]\n * @property {boolean} [hasJSActions]\n * @property {Object} [fieldObjects]\n * @property {Object} [mouseState]\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(\n    parameters,\n    {\n      isRenderable = false,\n      ignoreBorder = false,\n      createQuadrilaterals = false,\n    } = {}\n  ) {\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.renderForms = parameters.renderForms;\n    this.svgFactory = parameters.svgFactory;\n    this.annotationStorage = parameters.annotationStorage;\n    this.enableScripting = parameters.enableScripting;\n    this.hasJSActions = parameters.hasJSActions;\n    this._fieldObjects = parameters.fieldObjects;\n    this._mouseState = parameters.mouseState;\n\n    if (isRenderable) {\n      this.container = this._createContainer(ignoreBorder);\n    }\n    if (createQuadrilaterals) {\n      this.quadrilaterals = this._createQuadrilaterals(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    if (data.hasOwnCanvas) {\n      const transform = viewport.transform.slice();\n      const [scaleX, scaleY] = Util.singularValueDecompose2dScale(transform);\n      width = Math.ceil(width * scaleX);\n      height = Math.ceil(height * scaleY);\n      rect[0] *= scaleX;\n      rect[1] *= scaleY;\n      // Reset the scale part of the transform matrix (which must be diagonal\n      // or anti-diagonal) in order to avoid to rescale the canvas.\n      // The canvas for the annotation is correctly scaled when it is drawn\n      // (see `beginAnnotation` in canvas.js).\n      for (let i = 0; i < 4; i++) {\n        transform[i] = Math.sign(transform[i]);\n      }\n      container.style.transform = `matrix(${transform.join(\",\")})`;\n    } else {\n      container.style.transform = `matrix(${viewport.transform.join(\",\")})`;\n    }\n\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 -= 2 * data.borderStyle.width;\n        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      const borderColor = data.borderColor || data.color || null;\n      if (borderColor) {\n        container.style.borderColor = Util.makeHexColor(\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\n    if (data.hasOwnCanvas) {\n      container.style.width = container.style.height = \"auto\";\n    } else {\n      container.style.width = `${width}px`;\n      container.style.height = `${height}px`;\n    }\n    return container;\n  }\n\n  /**\n   * Create quadrilaterals from the annotation's quadpoints.\n   *\n   * @private\n   * @param {boolean} ignoreBorder\n   * @memberof AnnotationElement\n   * @returns {Array<HTMLSectionElement>}\n   */\n  _createQuadrilaterals(ignoreBorder = false) {\n    if (!this.data.quadPoints) {\n      return null;\n    }\n\n    const quadrilaterals = [];\n    const savedRect = this.data.rect;\n    for (const quadPoint of this.data.quadPoints) {\n      this.data.rect = [\n        quadPoint[2].x,\n        quadPoint[2].y,\n        quadPoint[1].x,\n        quadPoint[1].y,\n      ];\n      quadrilaterals.push(this._createContainer(ignoreBorder));\n    }\n    this.data.rect = savedRect;\n    return quadrilaterals;\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 {HTMLDivElement|HTMLImageElement|null} trigger\n   * @param {Object} data\n   * @memberof AnnotationElement\n   */\n  _createPopup(trigger, data) {\n    let container = this.container;\n    if (this.quadrilaterals) {\n      trigger = trigger || this.quadrilaterals;\n      container = this.quadrilaterals[0];\n    }\n\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      titleObj: data.titleObj,\n      modificationDate: data.modificationDate,\n      contentsObj: data.contentsObj,\n      richText: data.richText,\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 quadrilaterals of the annotation.\n   *\n   * @private\n   * @param {string} className\n   * @memberof AnnotationElement\n   * @returns {Array<HTMLSectionElement>}\n   */\n  _renderQuadrilaterals(className) {\n    if (\n      typeof PDFJSDev === \"undefined\" ||\n      PDFJSDev.test(\"!PRODUCTION || TESTING\")\n    ) {\n      assert(this.quadrilaterals, \"Missing quadrilaterals during rendering\");\n    }\n\n    for (const quadrilateral of this.quadrilaterals) {\n      quadrilateral.className = className;\n    }\n    return this.quadrilaterals;\n  }\n\n  /**\n   * Render the annotation's HTML element(s).\n   *\n   * @public\n   * @memberof AnnotationElement\n   * @returns {HTMLSectionElement|Array<HTMLSectionElement>}\n   */\n  render() {\n    unreachable(\"Abstract method `AnnotationElement.render` called\");\n  }\n\n  /**\n   * @private\n   * @returns {Array}\n   */\n  _getElementsByName(name, skipId = null) {\n    const fields = [];\n\n    if (this._fieldObjects) {\n      const fieldObj = this._fieldObjects[name];\n      if (fieldObj) {\n        for (const { page, id, exportValues } of fieldObj) {\n          if (page === -1) {\n            continue;\n          }\n          if (id === skipId) {\n            continue;\n          }\n          const exportValue =\n            typeof exportValues === \"string\" ? exportValues : null;\n\n          const domElement = document.getElementById(id);\n          if (domElement && !GetElementsByNameSet.has(domElement)) {\n            warn(`_getElementsByName - element not allowed: ${id}`);\n            continue;\n          }\n          fields.push({ id, exportValue, domElement });\n        }\n      }\n      return fields;\n    }\n    // Fallback to a regular DOM lookup, to ensure that the standalone\n    // viewer components won't break.\n    for (const domElement of document.getElementsByName(name)) {\n      const { id, exportValue } = domElement;\n      if (id === skipId) {\n        continue;\n      }\n      if (!GetElementsByNameSet.has(domElement)) {\n        continue;\n      }\n      fields.push({ id, exportValue, domElement });\n    }\n    return fields;\n  }\n\n  static get platform() {\n    const platform = typeof navigator !== \"undefined\" ? navigator.platform : \"\";\n\n    return shadow(this, \"platform\", {\n      isWin: platform.includes(\"Win\"),\n      isMac: platform.includes(\"Mac\"),\n    });\n  }\n}\n\nclass LinkAnnotationElement extends AnnotationElement {\n  constructor(parameters, options = null) {\n    const isRenderable = !!(\n      parameters.data.url ||\n      parameters.data.dest ||\n      parameters.data.action ||\n      parameters.data.isTooltipOnly ||\n      parameters.data.resetForm ||\n      (parameters.data.actions &&\n        (parameters.data.actions.Action ||\n          parameters.data.actions[\"Mouse Up\"] ||\n          parameters.data.actions[\"Mouse Down\"]))\n    );\n    super(parameters, {\n      isRenderable,\n      ignoreBorder: !!options?.ignoreBorder,\n      createQuadrilaterals: true,\n    });\n  }\n\n  render() {\n    const { data, linkService } = this;\n    const link = document.createElement(\"a\");\n\n    if (data.url) {\n      if (\n        (typeof PDFJSDev === \"undefined\" || PDFJSDev.test(\"GENERIC\")) &&\n        !linkService.addLinkAttributes\n      ) {\n        warn(\n          \"LinkAnnotationElement.render - missing `addLinkAttributes`-method on the `linkService`-instance.\"\n        );\n      }\n      linkService.addLinkAttributes?.(link, data.url, data.newWindow);\n    } else if (data.action) {\n      this._bindNamedAction(link, data.action);\n    } else if (data.dest) {\n      this._bindLink(link, data.dest);\n    } else {\n      let hasClickAction = false;\n      if (\n        data.actions &&\n        (data.actions.Action ||\n          data.actions[\"Mouse Up\"] ||\n          data.actions[\"Mouse Down\"]) &&\n        this.enableScripting &&\n        this.hasJSActions\n      ) {\n        hasClickAction = true;\n        this._bindJSAction(link, data);\n      }\n\n      if (data.resetForm) {\n        this._bindResetFormAction(link, data.resetForm);\n      } else if (!hasClickAction) {\n        this._bindLink(link, \"\");\n      }\n    }\n\n    if (this.quadrilaterals) {\n      return this._renderQuadrilaterals(\"linkAnnotation\").map(\n        (quadrilateral, index) => {\n          const linkElement = index === 0 ? link : link.cloneNode();\n          quadrilateral.appendChild(linkElement);\n          return quadrilateral;\n        }\n      );\n    }\n\n    this.container.className = \"linkAnnotation\";\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.goToDestination(destination);\n      }\n      return false;\n    };\n    if (destination || destination === /* isTooltipOnly = */ \"\") {\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  /**\n   * Bind JS actions to the link element.\n   *\n   * @private\n   * @param {Object} link\n   * @param {Object} data\n   * @memberof LinkAnnotationElement\n   */\n  _bindJSAction(link, data) {\n    link.href = this.linkService.getAnchorUrl(\"\");\n    const map = new Map([\n      [\"Action\", \"onclick\"],\n      [\"Mouse Up\", \"onmouseup\"],\n      [\"Mouse Down\", \"onmousedown\"],\n    ]);\n    for (const name of Object.keys(data.actions)) {\n      const jsName = map.get(name);\n      if (!jsName) {\n        continue;\n      }\n      link[jsName] = () => {\n        this.linkService.eventBus?.dispatch(\"dispatcheventinsandbox\", {\n          source: this,\n          detail: {\n            id: data.id,\n            name,\n          },\n        });\n        return false;\n      };\n    }\n\n    if (!link.onclick) {\n      link.onclick = () => false;\n    }\n    link.className = \"internalLink\";\n  }\n\n  _bindResetFormAction(link, resetForm) {\n    const otherClickAction = link.onclick;\n    if (!otherClickAction) {\n      link.href = this.linkService.getAnchorUrl(\"\");\n    }\n    link.className = \"internalLink\";\n\n    if (!this._fieldObjects) {\n      warn(\n        `_bindResetFormAction - \"resetForm\" action not supported, ` +\n          \"ensure that the `fieldObjects` parameter is provided.\"\n      );\n      if (!otherClickAction) {\n        link.onclick = () => false;\n      }\n      return;\n    }\n\n    link.onclick = () => {\n      if (otherClickAction) {\n        otherClickAction();\n      }\n\n      const {\n        fields: resetFormFields,\n        refs: resetFormRefs,\n        include,\n      } = resetForm;\n\n      const allFields = [];\n      if (resetFormFields.length !== 0 || resetFormRefs.length !== 0) {\n        const fieldIds = new Set(resetFormRefs);\n        for (const fieldName of resetFormFields) {\n          const fields = this._fieldObjects[fieldName] || [];\n          for (const { id } of fields) {\n            fieldIds.add(id);\n          }\n        }\n        for (const fields of Object.values(this._fieldObjects)) {\n          for (const field of fields) {\n            if (fieldIds.has(field.id) === include) {\n              allFields.push(field);\n            }\n          }\n        }\n      } else {\n        for (const fields of Object.values(this._fieldObjects)) {\n          allFields.push(...fields);\n        }\n      }\n\n      const storage = this.annotationStorage;\n      const allIds = [];\n      for (const field of allFields) {\n        const { id } = field;\n        allIds.push(id);\n        switch (field.type) {\n          case \"text\": {\n            const value = field.defaultValue || \"\";\n            storage.setValue(id, { value, valueAsString: value });\n            break;\n          }\n          case \"checkbox\":\n          case \"radiobutton\": {\n            const value = field.defaultValue === field.exportValues;\n            storage.setValue(id, { value });\n            break;\n          }\n          case \"combobox\":\n          case \"listbox\": {\n            const value = field.defaultValue || \"\";\n            storage.setValue(id, { value });\n            break;\n          }\n          default:\n            continue;\n        }\n        const domElement = document.getElementById(id);\n        if (!domElement || !GetElementsByNameSet.has(domElement)) {\n          continue;\n        }\n        domElement.dispatchEvent(new Event(\"resetform\"));\n      }\n\n      if (this.enableScripting) {\n        // Update the values in the sandbox.\n        this.linkService.eventBus?.dispatch(\"dispatcheventinsandbox\", {\n          source: this,\n          detail: {\n            id: \"app\",\n            ids: allIds,\n            name: \"ResetForm\",\n          },\n        });\n      }\n\n      return false;\n    };\n  }\n}\n\nclass TextAnnotationElement extends AnnotationElement {\n  constructor(parameters) {\n    const isRenderable = !!(\n      parameters.data.hasPopup ||\n      parameters.data.titleObj?.str ||\n      parameters.data.contentsObj?.str ||\n      parameters.data.richText?.str\n    );\n    super(parameters, { isRenderable });\n  }\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(image, this.data);\n    }\n\n    this.container.appendChild(image);\n    return this.container;\n  }\n}\n\nclass WidgetAnnotationElement extends AnnotationElement {\n  render() {\n    // Show only the container for unsupported field types.\n    if (this.data.alternativeText) {\n      this.container.title = this.data.alternativeText;\n    }\n\n    return this.container;\n  }\n\n  _getKeyModifier(event) {\n    const { isWin, isMac } = AnnotationElement.platform;\n    return (isWin && event.ctrlKey) || (isMac && event.metaKey);\n  }\n\n  _setEventListener(element, baseName, eventName, valueGetter) {\n    if (baseName.includes(\"mouse\")) {\n      // Mouse events\n      element.addEventListener(baseName, event => {\n        this.linkService.eventBus?.dispatch(\"dispatcheventinsandbox\", {\n          source: this,\n          detail: {\n            id: this.data.id,\n            name: eventName,\n            value: valueGetter(event),\n            shift: event.shiftKey,\n            modifier: this._getKeyModifier(event),\n          },\n        });\n      });\n    } else {\n      // Non mouse event\n      element.addEventListener(baseName, event => {\n        this.linkService.eventBus?.dispatch(\"dispatcheventinsandbox\", {\n          source: this,\n          detail: {\n            id: this.data.id,\n            name: eventName,\n            value: event.target.checked,\n          },\n        });\n      });\n    }\n  }\n\n  _setEventListeners(element, names, getter) {\n    for (const [baseName, eventName] of names) {\n      if (eventName === \"Action\" || this.data.actions?.[eventName]) {\n        this._setEventListener(element, baseName, eventName, getter);\n      }\n    }\n  }\n\n  _setBackgroundColor(element) {\n    const color = this.data.backgroundColor || null;\n    element.style.backgroundColor =\n      color === null\n        ? \"transparent\"\n        : Util.makeHexColor(color[0], color[1], color[2]);\n  }\n\n  _dispatchEventFromSandbox(actions, jsEvent) {\n    const setColor = (jsName, styleName, event) => {\n      const color = event.detail[jsName];\n      event.target.style[styleName] = ColorConverters[`${color[0]}_HTML`](\n        color.slice(1)\n      );\n    };\n\n    const commonActions = {\n      display: event => {\n        const hidden = event.detail.display % 2 === 1;\n        event.target.style.visibility = hidden ? \"hidden\" : \"visible\";\n        this.annotationStorage.setValue(this.data.id, {\n          hidden,\n          print: event.detail.display === 0 || event.detail.display === 3,\n        });\n      },\n      print: event => {\n        this.annotationStorage.setValue(this.data.id, {\n          print: event.detail.print,\n        });\n      },\n      hidden: event => {\n        event.target.style.visibility = event.detail.hidden\n          ? \"hidden\"\n          : \"visible\";\n        this.annotationStorage.setValue(this.data.id, {\n          hidden: event.detail.hidden,\n        });\n      },\n      focus: event => {\n        setTimeout(() => event.target.focus({ preventScroll: false }), 0);\n      },\n      userName: event => {\n        // tooltip\n        event.target.title = event.detail.userName;\n      },\n      readonly: event => {\n        if (event.detail.readonly) {\n          event.target.setAttribute(\"readonly\", \"\");\n        } else {\n          event.target.removeAttribute(\"readonly\");\n        }\n      },\n      required: event => {\n        if (event.detail.required) {\n          event.target.setAttribute(\"required\", \"\");\n        } else {\n          event.target.removeAttribute(\"required\");\n        }\n      },\n      bgColor: event => {\n        setColor(\"bgColor\", \"backgroundColor\", event);\n      },\n      fillColor: event => {\n        setColor(\"fillColor\", \"backgroundColor\", event);\n      },\n      fgColor: event => {\n        setColor(\"fgColor\", \"color\", event);\n      },\n      textColor: event => {\n        setColor(\"textColor\", \"color\", event);\n      },\n      borderColor: event => {\n        setColor(\"borderColor\", \"borderColor\", event);\n      },\n      strokeColor: event => {\n        setColor(\"strokeColor\", \"borderColor\", event);\n      },\n    };\n\n    for (const name of Object.keys(jsEvent.detail)) {\n      const action = actions[name] || commonActions[name];\n      if (action) {\n        action(jsEvent);\n      }\n    }\n  }\n}\n\nclass TextWidgetAnnotationElement extends WidgetAnnotationElement {\n  constructor(parameters) {\n    const isRenderable =\n      parameters.renderForms ||\n      (!parameters.data.hasAppearance && !!parameters.data.fieldValue);\n    super(parameters, { isRenderable });\n  }\n\n  setPropertyOnSiblings(base, key, value, keyInStorage) {\n    const storage = this.annotationStorage;\n    for (const element of this._getElementsByName(\n      base.name,\n      /* skipId = */ base.id\n    )) {\n      if (element.domElement) {\n        element.domElement[key] = value;\n      }\n      storage.setValue(element.id, { [keyInStorage]: value });\n    }\n  }\n\n  render() {\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.renderForms) {\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 storedData = storage.getValue(id, {\n        value: this.data.fieldValue,\n        valueAsString: this.data.fieldValue,\n      });\n      const textContent = storedData.valueAsString || storedData.value || \"\";\n      const elementData = {\n        userValue: null,\n        formattedValue: null,\n        beforeInputSelectionRange: null,\n        beforeInputValue: null,\n      };\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      GetElementsByNameSet.add(element);\n      element.disabled = this.data.readOnly;\n      element.name = this.data.fieldName;\n      element.tabIndex = DEFAULT_TAB_INDEX;\n\n      elementData.userValue = textContent;\n      element.setAttribute(\"id\", id);\n\n      element.addEventListener(\"input\", event => {\n        storage.setValue(id, { value: event.target.value });\n        this.setPropertyOnSiblings(\n          element,\n          \"value\",\n          event.target.value,\n          \"value\"\n        );\n      });\n\n      element.addEventListener(\"resetform\", event => {\n        const defaultValue = this.data.defaultFieldValue || \"\";\n        element.value = elementData.userValue = defaultValue;\n        delete elementData.formattedValue;\n      });\n\n      let blurListener = event => {\n        if (elementData.formattedValue) {\n          event.target.value = elementData.formattedValue;\n        }\n        // Reset the cursor position to the start of the field (issue 12359).\n        event.target.scrollLeft = 0;\n        elementData.beforeInputSelectionRange = null;\n      };\n\n      if (this.enableScripting && this.hasJSActions) {\n        element.addEventListener(\"focus\", event => {\n          if (elementData.userValue) {\n            event.target.value = elementData.userValue;\n          }\n        });\n\n        element.addEventListener(\"updatefromsandbox\", jsEvent => {\n          const actions = {\n            value(event) {\n              elementData.userValue = event.detail.value || \"\";\n              storage.setValue(id, { value: elementData.userValue.toString() });\n              if (!elementData.formattedValue) {\n                event.target.value = elementData.userValue;\n              }\n            },\n            valueAsString(event) {\n              elementData.formattedValue = event.detail.valueAsString || \"\";\n              if (event.target !== document.activeElement) {\n                // Input hasn't the focus so display formatted string\n                event.target.value = elementData.formattedValue;\n              }\n              storage.setValue(id, {\n                formattedValue: elementData.formattedValue,\n              });\n            },\n            selRange(event) {\n              const [selStart, selEnd] = event.detail.selRange;\n              if (selStart >= 0 && selEnd < event.target.value.length) {\n                event.target.setSelectionRange(selStart, selEnd);\n              }\n            },\n          };\n          this._dispatchEventFromSandbox(actions, jsEvent);\n        });\n\n        // Even if the field hasn't any actions\n        // leaving it can still trigger some actions with Calculate\n        element.addEventListener(\"keydown\", event => {\n          elementData.beforeInputValue = event.target.value;\n          // if the key is one of Escape, Enter or Tab\n          // then the data are committed\n          let commitKey = -1;\n          if (event.key === \"Escape\") {\n            commitKey = 0;\n          } else if (event.key === \"Enter\") {\n            commitKey = 2;\n          } else if (event.key === \"Tab\") {\n            commitKey = 3;\n          }\n          if (commitKey === -1) {\n            return;\n          }\n          // Save the entered value\n          elementData.userValue = event.target.value;\n          this.linkService.eventBus?.dispatch(\"dispatcheventinsandbox\", {\n            source: this,\n            detail: {\n              id,\n              name: \"Keystroke\",\n              value: event.target.value,\n              willCommit: true,\n              commitKey,\n              selStart: event.target.selectionStart,\n              selEnd: event.target.selectionEnd,\n            },\n          });\n        });\n        const _blurListener = blurListener;\n        blurListener = null;\n        element.addEventListener(\"blur\", event => {\n          if (this._mouseState.isDown) {\n            // Focus out using the mouse: data are committed\n            elementData.userValue = event.target.value;\n            this.linkService.eventBus?.dispatch(\"dispatcheventinsandbox\", {\n              source: this,\n              detail: {\n                id,\n                name: \"Keystroke\",\n                value: event.target.value,\n                willCommit: true,\n                commitKey: 1,\n                selStart: event.target.selectionStart,\n                selEnd: event.target.selectionEnd,\n              },\n            });\n          }\n          _blurListener(event);\n        });\n        element.addEventListener(\"mousedown\", event => {\n          elementData.beforeInputValue = event.target.value;\n          elementData.beforeInputSelectionRange = null;\n        });\n        element.addEventListener(\"keyup\", event => {\n          // keyup is triggered after input\n          if (event.target.selectionStart === event.target.selectionEnd) {\n            elementData.beforeInputSelectionRange = null;\n          }\n        });\n        element.addEventListener(\"select\", event => {\n          elementData.beforeInputSelectionRange = [\n            event.target.selectionStart,\n            event.target.selectionEnd,\n          ];\n        });\n\n        if (this.data.actions?.Keystroke) {\n          // We should use beforeinput but this\n          // event isn't available in Firefox\n          element.addEventListener(\"input\", event => {\n            let selStart = -1;\n            let selEnd = -1;\n            if (elementData.beforeInputSelectionRange) {\n              [selStart, selEnd] = elementData.beforeInputSelectionRange;\n            }\n            this.linkService.eventBus?.dispatch(\"dispatcheventinsandbox\", {\n              source: this,\n              detail: {\n                id,\n                name: \"Keystroke\",\n                value: elementData.beforeInputValue,\n                change: event.data,\n                willCommit: false,\n                selStart,\n                selEnd,\n              },\n            });\n          });\n        }\n\n        this._setEventListeners(\n          element,\n          [\n            [\"focus\", \"Focus\"],\n            [\"blur\", \"Blur\"],\n            [\"mousedown\", \"Mouse Down\"],\n            [\"mouseenter\", \"Mouse Enter\"],\n            [\"mouseleave\", \"Mouse Exit\"],\n            [\"mouseup\", \"Mouse Up\"],\n          ],\n          event => event.target.value\n        );\n      }\n\n      if (blurListener) {\n        element.addEventListener(\"blur\", blurListener);\n      }\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\n    this._setTextStyle(element);\n    this._setBackgroundColor(element);\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   * @memberof TextWidgetAnnotationElement\n   */\n  _setTextStyle(element) {\n    const TEXT_ALIGNMENT = [\"left\", \"center\", \"right\"];\n    const { fontSize, fontColor } = this.data.defaultAppearanceData;\n    const style = element.style;\n\n    // TODO: If the font-size is zero, calculate it based on the height and\n    //       width of the element.\n    // Not setting `style.fontSize` will use the default font-size for now.\n    if (fontSize) {\n      style.fontSize = `${fontSize}px`;\n    }\n\n    style.color = Util.makeHexColor(fontColor[0], fontColor[1], fontColor[2]);\n\n    if (this.data.textAlignment !== null) {\n      style.textAlign = TEXT_ALIGNMENT[this.data.textAlignment];\n    }\n  }\n}\n\nclass CheckboxWidgetAnnotationElement extends WidgetAnnotationElement {\n  constructor(parameters) {\n    super(parameters, { isRenderable: parameters.renderForms });\n  }\n\n  render() {\n    const storage = this.annotationStorage;\n    const data = this.data;\n    const id = data.id;\n    let value = storage.getValue(id, {\n      value: data.exportValue === data.fieldValue,\n    }).value;\n    if (typeof value === \"string\") {\n      // The value has been changed through js and set in annotationStorage.\n      value = value !== \"Off\";\n      storage.setValue(id, { value });\n    }\n\n    this.container.className = \"buttonWidgetAnnotation checkBox\";\n\n    const element = document.createElement(\"input\");\n    GetElementsByNameSet.add(element);\n    element.disabled = data.readOnly;\n    element.type = \"checkbox\";\n    element.name = data.fieldName;\n    if (value) {\n      element.setAttribute(\"checked\", true);\n    }\n    element.setAttribute(\"id\", id);\n    element.setAttribute(\"exportValue\", data.exportValue);\n    element.tabIndex = DEFAULT_TAB_INDEX;\n\n    element.addEventListener(\"change\", event => {\n      const { name, checked } = event.target;\n      for (const checkbox of this._getElementsByName(name, /* skipId = */ id)) {\n        const curChecked = checked && checkbox.exportValue === data.exportValue;\n        if (checkbox.domElement) {\n          checkbox.domElement.checked = curChecked;\n        }\n        storage.setValue(checkbox.id, { value: curChecked });\n      }\n      storage.setValue(id, { value: checked });\n    });\n\n    element.addEventListener(\"resetform\", event => {\n      const defaultValue = data.defaultFieldValue || \"Off\";\n      event.target.checked = defaultValue === data.exportValue;\n    });\n\n    if (this.enableScripting && this.hasJSActions) {\n      element.addEventListener(\"updatefromsandbox\", jsEvent => {\n        const actions = {\n          value(event) {\n            event.target.checked = event.detail.value !== \"Off\";\n            storage.setValue(id, { value: event.target.checked });\n          },\n        };\n        this._dispatchEventFromSandbox(actions, jsEvent);\n      });\n\n      this._setEventListeners(\n        element,\n        [\n          [\"change\", \"Validate\"],\n          [\"change\", \"Action\"],\n          [\"focus\", \"Focus\"],\n          [\"blur\", \"Blur\"],\n          [\"mousedown\", \"Mouse Down\"],\n          [\"mouseenter\", \"Mouse Enter\"],\n          [\"mouseleave\", \"Mouse Exit\"],\n          [\"mouseup\", \"Mouse Up\"],\n        ],\n        event => event.target.checked\n      );\n    }\n\n    this._setBackgroundColor(element);\n\n    this.container.appendChild(element);\n    return this.container;\n  }\n}\n\nclass RadioButtonWidgetAnnotationElement extends WidgetAnnotationElement {\n  constructor(parameters) {\n    super(parameters, { isRenderable: parameters.renderForms });\n  }\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    let value = storage.getValue(id, {\n      value: data.fieldValue === data.buttonValue,\n    }).value;\n    if (typeof value === \"string\") {\n      // The value has been changed through js and set in annotationStorage.\n      value = value !== data.buttonValue;\n      storage.setValue(id, { value });\n    }\n\n    const element = document.createElement(\"input\");\n    GetElementsByNameSet.add(element);\n    element.disabled = data.readOnly;\n    element.type = \"radio\";\n    element.name = data.fieldName;\n    if (value) {\n      element.setAttribute(\"checked\", true);\n    }\n    element.setAttribute(\"id\", id);\n    element.tabIndex = DEFAULT_TAB_INDEX;\n\n    element.addEventListener(\"change\", event => {\n      const { name, checked } = event.target;\n      for (const radio of this._getElementsByName(name, /* skipId = */ id)) {\n        storage.setValue(radio.id, { value: false });\n      }\n      storage.setValue(id, { value: checked });\n    });\n\n    element.addEventListener(\"resetform\", event => {\n      const defaultValue = data.defaultFieldValue;\n      event.target.checked =\n        defaultValue !== null &&\n        defaultValue !== undefined &&\n        defaultValue === data.buttonValue;\n    });\n\n    if (this.enableScripting && this.hasJSActions) {\n      const pdfButtonValue = data.buttonValue;\n      element.addEventListener(\"updatefromsandbox\", jsEvent => {\n        const actions = {\n          value: event => {\n            const checked = pdfButtonValue === event.detail.value;\n            for (const radio of this._getElementsByName(event.target.name)) {\n              const curChecked = checked && radio.id === id;\n              if (radio.domElement) {\n                radio.domElement.checked = curChecked;\n              }\n              storage.setValue(radio.id, { value: curChecked });\n            }\n          },\n        };\n        this._dispatchEventFromSandbox(actions, jsEvent);\n      });\n\n      this._setEventListeners(\n        element,\n        [\n          [\"change\", \"Validate\"],\n          [\"change\", \"Action\"],\n          [\"focus\", \"Focus\"],\n          [\"blur\", \"Blur\"],\n          [\"mousedown\", \"Mouse Down\"],\n          [\"mouseenter\", \"Mouse Enter\"],\n          [\"mouseleave\", \"Mouse Exit\"],\n          [\"mouseup\", \"Mouse Up\"],\n        ],\n        event => event.target.checked\n      );\n    }\n\n    this._setBackgroundColor(element);\n\n    this.container.appendChild(element);\n    return this.container;\n  }\n}\n\nclass PushButtonWidgetAnnotationElement extends LinkAnnotationElement {\n  constructor(parameters) {\n    super(parameters, { ignoreBorder: parameters.data.hasAppearance });\n  }\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\n    if (this.data.alternativeText) {\n      container.title = this.data.alternativeText;\n    }\n\n    return container;\n  }\n}\n\nclass ChoiceWidgetAnnotationElement extends WidgetAnnotationElement {\n  constructor(parameters) {\n    super(parameters, { isRenderable: parameters.renderForms });\n  }\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 `getValue`\n    // is used and the full array of field values is stored.\n    storage.getValue(id, {\n      value:\n        this.data.fieldValue.length > 0 ? this.data.fieldValue[0] : undefined,\n    });\n\n    let { fontSize } = this.data.defaultAppearanceData;\n    if (!fontSize) {\n      fontSize = 9;\n    }\n    const fontSizeStyle = `calc(${fontSize}px * var(--zoom-factor))`;\n\n    const selectElement = document.createElement(\"select\");\n    GetElementsByNameSet.add(selectElement);\n    selectElement.disabled = this.data.readOnly;\n    selectElement.name = this.data.fieldName;\n    selectElement.setAttribute(\"id\", id);\n    selectElement.tabIndex = DEFAULT_TAB_INDEX;\n\n    selectElement.style.fontSize = `${fontSize}px`;\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    selectElement.addEventListener(\"resetform\", event => {\n      const defaultValue = this.data.defaultFieldValue;\n      for (const option of selectElement.options) {\n        option.selected = option.value === defaultValue;\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.combo) {\n        optionElement.style.fontSize = fontSizeStyle;\n      }\n      if (this.data.fieldValue.includes(option.exportValue)) {\n        optionElement.setAttribute(\"selected\", true);\n      }\n      selectElement.appendChild(optionElement);\n    }\n\n    const getValue = (event, isExport) => {\n      const name = isExport ? \"value\" : \"textContent\";\n      const options = event.target.options;\n      if (!event.target.multiple) {\n        return options.selectedIndex === -1\n          ? null\n          : options[options.selectedIndex][name];\n      }\n      return Array.prototype.filter\n        .call(options, option => option.selected)\n        .map(option => option[name]);\n    };\n\n    const getItems = event => {\n      const options = event.target.options;\n      return Array.prototype.map.call(options, option => {\n        return { displayValue: option.textContent, exportValue: option.value };\n      });\n    };\n\n    if (this.enableScripting && this.hasJSActions) {\n      selectElement.addEventListener(\"updatefromsandbox\", jsEvent => {\n        const actions = {\n          value(event) {\n            const value = event.detail.value;\n            const values = new Set(Array.isArray(value) ? value : [value]);\n            for (const option of selectElement.options) {\n              option.selected = values.has(option.value);\n            }\n            storage.setValue(id, {\n              value: getValue(event, /* isExport */ true),\n            });\n          },\n          multipleSelection(event) {\n            selectElement.multiple = true;\n          },\n          remove(event) {\n            const options = selectElement.options;\n            const index = event.detail.remove;\n            options[index].selected = false;\n            selectElement.remove(index);\n            if (options.length > 0) {\n              const i = Array.prototype.findIndex.call(\n                options,\n                option => option.selected\n              );\n              if (i === -1) {\n                options[0].selected = true;\n              }\n            }\n            storage.setValue(id, {\n              value: getValue(event, /* isExport */ true),\n              items: getItems(event),\n            });\n          },\n          clear(event) {\n            while (selectElement.length !== 0) {\n              selectElement.remove(0);\n            }\n            storage.setValue(id, { value: null, items: [] });\n          },\n          insert(event) {\n            const { index, displayValue, exportValue } = event.detail.insert;\n            const optionElement = document.createElement(\"option\");\n            optionElement.textContent = displayValue;\n            optionElement.value = exportValue;\n            selectElement.insertBefore(\n              optionElement,\n              selectElement.children[index]\n            );\n            storage.setValue(id, {\n              value: getValue(event, /* isExport */ true),\n              items: getItems(event),\n            });\n          },\n          items(event) {\n            const { items } = event.detail;\n            while (selectElement.length !== 0) {\n              selectElement.remove(0);\n            }\n            for (const item of items) {\n              const { displayValue, exportValue } = item;\n              const optionElement = document.createElement(\"option\");\n              optionElement.textContent = displayValue;\n              optionElement.value = exportValue;\n              selectElement.appendChild(optionElement);\n            }\n            if (selectElement.options.length > 0) {\n              selectElement.options[0].selected = true;\n            }\n            storage.setValue(id, {\n              value: getValue(event, /* isExport */ true),\n              items: getItems(event),\n            });\n          },\n          indices(event) {\n            const indices = new Set(event.detail.indices);\n            for (const option of event.target.options) {\n              option.selected = indices.has(option.index);\n            }\n            storage.setValue(id, {\n              value: getValue(event, /* isExport */ true),\n            });\n          },\n          editable(event) {\n            event.target.disabled = !event.detail.editable;\n          },\n        };\n        this._dispatchEventFromSandbox(actions, jsEvent);\n      });\n\n      selectElement.addEventListener(\"input\", event => {\n        const exportValue = getValue(event, /* isExport */ true);\n        const value = getValue(event, /* isExport */ false);\n        storage.setValue(id, { value: exportValue });\n\n        this.linkService.eventBus?.dispatch(\"dispatcheventinsandbox\", {\n          source: this,\n          detail: {\n            id,\n            name: \"Keystroke\",\n            value,\n            changeEx: exportValue,\n            willCommit: true,\n            commitKey: 1,\n            keyDown: false,\n          },\n        });\n      });\n\n      this._setEventListeners(\n        selectElement,\n        [\n          [\"focus\", \"Focus\"],\n          [\"blur\", \"Blur\"],\n          [\"mousedown\", \"Mouse Down\"],\n          [\"mouseenter\", \"Mouse Enter\"],\n          [\"mouseleave\", \"Mouse Exit\"],\n          [\"mouseup\", \"Mouse Up\"],\n          [\"input\", \"Action\"],\n        ],\n        event => event.target.checked\n      );\n    } else {\n      selectElement.addEventListener(\"input\", function (event) {\n        storage.setValue(id, { value: getValue(event) });\n      });\n    }\n\n    this._setBackgroundColor(selectElement);\n\n    this.container.appendChild(selectElement);\n    return this.container;\n  }\n}\n\nclass PopupAnnotationElement extends AnnotationElement {\n  constructor(parameters) {\n    const isRenderable = !!(\n      parameters.data.titleObj?.str ||\n      parameters.data.contentsObj?.str ||\n      parameters.data.richText?.str\n    );\n    super(parameters, { isRenderable });\n  }\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 parentElements = this.layer.querySelectorAll(selector);\n    if (parentElements.length === 0) {\n      return this.container;\n    }\n\n    const popup = new PopupElement({\n      container: this.container,\n      trigger: Array.from(parentElements),\n      color: this.data.color,\n      titleObj: this.data.titleObj,\n      modificationDate: this.data.modificationDate,\n      contentsObj: this.data.contentsObj,\n      richText: this.data.richText,\n    });\n\n    // Position the popup next to the parent annotation's container.\n    // PDF viewers ignore a popup annotation's rectangle.\n    const page = this.page;\n    const rect = Util.normalizeRect([\n      this.data.parentRect[0],\n      page.view[3] - this.data.parentRect[1] + page.view[1],\n      this.data.parentRect[2],\n      page.view[3] - this.data.parentRect[3] + page.view[1],\n    ]);\n    const popupLeft =\n      rect[0] + this.data.parentRect[2] - this.data.parentRect[0];\n    const popupTop = rect[1];\n\n    this.container.style.transformOrigin = `${-popupLeft}px ${-popupTop}px`;\n    this.container.style.left = `${popupLeft}px`;\n    this.container.style.top = `${popupTop}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.titleObj = parameters.titleObj;\n    this.modificationDate = parameters.modificationDate;\n    this.contentsObj = parameters.contentsObj;\n    this.richText = parameters.richText;\n    this.hideWrapper = parameters.hideWrapper || false;\n\n    this.pinned = false;\n  }\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.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.makeHexColor(r | 0, g | 0, b | 0);\n    }\n\n    const title = document.createElement(\"h1\");\n    title.dir = this.titleObj.dir;\n    title.textContent = this.titleObj.str;\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.className = \"popupDate\";\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    if (\n      this.richText?.str &&\n      (!this.contentsObj?.str || this.contentsObj.str === this.richText.str)\n    ) {\n      XfaLayer.render({\n        xfaHtml: this.richText.html,\n        intent: \"richText\",\n        div: popup,\n      });\n      popup.lastChild.className = \"richText popupContent\";\n    } else {\n      const contents = this._formatContents(this.contentsObj);\n      popup.appendChild(contents);\n    }\n\n    if (!Array.isArray(this.trigger)) {\n      this.trigger = [this.trigger];\n    }\n\n    // Attach the event listeners to the trigger element.\n    for (const element of this.trigger) {\n      element.addEventListener(\"click\", this._toggle.bind(this));\n      element.addEventListener(\"mouseover\", this._show.bind(this, false));\n      element.addEventListener(\"mouseout\", this._hide.bind(this, false));\n    }\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 {Object<string, string>} contentsObj\n   * @memberof PopupElement\n   * @returns {HTMLParagraphElement}\n   */\n  _formatContents({ str, dir }) {\n    const p = document.createElement(\"p\");\n    p.className = \"popupContent\";\n    p.dir = dir;\n    const lines = str.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.hidden) {\n      this.hideElement.hidden = false;\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.hidden && !this.pinned) {\n      this.hideElement.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.titleObj?.str ||\n      parameters.data.contentsObj?.str ||\n      parameters.data.richText?.str\n    );\n    super(parameters, { isRenderable, ignoreBorder: true });\n  }\n\n  render() {\n    this.container.className = \"freeTextAnnotation\";\n\n    if (!this.data.hasPopup) {\n      this._createPopup(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.titleObj?.str ||\n      parameters.data.contentsObj?.str ||\n      parameters.data.richText?.str\n    );\n    super(parameters, { isRenderable, ignoreBorder: true });\n  }\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    line.setAttribute(\"fill\", \"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(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.titleObj?.str ||\n      parameters.data.contentsObj?.str ||\n      parameters.data.richText?.str\n    );\n    super(parameters, { isRenderable, ignoreBorder: true });\n  }\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\", \"transparent\");\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(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.titleObj?.str ||\n      parameters.data.contentsObj?.str ||\n      parameters.data.richText?.str\n    );\n    super(parameters, { isRenderable, ignoreBorder: true });\n  }\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\", \"transparent\");\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(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.titleObj?.str ||\n      parameters.data.contentsObj?.str ||\n      parameters.data.richText?.str\n    );\n    super(parameters, { isRenderable, ignoreBorder: true });\n\n    this.containerClassName = \"polylineAnnotation\";\n    this.svgElementName = \"svg:polyline\";\n  }\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\", \"transparent\");\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(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.titleObj?.str ||\n      parameters.data.contentsObj?.str ||\n      parameters.data.richText?.str\n    );\n    super(parameters, { isRenderable, ignoreBorder: true });\n  }\n\n  render() {\n    this.container.className = \"caretAnnotation\";\n\n    if (!this.data.hasPopup) {\n      this._createPopup(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.titleObj?.str ||\n      parameters.data.contentsObj?.str ||\n      parameters.data.richText?.str\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  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\", \"transparent\");\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(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.titleObj?.str ||\n      parameters.data.contentsObj?.str ||\n      parameters.data.richText?.str\n    );\n    super(parameters, {\n      isRenderable,\n      ignoreBorder: true,\n      createQuadrilaterals: true,\n    });\n  }\n\n  render() {\n    if (!this.data.hasPopup) {\n      this._createPopup(null, this.data);\n    }\n\n    if (this.quadrilaterals) {\n      return this._renderQuadrilaterals(\"highlightAnnotation\");\n    }\n\n    this.container.className = \"highlightAnnotation\";\n    return this.container;\n  }\n}\n\nclass UnderlineAnnotationElement extends AnnotationElement {\n  constructor(parameters) {\n    const isRenderable = !!(\n      parameters.data.hasPopup ||\n      parameters.data.titleObj?.str ||\n      parameters.data.contentsObj?.str ||\n      parameters.data.richText?.str\n    );\n    super(parameters, {\n      isRenderable,\n      ignoreBorder: true,\n      createQuadrilaterals: true,\n    });\n  }\n\n  render() {\n    if (!this.data.hasPopup) {\n      this._createPopup(null, this.data);\n    }\n\n    if (this.quadrilaterals) {\n      return this._renderQuadrilaterals(\"underlineAnnotation\");\n    }\n\n    this.container.className = \"underlineAnnotation\";\n    return this.container;\n  }\n}\n\nclass SquigglyAnnotationElement extends AnnotationElement {\n  constructor(parameters) {\n    const isRenderable = !!(\n      parameters.data.hasPopup ||\n      parameters.data.titleObj?.str ||\n      parameters.data.contentsObj?.str ||\n      parameters.data.richText?.str\n    );\n    super(parameters, {\n      isRenderable,\n      ignoreBorder: true,\n      createQuadrilaterals: true,\n    });\n  }\n\n  render() {\n    if (!this.data.hasPopup) {\n      this._createPopup(null, this.data);\n    }\n\n    if (this.quadrilaterals) {\n      return this._renderQuadrilaterals(\"squigglyAnnotation\");\n    }\n\n    this.container.className = \"squigglyAnnotation\";\n    return this.container;\n  }\n}\n\nclass StrikeOutAnnotationElement extends AnnotationElement {\n  constructor(parameters) {\n    const isRenderable = !!(\n      parameters.data.hasPopup ||\n      parameters.data.titleObj?.str ||\n      parameters.data.contentsObj?.str ||\n      parameters.data.richText?.str\n    );\n    super(parameters, {\n      isRenderable,\n      ignoreBorder: true,\n      createQuadrilaterals: true,\n    });\n  }\n\n  render() {\n    if (!this.data.hasPopup) {\n      this._createPopup(null, this.data);\n    }\n\n    if (this.quadrilaterals) {\n      return this._renderQuadrilaterals(\"strikeoutAnnotation\");\n    }\n\n    this.container.className = \"strikeoutAnnotation\";\n    return this.container;\n  }\n}\n\nclass StampAnnotationElement extends AnnotationElement {\n  constructor(parameters) {\n    const isRenderable = !!(\n      parameters.data.hasPopup ||\n      parameters.data.titleObj?.str ||\n      parameters.data.contentsObj?.str ||\n      parameters.data.richText?.str\n    );\n    super(parameters, { isRenderable, ignoreBorder: true });\n  }\n\n  render() {\n    this.container.className = \"stampAnnotation\";\n\n    if (!this.data.hasPopup) {\n      this._createPopup(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    this.linkService.eventBus?.dispatch(\"fileattachmentannotation\", {\n      source: this,\n      id: stringToPDFString(filename),\n      filename,\n      content,\n    });\n  }\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 (\n      !this.data.hasPopup &&\n      (this.data.titleObj?.str ||\n        this.data.contentsObj?.str ||\n        this.data.richText)\n    ) {\n      this._createPopup(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    this.downloadManager?.openOrDownloadData(\n      this.container,\n      this.content,\n      this.filename\n    );\n  }\n}\n\n/**\n * @typedef {Object} AnnotationLayerParameters\n * @property {PageViewport} viewport\n * @property {HTMLDivElement} div\n * @property {Array} annotations\n * @property {PDFPageProxy} page\n * @property {IPDFLinkService} linkService\n * @property {IDownloadManager} downloadManager\n * @property {string} [imageResourcesPath] - Path for image resources, mainly\n *   for annotation icons. Include trailing slash.\n * @property {boolean} renderForms\n * @property {boolean} [enableScripting] - Enable embedded script execution.\n * @property {boolean} [hasJSActions] - Some fields have JS actions.\n *   The default value is `false`.\n * @property {Map<string, HTMLCanvasElement>} [annotationCanvasMap]\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    const div = parameters.div;\n\n    for (const data of sortedAnnotations) {\n      const element = AnnotationElementFactory.create({\n        data,\n        layer: div,\n        page: parameters.page,\n        viewport: parameters.viewport,\n        linkService: parameters.linkService,\n        downloadManager: parameters.downloadManager,\n        imageResourcesPath: parameters.imageResourcesPath || \"\",\n        renderForms: parameters.renderForms !== false,\n        svgFactory: new DOMSVGFactory(),\n        annotationStorage:\n          parameters.annotationStorage || new AnnotationStorage(),\n        enableScripting: parameters.enableScripting,\n        hasJSActions: parameters.hasJSActions,\n        fieldObjects: parameters.fieldObjects,\n        mouseState: parameters.mouseState || { isDown: false },\n      });\n      if (element.isRenderable) {\n        const rendered = element.render();\n        if (data.hidden) {\n          rendered.style.visibility = \"hidden\";\n        }\n        if (Array.isArray(rendered)) {\n          for (const renderedElement of rendered) {\n            div.appendChild(renderedElement);\n          }\n        } else {\n          if (element instanceof PopupAnnotationElement) {\n            // Popup annotation elements should not be on top of other\n            // annotation elements to prevent interfering with mouse events.\n            div.prepend(rendered);\n          } else {\n            div.appendChild(rendered);\n          }\n        }\n      }\n    }\n\n    this.#setAnnotationCanvasMap(div, parameters.annotationCanvasMap);\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    const { page, viewport, annotations, annotationCanvasMap, div } =\n      parameters;\n    const transform = viewport.transform;\n    const matrix = `matrix(${transform.join(\",\")})`;\n\n    let scale, ownMatrix;\n    for (const data of annotations) {\n      const elements = div.querySelectorAll(\n        `[data-annotation-id=\"${data.id}\"]`\n      );\n      if (elements) {\n        for (const element of elements) {\n          if (data.hasOwnCanvas) {\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            if (!ownMatrix) {\n              // When an annotation has its own canvas, then\n              // the scale has been already applied to the canvas,\n              // so we musn't scale it twice.\n              scale = Math.abs(transform[0] || transform[1]);\n              const ownTransform = transform.slice();\n              for (let i = 0; i < 4; i++) {\n                ownTransform[i] = Math.sign(ownTransform[i]);\n              }\n              ownMatrix = `matrix(${ownTransform.join(\",\")})`;\n            }\n\n            const left = rect[0] * scale;\n            const top = rect[1] * scale;\n            element.style.left = `${left}px`;\n            element.style.top = `${top}px`;\n            element.style.transformOrigin = `${-left}px ${-top}px`;\n            element.style.transform = ownMatrix;\n          } else {\n            element.style.transform = matrix;\n          }\n        }\n      }\n    }\n\n    this.#setAnnotationCanvasMap(div, annotationCanvasMap);\n    div.hidden = false;\n  }\n\n  static #setAnnotationCanvasMap(div, annotationCanvasMap) {\n    if (!annotationCanvasMap) {\n      return;\n    }\n    for (const [id, canvas] of annotationCanvasMap) {\n      const element = div.querySelector(`[data-annotation-id=\"${id}\"]`);\n      if (!element) {\n        continue;\n      }\n\n      const { firstChild } = element;\n      if (firstChild.nodeName === \"CANVAS\") {\n        element.replaceChild(canvas, firstChild);\n      } else {\n        element.insertBefore(canvas, firstChild);\n      }\n    }\n    annotationCanvasMap.clear();\n  }\n}\n\nexport { AnnotationLayer };\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 * PLEASE NOTE: This file is currently imported in both the `../display/` and\n *              `../scripting_api/` folders, hence be EXTREMELY careful about\n *              introducing any dependencies here since that can lead to an\n *              unexpected/unnecessary size increase of the *built* files.\n */\n\nfunction makeColorComp(n) {\n  return Math.floor(Math.max(0, Math.min(1, n)) * 255)\n    .toString(16)\n    .padStart(2, \"0\");\n}\n\n// PDF specifications section 10.3\nclass ColorConverters {\n  static CMYK_G([c, y, m, k]) {\n    return [\"G\", 1 - Math.min(1, 0.3 * c + 0.59 * m + 0.11 * y + k)];\n  }\n\n  static G_CMYK([g]) {\n    return [\"CMYK\", 0, 0, 0, 1 - g];\n  }\n\n  static G_RGB([g]) {\n    return [\"RGB\", g, g, g];\n  }\n\n  static G_HTML([g]) {\n    const G = makeColorComp(g);\n    return `#${G}${G}${G}`;\n  }\n\n  static RGB_G([r, g, b]) {\n    return [\"G\", 0.3 * r + 0.59 * g + 0.11 * b];\n  }\n\n  static RGB_HTML([r, g, b]) {\n    const R = makeColorComp(r);\n    const G = makeColorComp(g);\n    const B = makeColorComp(b);\n    return `#${R}${G}${B}`;\n  }\n\n  static T_HTML() {\n    return \"#00000000\";\n  }\n\n  static CMYK_RGB([c, y, m, k]) {\n    return [\n      \"RGB\",\n      1 - Math.min(1, c + k),\n      1 - Math.min(1, m + k),\n      1 - Math.min(1, y + k),\n    ];\n  }\n\n  static CMYK_HTML(components) {\n    return this.RGB_HTML(this.CMYK_RGB(components));\n  }\n\n  static RGB_CMYK([r, g, b]) {\n    const c = 1 - r;\n    const m = 1 - g;\n    const y = 1 - b;\n    const k = Math.min(c, m, y);\n    return [\"CMYK\", c, m, y, k];\n  }\n}\n\nexport { ColorConverters };\n","/* Copyright 2021 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/** @typedef {import(\"./display_utils\").PageViewport} PageViewport */\n/** @typedef {import(\"../../web/interfaces\").IPDFLinkService} IPDFLinkService */\n\nimport { warn } from \"../shared/util.js\";\nimport { XfaText } from \"./xfa_text.js\";\n\n/**\n * @typedef {Object} XfaLayerParameters\n * @property {PageViewport} viewport\n * @property {HTMLDivElement} div\n * @property {Object} xfaHtml\n * @property {AnnotationStorage} [annotationStorage]\n * @property {IPDFLinkService} linkService\n * @property {string} [intent] - (default value is 'display').\n */\n\nclass XfaLayer {\n  static setupStorage(html, id, element, storage, intent) {\n    const storedData = storage.getValue(id, { value: null });\n    switch (element.name) {\n      case \"textarea\":\n        if (storedData.value !== null) {\n          html.textContent = storedData.value;\n        }\n        if (intent === \"print\") {\n          break;\n        }\n        html.addEventListener(\"input\", event => {\n          storage.setValue(id, { value: event.target.value });\n        });\n        break;\n      case \"input\":\n        if (\n          element.attributes.type === \"radio\" ||\n          element.attributes.type === \"checkbox\"\n        ) {\n          if (storedData.value === element.attributes.xfaOn) {\n            html.setAttribute(\"checked\", true);\n          } else if (storedData.value === element.attributes.xfaOff) {\n            // The checked attribute may have been set when opening the file,\n            // unset through the UI and we're here because of printing.\n            html.removeAttribute(\"checked\");\n          }\n          if (intent === \"print\") {\n            break;\n          }\n          html.addEventListener(\"change\", event => {\n            storage.setValue(id, {\n              value: event.target.checked\n                ? event.target.getAttribute(\"xfaOn\")\n                : event.target.getAttribute(\"xfaOff\"),\n            });\n          });\n        } else {\n          if (storedData.value !== null) {\n            html.setAttribute(\"value\", storedData.value);\n          }\n          if (intent === \"print\") {\n            break;\n          }\n          html.addEventListener(\"input\", event => {\n            storage.setValue(id, { value: event.target.value });\n          });\n        }\n        break;\n      case \"select\":\n        if (storedData.value !== null) {\n          for (const option of element.children) {\n            if (option.attributes.value === storedData.value) {\n              option.attributes.selected = true;\n            }\n          }\n        }\n        html.addEventListener(\"input\", event => {\n          const options = event.target.options;\n          const value =\n            options.selectedIndex === -1\n              ? \"\"\n              : options[options.selectedIndex].value;\n          storage.setValue(id, { value });\n        });\n        break;\n    }\n  }\n\n  static setAttributes({ html, element, storage = null, intent, linkService }) {\n    const { attributes } = element;\n    const isHTMLAnchorElement = html instanceof HTMLAnchorElement;\n\n    if (attributes.type === \"radio\") {\n      // Avoid to have a radio group when printing with the same as one\n      // already displayed.\n      attributes.name = `${attributes.name}-${intent}`;\n    }\n    for (const [key, value] of Object.entries(attributes)) {\n      // We don't need to add dataId in the html object but it can\n      // be useful to know its value when writing printing tests:\n      // in this case, don't skip dataId to have its value.\n      if (value === null || value === undefined || key === \"dataId\") {\n        continue;\n      }\n\n      if (key !== \"style\") {\n        if (key === \"textContent\") {\n          html.textContent = value;\n        } else if (key === \"class\") {\n          if (value.length) {\n            html.setAttribute(key, value.join(\" \"));\n          }\n        } else {\n          if (isHTMLAnchorElement && (key === \"href\" || key === \"newWindow\")) {\n            continue; // Handled below.\n          }\n          html.setAttribute(key, value);\n        }\n      } else {\n        Object.assign(html.style, value);\n      }\n    }\n\n    if (isHTMLAnchorElement) {\n      if (\n        (typeof PDFJSDev === \"undefined\" || PDFJSDev.test(\"GENERIC\")) &&\n        !linkService.addLinkAttributes\n      ) {\n        warn(\n          \"XfaLayer.setAttribute - missing `addLinkAttributes`-method on the `linkService`-instance.\"\n        );\n      }\n      linkService.addLinkAttributes?.(\n        html,\n        attributes.href,\n        attributes.newWindow\n      );\n    }\n\n    // Set the value after the others to be sure overwrite\n    // any other values.\n    if (storage && attributes.dataId) {\n      this.setupStorage(html, attributes.dataId, element, storage);\n    }\n  }\n\n  /**\n   * Render the XFA layer.\n   *\n   * @param {XfaLayerParameters} parameters\n   */\n  static render(parameters) {\n    const storage = parameters.annotationStorage;\n    const linkService = parameters.linkService;\n    const root = parameters.xfaHtml;\n    const intent = parameters.intent || \"display\";\n    const rootHtml = document.createElement(root.name);\n    if (root.attributes) {\n      this.setAttributes({\n        html: rootHtml,\n        element: root,\n        intent,\n        linkService,\n      });\n    }\n    const stack = [[root, -1, rootHtml]];\n\n    const rootDiv = parameters.div;\n    rootDiv.appendChild(rootHtml);\n\n    if (parameters.viewport) {\n      const transform = `matrix(${parameters.viewport.transform.join(\",\")})`;\n      rootDiv.style.transform = transform;\n    }\n\n    // Set defaults.\n    if (intent !== \"richText\") {\n      rootDiv.setAttribute(\"class\", \"xfaLayer xfaFont\");\n    }\n\n    // Text nodes used for the text highlighter.\n    const textDivs = [];\n\n    while (stack.length > 0) {\n      const [parent, i, html] = stack[stack.length - 1];\n      if (i + 1 === parent.children.length) {\n        stack.pop();\n        continue;\n      }\n\n      const child = parent.children[++stack[stack.length - 1][1]];\n      if (child === null) {\n        continue;\n      }\n\n      const { name } = child;\n      if (name === \"#text\") {\n        const node = document.createTextNode(child.value);\n        textDivs.push(node);\n        html.appendChild(node);\n        continue;\n      }\n\n      let childHtml;\n      if (child?.attributes?.xmlns) {\n        childHtml = document.createElementNS(child.attributes.xmlns, name);\n      } else {\n        childHtml = document.createElement(name);\n      }\n\n      html.appendChild(childHtml);\n      if (child.attributes) {\n        this.setAttributes({\n          html: childHtml,\n          element: child,\n          storage,\n          intent,\n          linkService,\n        });\n      }\n\n      if (child.children && child.children.length > 0) {\n        stack.push([child, -1, childHtml]);\n      } else if (child.value) {\n        const node = document.createTextNode(child.value);\n        if (XfaText.shouldBuildText(name)) {\n          textDivs.push(node);\n        }\n        childHtml.appendChild(node);\n      }\n    }\n\n    /**\n     * TODO: re-enable that stuff once we've JS implementation.\n     * See https://bugzilla.mozilla.org/show_bug.cgi?id=1719465.\n     *\n     * for (const el of rootDiv.querySelectorAll(\n     * \".xfaDisabled input, .xfaDisabled textarea\"\n     * )) {\n     * el.setAttribute(\"disabled\", true);\n     * }\n     * for (const el of rootDiv.querySelectorAll(\n     * \".xfaReadOnly input, .xfaReadOnly textarea\"\n     * )) {\n     * el.setAttribute(\"readOnly\", true);\n     * }\n     */\n\n    for (const el of rootDiv.querySelectorAll(\n      \".xfaNonInteractive input, .xfaNonInteractive textarea\"\n    )) {\n      el.setAttribute(\"readOnly\", true);\n    }\n\n    return {\n      textDivs,\n    };\n  }\n\n  /**\n   * Update the XFA layer.\n   *\n   * @param {XfaLayerParameters} parameters\n   */\n  static update(parameters) {\n    const transform = `matrix(${parameters.viewport.transform.join(\",\")})`;\n    parameters.div.style.transform = transform;\n    parameters.div.hidden = false;\n  }\n}\n\nexport { XfaLayer };\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\nconst MAX_TEXT_DIVS_TO_RENDER = 100000;\nconst DEFAULT_FONT_SIZE = 30;\nconst DEFAULT_FONT_ASCENT = 0.8;\nconst ascentCache = new Map();\nconst AllWhitespaceRegexp = /^\\s+$/g;\n\nfunction getAscent(fontFamily, ctx) {\n  const cachedAscent = ascentCache.get(fontFamily);\n  if (cachedAscent) {\n    return cachedAscent;\n  }\n\n  ctx.save();\n  ctx.font = `${DEFAULT_FONT_SIZE}px ${fontFamily}`;\n  const metrics = ctx.measureText(\"\");\n\n  // Both properties aren't available by default in Firefox.\n  let ascent = metrics.fontBoundingBoxAscent;\n  let descent = Math.abs(metrics.fontBoundingBoxDescent);\n  if (ascent) {\n    ctx.restore();\n    const ratio = ascent / (ascent + descent);\n    ascentCache.set(fontFamily, ratio);\n    return ratio;\n  }\n\n  // Try basic heuristic to guess ascent/descent.\n  // Draw a g with baseline at 0,0 and then get the line\n  // number where a pixel has non-null red component (starting\n  // from bottom).\n  ctx.strokeStyle = \"red\";\n  ctx.clearRect(0, 0, DEFAULT_FONT_SIZE, DEFAULT_FONT_SIZE);\n  ctx.strokeText(\"g\", 0, 0);\n  let pixels = ctx.getImageData(\n    0,\n    0,\n    DEFAULT_FONT_SIZE,\n    DEFAULT_FONT_SIZE\n  ).data;\n  descent = 0;\n  for (let i = pixels.length - 1 - 3; i >= 0; i -= 4) {\n    if (pixels[i] > 0) {\n      descent = Math.ceil(i / 4 / DEFAULT_FONT_SIZE);\n      break;\n    }\n  }\n\n  // Draw an A with baseline at 0,DEFAULT_FONT_SIZE and then get the line\n  // number where a pixel has non-null red component (starting\n  // from top).\n  ctx.clearRect(0, 0, DEFAULT_FONT_SIZE, DEFAULT_FONT_SIZE);\n  ctx.strokeText(\"A\", 0, DEFAULT_FONT_SIZE);\n  pixels = ctx.getImageData(0, 0, DEFAULT_FONT_SIZE, DEFAULT_FONT_SIZE).data;\n  ascent = 0;\n  for (let i = 0, ii = pixels.length; i < ii; i += 4) {\n    if (pixels[i] > 0) {\n      ascent = DEFAULT_FONT_SIZE - Math.floor(i / 4 / DEFAULT_FONT_SIZE);\n      break;\n    }\n  }\n\n  ctx.restore();\n\n  if (ascent) {\n    const ratio = ascent / (ascent + descent);\n    ascentCache.set(fontFamily, ratio);\n    return ratio;\n  }\n\n  ascentCache.set(fontFamily, DEFAULT_FONT_ASCENT);\n  return DEFAULT_FONT_ASCENT;\n}\n\nfunction appendText(task, geom, styles, ctx) {\n  // Initialize all used properties to keep the caches monomorphic.\n  const textDiv = document.createElement(\"span\");\n  const textDivProperties = task._enhanceTextSelection\n    ? {\n        angle: 0,\n        canvasWidth: 0,\n        hasText: geom.str !== \"\",\n        hasEOL: geom.hasEOL,\n        originalTransform: null,\n        paddingBottom: 0,\n        paddingLeft: 0,\n        paddingRight: 0,\n        paddingTop: 0,\n        scale: 1,\n      }\n    : {\n        angle: 0,\n        canvasWidth: 0,\n        hasText: geom.str !== \"\",\n        hasEOL: geom.hasEOL,\n      };\n\n  task._textDivs.push(textDiv);\n\n  const tx = Util.transform(task._viewport.transform, geom.transform);\n  let angle = Math.atan2(tx[1], tx[0]);\n  const style = styles[geom.fontName];\n  if (style.vertical) {\n    angle += Math.PI / 2;\n  }\n  const fontHeight = Math.hypot(tx[2], tx[3]);\n  const fontAscent = fontHeight * getAscent(style.fontFamily, ctx);\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  // Keeps screen readers from pausing on every new text span.\n  textDiv.setAttribute(\"role\", \"presentation\");\n\n  textDiv.textContent = geom.str;\n  // geom.dir may be 'ttb' for vertical texts.\n  textDiv.dir = geom.dir;\n\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 (\n    geom.str.length > 1 ||\n    (task._enhanceTextSelection && AllWhitespaceRegexp.test(geom.str))\n  ) {\n    shouldScaleText = true;\n  } else if (geom.str !== \" \" && 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 && textDivProperties.hasText) {\n    let angleCos = 1,\n      angleSin = 0;\n    if (angle !== 0) {\n      angleCos = Math.cos(angle);\n      angleSin = Math.sin(angle);\n    }\n    const divWidth =\n      (style.vertical ? geom.height : geom.width) * task._viewport.scale;\n    const divHeight = fontHeight;\n\n    let 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\nfunction render(task) {\n  if (task._canceled) {\n    return;\n  }\n  const textDivs = task._textDivs;\n  const capability = task._capability;\n  const 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 (let i = 0; i < textDivsLength; i++) {\n      task._layoutText(textDivs[i]);\n    }\n  }\n\n  task._renderingDone = true;\n  capability.resolve();\n}\n\nfunction 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\nfunction expand(task) {\n  const bounds = task._bounds;\n  const viewport = task._viewport;\n\n  const expanded = expandBounds(viewport.width, viewport.height, bounds);\n  for (let i = 0; i < expanded.length; i++) {\n    const div = bounds[i].div;\n    const 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    const e = expanded[i],\n      b = bounds[i];\n    const m = b.m,\n      c = m[0],\n      s = m[1];\n    // Finding intersections with expanded box.\n    const points = [[0, 0], [0, b.size[1]], [b.size[0], 0], b.size];\n    const ts = new Float64Array(64);\n    for (let j = 0, jj = points.length; j < jj; j++) {\n      const t = Util.applyTransform(points[j], 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    const 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\nfunction expandBounds(width, height, boxes) {\n  const 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\n  const expanded = new Array(boxes.length);\n  for (const b of bounds) {\n    const 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    const 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  for (const b of bounds) {\n    const i = b.index;\n    expanded[i].top = b.x1New;\n    expanded[i].bottom = b.x2New;\n  }\n  return expanded;\n}\n\nfunction 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  const fakeBoundary = {\n    x1: -Infinity,\n    y1: -Infinity,\n    x2: 0,\n    y2: Infinity,\n    index: -1,\n    x1New: 0,\n    x2New: 0,\n  };\n  const horizon = [\n    {\n      start: -Infinity,\n      end: Infinity,\n      boundary: fakeBoundary,\n    },\n  ];\n\n  for (const boundary of bounds) {\n    // Searching for the affected part of horizon.\n    // TODO red-black tree or simple binary search\n    let i = 0;\n    while (i < horizon.length && horizon[i].end <= boundary.y1) {\n      i++;\n    }\n    let j = horizon.length - 1;\n    while (j >= 0 && horizon[j].start >= boundary.y2) {\n      j--;\n    }\n\n    let horizonPart, affectedBoundary;\n    let q,\n      k,\n      maxXNew = -Infinity;\n    for (q = i; q <= j; q++) {\n      horizonPart = horizon[q];\n      affectedBoundary = horizonPart.boundary;\n      let 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    const changedHorizon = [];\n    let 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      const 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      let 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  for (const horizonPart of horizon) {\n    const affectedBoundary = horizonPart.boundary;\n    if (affectedBoundary.x2New === undefined) {\n      affectedBoundary.x2New = Math.max(width, affectedBoundary.x2);\n    }\n  }\n}\n\nclass TextLayerRenderTask {\n  constructor({\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 = !!globalThis.FontInspector?.enabled;\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._enhanceTextSelection) {\n          // The `textDiv` properties are no longer needed.\n          this._textDivProperties = null;\n        }\n\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\n  /**\n   * Promise for textLayer rendering task completion.\n   * @type {Promise<void>}\n   */\n  get promise() {\n    return this._capability.promise;\n  }\n\n  /**\n   * Cancel rendering of the textLayer.\n   */\n  cancel() {\n    this._canceled = true;\n    if (this._reader) {\n      this._reader\n        .cancel(new AbortException(\"TextLayer task cancelled.\"))\n        .catch(() => {\n          // Avoid \"Uncaught promise\" messages in the console.\n        });\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  /**\n   * @private\n   */\n  _processItems(items, styleCache) {\n    for (let i = 0, len = items.length; i < len; i++) {\n      if (items[i].str === undefined) {\n        if (\n          items[i].type === \"beginMarkedContentProps\" ||\n          items[i].type === \"beginMarkedContent\"\n        ) {\n          const parent = this._container;\n          this._container = document.createElement(\"span\");\n          this._container.classList.add(\"markedContent\");\n          if (items[i].id !== null) {\n            this._container.setAttribute(\"id\", `${items[i].id}`);\n          }\n          parent.appendChild(this._container);\n        } else if (items[i].type === \"endMarkedContent\") {\n          this._container = this._container.parentNode;\n        }\n        continue;\n      }\n      this._textContentItemsStr.push(items[i].str);\n      appendText(this, items[i], styleCache, this._layoutTextCtx);\n    }\n  }\n\n  /**\n   * @private\n   */\n  _layoutText(textDiv) {\n    const textDivProperties = this._textDivProperties.get(textDiv);\n\n    let transform = \"\";\n    if (textDivProperties.canvasWidth !== 0 && textDivProperties.hasText) {\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        const scale = textDivProperties.canvasWidth / width;\n        if (this._enhanceTextSelection) {\n          textDivProperties.scale = scale;\n        }\n        transform = `scaleX(${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\n    if (textDivProperties.hasText) {\n      this._container.appendChild(textDiv);\n    }\n    if (textDivProperties.hasEOL) {\n      const br = document.createElement(\"br\");\n      br.setAttribute(\"role\", \"presentation\");\n      this._container.appendChild(br);\n    }\n  }\n\n  /**\n   * @private\n   */\n  _render(timeout = 0) {\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    canvas.height = canvas.width = DEFAULT_FONT_SIZE;\n\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\" 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  /**\n   * @param {boolean} [expandDivs]\n   */\n  expandTextDivs(expandDivs = false) {\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 (let 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.hasText) {\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/**\n * @param {TextLayerRenderParameters} renderParameters\n * @returns {TextLayerRenderTask}\n */\nfunction renderTextLayer(renderParameters) {\n  const 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\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\nimport {\n  createObjectURL,\n  FONT_IDENTITY_MATRIX,\n  IDENTITY_MATRIX,\n  ImageKind,\n  isNum,\n  OPS,\n  TextRenderingMode,\n  unreachable,\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 = class {\n  constructor() {\n    unreachable(\"Not implemented: SVGGraphics\");\n  }\n};\n\nif (\n  typeof PDFJSDev === \"undefined\" ||\n  PDFJSDev.test(\"!PRODUCTION || GENERIC\")\n) {\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, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 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  SVGGraphics = class {\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.hypot(a, 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      current.fontMatrix = fontObj.fontMatrix || 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?.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.makeHexColor(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.makeHexColor(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, tx1, ty1] = Util.normalizeRect([\n        ...Util.applyTransform([x0, y0], matrix),\n        ...Util.applyTransform([x1, y1], matrix),\n      ]);\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.makeHexColor(...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      if (typeof args === \"string\") {\n        args = this.objs.get(args);\n      }\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        for (const prev of this.extraStack) {\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?._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    for (const reader of this._rangeRequestReaders.slice(0)) {\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 { allowRangeRequests, 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\";\nimport { isPdfFile } from \"./display_utils.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 (isPdfFile(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 (${status}) while retrieving PDF \"${url}\".`,\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\nimport { stringToBytes } from \"../shared/util.js\";\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 buffer = stringToBytes(value);\n        value = decoder.decode(buffer);\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\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    this.isHttp = /^https?:/i.test(url);\n    this.httpHeaders = (this.isHttp && args.httpHeaders) || Object.create(null);\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] = { xhr });\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      return; // Maybe abortRequest was called...\n    }\n    pendingRequest.onProgress?.(evt);\n  }\n\n  onStateChange(xhrId, evt) {\n    const pendingRequest = this.pendingRequests[xhrId];\n    if (!pendingRequest) {\n      return; // Maybe abortRequest was called...\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      pendingRequest.onError?.(xhr.status);\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      pendingRequest.onError?.(xhr.status);\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 {\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    this._fullRequestReader?.cancel(reason);\n\n    for (const reader of this._rangeRequestReaders.slice(0)) {\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 { allowRangeRequests, 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(data) {\n    if (data) {\n      if (this._requests.length > 0) {\n        const requestCapability = this._requests.shift();\n        requestCapability.resolve({ value: data.chunk, done: false });\n      } else {\n        this._cachedChunks.push(data.chunk);\n      }\n    }\n    this._done = true;\n    if (this._cachedChunks.length > 0) {\n      return;\n    }\n    for (const requestCapability of this._requests) {\n      requestCapability.resolve({ value: undefined, done: true });\n    }\n    this._requests.length = 0;\n  }\n\n  _onError(status) {\n    this._storedError = createResponseStatusError(status, this._url);\n    this._headersReceivedCapability.reject(this._storedError);\n    for (const requestCapability of this._requests) {\n      requestCapability.reject(this._storedError);\n    }\n    this._requests.length = 0;\n    this._cachedChunks.length = 0;\n  }\n\n  _onProgress(evt) {\n    this.onProgress?.({\n      loaded: evt.loaded,\n      total: evt.lengthComputable ? evt.total : this._contentLength,\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    for (const requestCapability of this._requests) {\n      requestCapability.resolve({ value: undefined, done: true });\n    }\n    this._requests.length = 0;\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\n    const args = {\n      onDone: this._onDone.bind(this),\n      onError: this._onError.bind(this),\n      onProgress: this._onProgress.bind(this),\n    };\n    this._url = manager.url;\n    this._requestId = manager.requestRange(begin, end, args);\n    this._requests = [];\n    this._queuedChunk = null;\n    this._done = false;\n    this._storedError = undefined;\n\n    this.onProgress = null;\n    this.onClosed = null;\n  }\n\n  _close() {\n    this.onClosed?.(this);\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    for (const requestCapability of this._requests) {\n      requestCapability.resolve({ value: undefined, done: true });\n    }\n    this._requests.length = 0;\n    this._close();\n  }\n\n  _onError(status) {\n    this._storedError = createResponseStatusError(status, this._url);\n    for (const requestCapability of this._requests) {\n      requestCapability.reject(this._storedError);\n    }\n    this._requests.length = 0;\n    this._queuedChunk = null;\n  }\n\n  _onProgress(evt) {\n    if (!this.isStreamingSupported) {\n      this.onProgress?.({ loaded: evt.loaded });\n    }\n  }\n\n  get isStreamingSupported() {\n    return false;\n  }\n\n  async read() {\n    if (this._storedError) {\n      throw this._storedError;\n    }\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    for (const requestCapability of this._requests) {\n      requestCapability.resolve({ value: undefined, done: true });\n    }\n    this._requests.length = 0;\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\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?.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?._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    for (const reader of this._rangeRequestReaders.slice(0)) {\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 { allowRangeRequests, 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(this._readCapability.reject);\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","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __w_pdfjs_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\tid: moduleId,\n\t\tloaded: false,\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __w_pdfjs_require__);\n\n\t// Flag the module as loaded\n\tmodule.loaded = true;\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","__w_pdfjs_require__.nmd = (module) => {\n\tmodule.paths = [];\n\tif (!module.children) module.children = [];\n\treturn module;\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-disable sort-exports/sort-exports */\n\n// eslint-disable-next-line max-len\n/** @typedef {import(\"./display/api\").PDFDocumentLoadingTask} PDFDocumentLoadingTask */\n/** @typedef {import(\"./display/api\").PDFDocumentProxy} PDFDocumentProxy */\n/** @typedef {import(\"./display/api\").PDFPageProxy} PDFPageProxy */\n/** @typedef {import(\"./display/api\").RenderTask} RenderTask */\n\nimport {\n  addLinkAttributes,\n  getFilenameFromUrl,\n  getPdfFilenameFromUrl,\n  getXfaPageViewport,\n  isPdfFile,\n  isValidFetchUrl,\n  LinkTarget,\n  loadScript,\n  PDFDateString,\n  PixelsPerInch,\n  RenderingCancelledException,\n} from \"./display/display_utils.js\";\nimport {\n  AnnotationMode,\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 {\n  build,\n  getDocument,\n  LoopbackPort,\n  PDFDataRangeTransport,\n  PDFWorker,\n  setPDFNetworkStreamFactory,\n  version,\n} from \"./display/api.js\";\nimport { AnnotationLayer } from \"./display/annotation_layer.js\";\nimport { GlobalWorkerOptions } from \"./display/worker_options.js\";\nimport { isNodeJS } from \"./shared/is_node.js\";\nimport { renderTextLayer } from \"./display/text_layer.js\";\nimport { SVGGraphics } from \"./display/svg.js\";\nimport { XfaLayer } from \"./display/xfa_layer.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\n  setPDFNetworkStreamFactory(async params => {\n    const [{ PDFNetworkStream }, { PDFFetchStream }] = await streamsPromise;\n    if (isValidFetchUrl(params.url)) {\n      return new PDFFetchStream(params);\n    }\n    return new PDFNetworkStream(params);\n  });\n} else if (PDFJSDev.test(\"GENERIC || CHROME\")) {\n  if (PDFJSDev.test(\"GENERIC\") && isNodeJS) {\n    const { PDFNodeStream } = require(\"./display/node_stream.js\");\n\n    setPDFNetworkStreamFactory(params => {\n      return new PDFNodeStream(params);\n    });\n  } else {\n    const { PDFNetworkStream } = require(\"./display/network.js\");\n    const { PDFFetchStream } = require(\"./display/fetch_stream.js\");\n\n    setPDFNetworkStreamFactory(params => {\n      if (isValidFetchUrl(params.url)) {\n        return new PDFFetchStream(params);\n      }\n      return new PDFNetworkStream(params);\n    });\n  }\n}\n\nexport {\n  // From \"./display/display_utils.js\":\n  addLinkAttributes,\n  getFilenameFromUrl,\n  getPdfFilenameFromUrl,\n  isPdfFile,\n  LinkTarget,\n  loadScript,\n  PDFDateString,\n  PixelsPerInch,\n  RenderingCancelledException,\n  getXfaPageViewport,\n  // From \"./shared/util.js\":\n  AnnotationMode,\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/api.js\":\n  build,\n  getDocument,\n  LoopbackPort,\n  PDFDataRangeTransport,\n  PDFWorker,\n  version,\n  // From \"./display/annotation_layer.js\":\n  AnnotationLayer,\n  // From \"./display/worker_options.js\":\n  GlobalWorkerOptions,\n  // From \"./display/text_layer.js\":\n  renderTextLayer,\n  // From \"./display/svg.js\":\n  SVGGraphics,\n  // From \"./display/xfa_layer.js\":\n  XfaLayer,\n};\n"],"names":["factory","link","_ref4","arguments","length","undefined","url","target","rel","_ref4$enabled","enabled","_util","assert","urlNullRemoved","removeNullCharacters","href","title","concat","onclick","targetStr","LinkTarget","NONE","SELF","BLANK","PARENT","TOP","DEFAULT_LINK_REL","details","console","log","anchor","indexOf","query","end","Math","min","substring","lastIndexOf","defaultFilename","isDataScheme","warn","reFilename","splitURI","exec","suggestedFilename","includes","decodeURIComponent","ex","xfaPage","_ref6","_ref6$scale","scale","_ref6$rotation","rotation","_xfaPage$attributes$s","attributes","style","width","height","viewBox","parseInt","PageViewport","filename","test","src","removeScriptElement","Promise","resolve","reject","script","document","createElement","onload","evt","remove","onerror","Error","head","documentElement","appendChild","__w_pdfjs_require__","_base_factory","PixelsPerInch","CSS","PDF","PDF_TO_CSS_UNITS","shadow","this","DOMCanvasFactory","_BaseCanvasFactory","_this","_ref$ownerDocument","ownerDocument","globalThis","_classCallCheck","_super","call","_document","canvas","BaseCanvasFactory","fetchData","_x","_callee","asTypedArray","response","_args","_regenerator","wrap","_context","prev","next","isValidFetchUrl","baseURI","fetch","sent","ok","statusText","t1","Uint8Array","arrayBuffer","t2","t0","t3","stringToBytes","text","t4","abrupt","request","XMLHttpRequest","open","responseType","onreadystatechange","readyState","DONE","data","status","responseText","send","stop","DOMCMapReaderFactory","_BaseCMapReaderFactor","compressionType","isCompressed","then","cMapData","BaseCMapReaderFactory","DOMStandardFontDataFactory","_BaseStandardFontData","BaseStandardFontDataFactory","DOMSVGFactory","_BaseSVGFactory","type","createElementNS","BaseSVGFactory","_ref2","_ref2$offsetX","offsetX","_ref2$offsetY","offsetY","_ref2$dontFlip","dontFlip","rotateA","rotateB","rotateC","rotateD","offsetCanvasX","offsetCanvasY","centerX","centerY","abs","transform","_ref3","_ref3$scale","_ref3$rotation","_ref3$offsetX","_ref3$offsetY","_ref3$dontFlip","slice","x","y","Util","applyTransform","rect","topLeft","bottomRight","applyInverseTransform","RenderingCancelledException","_BaseException","msg","_this2","_super5","BaseException","ii","i","trim","toLowerCase","pdfDateStringRegex","StatTimer","started","Object","create","times","name","Date","now","push","start","_step","outBuf","longest","_iterator","_createForOfIteratorHelper","s","n","done","value","err","e","f","_step2","_iterator2","_time","duration","padEnd","join","baseUrl","protocol","URL","PDFDateString","input","isString","RegExp","matches","year","month","day","hour","minute","second","universalTimeRelation","offsetHour","offsetMinute","UTC","module","exports","runtime","Op","prototype","hasOwn","hasOwnProperty","$Symbol","Symbol","iteratorSymbol","iterator","asyncIteratorSymbol","asyncIterator","toStringTagSymbol","toStringTag","define","obj","key","defineProperty","enumerable","configurable","writable","innerFn","outerFn","self","tryLocsList","protoGenerator","Generator","generator","context","Context","_invoke","state","GenStateSuspendedStart","method","arg","GenStateExecuting","GenStateCompleted","doneResult","delegate","delegateResult","maybeInvokeDelegate","ContinueSentinel","_sent","dispatchException","record","tryCatch","GenStateSuspendedYield","makeInvokeMethod","fn","GeneratorFunction","GeneratorFunctionPrototype","IteratorPrototype","getProto","getPrototypeOf","NativeIteratorPrototype","values","Gp","defineIteratorMethods","forEach","AsyncIterator","PromiseImpl","invoke","result","_typeof","__await","unwrapped","error","previousPromise","callInvokeWithMethodAndArg","TypeError","info","resultName","nextLoc","pushTryEntry","locs","entry","tryLoc","catchLoc","finallyLoc","afterLoc","tryEntries","resetTryEntry","completion","reset","iterable","iteratorMethod","isNaN","displayName","isGeneratorFunction","genFun","ctor","constructor","mark","setPrototypeOf","__proto__","awrap","async","iter","keys","object","reverse","pop","skipTempReset","charAt","rootRecord","rval","exception","handle","loc","caught","hasCatch","hasFinally","finallyEntry","complete","finish","thrown","delegateYield","regeneratorRuntime","accidentalStrictMode","Function","arr","resultLength","arrayByteLength","pos","_i","item","itemLength","byteLength","set","bytes","MAX_ARGUMENT_COUNT","String","fromCharCode","apply","strBuf","chunkEnd","chunk","subarray","contentType","forceDataSchema","createObjectURL","Blob","digits","buffer","b1","b2","b3","capability","isSettled","get","promise","reason","options","addDefaultProtocol","startsWith","dots","match","tryConvertEncoding","stringToUTF8String","absoluteUrl","_isValidProtocol","str","replace","date","getUTCFullYear","toString","getUTCMonth","padStart","getUTCDate","getUTCHours","getUTCMinutes","getUTCSeconds","verbosity","VerbosityLevel","INFOS","v","arr1","arr2","otherUrl","base","origin","other","map","_step$value","replaceInvisible","InvisibleCharactersRegExp","NullCharactersRegExp","level","Number","isInteger","charCodeAt","_i2","_i3","code","PDFStringTranslateTable","buf","_char","unescape","encodeURIComponent","ANY","DISPLAY","PRINT","ANNOTATIONS_FORMS","ANNOTATIONS_STORAGE","ANNOTATIONS_DISABLE","OPLIST","DISABLE","ENABLE","ENABLE_FORMS","ENABLE_STORAGE","MODIFY_CONTENTS","COPY","MODIFY_ANNOTATIONS","FILL_INTERACTIVE_FORMS","COPY_FOR_ACCESSIBILITY","ASSEMBLE","PRINT_HIGH_QUALITY","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","GRAYSCALE_1BPP","RGB_24BPP","RGBA_32BPP","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","MARKED","REVIEW","UNMARKED","ACCEPTED","REJECTED","CANCELLED","COMPLETED","GROUP","REPLY","HIDDEN","NOZOOM","NOROTATE","NOVIEW","READONLY","LOCKED","TOGGLENOVIEW","LOCKEDCONTENTS","REQUIRED","NOEXPORT","MULTILINE","PASSWORD","NOTOGGLETOOFF","RADIO","PUSHBUTTON","COMBO","EDIT","SORT","FILESELECT","MULTISELECT","DONOTSPELLCHECK","DONOTSCROLL","COMB","RICHTEXT","RADIOSINUNISON","COMMITONSELCHANGE","SOLID","DASHED","BEVELED","INSET","E","X","D","U","Fo","Bl","PO","PC","PV","PI","K","F","V","C","WC","WS","DS","WP","DP","O","UNKNOWN","FLATE","LZW","DCT","JPX","JBIG","A85","AHX","CCF","RLX","TYPE1","TYPE1STANDARD","TYPE1C","CIDFONTTYPE0","CIDFONTTYPE0C","TRUETYPE","CIDFONTTYPE2","TYPE3","OPENTYPE","TYPE0","MMTYPE1","ERRORS","WARNINGS","BINARY","STREAM","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","unknown","forms","javaScript","signatures","smask","shadingPattern","font","errorTilingPattern","errorExtGState","errorXObject","errorFontLoadType3","errorFontState","errorFontMissing","errorFontTranslate","errorColorSpace","errorOperatorList","errorFontToUnicode","errorFontLoadNative","errorFontBuildPath","errorFontGetPath","errorMarkedContent","errorContentSubStream","NEED_PASSWORD","INCORRECT_PASSWORD","unreachable","cond","prop","message","PasswordException","UnknownErrorException","_BaseException2","_super2","InvalidPDFException","_BaseException3","_super3","MissingPDFException","_BaseException4","_super4","UnexpectedResponseException","_BaseException5","_this3","FormatError","_BaseException6","_super6","AbortException","_BaseException7","_super7","IsLittleEndianCached","buffer8","Uint32Array","IsEvalSupportedCached","isEvalSupported","hexNumbers","_toConsumableArray","Array","r","g","b","m1","m2","p","m","d","p1","p2","p3","p4","max","transpose","a","c","first","sqrt","pow","sx","sy","rect1","rect2","compare","orderedX","sort","orderedY","normalizeRect","x0","y0","x1","y1","x2","y2","x3","y3","t","b2ac","sqrtb2ac","tvalues","bounds","mt","j","jlen","escape","_is_node","_pdfjsCompatibilityChecked","btoa","isNodeJS","chars","Buffer","from","atob","DOMMatrix","fromEntries","allSettled","ReadableStream","process","versions","nw","electron","$","global","getOwnPropertyDescriptor","createNonEnumerableProperty","redefine","setGlobal","copyConstructorProperties","isForced","source","targetProperty","sourceProperty","descriptor","TARGET","GLOBAL","STATIC","stat","noTargetGet","forced","sham","check","it","window","DESCRIPTORS","propertyIsEnumerableModule","createPropertyDescriptor","toIndexedObject","toPropertyKey","IE8_DOM_DEFINE","$getOwnPropertyDescriptor","P","fails","bind","$propertyIsEnumerable","propertyIsEnumerable","NASHORN_BUG","bitmap","IndexedObject","requireObjectCoercible","uncurryThis","classof","split","FunctionPrototype","callBind","stringSlice","toPrimitive","isSymbol","argument","isObject","getMethod","ordinaryToPrimitive","wellKnownSymbol","TO_PRIMITIVE","pref","exoticToPrim","isCallable","getBuiltIn","isPrototypeOf","USE_SYMBOL_AS_UID","namespace","NATIVE_SYMBOL","V8_VERSION","getOwnPropertySymbols","symbol","version","userAgent","Deno","v8","aCallable","func","tryToString","val","valueOf","shared","uid","WellKnownSymbolsStore","symbolFor","createWellKnownSymbol","withoutSetter","description","IS_PURE","store","mode","copyright","SHARED","toObject","id","postfix","random","EXISTS","definePropertyModule","anObject","$defineProperty","Attributes","inspectSource","InternalStateModule","CONFIGURABLE_FUNCTION_NAME","CONFIGURABLE","getInternalState","enforceInternalState","enforce","TEMPLATE","unsafe","simple","functionToString","has","NATIVE_WEAK_MAP","sharedKey","hiddenKeys","OBJECT_ALREADY_INITIALIZED","WeakMap","wmget","wmhas","wmset","metadata","facade","STATE","getterFor","TYPE","getDescriptor","PROPER","ownKeys","getOwnPropertyDescriptorModule","getOwnPropertyNamesModule","getOwnPropertySymbolsModule","internalObjectKeys","getOwnPropertyNames","names","toAbsoluteIndex","lengthOfArrayLike","createMethod","IS_INCLUDES","$this","el","fromIndex","index","toIntegerOrInfinity","integer","ceil","floor","number","toLength","replacement","feature","detection","normalize","POLYFILL","NATIVE","string","fromArray","array","CSSMatrix","every","m11","m12","m13","m14","m21","m22","m23","m24","m31","m32","m33","m34","m41","m42","m43","m44","M11","M12","M21","M22","M41","M42","fromMatrix","k","fromString","invalidStringError","filter","tf","ref","components","parseFloat","z","xyz","xyza","multiply","translate","rotateAxisAngle","rotate","some","skewX","skewY","axis","idx","axeValues","Translate","Rotate","rx","ry","rz","degToRad","radX","radY","radZ","cosx","cos","sinx","sin","cosy","siny","cosz","sinz","RotateAxisAngle","alpha","angle","sinA","cosA","sinA2","Y","Z","z2","Scale","SkewX","radA","tan","SkewY","Multiply","args","len","ARGS","l","setMatrixValue","prototypeAccessors","isIdentity","is2D","Float64Array","Float32Array","toArray","toJSON","assign","RX","RY","RZ","transformPoint","w","defineProperties","Version","__WEBPACK_AMD_DEFINE_RESULT__","__WEBPACK_AMD_DEFINE_FACTORY__","path","addToUnscopables","Iterators","defineIterator","ARRAY_ITERATOR","setInternalState","iterated","kind","Arguments","UNSCOPABLES","ArrayPrototype","activeXDocument","enumBugKeys","html","documentCreateElement","PROTOTYPE","SCRIPT","IE_PROTO","EmptyConstructor","scriptTag","content","LT","NullProtoObjectViaActiveX","write","close","temp","parentWindow","NullProtoObject","ActiveXObject","iframeDocument","iframe","JS","domain","display","contentWindow","Properties","objectKeys","props","FunctionName","createIteratorConstructor","setToStringTag","IteratorsCore","PROPER_FUNCTION_NAME","BUGGY_SAFARI_ITERATORS","ITERATOR","KEYS","VALUES","ENTRIES","returnThis","Iterable","NAME","IteratorConstructor","DEFAULT","IS_SET","FORCED","CurrentIteratorPrototype","methods","KEY","getIterationMethod","KIND","defaultIterator","IterablePrototype","TO_STRING_TAG","INCORRECT_VALUES_NAME","nativeIterator","anyNativeIterator","entries","proto","ENUMERABLE_NEXT","PrototypeOfArrayIteratorPrototype","arrayIterator","CORRECT_PROTOTYPE_GETTER","ObjectPrototype","TAG","aPossiblePrototype","setter","CORRECT_SETTER","iterate","createProperty","AS_ENTRIES","isArrayIteratorMethod","getIterator","getIteratorMethod","iteratorClose","Result","stopped","ResultPrototype","unboundFunction","iterFn","step","that","IS_ITERATOR","INTERRUPTED","condition","callFn","usingIterator","TO_STRING_TAG_SUPPORT","classofRaw","CORRECT_ARGUMENTS","tag","tryGet","callee","innerResult","innerError","propertyKey","clearErrorStack","installErrorCause","normalizeStringArgument","ERROR_STACK_INSTALLABLE","$AggregateError","errors","isInstance","AggregateErrorPrototype","stack","errorsArray","AggregateError","arraySlice","TEST","V8_OR_CHAKRA_STACK_ENTRY","IS_V8_OR_CHAKRA_STACK","IS_FIREFOX_OR_SAFARI_STACK","dropEntries","fin","cause","$default","Internal","OwnPromiseCapability","PromiseWrapper","nativeThen","NativePromise","redefineAll","setSpecies","anInstance","checkCorrectnessOfIteration","speciesConstructor","task","microtask","promiseResolve","hostReportErrors","newPromiseCapabilityModule","perform","IS_BROWSER","IS_NODE","SPECIES","PROMISE","getInternalPromiseState","NativePromisePrototype","PromiseConstructor","PromisePrototype","newPromiseCapability","newGenericPromiseCapability","DISPATCH_EVENT","createEvent","dispatchEvent","NATIVE_REJECTION_EVENT","PromiseRejectionEvent","UNHANDLED_REJECTION","SUBCLASSING","PROMISE_CONSTRUCTOR_SOURCE","GLOBAL_CORE_JS_PROMISE","FakePromise","INCORRECT_ITERATION","all","isThenable","notify","isReject","notified","chain","reactions","exited","reaction","handler","fail","rejection","onHandleUnhandled","enter","exit","onUnhandled","event","initEvent","isUnhandled","emit","parent","unwrap","internalReject","internalResolve","wrapper","executor","onFulfilled","onRejected","$promiseResolve","counter","remaining","alreadyCalled","race","CONSTRUCTOR_NAME","Constructor","Prototype","SAFE_CLOSING","called","iteratorWithReturn","SKIP_CLOSING","ITERATION_SUPPORT","aConstructor","defaultConstructor","S","isConstructor","noop","empty","construct","constructorRegExp","INCORRECT_TO_STRING","isConstructorModern","location","defer","channel","port","IS_IOS","setImmediate","clear","clearImmediate","Dispatch","MessageChannel","queue","ONREADYSTATECHANGE","run","runner","listener","post","postMessage","host","nextTick","port2","port1","onmessage","addEventListener","importScripts","removeChild","setTimeout","Reflect","flush","last","toggle","node","macrotask","IS_IOS_PEBBLE","IS_WEBOS_WEBKIT","MutationObserver","WebKitMutationObserver","queueMicrotaskDescriptor","queueMicrotask","createTextNode","observe","characterData","Pebble","promiseCapability","PromiseCapability","$$resolve","$$reject","PROMISE_ANY_ERROR","any","alreadyResolved","alreadyRejected","real","onFinally","isFunction","STRING_ITERATOR","point","CONVERT_TO_STRING","position","size","codeAt","SymbolPolyfill","getGlobals","globals","typeIsObject","rethrowAssertionErrorRejection","originalPromise","originalPromiseThen","originalPromiseResolve","originalPromiseReject","newPromise","promiseResolvedWith","promiseRejectedWith","PerformPromiseThen","uponPromise","uponFulfillment","uponRejection","transformPromiseWith","fulfillmentHandler","rejectionHandler","setPromiseIsHandledToTrue","globalQueueMicrotask","resolvedPromise","reflectCall","promiseCall","QUEUE_MAX_ARRAY_SIZE","SimpleQueue","_cursor","_size","_front","_elements","_next","_back","element","oldBack","newBack","shift","oldFront","newFront","oldCursor","newCursor","elements","callback","peek","front","cursor","ReadableStreamReaderGenericInitialize","reader","stream","_ownerReadableStream","_reader","_state","defaultReaderClosedPromiseInitialize","defaultReaderClosedPromiseInitializeAsResolved","defaultReaderClosedPromiseInitializeAsRejected","_storedError","ReadableStreamReaderGenericCancel","ReadableStreamCancel","ReadableStreamReaderGenericRelease","defaultReaderClosedPromiseReject","defaultReaderClosedPromiseResetToRejected","readerLockException","_closedPromise","_closedPromise_resolve","_closedPromise_reject","defaultReaderClosedPromiseResolve","AbortSteps","ErrorSteps","CancelSteps","PullSteps","NumberIsFinite","isFinite","MathTrunc","trunc","isDictionary","assertDictionary","assertFunction","assertObject","assertRequiredArgument","assertRequiredField","field","convertUnrestrictedDouble","censorNegativeZero","integerPart","convertUnsignedLongLongWithEnforceRange","lowerBound","upperBound","MAX_SAFE_INTEGER","assertReadableStream","IsReadableStream","AcquireReadableStreamDefaultReader","ReadableStreamDefaultReader","ReadableStreamAddReadRequest","readRequest","_readRequests","ReadableStreamFulfillReadRequest","_closeSteps","_chunkSteps","ReadableStreamGetNumReadRequests","ReadableStreamHasDefaultReader","IsReadableStreamDefaultReader","_a","AsyncIteratorPrototype","IsReadableStreamLocked","defaultReaderBrandCheckException","cancel","read","resolvePromise","rejectPromise","ReadableStreamDefaultReaderRead","_errorSteps","releaseLock","_disturbed","_readableStreamController","closed","ReadableStreamAsyncIteratorImpl","preventCancel","_ongoingPromise","_isFinished","_preventCancel","nextSteps","_nextSteps","return","returnSteps","_returnSteps","ReadableStreamAsyncIteratorPrototype","IsReadableStreamAsyncIterator","_asyncIteratorImpl","streamAsyncIteratorBrandCheckException","AcquireReadableStreamAsyncIterator","impl","NumberIsNaN","CreateArrayFromList","CopyDataBlockBytes","dest","destOffset","srcOffset","TransferArrayBuffer","IsDetachedBuffer","ArrayBufferSlice","begin","ArrayBuffer","IsNonNegativeNumber","CloneAsUint8Array","byteOffset","DequeueValue","container","pair","_queue","_queueTotalSize","EnqueueValueWithSize","Infinity","RangeError","PeekQueueValue","ResetQueue","ReadableStreamBYOBRequest","IsReadableStreamBYOBRequest","byobRequestBrandCheckException","_view","respond","bytesWritten","_associatedReadableByteStreamController","ReadableByteStreamControllerRespond","respondWithNewView","view","isView","ReadableByteStreamControllerRespondWithNewView","ReadableByteStreamController","IsReadableByteStreamController","byteStreamControllerBrandCheckException","ReadableByteStreamControllerGetBYOBRequest","ReadableByteStreamControllerGetDesiredSize","_closeRequested","_controlledReadableByteStream","ReadableByteStreamControllerClose","enqueue","ReadableByteStreamControllerEnqueue","ReadableByteStreamControllerError","ReadableByteStreamControllerClearPendingPullIntos","_cancelAlgorithm","ReadableByteStreamControllerClearAlgorithms","ReadableByteStreamControllerHandleQueueDrain","autoAllocateChunkSize","_autoAllocateChunkSize","bufferE","pullIntoDescriptor","bufferByteLength","bytesFilled","elementSize","viewConstructor","readerType","_pendingPullIntos","ReadableByteStreamControllerCallPullIfNeeded","controller","ReadableByteStreamControllerShouldCallPull","_pulling","_pullAgain","_pullAlgorithm","ReadableByteStreamControllerInvalidateBYOBRequest","ReadableByteStreamControllerCommitPullIntoDescriptor","filledView","ReadableByteStreamControllerConvertPullIntoDescriptor","ReadableStreamFulfillReadIntoRequest","ReadableByteStreamControllerEnqueueChunkToQueue","ReadableByteStreamControllerFillPullIntoDescriptorFromQueue","currentAlignedBytes","maxBytesToCopy","maxBytesFilled","maxAlignedBytes","totalBytesToCopyRemaining","ready","headOfQueue","bytesToCopy","destStart","ReadableByteStreamControllerFillHeadPullIntoDescriptor","ReadableStreamClose","_byobRequest","ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue","ReadableByteStreamControllerShiftPendingPullInto","ReadableByteStreamControllerPullInto","readIntoRequest","DataView","BYTES_PER_ELEMENT","ReadableStreamAddReadIntoRequest","emptyView","ReadableByteStreamControllerRespondInClosedState","firstDescriptor","ReadableStreamHasBYOBReader","ReadableStreamGetNumReadIntoRequests","ReadableByteStreamControllerRespondInReadableState","remainderSize","remainder","ReadableByteStreamControllerRespondInternal","_started","transferredBuffer","firstPendingPullInto","ReadableStreamError","byobRequest","SetUpReadableStreamBYOBRequest","_strategyHWM","viewByteLength","SetUpReadableByteStreamController","startAlgorithm","pullAlgorithm","cancelAlgorithm","highWaterMark","SetUpReadableByteStreamControllerFromUnderlyingSource","underlyingByteSource","pull","AcquireReadableStreamBYOBReader","ReadableStreamBYOBReader","_readIntoRequests","IsReadableStreamBYOBReader","desiredSize","byobReaderBrandCheckException","ReadableStreamBYOBReaderRead","ExtractHighWaterMark","strategy","defaultHWM","ExtractSizeAlgorithm","convertQueuingStrategy","init","convertQueuingStrategySize","convertUnderlyingSink","original","abort","convertUnderlyingSinkAbortCallback","convertUnderlyingSinkCloseCallback","convertUnderlyingSinkStartCallback","convertUnderlyingSinkWriteCallback","assertWritableStream","IsWritableStream","isAbortSignal","aborted","supportsAbortController","AbortController","createAbortController","WritableStream","rawUnderlyingSink","rawStrategy","underlyingSink","InitializeWritableStream","sizeAlgorithm","SetUpWritableStreamDefaultControllerFromUnderlyingSink","streamBrandCheckException$2","IsWritableStreamLocked","WritableStreamAbort","WritableStreamCloseQueuedOrInFlight","WritableStreamClose","getWriter","AcquireWritableStreamDefaultWriter","WritableStreamDefaultWriter","CreateWritableStream","writeAlgorithm","closeAlgorithm","abortAlgorithm","SetUpWritableStreamDefaultController","WritableStreamDefaultController","_writer","_writableStreamController","_writeRequests","_inFlightWriteRequest","_closeRequest","_inFlightCloseRequest","_pendingAbortRequest","_backpressure","_abortReason","_abortController","_promise","wasAlreadyErroring","_resolve","_reject","_reason","_wasAlreadyErroring","WritableStreamStartErroring","closeRequest","writer","defaultWriterReadyPromiseResolve","WritableStreamDefaultControllerClose","WritableStreamAddWriteRequest","writeRequest","WritableStreamDealWithRejection","WritableStreamFinishErroring","WritableStreamDefaultWriterEnsureReadyPromiseRejected","WritableStreamHasOperationMarkedInFlight","storedError","abortRequest","WritableStreamRejectCloseAndClosedPromiseIfNeeded","WritableStreamFinishInFlightWrite","WritableStreamFinishInFlightWriteWithError","WritableStreamFinishInFlightClose","defaultWriterClosedPromiseResolve","WritableStreamFinishInFlightCloseWithError","WritableStreamMarkCloseRequestInFlight","WritableStreamMarkFirstWriteRequestInFlight","defaultWriterClosedPromiseReject","WritableStreamUpdateBackpressure","backpressure","defaultWriterReadyPromiseReset","locked","_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","closeSentinel","IsWritableStreamDefaultController","defaultControllerBrandCheckException$2","signal","_controlledWritableStream","WritableStreamDefaultControllerError","_abortAlgorithm","WritableStreamDefaultControllerClearAlgorithms","_strategySizeAlgorithm","_writeAlgorithm","_closeAlgorithm","WritableStreamDefaultControllerGetBackpressure","WritableStreamDefaultControllerAdvanceQueueIfNeeded","chunkSizeE","WritableStreamDefaultControllerErrorIfNeeded","enqueueE","WritableStreamDefaultControllerProcessClose","WritableStreamDefaultControllerProcessWrite","sinkClosePromise","_readyPromise_resolve","_readyPromise_reject","abortReason","NativeDOMException","DOMException","isDOMExceptionConstructor","createDOMExceptionPolyfill","captureStackTrace","DOMException$1","ReadableStreamPipeTo","preventClose","preventAbort","shuttingDown","currentWrite","actions","shutdownWithAction","action","pipeLoop","resolveLoop","rejectLoop","pipeStep","resolveRead","rejectRead","isOrBecomesErrored","shutdown","isOrBecomesClosed","destClosed_1","waitForWritesToFinish","oldCurrentWrite","originalIsError","originalError","doTheRest","finalize","newError","isError","removeEventListener","ReadableStreamDefaultController","IsReadableStreamDefaultController","defaultControllerBrandCheckException$1","ReadableStreamDefaultControllerGetDesiredSize","ReadableStreamDefaultControllerCanCloseOrEnqueue","ReadableStreamDefaultControllerClose","ReadableStreamDefaultControllerEnqueue","ReadableStreamDefaultControllerError","ReadableStreamDefaultControllerClearAlgorithms","_controlledReadableStream","ReadableStreamDefaultControllerCallPullIfNeeded","ReadableStreamDefaultControllerShouldCallPull","ReadableStreamDefaultControllerHasBackpressure","SetUpReadableStreamDefaultController","SetUpReadableStreamDefaultControllerFromUnderlyingSource","underlyingSource","ReadableStreamTee","cloneForBranch2","ReadableByteStreamTee","ReadableStreamDefaultTee","reason1","reason2","branch1","branch2","resolveCancelPromise","reading","readAgain","canceled1","canceled2","cancelPromise","chunk1","chunk2","cancel1Algorithm","compositeReason","cancelResult","cancel2Algorithm","CreateReadableStream","readAgainForBranch1","readAgainForBranch2","forwardReaderError","thisReader","pullWithDefaultReader","cloneE","pull1Algorithm","pull2Algorithm","pullWithBYOBReader","forBranch2","byobBranch","otherBranch","byobCanceled","clonedChunk","otherCanceled","CreateReadableByteStream","convertUnderlyingDefaultOrByteSource","convertUnderlyingSourceCancelCallback","convertUnderlyingSourcePullCallback","convertUnderlyingSourceStartCallback","convertReadableStreamType","convertReaderOptions","convertReadableStreamReaderMode","convertIteratorOptions","Boolean","convertPipeOptions","assertAbortSignal","convertReadableWritablePair","readable","rawUnderlyingSource","InitializeReadableStream","streamBrandCheckException$1","getReader","rawOptions","pipeThrough","rawTransform","pipeTo","destination","tee","convertQueuingStrategyInit","byteLengthSizeFunction","ByteLengthQueuingStrategy","_byteLengthQueuingStrategyHighWaterMark","IsByteLengthQueuingStrategy","byteLengthBrandCheckException","countSizeFunction","CountQueuingStrategy","_countQueuingStrategyHighWaterMark","IsCountQueuingStrategy","countBrandCheckException","convertTransformer","readableType","writableType","convertTransformerFlushCallback","convertTransformerStartCallback","convertTransformerTransformCallback","TransformStream","rawTransformer","rawWritableStrategy","rawReadableStrategy","writableStrategy","readableStrategy","transformer","startPromise_resolve","readableHighWaterMark","readableSizeAlgorithm","writableHighWaterMark","writableSizeAlgorithm","InitializeTransformStream","SetUpTransformStreamDefaultControllerFromTransformer","_transformStreamController","IsTransformStream","streamBrandCheckException","_readable","_writable","startPromise","TransformStreamDefaultSinkWriteAlgorithm","TransformStreamDefaultSinkAbortAlgorithm","TransformStreamDefaultSinkCloseAlgorithm","TransformStreamDefaultSourcePullAlgorithm","TransformStreamErrorWritableAndUnblockWrite","_backpressureChangePromise","_backpressureChangePromise_resolve","TransformStreamSetBackpressure","TransformStreamError","TransformStreamDefaultControllerClearAlgorithms","TransformStreamDefaultController","IsTransformStreamDefaultController","defaultControllerBrandCheckException","_controlledTransformStream","TransformStreamDefaultControllerEnqueue","TransformStreamDefaultControllerError","terminate","TransformStreamDefaultControllerTerminate","SetUpTransformStreamDefaultController","transformAlgorithm","flushAlgorithm","_transformAlgorithm","_flushAlgorithm","transformResultE","readableController","TransformStreamDefaultControllerPerformTransform","flushPromise","_createCanvas","getContext","canvasAndContext","_ref","_ref$baseUrl","_ref$isCompressed","CMapCompressionType","_fetchData","_ref3$baseUrl","_callee2","_context2","svg","_createSVG","setAttribute","_display_utils","_font_loader","_node_utils","_annotation_storage","_canvas","_worker_options","_message_handler","_metadata","_optional_content_config","_transport_stream","_xfa_text","DEFAULT_RANGE_CHUNK_SIZE","RENDERING_CANCELLED_TIMEOUT","DefaultCanvasFactory","NodeCanvasFactory","DefaultCMapReaderFactory","NodeCMapReaderFactory","DefaultStandardFontDataFactory","NodeStandardFontDataFactory","createPDFNetworkStream","setPDFNetworkStreamFactory","pdfNetworkStreamFactory","getDocument","PDFDocumentLoadingTask","isArrayBuffer","PDFDataRangeTransport","range","params","rangeTransport","worker","rangeChunkSize","CMapReaderFactory","StandardFontDataFactory","ignoreErrors","stopAtErrors","fontExtraProperties","pdfBug","enableXfa","docBaseUrl","maxImageSize","useWorkerFetch","disableFontFace","useSystemFonts","disableRange","disableStream","disableAutoFetch","setVerbosityLevel","workerParams","GlobalWorkerOptions","workerPort","PDFWorker","fromPort","_worker","docId","destroyed","workerIdPromise","_fetchDocument","networkStreamPromise","networkStream","PDFDataTransportStream","initialData","progressiveDone","contentDispositionFilename","httpHeaders","withCredentials","_slicedToArray","workerId","messageHandler","MessageHandler","transport","WorkerTransport","_transport","_capability","_x2","_x3","_x4","_callee7","pdfDataRangeTransport","_context7","sendWithPromise","apiVersion","password","cMapUrl","standardFontDataUrl","createPromiseCapability","idCounters","doc","onPassword","onProgress","onUnsupportedFeature","_this$_transport","destroy","_rangeListeners","_progressListeners","_progressiveReadListeners","_progressiveDoneListeners","_readyCapability","loaded","total","_step3","_iterator3","_step4","_iterator4","PDFDocumentProxy","pdfInfo","_value","_this4","_pdfInfo","deprecated","fingerprints","_asyncToGenerator","stats","streamTypes","fontTypes","annotationStorage","numPages","_htmlForXfa","pageNumber","getPage","getPageIndex","getDestinations","getDestination","getPageLabels","getPageLayout","getPageMode","getViewerPreferences","getOpenAction","getAttachments","getJavaScript","getDocJSActions","getOutline","getOptionalContentConfig","getPermissions","getMetadata","getMarkInfo","getData","downloadInfoCapability","keepLoadedFonts","startCleanup","isPureXfa","loadingTask","loadingParams","saveDocument","getFieldObjects","hasJSActions","getCalculationOrderIds","PDFPageProxy","pageIndex","pageInfo","_pageIndex","_pageInfo","_ownerDocument","_stats","_pdfBug","commonObjs","objs","PDFObjects","cleanupAfterRender","pendingCleanup","_intentStates","Map","_annotationPromises","userUnit","_ref4$intent","intent","intentArgs","getRenderingIntent","cacheKey","getAnnotations","renderingIntent","annotations","_step5","_iterator5","_loop","annotation","titleObj","contentsObj","_jsActionsPromise","getPageJSActions","_callee3","_this$_transport$_htm","_context3","children","_ref5","_arguments$","_arguments$2","_intentState","_this5","canvasContext","viewport","_ref5$intent","_ref5$annotationMode","annotationMode","AnnotationMode","_ref5$transform","_ref5$imageLayer","imageLayer","_ref5$canvasFactory","canvasFactory","_ref5$background","background","_ref5$optionalContent","optionalContentConfigPromise","_ref5$annotationCanva","annotationCanvasMap","renderInteractiveForms","includeAnnotationStorage","time","intentState","streamReaderCancelTimeout","clearTimeout","canvasFactoryInstance","intentPrint","RenderingIntentFlag","displayReadyCapability","operatorList","fnArray","argsArray","lastChunk","_pumpOperatorList","renderTasks","internalRenderTask","_tryCleanup","_abortOperatorList","timeEnd","InternalRenderTask","useRequestAnimationFrame","Set","add","renderTask","_ref7","transparency","optionalContentConfig","initializeGraphics","operatorListChanged","opListTask","_intentState2","_ref8","_ref8$intent","_ref8$annotationMode","opListReadCapability","_ref9","_ref9$normalizeWhites","normalizeWhitespace","_ref9$disableCombineT","disableCombineTextItems","_ref9$includeMarkedCo","includeMarkedContent","sendWithStream","combineTextItems","textContent","items","getXfa","xfa","XfaText","readableStream","streamTextContent","styles","pump","_ref10","_textContent$items","_structTreePromise","getStructTree","_step6","waitOn","_iterator6","force","_step7","_iterator7","completed","resetStats","_step8","_iterator8","_step8$value","operatorListChunk","_step9","_iterator9","_ref11","_this6","serializable","streamReader","_ref12","_renderPageChunk","_step10","_iterator10","_ref13","_this7","_ref13$force","_step11","_iterator11","_step11$value","curCacheKey","cleanup","LoopbackPort","_listeners","_deferred","transfers","_this8","structuredClone","cloned","fallbackCloneValue","_step12","_iterator12","_step12$value","_step13","_iterator13","_val","isArray","_value$hasOwnProperty","desc","cloneValue","_step14","_iterator14","splice","PDFWorkerUtil","isWorkerDisabled","fallbackWorkerSrc","fakeWorkerId","_document$currentScri","pdfjsFilePath","currentScript","createCDNWrapper","_ref14","_ref14$name","_ref14$port","_ref14$verbosity","getVerbosityLevel","_workerPorts","_port","_webWorker","_messageHandler","_initializeFromPort","_initialize","on","_this9","Worker","_mainThreadWorkerMessageHandler","workerSrc","isSameOrigin","terminateEarly","onWorkerError","_setupFakeWorker","sendTest","testObj","_this10","_setupFakeWorkerGlobal","WorkerMessageHandler","workerHandler","setup","_globalThis$pdfjsWork","pdfjsWorker","_this11","loader","_ref15","_callee4","mainWorkerMessageHandler","_callee4$","_context4","eval","loadScript","getWorkerSrc","_classPrivateFieldInitSpec","_docStats","_pageCache","_pagePromises","_metadataPromise","fontLoader","FontLoader","_onUnsupportedFeature","styleElement","_params","cMapPacked","destroyCapability","_passwordCapability","_networkStream","_fullReader","_lastProgress","setupMessageHandler","AnnotationStorage","_classPrivateFieldGet","isOpList","lastModified","_this12","_step15","_iterator15","page","_destroy","resetModified","terminated","_classPrivateFieldSet","_getFieldObjectsPromise","_hasJSActionsPromise","cancelAllRequests","_this13","sink","getFullReader","onPull","_ref16","onCancel","readyReason","headersCapability","fullReader","headersReady","_loadingTask$onProgre","isStreamingSupported","isRangeSupported","_loadingTask$onProgre2","contentLength","rangeReader","getRangeReader","_ref17","_ref18","_numPages","htmlForXfa","_loadingTask$onProgre3","_startRenderPage","_ref19","_globalThis$FontInspe","_ref20","exportedData","exportedError","fontRegistry","FontInspector","registerFont","fontAdded","FontFaceObject","_ref21","_imageData$data","_ref22","imageData","pageProxy","_loadingTask$onProgre4","freeze","_ref23","_this$loadingTask$onU","_this$loadingTask","featureId","_this14","cachedPromise","_this$_fullReader$fil","_this$_fullReader","_this15","results","OptionalContentConfig","_this16","_this16$_fullReader$f","_this16$_fullReader","_this16$_fullReader$c","_this16$_fullReader2","Metadata","_callee5","_iterator16","_step16","_args5","_context5","_objs","objId","resolved","_ensureObj","RenderTask","_internalRenderTask","onContinue","_ref24","_ref24$useRequestAnim","_ref24$pdfBug","operatorListIdx","running","graphicsReadyCallback","graphicsReady","_useRequestAnimationFrame","cancelled","_cancelBound","_continueBound","_continue","_scheduleNextBound","_scheduleNext","_nextBound","_ref25","_globalThis$StepperMa","_ref25$transparency","canvasInUse","StepperManager","stepper","nextBreakPoint","getNextBreakPoint","_this$params","gfx","CanvasGraphics","beginDrawing","endDrawing","updateOperatorList","_this17","requestAnimationFrame","_callee6","_context6","executeOperatorList","WeakSet","build","BaseFontLoader","nativeFontFaces","nativeFontFace","fonts","rule","getElementsByTagName","styleSheet","sheet","insertRule","cssRules","attached","missingFile","isFontLoadingAPISupported","createNativeFontFace","addNativeFontFace","UNSUPPORTED_FEATURES","family","createFontFaceRule","isSyncFontLoadingSupported","_queueLoadingCallback","_prepareFontLoadEvent","_this$_document","hasFonts","rules","fontsToLoad","_BaseFontLoader","_inherits","GenericFontLoader","_createSuper","loadingContext","requests","nextRequestId","loadTestFontId","_createClass","supported","navigator","otherRequest","int32","offset","spliceString","insert","ctx","_loadTestFont","XXXX_VALUE","checksum","string32","loadedName","div","visibility","top","left","_names","span","fontFamily","body","isFontReady","fillText","getImageData","translatedData","_ref2$isEvalSupported","_ref2$disableFontFace","_ref2$ignoreErrors","_ref2$fontRegistry","compiledGlyphs","cssFontInfo","css","weight","fontWeight","italicAngle","FontFace","bytesToString","mimetype","character","cmds","jsBuf","current","cmd","_current","require","readFile","createCanvas","_storage","_timeStamp","_modified","onSetModified","onResetModified","defaultValue","modified","_Object$entries","_Object$entries$_i","_setModified","objectFromMap","_pattern_helper","MAX_GROUP_SIZE","FULL_CHUNK_HEIGHT","addContextCurrentTransform","mozCurrentTransform","_originalSave","_originalRestore","_originalRotate","_originalScale","_originalTranslate","_originalTransform","_originalSetTransform","setTransform","_originalResetTransform","resetTransform","_transformMatrix","_transformStack","_setLineWidth","_getLineWidth","_","_this$_transformMatri","ad_bc","bc_ad","old","cosValue","sinValue","CachedCanvases","cache","trackTransform","canvasEntry","CanvasExtraState","alphaIsShape","fontSize","fontSizeScale","textMatrix","IDENTITY_MATRIX","textMatrixScale","fontMatrix","FONT_IDENTITY_MATRIX","leading","lineX","lineY","charSpacing","wordSpacing","textHScale","textRenderingMode","TextRenderingMode","textRise","fillColor","strokeColor","patternFill","fillAlpha","strokeAlpha","lineWidth","activeSMask","transferMaps","startNewPathAndClipBox","clone","clipBox","_Util$applyTransform2","minX","minY","maxX","maxY","box","bezierBoundingBox","updatePathMinMax","pathType","PathType","singularValueDecompose2dScale","xStrokePad","yStrokePad","intersect","getPathBoundingBox","putBinaryImageData","imgData","ImageData","putImageData","destPos","thisChunkHeight","elemsInThisChunk","transferMapRed","transferMapGreen","transferMapBlue","transferMapGray","partialChunkHeight","fullChunks","totalChunks","chunkImgData","createImageData","srcPos","ImageKind","srcLength","dest32","dest32DataLength","fullSrcDiff","white","black","srcDiff","kEnd","kEndUnrolled","mask","srcByte","hasTransferMaps","_k","_k2","_hasTransferMaps","_k3","putBinaryImageMask","elem","copyCtxState","sourceCtx","destCtx","properties","property","setLineDash","getLineDash","lineDashOffset","resetCtxToDefault","strokeStyle","fillStyle","fillRule","globalAlpha","lineCap","lineJoin","miterLimit","globalCompositeOperation","composeSMaskBackdrop","r0","g0","b0","alpha_","composeSMaskAlpha","maskData","layerData","transferMap","composeSMaskLuminosity","composeSMask","layerCtx","layerBox","layerOffsetX","layerOffsetY","layerWidth","layerHeight","maskCtx","subtype","backdrop","maskOffsetX","maskOffsetY","composeFn","hasBackdrop","row","chunkHeight","genericComposeSMask","drawImage","getImageSmoothingEnabled","interpolate","fround","actualScale","devicePixelRatio","LINE_CAP_STYLES","LINE_JOIN_STYLES","NORMAL_CLIP","EO_CLIP","canvasCtx","stateStack","pendingClip","pendingEOFill","res","xobjs","groupStack","processingType3","baseTransform","baseTransformStack","groupLevel","smaskStack","smaskCounter","tempSMask","suspendedCtx","contentVisible","markedContentStack","cachedCanvases","cachedPatterns","viewportScale","outputScaleX","outputScaleY","_cachedGetSinglePixelWidth","_ref2$transparency","_ref2$background","fillRect","transparentCanvas","getCanvas","compositeCtx","_combinedScaleFactor","hypot","beginLayout","executionStartIdx","continueCallback","argsArrayLen","fnId","chunkOperations","endTime","steps","breakIt","OPS","depObjId","objsPool","endLayout","img","inverseTransform","tmpCanvas","tmpCtx","widthScale","heightScale","paintWidth","paintHeight","tmpCanvasId","newWidth","newHeight","clearRect","isPatternFill","maskCanvas","objToCanvas","maskToCanvas","cord1","cord2","drawnWidth","drawnHeight","fillCanvas","fillCtx","scaled","_scaleImage","mozCurrentTransformInverse","imageSmoothingEnabled","inverse","getPattern","round","limit","dashArray","dashPhase","flatness","states","checkSMaskState","inSMaskMode","beginSMaskMode","endSMaskMode","cacheId","scratchCanvas","_removeMirroring","__originalSave","__originalRestore","__originalRotate","__originalScale","__originalTranslate","__originalTransform","__originalSetTransform","__originalResetTransform","__originalClip","__originalMoveTo","__originalLineTo","__originalBezierCurveTo","bezierCurveTo","__originalRect","__originalClosePath","__originalBeginPath","beginPath","cp1x","cp1y","cp2x","cp2y","mirrorContextOperations","dirtyBox","ops","startX","startY","xw","yh","updateCurvePathMinMax","setCurrentPoint","consumePath","getSinglePixelWidth","_lineWidth","getClippedPathBoundingBox","needRestore","paths","pendingTextPaths","addToPath","spacing","fontRefName","fontObj","fontDirection","isType3Font","bold","italic","typeface","fallbackName","browserFontSize","rise","patternTransform","resetLineWidthToOne","fillStrokeMode","isAddToPathSet","getPathGenerator","strokeText","glyphs","showType3Text","glyphsLength","vertical","spacingDir","defaultVMetrics","widthAdvanceScale","simpleFillText","pattern","glyph","isNum","restoreNeeded","isSpace","fontChar","accent","scaledX","scaledY","vmetric","vx","vy","remeasure","measuredWidth","measureText","isFontSubpixelAAEnabled","characterScaleX","isInFont","paintChar","scaledAccentX","scaledAccentY","compose","spacingLength","charProcOperatorList","operatorListId","xWidth","yWidth","llx","lly","urx","ury","IR","color","canvasGraphicsFactory","createCanvasGraphics","TilingPattern","_getPattern","getColorN_Pattern","makeHexColor","matrix","getShadingPattern","SHADING","inv","bl","br","ul","ur","bbox","group","currentCtx","isolated","knockout","currentTransform","getAxialAlignedBoundingBox","canvasBounds","scaleX","scaleY","groupCtx","startTransformInverse","_this$groupStack$pop","currentMtx","hasOwnCanvas","_Util$singularValueDe2","canvasWidth","canvasHeight","annotationCanvas","_this$annotationCanva","savedCtx","compiled","j0","POINT_TYPES","width1","points","lineSize","data0","count","sum","Int32Array","outlines","coords","p0","pp","kk","o","ll","compileType3Glyph","_createMaskCanvas","positions","trans","_Util$applyTransform4","images","image","h","imgToPaint","HTMLElement","getCanvasPosition","appendImage","visible","isVisible","isContentVisible","updateClipFromPath","absDet","sqNorm1","sqNorm2","pixelHeight","EPSILON","op","RadialAxialShadingPattern","MeshShadingPattern","DummyShadingPattern","applyBoundingBox","Path2D","region","BaseShadingPattern","_BaseShadingPattern","_type","_bbox","_colorStops","_p0","_p1","_r0","_r1","grad","createLinearGradient","createRadialGradient","colorStop","addColorStop","owner","ownerBBox","_createGradient","createPattern","domMatrix","drawTriangle","c1","c2","c3","tmp","colors","rowSize","xa","car","cag","cab","xb","cbr","cbg","cbb","c1r","c1g","c1b","c2r","c2g","c2b","c3r","c3g","c3b","x1_","x2_","drawFigure","figure","ps","cs","verticesPerRow","rows","cols","q","_BaseShadingPattern2","_coords","_colors","_figures","_bounds","_background","combinedScale","backgroundColor","boundsWidth","boundsHeight","paddedWidth","BORDER_SIZE","paddedHeight","matrixScale","temporaryPatternCanvas","_createMeshCanvas","_BaseShadingPattern3","PaintType","xstep","ystep","paintType","tilingType","curMatrixScale","dimx","getSizeAndScale","dimy","graphics","setFillAndStrokeStyleToContext","adjustedX0","adjustedY0","adjustedX1","adjustedY1","clipBbox","realOutputSize","maxSize","MAX_PATTERN_SIZE","bboxWidth","bboxHeight","cssColor","createPatternCanvas","CallbackKind","StreamKind","wrapReason","sourceName","targetName","comObj","callbackId","streamId","streamSinks","streamControllers","callbackCapabilities","actionHandler","_onComObjOnMessage","_processStreamMessage","cbSourceName","cbTargetName","_createStreamSink","actionName","ah","queueingStrategy","startCapability","startCall","pullCall","cancelCall","isClosed","pullCapability","cancelCapability","streamSink","isCancelled","lastDesiredSize","sinkCapability","success","streamController","_deleteStreamController","parsedData","rawData","_metadataMap","_data","_classPrivateFieldGet2","OptionalContentGroup","creator","_order","_groups","order","groups","_group","baseState","off","operator","_evaluateVisibilityExpression","expression","policy","ids","_id","_id2","_id3","_queuedChunks","_progressiveDone","_contentDispositionFilename","_pdfDataRangeTransport","_isStreamingSupported","_isRangeSupported","_contentLength","_fullRequestReader","_rangeReaders","addRangeListener","_onReceiveData","addProgressListener","_onProgress","addProgressiveReadListener","addProgressiveDoneListener","_onProgressiveDone","transportReady","_enqueue","found","_begin","_this$_fullRequestRea","_this$_fullRequestRea2","_loaded","firstReader","queuedChunks","PDFDataTransportStreamReader","_progressiveDataLength","PDFDataTransportStreamRangeReader","requestDataRange","_stream","_done","_filename","isPdfFile","_requests","_headersReady","requestCapability","_end","_queuedChunk","_removeRangeReader","output","walk","_node$attributes","shouldBuildText","_scripting_utils","_xfa_layer","DEFAULT_TAB_INDEX","GetElementsByNameSet","AnnotationElementFactory","parameters","annotationType","AnnotationType","LinkAnnotationElement","TextAnnotationElement","fieldType","TextWidgetAnnotationElement","radioButton","RadioButtonWidgetAnnotationElement","checkBox","CheckboxWidgetAnnotationElement","PushButtonWidgetAnnotationElement","ChoiceWidgetAnnotationElement","WidgetAnnotationElement","PopupAnnotationElement","FreeTextAnnotationElement","LineAnnotationElement","SquareAnnotationElement","CircleAnnotationElement","PolylineAnnotationElement","CaretAnnotationElement","InkAnnotationElement","PolygonAnnotationElement","HighlightAnnotationElement","UnderlineAnnotationElement","SquigglyAnnotationElement","StrikeOutAnnotationElement","StampAnnotationElement","FileAttachmentAnnotationElement","AnnotationElement","_ref$isRenderable","isRenderable","_ref$ignoreBorder","ignoreBorder","_ref$createQuadrilate","createQuadrilaterals","layer","linkService","downloadManager","imageResourcesPath","renderForms","svgFactory","enableScripting","_fieldObjects","fieldObjects","_mouseState","mouseState","_createContainer","quadrilaterals","_createQuadrilaterals","sign","transformOrigin","borderStyle","borderWidth","AnnotationBorderStyleType","horizontalRadius","horizontalCornerRadius","verticalRadius","verticalCornerRadius","radius","borderRadius","borderBottomStyle","borderColor","quadPoints","savedRect","quadPoint","trigger","popup","PopupElement","modificationDate","richText","hideWrapper","render","className","skipId","fields","fieldObj","_step3$value","exportValues","exportValue","domElement","getElementById","getElementsByName","_domElement","_exportValue","platform","isWin","isMac","_AnnotationElement","isTooltipOnly","resetForm","Action","_linkService$addLinkA","addLinkAttributes","newWindow","_bindNamedAction","_bindLink","hasClickAction","_bindJSAction","_bindResetFormAction","_renderQuadrilaterals","quadrilateral","linkElement","cloneNode","getDestinationHash","goToDestination","getAnchorUrl","executeNamedAction","_Object$keys","jsName","_this3$linkService$ev","eventBus","dispatch","detail","otherClickAction","resetFormFields","resetFormRefs","refs","include","allFields","fieldIds","fieldName","_Object$values","_i4","_Object$values2","_fields2","_this4$linkService$ev","storage","allIds","_i5","_allFields","_field","setValue","valueAsString","_value2","Event","_AnnotationElement2","_parameters$data$titl","_parameters$data$cont","_parameters$data$rich","hasPopup","alt","dataset","l10nId","l10nArgs","JSON","stringify","_createPopup","_AnnotationElement3","alternativeText","_AnnotationElement$pl","ctrlKey","metaKey","baseName","eventName","valueGetter","_this5$linkService$ev","shiftKey","modifier","_getKeyModifier","_this5$linkService$ev2","checked","getter","_this$data$actions","_setEventListener","jsEvent","setColor","styleName","ColorConverters","commonActions","hidden","print","focus","preventScroll","userName","readonly","removeAttribute","required","bgColor","fgColor","textColor","_i6","_Object$keys2","_WidgetAnnotationElem","hasAppearance","fieldValue","keyInStorage","_getElementsByName","_defineProperty","storedData","getValue","elementData","userValue","formattedValue","beforeInputSelectionRange","beforeInputValue","multiLine","disabled","readOnly","tabIndex","setPropertyOnSiblings","defaultFieldValue","blurListener","scrollLeft","_this$data$actions2","activeElement","selRange","_event$detail$selRang","selStart","selEnd","setSelectionRange","_dispatchEventFromSandbox","_this7$linkService$ev","commitKey","willCommit","selectionStart","selectionEnd","_blurListener","_this7$linkService$ev2","isDown","Keystroke","_this7$linkService$ev3","_elementData$beforeIn","change","_setEventListeners","maxLen","maxLength","comb","combWidth","classList","letterSpacing","verticalAlign","_setTextStyle","_setBackgroundColor","_this$data$defaultApp","defaultAppearanceData","fontColor","textAlignment","textAlign","_WidgetAnnotationElem2","_event$target","checkbox","curChecked","_WidgetAnnotationElem3","buttonValue","_event$target2","radio","pdfButtonValue","_LinkAnnotationElemen","_get","_getPrototypeOf","_WidgetAnnotationElem4","_super8","fontSizeStyle","selectElement","combo","multiSelect","multiple","option","selected","optionElement","displayValue","isExport","selectedIndex","getItems","multipleSelection","findIndex","_event$detail$insert","insertBefore","indices","_step17","_iterator17","editable","_this10$linkService$e","changeEx","keyDown","_AnnotationElement4","_parameters$data$titl2","_parameters$data$cont2","_parameters$data$rich2","_super9","parentType","selector","parentId","parentElements","querySelectorAll","parentRect","popupLeft","popupTop","pinned","_this$richText","_this$contentsObj","hideElement","dir","dateObject","toDateObject","toLocaleDateString","toLocaleTimeString","contents","_formatContents","XfaLayer","xfaHtml","lastChild","_step18","_iterator18","_toggle","_show","_hide","lines","line","zIndex","_AnnotationElement5","_parameters$data$titl3","_parameters$data$cont3","_parameters$data$rich3","_super10","_AnnotationElement6","_parameters$data$titl4","_parameters$data$cont4","_parameters$data$rich4","_super11","lineCoordinates","append","_AnnotationElement7","_parameters$data$titl5","_parameters$data$cont5","_parameters$data$rich5","_super12","square","_AnnotationElement8","_parameters$data$titl6","_parameters$data$cont6","_parameters$data$rich6","_super13","circle","_AnnotationElement9","_parameters$data$titl7","_parameters$data$cont7","_parameters$data$rich7","_super14","containerClassName","svgElementName","_step19","_iterator19","vertices","coordinate","polyline","_PolylineAnnotationEl","_super15","_AnnotationElement10","_parameters$data$titl8","_parameters$data$cont8","_parameters$data$rich8","_super16","_AnnotationElement11","_parameters$data$titl9","_parameters$data$cont9","_parameters$data$rich9","_super17","_step20","_iterator20","inkLists","_step21","inkList","_iterator21","_AnnotationElement12","_parameters$data$titl10","_parameters$data$cont10","_parameters$data$rich10","_super18","_AnnotationElement13","_parameters$data$titl11","_parameters$data$cont11","_parameters$data$rich11","_super19","_AnnotationElement14","_parameters$data$titl12","_parameters$data$cont12","_parameters$data$rich12","_super20","_AnnotationElement15","_parameters$data$titl13","_parameters$data$cont13","_parameters$data$rich13","_super21","_AnnotationElement16","_parameters$data$titl14","_parameters$data$cont14","_parameters$data$rich14","_super22","_AnnotationElement17","_this14$linkService$e","_this14$data$file","_super23","file","getFilenameFromUrl","_assertThisInitialized","stringToPDFString","_this$data$titleObj","_this$data$contentsOb","_download","_this$downloadManager","openOrDownloadData","AnnotationLayer","_step22","sortedAnnotations","popupAnnotations","_iterator22","_i7","_sortedAnnotations","rendered","_step23","_iterator23","renderedElement","prepend","_classStaticPrivateMethodGet","_setAnnotationCanvasMap","ownMatrix","_step24","_iterator24","_step25","_iterator25","ownTransform","_step26","_iterator26","_step26$value","querySelector","firstChild","nodeName","replaceChild","makeColorComp","G","R","B","RGB_HTML","CMYK_RGB","xfaOn","xfaOff","getAttribute","_ref$storage","isHTMLAnchorElement","HTMLAnchorElement","dataId","setupStorage","root","rootHtml","setAttributes","rootDiv","textDivs","_child$attributes","_stack","child","childHtml","xmlns","_node","renderParameters","TextLayerRenderTask","textContentStream","textContentItemsStr","enhanceTextSelection","_render","timeout","DEFAULT_FONT_SIZE","ascentCache","AllWhitespaceRegexp","appendText","geom","textDiv","textDivProperties","_enhanceTextSelection","hasText","hasEOL","originalTransform","paddingBottom","paddingLeft","paddingRight","paddingTop","_textDivs","tx","_viewport","atan2","fontName","fontHeight","fontAscent","cachedAscent","metrics","ascent","fontBoundingBoxAscent","descent","fontBoundingBoxDescent","ratio","pixels","_ratio","getAscent","_fontInspectorEnabled","shouldScaleText","absScaleX","absScaleY","_textDivProperties","_textContentStream","_layoutText","angleCos","angleSin","divWidth","divHeight","right","bottom","_canceled","textDivsLength","_renderingDone","findPositiveMin","ts","expand","expanded","boxes","x1New","x2New","expandBoundsLTR","_b","expandBounds","divProperties","jj","boxScale","horizon","boundary","_horizonPart","_affectedBoundary","maxXNew","xNew","changedHorizon","lastBoundary","useBoundary","unshift","used","_horizon","affectedBoundary","_textContent","_container","_textContentItemsStr","_layoutTextLastFontSize","_layoutTextLastFontFamily","_layoutTextCtx","_renderTimer","styleCache","parentNode","_textDiv$style","mozOpaque","textItems","textStyles","_processItems","expandDivs","transformBuf","paddingBuf","divProps","padding","SVGGraphics","pf","toFixed","pm","acos","SVG_DEFAULTS","fontStyle","convertImgDataToPng","PNG_HEADER","crcTable","writePngChunk","crc","crc32","deflateSyncUncompressed","literals","maxBlockLength","deflateBlocks","idat","pi","adler","adler32","encode","isMask","bitDepth","colorType","offsetLiterals","offsetBytes","_y","ihdr","deflateSync","pngLength","CHUNK_WRAPPER_SIZE","SVGExtraState","dependencies","activeClipUrl","clipGroup","maskId","clipCount","maskCount","shadingCount","transformMatrix","transformStack","extraStack","embedFonts","embeddedFonts","cssStyle","_operatorIdMapping","tgrp","executeOpTree","svgElement","loadDependencies","convertOpList","operatorIdMapping","opList","opTree","opListElement","opListToTree","opTreeElement","lineMatrix","xcoords","ycoords","tspan","setAttributeNS","txtElement","txtgrp","lineWidthScale","_setStrokeAttributes","_ensureTransformGroup","defs","addFontStyle","_current$txtElement","hasChildNodes","_makeColorN_Pattern","_makeShadingPattern","_makeTilingPattern","_args$","tilingId","_Util$normalizeRect2","tx0","ty0","tx1","ty1","txstep","tystep","tiling","childNodes","gradient","shadingId","colorStops","point0","point1","focalPoint","circlePoint","focalRadius","circleRadius","getAttributeNS","clipId","clipPath","clipElement","setStrokeAlpha","setFillAlpha","imgSrc","cliprect","imgEl","definitions","rootGroup","_ensureClipGroup","_network_utils","fs","http","https","fileUriRegex","PDFNodeStream","sourceUrl","parsedUrl","parse","isHttp","isFsUrl","_rangeRequestReaders","PDFNodeStreamFsFullReader","PDFNodeStreamFullReader","PDFNodeStreamFsRangeReader","PDFNodeStreamRangeReader","BaseFullReader","_url","_disableRange","_rangeChunkSize","_readableStream","_readCapability","_headersCapability","_error","BaseRangeReader","createRequestOptions","headers","auth","hostname","_BaseFullReader","handleResponse","statusCode","_setReadableStream","getResponseHeader","_validateRangeRequest","validateRangeRequestCapabilities","allowRangeRequests","suggestedLength","extractFilenameFromHeader","_request","_BaseRangeReader","_httpHeaders","Range","_BaseFullReader2","lstat","createReadStream","_BaseRangeReader2","contentDisposition","_content_disposition","getFilenameFromContentDispositionHeader","returnValues","needsEncodingFixup","toParamRegExp","rfc2616unquote","fixupEncoding","rfc2047decode","rfc5987decode","contentDispositionStr","_match2","quot","part","parts","_n2","_matches$_n","_quot","_part","rfc2231getparam","_filename2","attributePattern","flags","textdecode","encoding","decoder","TextDecoder","fatal","decode","quotindex","extvalue","encodingend","charset","hex","NetworkManager","getXhr","currXhrId","pendingRequests","listeners","xhr","xhrId","pendingRequest","setRequestHeader","expectedStatus","onError","onStateChange","onprogress","onHeadersReceived","onDone","_pendingRequest$onPro","_pendingRequest$onErr","xhrStatus","getArrayBuffer","rangeHeader","_pendingRequest$onErr3","_pendingRequest$onErr2","PDFNetworkStream","_source","_manager","PDFNetworkStreamFullRequestReader","PDFNetworkStreamRangeRequestReader","onClosed","_onRangeRequestReaderClosed","manager","_onHeadersReceived","_onDone","_onError","_fullRequestId","requestFull","_headersReceivedCapability","_cachedChunks","fullRequestXhrId","fullRequestXhr","getRequestXhr","createResponseStatusError","_this$onProgress","lengthComputable","isPendingRequest","_requestId","requestRange","_this$onClosed","_close","_this$onProgress2","createFetchOptions","abortController","credentials","redirect","createHeaders","Headers","PDFFetchStream","PDFFetchStreamReader","PDFFetchStreamRangeReader","_withCredentials","_headers","validateResponseStatus","_yield$this$_reader$r","_yield$this$_reader$r2","__webpack_module_cache__","moduleId","cachedModule","__webpack_modules__","nmd","_api","_annotation_layer","_text_layer","_svg"],"sourceRoot":""}