diff options
Diffstat (limited to 'js/pdfjs/build/pdf.js')
| -rw-r--r-- | js/pdfjs/build/pdf.js | 24027 |
1 files changed, 18113 insertions, 5914 deletions
diff --git a/js/pdfjs/build/pdf.js b/js/pdfjs/build/pdf.js index a2ee957..24f3191 100644 --- a/js/pdfjs/build/pdf.js +++ b/js/pdfjs/build/pdf.js @@ -128,236 +128,235 @@ Object.defineProperty(exports, "__esModule", { }); Object.defineProperty(exports, "addLinkAttributes", { enumerable: true, - get: function () { + get: function get() { return _display_utils.addLinkAttributes; } }); Object.defineProperty(exports, "getFilenameFromUrl", { enumerable: true, - get: function () { + get: function get() { return _display_utils.getFilenameFromUrl; } }); Object.defineProperty(exports, "LinkTarget", { enumerable: true, - get: function () { + get: function get() { return _display_utils.LinkTarget; } }); Object.defineProperty(exports, "loadScript", { enumerable: true, - get: function () { + get: function get() { return _display_utils.loadScript; } }); Object.defineProperty(exports, "PDFDateString", { enumerable: true, - get: function () { + get: function get() { return _display_utils.PDFDateString; } }); Object.defineProperty(exports, "RenderingCancelledException", { enumerable: true, - get: function () { + get: function get() { return _display_utils.RenderingCancelledException; } }); Object.defineProperty(exports, "build", { enumerable: true, - get: function () { + get: function get() { return _api.build; } }); Object.defineProperty(exports, "getDocument", { enumerable: true, - get: function () { + get: function get() { return _api.getDocument; } }); Object.defineProperty(exports, "LoopbackPort", { enumerable: true, - get: function () { + get: function get() { return _api.LoopbackPort; } }); Object.defineProperty(exports, "PDFDataRangeTransport", { enumerable: true, - get: function () { + get: function get() { return _api.PDFDataRangeTransport; } }); Object.defineProperty(exports, "PDFWorker", { enumerable: true, - get: function () { + get: function get() { return _api.PDFWorker; } }); Object.defineProperty(exports, "version", { enumerable: true, - get: function () { + get: function get() { return _api.version; } }); Object.defineProperty(exports, "CMapCompressionType", { enumerable: true, - get: function () { + get: function get() { return _util.CMapCompressionType; } }); Object.defineProperty(exports, "createObjectURL", { enumerable: true, - get: function () { + get: function get() { return _util.createObjectURL; } }); Object.defineProperty(exports, "createPromiseCapability", { enumerable: true, - get: function () { + get: function get() { return _util.createPromiseCapability; } }); Object.defineProperty(exports, "createValidAbsoluteUrl", { enumerable: true, - get: function () { + get: function get() { return _util.createValidAbsoluteUrl; } }); Object.defineProperty(exports, "InvalidPDFException", { enumerable: true, - get: function () { + get: function get() { return _util.InvalidPDFException; } }); Object.defineProperty(exports, "MissingPDFException", { enumerable: true, - get: function () { + get: function get() { return _util.MissingPDFException; } }); Object.defineProperty(exports, "OPS", { enumerable: true, - get: function () { + get: function get() { return _util.OPS; } }); Object.defineProperty(exports, "PasswordResponses", { enumerable: true, - get: function () { + get: function get() { return _util.PasswordResponses; } }); Object.defineProperty(exports, "PermissionFlag", { enumerable: true, - get: function () { + get: function get() { return _util.PermissionFlag; } }); Object.defineProperty(exports, "removeNullCharacters", { enumerable: true, - get: function () { + get: function get() { return _util.removeNullCharacters; } }); Object.defineProperty(exports, "shadow", { enumerable: true, - get: function () { + get: function get() { return _util.shadow; } }); Object.defineProperty(exports, "UnexpectedResponseException", { enumerable: true, - get: function () { + get: function get() { return _util.UnexpectedResponseException; } }); Object.defineProperty(exports, "UNSUPPORTED_FEATURES", { enumerable: true, - get: function () { + get: function get() { return _util.UNSUPPORTED_FEATURES; } }); Object.defineProperty(exports, "Util", { enumerable: true, - get: function () { + get: function get() { return _util.Util; } }); Object.defineProperty(exports, "VerbosityLevel", { enumerable: true, - get: function () { + get: function get() { return _util.VerbosityLevel; } }); Object.defineProperty(exports, "AnnotationLayer", { enumerable: true, - get: function () { + get: function get() { return _annotation_layer.AnnotationLayer; } }); Object.defineProperty(exports, "apiCompatibilityParams", { enumerable: true, - get: function () { + get: function get() { return _api_compatibility.apiCompatibilityParams; } }); Object.defineProperty(exports, "GlobalWorkerOptions", { enumerable: true, - get: function () { + get: function get() { return _worker_options.GlobalWorkerOptions; } }); Object.defineProperty(exports, "renderTextLayer", { enumerable: true, - get: function () { + get: function get() { return _text_layer.renderTextLayer; } }); Object.defineProperty(exports, "SVGGraphics", { enumerable: true, - get: function () { + get: function get() { return _svg.SVGGraphics; } }); var _display_utils = __w_pdfjs_require__(1); -var _api = __w_pdfjs_require__(5); +var _api = __w_pdfjs_require__(198); -var _util = __w_pdfjs_require__(2); +var _util = __w_pdfjs_require__(5); -var _annotation_layer = __w_pdfjs_require__(16); +var _annotation_layer = __w_pdfjs_require__(209); -var _api_compatibility = __w_pdfjs_require__(7); +var _api_compatibility = __w_pdfjs_require__(200); -var _worker_options = __w_pdfjs_require__(10); +var _worker_options = __w_pdfjs_require__(203); -var _text_layer = __w_pdfjs_require__(17); +var _text_layer = __w_pdfjs_require__(210); -var _svg = __w_pdfjs_require__(18); +var _svg = __w_pdfjs_require__(211); -const pdfjsVersion = '2.5.207'; -const pdfjsBuild = '0974d6052'; +var pdfjsVersion = '2.5.207'; +var pdfjsBuild = '0974d6052'; { - const { - isNodeJS - } = __w_pdfjs_require__(4); + var _require = __w_pdfjs_require__(7), + isNodeJS = _require.isNodeJS; if (isNodeJS) { - const PDFNodeStream = __w_pdfjs_require__(19).PDFNodeStream; + var PDFNodeStream = __w_pdfjs_require__(212).PDFNodeStream; - (0, _api.setPDFNetworkStreamFactory)(params => { + (0, _api.setPDFNetworkStreamFactory)(function (params) { return new PDFNodeStream(params); }); } else { - const PDFNetworkStream = __w_pdfjs_require__(22).PDFNetworkStream; + var PDFNetworkStream = __w_pdfjs_require__(215).PDFNetworkStream; - let PDFFetchStream; + var PDFFetchStream; if ((0, _display_utils.isFetchSupported)()) { - PDFFetchStream = __w_pdfjs_require__(23).PDFFetchStream; + PDFFetchStream = __w_pdfjs_require__(216).PDFFetchStream; } - (0, _api.setPDFNetworkStreamFactory)(params => { + (0, _api.setPDFNetworkStreamFactory)(function (params) { if (PDFFetchStream && (0, _display_utils.isValidFetchUrl)(params.url)) { return new PDFFetchStream(params); } @@ -385,184 +384,333 @@ exports.loadScript = loadScript; exports.deprecated = deprecated; exports.PDFDateString = exports.StatTimer = exports.DOMSVGFactory = exports.DOMCMapReaderFactory = exports.DOMCanvasFactory = exports.DEFAULT_LINK_REL = exports.LinkTarget = exports.RenderingCancelledException = exports.PageViewport = void 0; -var _util = __w_pdfjs_require__(2); +var _regenerator = _interopRequireDefault(__w_pdfjs_require__(2)); -const DEFAULT_LINK_REL = "noopener noreferrer nofollow"; -exports.DEFAULT_LINK_REL = DEFAULT_LINK_REL; -const SVG_NS = "http://www.w3.org/2000/svg"; +var _util = __w_pdfjs_require__(5); -class DOMCanvasFactory { - create(width, height) { - if (width <= 0 || height <= 0) { - throw new Error("Invalid canvas size"); - } +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } - const canvas = document.createElement("canvas"); - const context = canvas.getContext("2d"); - canvas.width = width; - canvas.height = height; - return { - canvas, - context - }; - } +function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; } - reset(canvasAndContext, width, height) { - if (!canvasAndContext.canvas) { - throw new Error("Canvas is not specified"); - } +function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); } - if (width <= 0 || height <= 0) { - throw new Error("Invalid canvas size"); - } +function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } - canvasAndContext.canvas.width = width; - canvasAndContext.canvas.height = height; - } +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } - destroy(canvasAndContext) { - if (!canvasAndContext.canvas) { - throw new Error("Canvas is not specified"); - } +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } - canvasAndContext.canvas.width = 0; - canvasAndContext.canvas.height = 0; - canvasAndContext.canvas = null; - canvasAndContext.context = null; - } +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } -} +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } -exports.DOMCanvasFactory = DOMCanvasFactory; +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } -class DOMCMapReaderFactory { - constructor({ - baseUrl = null, - isCompressed = false - }) { - this.baseUrl = baseUrl; - this.isCompressed = isCompressed; +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } + +function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } } + +function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +var DEFAULT_LINK_REL = "noopener noreferrer nofollow"; +exports.DEFAULT_LINK_REL = DEFAULT_LINK_REL; +var SVG_NS = "http://www.w3.org/2000/svg"; + +var DOMCanvasFactory = /*#__PURE__*/function () { + function DOMCanvasFactory() { + _classCallCheck(this, DOMCanvasFactory); } - async fetch({ - name - }) { - if (!this.baseUrl) { - throw new Error('The CMap "baseUrl" parameter must be specified, ensure that ' + 'the "cMapUrl" and "cMapPacked" API parameters are provided.'); + _createClass(DOMCanvasFactory, [{ + key: "create", + value: function create(width, height) { + if (width <= 0 || height <= 0) { + throw new Error("Invalid canvas size"); + } + + var canvas = document.createElement("canvas"); + var context = canvas.getContext("2d"); + canvas.width = width; + canvas.height = height; + return { + canvas: canvas, + context: context + }; } + }, { + key: "reset", + value: function reset(canvasAndContext, width, height) { + if (!canvasAndContext.canvas) { + throw new Error("Canvas is not specified"); + } - if (!name) { - throw new Error("CMap name must be specified."); + if (width <= 0 || height <= 0) { + throw new Error("Invalid canvas size"); + } + + canvasAndContext.canvas.width = width; + canvasAndContext.canvas.height = height; } + }, { + key: "destroy", + value: function destroy(canvasAndContext) { + if (!canvasAndContext.canvas) { + throw new Error("Canvas is not specified"); + } - const url = this.baseUrl + name + (this.isCompressed ? ".bcmap" : ""); - const compressionType = this.isCompressed ? _util.CMapCompressionType.BINARY : _util.CMapCompressionType.NONE; + canvasAndContext.canvas.width = 0; + canvasAndContext.canvas.height = 0; + canvasAndContext.canvas = null; + canvasAndContext.context = null; + } + }]); - if (isFetchSupported() && isValidFetchUrl(url, document.baseURI)) { - return fetch(url).then(async response => { - if (!response.ok) { - throw new Error(response.statusText); - } + return DOMCanvasFactory; +}(); - let cMapData; +exports.DOMCanvasFactory = DOMCanvasFactory; - if (this.isCompressed) { - cMapData = new Uint8Array(await response.arrayBuffer()); - } else { - cMapData = (0, _util.stringToBytes)(await response.text()); - } +var DOMCMapReaderFactory = /*#__PURE__*/function () { + function DOMCMapReaderFactory(_ref) { + var _ref$baseUrl = _ref.baseUrl, + baseUrl = _ref$baseUrl === void 0 ? null : _ref$baseUrl, + _ref$isCompressed = _ref.isCompressed, + isCompressed = _ref$isCompressed === void 0 ? false : _ref$isCompressed; - return { - cMapData, - compressionType - }; - }).catch(reason => { - throw new Error(`Unable to load ${this.isCompressed ? "binary " : ""}` + `CMap at: ${url}`); - }); - } + _classCallCheck(this, DOMCMapReaderFactory); - return new Promise((resolve, reject) => { - const request = new XMLHttpRequest(); - request.open("GET", url, true); + this.baseUrl = baseUrl; + this.isCompressed = isCompressed; + } - if (this.isCompressed) { - request.responseType = "arraybuffer"; + _createClass(DOMCMapReaderFactory, [{ + key: "fetch", + value: function (_fetch) { + function fetch(_x) { + return _fetch.apply(this, arguments); } - request.onreadystatechange = () => { - if (request.readyState !== XMLHttpRequest.DONE) { - return; - } + fetch.toString = function () { + return _fetch.toString(); + }; - if (request.status === 200 || request.status === 0) { - let cMapData; + return fetch; + }( /*#__PURE__*/function () { + var _ref3 = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee2(_ref2) { + var _this = this; + + var name, url, compressionType; + return _regenerator["default"].wrap(function _callee2$(_context2) { + while (1) { + switch (_context2.prev = _context2.next) { + case 0: + name = _ref2.name; + + if (this.baseUrl) { + _context2.next = 3; + break; + } - if (this.isCompressed && request.response) { - cMapData = new Uint8Array(request.response); - } else if (!this.isCompressed && request.responseText) { - cMapData = (0, _util.stringToBytes)(request.responseText); - } + throw new Error('The CMap "baseUrl" parameter must be specified, ensure that ' + 'the "cMapUrl" and "cMapPacked" API parameters are provided.'); - if (cMapData) { - resolve({ - cMapData, - compressionType - }); - return; + case 3: + if (name) { + _context2.next = 5; + break; + } + + throw new Error("CMap name must be specified."); + + case 5: + url = this.baseUrl + name + (this.isCompressed ? ".bcmap" : ""); + compressionType = this.isCompressed ? _util.CMapCompressionType.BINARY : _util.CMapCompressionType.NONE; + + if (!(isFetchSupported() && isValidFetchUrl(url, document.baseURI))) { + _context2.next = 9; + break; + } + + return _context2.abrupt("return", fetch(url).then( /*#__PURE__*/function () { + var _ref4 = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee(response) { + var cMapData; + return _regenerator["default"].wrap(function _callee$(_context) { + while (1) { + switch (_context.prev = _context.next) { + case 0: + if (response.ok) { + _context.next = 2; + break; + } + + throw new Error(response.statusText); + + case 2: + if (!_this.isCompressed) { + _context.next = 10; + break; + } + + _context.t0 = Uint8Array; + _context.next = 6; + return response.arrayBuffer(); + + case 6: + _context.t1 = _context.sent; + cMapData = new _context.t0(_context.t1); + _context.next = 15; + break; + + case 10: + _context.t2 = _util.stringToBytes; + _context.next = 13; + return response.text(); + + case 13: + _context.t3 = _context.sent; + cMapData = (0, _context.t2)(_context.t3); + + case 15: + return _context.abrupt("return", { + cMapData: cMapData, + compressionType: compressionType + }); + + case 16: + case "end": + return _context.stop(); + } + } + }, _callee); + })); + + return function (_x3) { + return _ref4.apply(this, arguments); + }; + }())["catch"](function (reason) { + throw new Error("Unable to load ".concat(_this.isCompressed ? "binary " : "") + "CMap at: ".concat(url)); + })); + + case 9: + return _context2.abrupt("return", new Promise(function (resolve, reject) { + var request = new XMLHttpRequest(); + request.open("GET", url, true); + + if (_this.isCompressed) { + request.responseType = "arraybuffer"; + } + + request.onreadystatechange = function () { + if (request.readyState !== XMLHttpRequest.DONE) { + return; + } + + if (request.status === 200 || request.status === 0) { + var cMapData; + + if (_this.isCompressed && request.response) { + cMapData = new Uint8Array(request.response); + } else if (!_this.isCompressed && request.responseText) { + cMapData = (0, _util.stringToBytes)(request.responseText); + } + + if (cMapData) { + resolve({ + cMapData: cMapData, + compressionType: compressionType + }); + return; + } + } + + reject(new Error(request.statusText)); + }; + + request.send(null); + })["catch"](function (reason) { + throw new Error("Unable to load ".concat(_this.isCompressed ? "binary " : "") + "CMap at: ".concat(url)); + })); + + case 10: + case "end": + return _context2.stop(); + } } - } + }, _callee2, this); + })); - reject(new Error(request.statusText)); + return function (_x2) { + return _ref3.apply(this, arguments); }; + }()) + }]); - request.send(null); - }).catch(reason => { - throw new Error(`Unable to load ${this.isCompressed ? "binary " : ""}` + `CMap at: ${url}`); - }); - } - -} + return DOMCMapReaderFactory; +}(); exports.DOMCMapReaderFactory = DOMCMapReaderFactory; -class DOMSVGFactory { - create(width, height) { - (0, _util.assert)(width > 0 && height > 0, "Invalid SVG dimensions"); - const svg = document.createElementNS(SVG_NS, "svg:svg"); - svg.setAttribute("version", "1.1"); - svg.setAttribute("width", width + "px"); - svg.setAttribute("height", height + "px"); - svg.setAttribute("preserveAspectRatio", "none"); - svg.setAttribute("viewBox", "0 0 " + width + " " + height); - return svg; - } - - createElement(type) { - (0, _util.assert)(typeof type === "string", "Invalid SVG element type"); - return document.createElementNS(SVG_NS, type); - } +var DOMSVGFactory = /*#__PURE__*/function () { + function DOMSVGFactory() { + _classCallCheck(this, DOMSVGFactory); + } + + _createClass(DOMSVGFactory, [{ + key: "create", + value: function create(width, height) { + (0, _util.assert)(width > 0 && height > 0, "Invalid SVG dimensions"); + var svg = document.createElementNS(SVG_NS, "svg:svg"); + svg.setAttribute("version", "1.1"); + svg.setAttribute("width", width + "px"); + svg.setAttribute("height", height + "px"); + svg.setAttribute("preserveAspectRatio", "none"); + svg.setAttribute("viewBox", "0 0 " + width + " " + height); + return svg; + } + }, { + key: "createElement", + value: function createElement(type) { + (0, _util.assert)(typeof type === "string", "Invalid SVG element type"); + return document.createElementNS(SVG_NS, type); + } + }]); -} + return DOMSVGFactory; +}(); exports.DOMSVGFactory = DOMSVGFactory; -class PageViewport { - constructor({ - viewBox, - scale, - rotation, - offsetX = 0, - offsetY = 0, - dontFlip = false - }) { +var PageViewport = /*#__PURE__*/function () { + function PageViewport(_ref5) { + var viewBox = _ref5.viewBox, + scale = _ref5.scale, + rotation = _ref5.rotation, + _ref5$offsetX = _ref5.offsetX, + offsetX = _ref5$offsetX === void 0 ? 0 : _ref5$offsetX, + _ref5$offsetY = _ref5.offsetY, + offsetY = _ref5$offsetY === void 0 ? 0 : _ref5$offsetY, + _ref5$dontFlip = _ref5.dontFlip, + dontFlip = _ref5$dontFlip === void 0 ? false : _ref5$dontFlip; + + _classCallCheck(this, PageViewport); + this.viewBox = viewBox; this.scale = scale; this.rotation = rotation; this.offsetX = offsetX; this.offsetY = offsetY; - const centerX = (viewBox[2] + viewBox[0]) / 2; - const centerY = (viewBox[3] + viewBox[1]) / 2; - let rotateA, rotateB, rotateC, rotateD; + var centerX = (viewBox[2] + viewBox[0]) / 2; + var centerY = (viewBox[3] + viewBox[1]) / 2; + var rotateA, rotateB, rotateC, rotateD; rotation = rotation % 360; rotation = rotation < 0 ? rotation + 360 : rotation; @@ -604,8 +752,8 @@ class PageViewport { rotateD = -rotateD; } - let offsetCanvasX, offsetCanvasY; - let width, height; + var offsetCanvasX, offsetCanvasY; + var width, height; if (rotateA === 0) { offsetCanvasX = Math.abs(centerY - viewBox[1]) * scale + offsetX; @@ -624,53 +772,76 @@ class PageViewport { this.height = height; } - clone({ - scale = this.scale, - rotation = this.rotation, - offsetX = this.offsetX, - offsetY = this.offsetY, - dontFlip = false - } = {}) { - return new PageViewport({ - viewBox: this.viewBox.slice(), - scale, - rotation, - offsetX, - offsetY, - dontFlip - }); - } + _createClass(PageViewport, [{ + key: "clone", + value: function clone() { + var _ref6 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}, + _ref6$scale = _ref6.scale, + scale = _ref6$scale === void 0 ? this.scale : _ref6$scale, + _ref6$rotation = _ref6.rotation, + rotation = _ref6$rotation === void 0 ? this.rotation : _ref6$rotation, + _ref6$offsetX = _ref6.offsetX, + offsetX = _ref6$offsetX === void 0 ? this.offsetX : _ref6$offsetX, + _ref6$offsetY = _ref6.offsetY, + offsetY = _ref6$offsetY === void 0 ? this.offsetY : _ref6$offsetY, + _ref6$dontFlip = _ref6.dontFlip, + dontFlip = _ref6$dontFlip === void 0 ? false : _ref6$dontFlip; + + return new PageViewport({ + viewBox: this.viewBox.slice(), + scale: scale, + rotation: rotation, + offsetX: offsetX, + offsetY: offsetY, + dontFlip: dontFlip + }); + } + }, { + key: "convertToViewportPoint", + value: function convertToViewportPoint(x, y) { + return _util.Util.applyTransform([x, y], this.transform); + } + }, { + key: "convertToViewportRectangle", + value: function convertToViewportRectangle(rect) { + var topLeft = _util.Util.applyTransform([rect[0], rect[1]], this.transform); - convertToViewportPoint(x, y) { - return _util.Util.applyTransform([x, y], this.transform); - } + var bottomRight = _util.Util.applyTransform([rect[2], rect[3]], this.transform); - convertToViewportRectangle(rect) { - const topLeft = _util.Util.applyTransform([rect[0], rect[1]], this.transform); + return [topLeft[0], topLeft[1], bottomRight[0], bottomRight[1]]; + } + }, { + key: "convertToPdfPoint", + value: function convertToPdfPoint(x, y) { + return _util.Util.applyInverseTransform([x, y], this.transform); + } + }]); - const bottomRight = _util.Util.applyTransform([rect[2], rect[3]], this.transform); + return PageViewport; +}(); - return [topLeft[0], topLeft[1], bottomRight[0], bottomRight[1]]; - } +exports.PageViewport = PageViewport; - convertToPdfPoint(x, y) { - return _util.Util.applyInverseTransform([x, y], this.transform); - } +var RenderingCancelledException = /*#__PURE__*/function (_BaseException) { + _inherits(RenderingCancelledException, _BaseException); -} + var _super = _createSuper(RenderingCancelledException); -exports.PageViewport = PageViewport; + function RenderingCancelledException(msg, type) { + var _this2; + + _classCallCheck(this, RenderingCancelledException); -class RenderingCancelledException extends _util.BaseException { - constructor(msg, type) { - super(msg); - this.type = type; + _this2 = _super.call(this, msg); + _this2.type = type; + return _this2; } -} + return RenderingCancelledException; +}(_util.BaseException); exports.RenderingCancelledException = RenderingCancelledException; -const LinkTarget = { +var LinkTarget = { NONE: 0, SELF: 1, BLANK: 2, @@ -679,27 +850,29 @@ const LinkTarget = { }; exports.LinkTarget = LinkTarget; -function addLinkAttributes(link, { - url, - target, - rel, - enabled = true -} = {}) { +function addLinkAttributes(link) { + var _ref7 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}, + url = _ref7.url, + target = _ref7.target, + rel = _ref7.rel, + _ref7$enabled = _ref7.enabled, + enabled = _ref7$enabled === void 0 ? true : _ref7$enabled; + (0, _util.assert)(url && typeof url === "string", 'addLinkAttributes: A valid "url" parameter must provided.'); - const urlNullRemoved = (0, _util.removeNullCharacters)(url); + var urlNullRemoved = (0, _util.removeNullCharacters)(url); if (enabled) { link.href = link.title = urlNullRemoved; } else { link.href = ""; - link.title = `Disabled: ${urlNullRemoved}`; + link.title = "Disabled: ".concat(urlNullRemoved); - link.onclick = () => { + link.onclick = function () { return false; }; } - let targetStr = ""; + var targetStr = ""; switch (target) { case LinkTarget.NONE: @@ -727,60 +900,88 @@ function addLinkAttributes(link, { } function getFilenameFromUrl(url) { - const anchor = url.indexOf("#"); - const query = url.indexOf("?"); - const end = Math.min(anchor > 0 ? anchor : url.length, query > 0 ? query : url.length); + var anchor = url.indexOf("#"); + var query = url.indexOf("?"); + var end = Math.min(anchor > 0 ? anchor : url.length, query > 0 ? query : url.length); return url.substring(url.lastIndexOf("/", end) + 1, end); } -class StatTimer { - constructor() { +var StatTimer = /*#__PURE__*/function () { + function StatTimer() { + _classCallCheck(this, StatTimer); + this.started = Object.create(null); this.times = []; } - time(name) { - if (name in this.started) { - (0, _util.warn)(`Timer is already running for ${name}`); - } + _createClass(StatTimer, [{ + key: "time", + value: function time(name) { + if (name in this.started) { + (0, _util.warn)("Timer is already running for ".concat(name)); + } - this.started[name] = Date.now(); - } + this.started[name] = Date.now(); + } + }, { + key: "timeEnd", + value: function timeEnd(name) { + if (!(name in this.started)) { + (0, _util.warn)("Timer has not been started for ".concat(name)); + } - timeEnd(name) { - if (!(name in this.started)) { - (0, _util.warn)(`Timer has not been started for ${name}`); + this.times.push({ + name: name, + start: this.started[name], + end: Date.now() + }); + delete this.started[name]; } + }, { + key: "toString", + value: function toString() { + var outBuf = []; + var longest = 0; - this.times.push({ - name, - start: this.started[name], - end: Date.now() - }); - delete this.started[name]; - } + var _iterator = _createForOfIteratorHelper(this.times), + _step; - toString() { - const outBuf = []; - let longest = 0; + try { + for (_iterator.s(); !(_step = _iterator.n()).done;) { + var time = _step.value; + var name = time.name; - for (const time of this.times) { - const name = time.name; + if (name.length > longest) { + longest = name.length; + } + } + } catch (err) { + _iterator.e(err); + } finally { + _iterator.f(); + } + + var _iterator2 = _createForOfIteratorHelper(this.times), + _step2; - if (name.length > longest) { - longest = name.length; + try { + for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) { + var _time = _step2.value; + var duration = _time.end - _time.start; + outBuf.push("".concat(_time.name.padEnd(longest), " ").concat(duration, "ms\n")); + } + } catch (err) { + _iterator2.e(err); + } finally { + _iterator2.f(); } - } - for (const time of this.times) { - const duration = time.end - time.start; - outBuf.push(`${time.name.padEnd(longest)} ${duration}ms\n`); + return outBuf.join(""); } + }]); - return outBuf.join(""); - } - -} + return StatTimer; +}(); exports.StatTimer = StatTimer; @@ -790,9 +991,9 @@ function isFetchSupported() { function isValidFetchUrl(url, baseUrl) { try { - const { - protocol - } = baseUrl ? new URL(url, baseUrl) : new URL(url); + var _ref8 = baseUrl ? new URL(url, baseUrl) : new URL(url), + protocol = _ref8.protocol; + return protocol === "http:" || protocol === "https:"; } catch (ex) { return false; @@ -800,13 +1001,13 @@ function isValidFetchUrl(url, baseUrl) { } function loadScript(src) { - return new Promise((resolve, reject) => { - const script = document.createElement("script"); + return new Promise(function (resolve, reject) { + var script = document.createElement("script"); script.src = src; script.onload = resolve; script.onerror = function () { - reject(new Error(`Cannot load script at: ${script.src}`)); + reject(new Error("Cannot load script at: ".concat(script.src))); }; (document.head || document.documentElement).appendChild(script); @@ -817,58 +1018,688 @@ function deprecated(details) { console.log("Deprecated API usage: " + details); } -let pdfDateStringRegex; +var pdfDateStringRegex; -class PDFDateString { - static toDateObject(input) { - if (!input || !(0, _util.isString)(input)) { - return null; +var PDFDateString = /*#__PURE__*/function () { + function PDFDateString() { + _classCallCheck(this, PDFDateString); + } + + _createClass(PDFDateString, null, [{ + key: "toDateObject", + value: function toDateObject(input) { + if (!input || !(0, _util.isString)(input)) { + return null; + } + + if (!pdfDateStringRegex) { + pdfDateStringRegex = new RegExp("^D:" + "(\\d{4})" + "(\\d{2})?" + "(\\d{2})?" + "(\\d{2})?" + "(\\d{2})?" + "(\\d{2})?" + "([Z|+|-])?" + "(\\d{2})?" + "'?" + "(\\d{2})?" + "'?"); + } + + var matches = pdfDateStringRegex.exec(input); + + if (!matches) { + return null; + } + + var year = parseInt(matches[1], 10); + var month = parseInt(matches[2], 10); + month = month >= 1 && month <= 12 ? month - 1 : 0; + var day = parseInt(matches[3], 10); + day = day >= 1 && day <= 31 ? day : 1; + var hour = parseInt(matches[4], 10); + hour = hour >= 0 && hour <= 23 ? hour : 0; + var minute = parseInt(matches[5], 10); + minute = minute >= 0 && minute <= 59 ? minute : 0; + var second = parseInt(matches[6], 10); + second = second >= 0 && second <= 59 ? second : 0; + var universalTimeRelation = matches[7] || "Z"; + var offsetHour = parseInt(matches[8], 10); + offsetHour = offsetHour >= 0 && offsetHour <= 23 ? offsetHour : 0; + var offsetMinute = parseInt(matches[9], 10) || 0; + offsetMinute = offsetMinute >= 0 && offsetMinute <= 59 ? offsetMinute : 0; + + if (universalTimeRelation === "-") { + hour += offsetHour; + minute += offsetMinute; + } else if (universalTimeRelation === "+") { + hour -= offsetHour; + minute -= offsetMinute; + } + + return new Date(Date.UTC(year, month, day, hour, minute, second)); + } + }]); + + return PDFDateString; +}(); + +exports.PDFDateString = PDFDateString; + +/***/ }), +/* 2 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + + +module.exports = __w_pdfjs_require__(3); + +/***/ }), +/* 3 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; +/* WEBPACK VAR INJECTION */(function(module) { + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +var runtime = function (exports) { + "use strict"; + + var Op = Object.prototype; + var hasOwn = Op.hasOwnProperty; + var undefined; + var $Symbol = typeof Symbol === "function" ? Symbol : {}; + var iteratorSymbol = $Symbol.iterator || "@@iterator"; + var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator"; + var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag"; + + function wrap(innerFn, outerFn, self, tryLocsList) { + var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator; + var generator = Object.create(protoGenerator.prototype); + var context = new Context(tryLocsList || []); + generator._invoke = makeInvokeMethod(innerFn, self, context); + return generator; + } + + exports.wrap = wrap; + + function tryCatch(fn, obj, arg) { + try { + return { + type: "normal", + arg: fn.call(obj, arg) + }; + } catch (err) { + return { + type: "throw", + arg: err + }; } + } + + var GenStateSuspendedStart = "suspendedStart"; + var GenStateSuspendedYield = "suspendedYield"; + var GenStateExecuting = "executing"; + var GenStateCompleted = "completed"; + var ContinueSentinel = {}; + + function Generator() {} + + function GeneratorFunction() {} + + function GeneratorFunctionPrototype() {} + + var IteratorPrototype = {}; + + IteratorPrototype[iteratorSymbol] = function () { + return this; + }; + + var getProto = Object.getPrototypeOf; + var NativeIteratorPrototype = getProto && getProto(getProto(values([]))); + + if (NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) { + IteratorPrototype = NativeIteratorPrototype; + } + + var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype); + GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype; + GeneratorFunctionPrototype.constructor = GeneratorFunction; + GeneratorFunctionPrototype[toStringTagSymbol] = GeneratorFunction.displayName = "GeneratorFunction"; + + function defineIteratorMethods(prototype) { + ["next", "throw", "return"].forEach(function (method) { + prototype[method] = function (arg) { + return this._invoke(method, arg); + }; + }); + } + + exports.isGeneratorFunction = function (genFun) { + var ctor = typeof genFun === "function" && genFun.constructor; + return ctor ? ctor === GeneratorFunction || (ctor.displayName || ctor.name) === "GeneratorFunction" : false; + }; + + exports.mark = function (genFun) { + if (Object.setPrototypeOf) { + Object.setPrototypeOf(genFun, GeneratorFunctionPrototype); + } else { + genFun.__proto__ = GeneratorFunctionPrototype; - if (!pdfDateStringRegex) { - pdfDateStringRegex = new RegExp("^D:" + "(\\d{4})" + "(\\d{2})?" + "(\\d{2})?" + "(\\d{2})?" + "(\\d{2})?" + "(\\d{2})?" + "([Z|+|-])?" + "(\\d{2})?" + "'?" + "(\\d{2})?" + "'?"); + if (!(toStringTagSymbol in genFun)) { + genFun[toStringTagSymbol] = "GeneratorFunction"; + } } - const matches = pdfDateStringRegex.exec(input); + genFun.prototype = Object.create(Gp); + return genFun; + }; - if (!matches) { - return null; + exports.awrap = function (arg) { + return { + __await: arg + }; + }; + + function AsyncIterator(generator, PromiseImpl) { + function invoke(method, arg, resolve, reject) { + var record = tryCatch(generator[method], generator, arg); + + if (record.type === "throw") { + reject(record.arg); + } else { + var result = record.arg; + var value = result.value; + + if (value && _typeof(value) === "object" && hasOwn.call(value, "__await")) { + return PromiseImpl.resolve(value.__await).then(function (value) { + invoke("next", value, resolve, reject); + }, function (err) { + invoke("throw", err, resolve, reject); + }); + } + + return PromiseImpl.resolve(value).then(function (unwrapped) { + result.value = unwrapped; + resolve(result); + }, function (error) { + return invoke("throw", error, resolve, reject); + }); + } } - const year = parseInt(matches[1], 10); - let month = parseInt(matches[2], 10); - month = month >= 1 && month <= 12 ? month - 1 : 0; - let day = parseInt(matches[3], 10); - day = day >= 1 && day <= 31 ? day : 1; - let hour = parseInt(matches[4], 10); - hour = hour >= 0 && hour <= 23 ? hour : 0; - let minute = parseInt(matches[5], 10); - minute = minute >= 0 && minute <= 59 ? minute : 0; - let second = parseInt(matches[6], 10); - second = second >= 0 && second <= 59 ? second : 0; - const universalTimeRelation = matches[7] || "Z"; - let offsetHour = parseInt(matches[8], 10); - offsetHour = offsetHour >= 0 && offsetHour <= 23 ? offsetHour : 0; - let offsetMinute = parseInt(matches[9], 10) || 0; - offsetMinute = offsetMinute >= 0 && offsetMinute <= 59 ? offsetMinute : 0; + var previousPromise; + + function enqueue(method, arg) { + function callInvokeWithMethodAndArg() { + return new PromiseImpl(function (resolve, reject) { + invoke(method, arg, resolve, reject); + }); + } - if (universalTimeRelation === "-") { - hour += offsetHour; - minute += offsetMinute; - } else if (universalTimeRelation === "+") { - hour -= offsetHour; - minute -= offsetMinute; + return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg(); } - return new Date(Date.UTC(year, month, day, hour, minute, second)); + this._invoke = enqueue; } + defineIteratorMethods(AsyncIterator.prototype); + + AsyncIterator.prototype[asyncIteratorSymbol] = function () { + return this; + }; + + exports.AsyncIterator = AsyncIterator; + + exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) { + if (PromiseImpl === void 0) PromiseImpl = Promise; + var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl); + return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) { + return result.done ? result.value : iter.next(); + }); + }; + + function makeInvokeMethod(innerFn, self, context) { + var state = GenStateSuspendedStart; + return function invoke(method, arg) { + if (state === GenStateExecuting) { + throw new Error("Generator is already running"); + } + + if (state === GenStateCompleted) { + if (method === "throw") { + throw arg; + } + + return doneResult(); + } + + context.method = method; + context.arg = arg; + + while (true) { + var delegate = context.delegate; + + if (delegate) { + var delegateResult = maybeInvokeDelegate(delegate, context); + + if (delegateResult) { + if (delegateResult === ContinueSentinel) continue; + return delegateResult; + } + } + + if (context.method === "next") { + context.sent = context._sent = context.arg; + } else if (context.method === "throw") { + if (state === GenStateSuspendedStart) { + state = GenStateCompleted; + throw context.arg; + } + + context.dispatchException(context.arg); + } else if (context.method === "return") { + context.abrupt("return", context.arg); + } + + state = GenStateExecuting; + var record = tryCatch(innerFn, self, context); + + if (record.type === "normal") { + state = context.done ? GenStateCompleted : GenStateSuspendedYield; + + if (record.arg === ContinueSentinel) { + continue; + } + + return { + value: record.arg, + done: context.done + }; + } else if (record.type === "throw") { + state = GenStateCompleted; + context.method = "throw"; + context.arg = record.arg; + } + } + }; + } + + function maybeInvokeDelegate(delegate, context) { + var method = delegate.iterator[context.method]; + + if (method === undefined) { + context.delegate = null; + + if (context.method === "throw") { + if (delegate.iterator["return"]) { + context.method = "return"; + context.arg = undefined; + maybeInvokeDelegate(delegate, context); + + if (context.method === "throw") { + return ContinueSentinel; + } + } + + context.method = "throw"; + context.arg = new TypeError("The iterator does not provide a 'throw' method"); + } + + return ContinueSentinel; + } + + var record = tryCatch(method, delegate.iterator, context.arg); + + if (record.type === "throw") { + context.method = "throw"; + context.arg = record.arg; + context.delegate = null; + return ContinueSentinel; + } + + var info = record.arg; + + if (!info) { + context.method = "throw"; + context.arg = new TypeError("iterator result is not an object"); + context.delegate = null; + return ContinueSentinel; + } + + if (info.done) { + context[delegate.resultName] = info.value; + context.next = delegate.nextLoc; + + if (context.method !== "return") { + context.method = "next"; + context.arg = undefined; + } + } else { + return info; + } + + context.delegate = null; + return ContinueSentinel; + } + + defineIteratorMethods(Gp); + Gp[toStringTagSymbol] = "Generator"; + + Gp[iteratorSymbol] = function () { + return this; + }; + + Gp.toString = function () { + return "[object Generator]"; + }; + + function pushTryEntry(locs) { + var entry = { + tryLoc: locs[0] + }; + + if (1 in locs) { + entry.catchLoc = locs[1]; + } + + if (2 in locs) { + entry.finallyLoc = locs[2]; + entry.afterLoc = locs[3]; + } + + this.tryEntries.push(entry); + } + + function resetTryEntry(entry) { + var record = entry.completion || {}; + record.type = "normal"; + delete record.arg; + entry.completion = record; + } + + function Context(tryLocsList) { + this.tryEntries = [{ + tryLoc: "root" + }]; + tryLocsList.forEach(pushTryEntry, this); + this.reset(true); + } + + exports.keys = function (object) { + var keys = []; + + for (var key in object) { + keys.push(key); + } + + keys.reverse(); + return function next() { + while (keys.length) { + var key = keys.pop(); + + if (key in object) { + next.value = key; + next.done = false; + return next; + } + } + + next.done = true; + return next; + }; + }; + + function values(iterable) { + if (iterable) { + var iteratorMethod = iterable[iteratorSymbol]; + + if (iteratorMethod) { + return iteratorMethod.call(iterable); + } + + if (typeof iterable.next === "function") { + return iterable; + } + + if (!isNaN(iterable.length)) { + var i = -1, + next = function next() { + while (++i < iterable.length) { + if (hasOwn.call(iterable, i)) { + next.value = iterable[i]; + next.done = false; + return next; + } + } + + next.value = undefined; + next.done = true; + return next; + }; + + return next.next = next; + } + } + + return { + next: doneResult + }; + } + + exports.values = values; + + function doneResult() { + return { + value: undefined, + done: true + }; + } + + Context.prototype = { + constructor: Context, + reset: function reset(skipTempReset) { + this.prev = 0; + this.next = 0; + this.sent = this._sent = undefined; + this.done = false; + this.delegate = null; + this.method = "next"; + this.arg = undefined; + this.tryEntries.forEach(resetTryEntry); + + if (!skipTempReset) { + for (var name in this) { + if (name.charAt(0) === "t" && hasOwn.call(this, name) && !isNaN(+name.slice(1))) { + this[name] = undefined; + } + } + } + }, + stop: function stop() { + this.done = true; + var rootEntry = this.tryEntries[0]; + var rootRecord = rootEntry.completion; + + if (rootRecord.type === "throw") { + throw rootRecord.arg; + } + + return this.rval; + }, + dispatchException: function dispatchException(exception) { + if (this.done) { + throw exception; + } + + var context = this; + + function handle(loc, caught) { + record.type = "throw"; + record.arg = exception; + context.next = loc; + + if (caught) { + context.method = "next"; + context.arg = undefined; + } + + return !!caught; + } + + for (var i = this.tryEntries.length - 1; i >= 0; --i) { + var entry = this.tryEntries[i]; + var record = entry.completion; + + if (entry.tryLoc === "root") { + return handle("end"); + } + + if (entry.tryLoc <= this.prev) { + var hasCatch = hasOwn.call(entry, "catchLoc"); + var hasFinally = hasOwn.call(entry, "finallyLoc"); + + if (hasCatch && hasFinally) { + if (this.prev < entry.catchLoc) { + return handle(entry.catchLoc, true); + } else if (this.prev < entry.finallyLoc) { + return handle(entry.finallyLoc); + } + } else if (hasCatch) { + if (this.prev < entry.catchLoc) { + return handle(entry.catchLoc, true); + } + } else if (hasFinally) { + if (this.prev < entry.finallyLoc) { + return handle(entry.finallyLoc); + } + } else { + throw new Error("try statement without catch or finally"); + } + } + } + }, + abrupt: function abrupt(type, arg) { + for (var i = this.tryEntries.length - 1; i >= 0; --i) { + var entry = this.tryEntries[i]; + + if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) { + var finallyEntry = entry; + break; + } + } + + if (finallyEntry && (type === "break" || type === "continue") && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc) { + finallyEntry = null; + } + + var record = finallyEntry ? finallyEntry.completion : {}; + record.type = type; + record.arg = arg; + + if (finallyEntry) { + this.method = "next"; + this.next = finallyEntry.finallyLoc; + return ContinueSentinel; + } + + return this.complete(record); + }, + complete: function complete(record, afterLoc) { + if (record.type === "throw") { + throw record.arg; + } + + if (record.type === "break" || record.type === "continue") { + this.next = record.arg; + } else if (record.type === "return") { + this.rval = this.arg = record.arg; + this.method = "return"; + this.next = "end"; + } else if (record.type === "normal" && afterLoc) { + this.next = afterLoc; + } + + return ContinueSentinel; + }, + finish: function finish(finallyLoc) { + for (var i = this.tryEntries.length - 1; i >= 0; --i) { + var entry = this.tryEntries[i]; + + if (entry.finallyLoc === finallyLoc) { + this.complete(entry.completion, entry.afterLoc); + resetTryEntry(entry); + return ContinueSentinel; + } + } + }, + "catch": function _catch(tryLoc) { + for (var i = this.tryEntries.length - 1; i >= 0; --i) { + var entry = this.tryEntries[i]; + + if (entry.tryLoc === tryLoc) { + var record = entry.completion; + + if (record.type === "throw") { + var thrown = record.arg; + resetTryEntry(entry); + } + + return thrown; + } + } + + throw new Error("illegal catch attempt"); + }, + delegateYield: function delegateYield(iterable, resultName, nextLoc) { + this.delegate = { + iterator: values(iterable), + resultName: resultName, + nextLoc: nextLoc + }; + + if (this.method === "next") { + this.arg = undefined; + } + + return ContinueSentinel; + } + }; + return exports; +}(( false ? undefined : _typeof(module)) === "object" ? module.exports : {}); + +try { + regeneratorRuntime = runtime; +} catch (accidentalStrictMode) { + Function("r", "regeneratorRuntime = r")(runtime); } +/* WEBPACK VAR INJECTION */}.call(this, __w_pdfjs_require__(4)(module))) -exports.PDFDateString = PDFDateString; +/***/ }), +/* 4 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + + +module.exports = function (module) { + if (!module.webpackPolyfill) { + module.deprecate = function () {}; + + module.paths = []; + if (!module.children) module.children = []; + Object.defineProperty(module, "loaded", { + enumerable: true, + get: function get() { + return module.l; + } + }); + Object.defineProperty(module, "id", { + enumerable: true, + get: function get() { + return module.i; + } + }); + module.webpackPolyfill = 1; + } + + return module; +}; /***/ }), -/* 2 */ +/* 5 */ /***/ (function(module, exports, __w_pdfjs_require__) { "use strict"; @@ -904,13 +1735,35 @@ exports.warn = warn; exports.unreachable = unreachable; exports.IsEvalSupportedCached = exports.IsLittleEndianCached = exports.createObjectURL = exports.FormatError = exports.Util = exports.UnknownErrorException = exports.UnexpectedResponseException = exports.TextRenderingMode = exports.StreamType = exports.PermissionFlag = exports.PasswordResponses = exports.PasswordException = exports.MissingPDFException = exports.InvalidPDFException = exports.AbortException = exports.CMapCompressionType = exports.ImageKind = exports.FontType = exports.AnnotationType = exports.AnnotationStateModelType = exports.AnnotationReviewState = exports.AnnotationReplyType = exports.AnnotationMarkedState = exports.AnnotationFlag = exports.AnnotationFieldFlag = exports.AnnotationBorderStyleType = exports.UNSUPPORTED_FEATURES = exports.VerbosityLevel = exports.OPS = exports.IDENTITY_MATRIX = exports.FONT_IDENTITY_MATRIX = exports.BaseException = void 0; -__w_pdfjs_require__(3); +__w_pdfjs_require__(6); + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } -const IDENTITY_MATRIX = [1, 0, 0, 1, 0, 0]; +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } + +var IDENTITY_MATRIX = [1, 0, 0, 1, 0, 0]; exports.IDENTITY_MATRIX = IDENTITY_MATRIX; -const FONT_IDENTITY_MATRIX = [0.001, 0, 0, 0.001, 0, 0]; +var FONT_IDENTITY_MATRIX = [0.001, 0, 0, 0.001, 0, 0]; exports.FONT_IDENTITY_MATRIX = FONT_IDENTITY_MATRIX; -const PermissionFlag = { +var PermissionFlag = { PRINT: 0x04, MODIFY_CONTENTS: 0x08, COPY: 0x10, @@ -921,7 +1774,7 @@ const PermissionFlag = { PRINT_HIGH_QUALITY: 0x800 }; exports.PermissionFlag = PermissionFlag; -const TextRenderingMode = { +var TextRenderingMode = { FILL: 0, STROKE: 1, FILL_STROKE: 2, @@ -934,13 +1787,13 @@ const TextRenderingMode = { ADD_TO_PATH_FLAG: 4 }; exports.TextRenderingMode = TextRenderingMode; -const ImageKind = { +var ImageKind = { GRAYSCALE_1BPP: 1, RGB_24BPP: 2, RGBA_32BPP: 3 }; exports.ImageKind = ImageKind; -const AnnotationType = { +var AnnotationType = { TEXT: 1, LINK: 2, FREETEXT: 3, @@ -969,17 +1822,17 @@ const AnnotationType = { REDACT: 26 }; exports.AnnotationType = AnnotationType; -const AnnotationStateModelType = { +var AnnotationStateModelType = { MARKED: "Marked", REVIEW: "Review" }; exports.AnnotationStateModelType = AnnotationStateModelType; -const AnnotationMarkedState = { +var AnnotationMarkedState = { MARKED: "Marked", UNMARKED: "Unmarked" }; exports.AnnotationMarkedState = AnnotationMarkedState; -const AnnotationReviewState = { +var AnnotationReviewState = { ACCEPTED: "Accepted", REJECTED: "Rejected", CANCELLED: "Cancelled", @@ -987,12 +1840,12 @@ const AnnotationReviewState = { NONE: "None" }; exports.AnnotationReviewState = AnnotationReviewState; -const AnnotationReplyType = { +var AnnotationReplyType = { GROUP: "Group", REPLY: "R" }; exports.AnnotationReplyType = AnnotationReplyType; -const AnnotationFlag = { +var AnnotationFlag = { INVISIBLE: 0x01, HIDDEN: 0x02, PRINT: 0x04, @@ -1005,7 +1858,7 @@ const AnnotationFlag = { LOCKEDCONTENTS: 0x200 }; exports.AnnotationFlag = AnnotationFlag; -const AnnotationFieldFlag = { +var AnnotationFieldFlag = { READONLY: 0x0000001, REQUIRED: 0x0000002, NOEXPORT: 0x0000004, @@ -1027,7 +1880,7 @@ const AnnotationFieldFlag = { COMMITONSELCHANGE: 0x4000000 }; exports.AnnotationFieldFlag = AnnotationFieldFlag; -const AnnotationBorderStyleType = { +var AnnotationBorderStyleType = { SOLID: 1, DASHED: 2, BEVELED: 3, @@ -1035,7 +1888,7 @@ const AnnotationBorderStyleType = { UNDERLINE: 5 }; exports.AnnotationBorderStyleType = AnnotationBorderStyleType; -const StreamType = { +var StreamType = { UNKNOWN: "UNKNOWN", FLATE: "FLATE", LZW: "LZW", @@ -1048,7 +1901,7 @@ const StreamType = { RLX: "RLX" }; exports.StreamType = StreamType; -const FontType = { +var FontType = { UNKNOWN: "UNKNOWN", TYPE1: "TYPE1", TYPE1C: "TYPE1C", @@ -1062,19 +1915,19 @@ const FontType = { MMTYPE1: "MMTYPE1" }; exports.FontType = FontType; -const VerbosityLevel = { +var VerbosityLevel = { ERRORS: 0, WARNINGS: 1, INFOS: 5 }; exports.VerbosityLevel = VerbosityLevel; -const CMapCompressionType = { +var CMapCompressionType = { NONE: 0, BINARY: 1, STREAM: 2 }; exports.CMapCompressionType = CMapCompressionType; -const OPS = { +var OPS = { dependency: 1, setLineWidth: 2, setLineCap: 3, @@ -1168,7 +2021,7 @@ const OPS = { constructPath: 91 }; exports.OPS = OPS; -const UNSUPPORTED_FEATURES = { +var UNSUPPORTED_FEATURES = { unknown: "unknown", forms: "forms", javaScript: "javaScript", @@ -1189,12 +2042,12 @@ const UNSUPPORTED_FEATURES = { errorFontGetPath: "errorFontGetPath" }; exports.UNSUPPORTED_FEATURES = UNSUPPORTED_FEATURES; -const PasswordResponses = { +var PasswordResponses = { NEED_PASSWORD: 1, INCORRECT_PASSWORD: 2 }; exports.PasswordResponses = PasswordResponses; -let verbosity = VerbosityLevel.WARNINGS; +var verbosity = VerbosityLevel.WARNINGS; function setVerbosityLevel(level) { if (Number.isInteger(level)) { @@ -1208,13 +2061,13 @@ function getVerbosityLevel() { function info(msg) { if (verbosity >= VerbosityLevel.INFOS) { - console.log(`Info: ${msg}`); + console.log("Info: ".concat(msg)); } } function warn(msg) { if (verbosity >= VerbosityLevel.WARNINGS) { - console.log(`Warning: ${msg}`); + console.log("Warning: ".concat(msg)); } } @@ -1229,7 +2082,7 @@ function assert(cond, msg) { } function isSameOrigin(baseUrl, otherUrl) { - let base; + var base; try { base = new URL(baseUrl); @@ -1241,7 +2094,7 @@ function isSameOrigin(baseUrl, otherUrl) { return false; } - const other = new URL(otherUrl, base); + var other = new URL(otherUrl, base); return base.origin === other.origin; } @@ -1269,7 +2122,7 @@ function createValidAbsoluteUrl(url, baseUrl) { } try { - const absoluteUrl = baseUrl ? new URL(url, baseUrl) : new URL(url); + var absoluteUrl = baseUrl ? new URL(url, baseUrl) : new URL(url); if (_isValidProtocol(absoluteUrl)) { return absoluteUrl; @@ -1281,7 +2134,7 @@ function createValidAbsoluteUrl(url, baseUrl) { function shadow(obj, prop, value) { Object.defineProperty(obj, prop, { - value, + value: value, enumerable: true, configurable: true, writable: false @@ -1289,7 +2142,7 @@ function shadow(obj, prop, value) { return value; } -const BaseException = function BaseExceptionClosure() { +var BaseException = function BaseExceptionClosure() { function BaseException(message) { if (this.constructor === BaseException) { unreachable("Cannot initialize BaseException."); @@ -1306,52 +2159,130 @@ const BaseException = function BaseExceptionClosure() { exports.BaseException = BaseException; -class PasswordException extends BaseException { - constructor(msg, code) { - super(msg); - this.code = code; +var PasswordException = /*#__PURE__*/function (_BaseException) { + _inherits(PasswordException, _BaseException); + + var _super = _createSuper(PasswordException); + + function PasswordException(msg, code) { + var _this; + + _classCallCheck(this, PasswordException); + + _this = _super.call(this, msg); + _this.code = code; + return _this; } -} + return PasswordException; +}(BaseException); exports.PasswordException = PasswordException; -class UnknownErrorException extends BaseException { - constructor(msg, details) { - super(msg); - this.details = details; +var UnknownErrorException = /*#__PURE__*/function (_BaseException2) { + _inherits(UnknownErrorException, _BaseException2); + + var _super2 = _createSuper(UnknownErrorException); + + function UnknownErrorException(msg, details) { + var _this2; + + _classCallCheck(this, UnknownErrorException); + + _this2 = _super2.call(this, msg); + _this2.details = details; + return _this2; } -} + return UnknownErrorException; +}(BaseException); exports.UnknownErrorException = UnknownErrorException; -class InvalidPDFException extends BaseException {} +var InvalidPDFException = /*#__PURE__*/function (_BaseException3) { + _inherits(InvalidPDFException, _BaseException3); + + var _super3 = _createSuper(InvalidPDFException); + + function InvalidPDFException() { + _classCallCheck(this, InvalidPDFException); + + return _super3.apply(this, arguments); + } + + return InvalidPDFException; +}(BaseException); exports.InvalidPDFException = InvalidPDFException; -class MissingPDFException extends BaseException {} +var MissingPDFException = /*#__PURE__*/function (_BaseException4) { + _inherits(MissingPDFException, _BaseException4); + + var _super4 = _createSuper(MissingPDFException); + + function MissingPDFException() { + _classCallCheck(this, MissingPDFException); + + return _super4.apply(this, arguments); + } + + return MissingPDFException; +}(BaseException); exports.MissingPDFException = MissingPDFException; -class UnexpectedResponseException extends BaseException { - constructor(msg, status) { - super(msg); - this.status = status; +var UnexpectedResponseException = /*#__PURE__*/function (_BaseException5) { + _inherits(UnexpectedResponseException, _BaseException5); + + var _super5 = _createSuper(UnexpectedResponseException); + + function UnexpectedResponseException(msg, status) { + var _this3; + + _classCallCheck(this, UnexpectedResponseException); + + _this3 = _super5.call(this, msg); + _this3.status = status; + return _this3; } -} + return UnexpectedResponseException; +}(BaseException); exports.UnexpectedResponseException = UnexpectedResponseException; -class FormatError extends BaseException {} +var FormatError = /*#__PURE__*/function (_BaseException6) { + _inherits(FormatError, _BaseException6); + + var _super6 = _createSuper(FormatError); + + function FormatError() { + _classCallCheck(this, FormatError); + + return _super6.apply(this, arguments); + } + + return FormatError; +}(BaseException); exports.FormatError = FormatError; -class AbortException extends BaseException {} +var AbortException = /*#__PURE__*/function (_BaseException7) { + _inherits(AbortException, _BaseException7); + + var _super7 = _createSuper(AbortException); + + function AbortException() { + _classCallCheck(this, AbortException); + + return _super7.apply(this, arguments); + } + + return AbortException; +}(BaseException); exports.AbortException = AbortException; -const NullCharactersRegExp = /\x00/g; +var NullCharactersRegExp = /\x00/g; function removeNullCharacters(str) { if (typeof str !== "string") { @@ -1363,19 +2294,19 @@ function removeNullCharacters(str) { } function bytesToString(bytes) { - assert(bytes !== null && typeof bytes === "object" && bytes.length !== undefined, "Invalid argument for bytesToString"); - const length = bytes.length; - const MAX_ARGUMENT_COUNT = 8192; + assert(bytes !== null && _typeof(bytes) === "object" && bytes.length !== undefined, "Invalid argument for bytesToString"); + var length = bytes.length; + var MAX_ARGUMENT_COUNT = 8192; if (length < MAX_ARGUMENT_COUNT) { return String.fromCharCode.apply(null, bytes); } - const strBuf = []; + var strBuf = []; - for (let i = 0; i < length; i += MAX_ARGUMENT_COUNT) { - const chunkEnd = Math.min(i + MAX_ARGUMENT_COUNT, length); - const chunk = bytes.subarray(i, chunkEnd); + for (var i = 0; i < length; i += MAX_ARGUMENT_COUNT) { + var chunkEnd = Math.min(i + MAX_ARGUMENT_COUNT, length); + var chunk = bytes.subarray(i, chunkEnd); strBuf.push(String.fromCharCode.apply(null, chunk)); } @@ -1384,10 +2315,10 @@ function bytesToString(bytes) { function stringToBytes(str) { assert(typeof str === "string", "Invalid argument for stringToBytes"); - const length = str.length; - const bytes = new Uint8Array(length); + var length = str.length; + var bytes = new Uint8Array(length); - for (let i = 0; i < length; ++i) { + for (var i = 0; i < length; ++i) { bytes[i] = str.charCodeAt(i) & 0xff; } @@ -1404,23 +2335,23 @@ function arrayByteLength(arr) { } function arraysToBytes(arr) { - const length = arr.length; + var length = arr.length; if (length === 1 && arr[0] instanceof Uint8Array) { return arr[0]; } - let resultLength = 0; + var resultLength = 0; - for (let i = 0; i < length; i++) { + for (var i = 0; i < length; i++) { resultLength += arrayByteLength(arr[i]); } - let pos = 0; - const data = new Uint8Array(resultLength); + var pos = 0; + var data = new Uint8Array(resultLength); - for (let i = 0; i < length; i++) { - let item = arr[i]; + for (var _i = 0; _i < length; _i++) { + var item = arr[_i]; if (!(item instanceof Uint8Array)) { if (typeof item === "string") { @@ -1430,7 +2361,7 @@ function arraysToBytes(arr) { } } - const itemLength = item.byteLength; + var itemLength = item.byteLength; data.set(item, pos); pos += itemLength; } @@ -1443,13 +2374,13 @@ function string32(value) { } function isLittleEndian() { - const buffer8 = new Uint8Array(4); + var buffer8 = new Uint8Array(4); buffer8[0] = 1; - const view32 = new Uint32Array(buffer8.buffer, 0, 1); + var view32 = new Uint32Array(buffer8.buffer, 0, 1); return view32[0] === 1; } -const IsLittleEndianCached = { +var IsLittleEndianCached = { get value() { return shadow(this, "value", isLittleEndian()); } @@ -1466,135 +2397,152 @@ function isEvalSupported() { } } -const IsEvalSupportedCached = { +var IsEvalSupportedCached = { get value() { return shadow(this, "value", isEvalSupported()); } }; exports.IsEvalSupportedCached = IsEvalSupportedCached; -const rgbBuf = ["rgb(", 0, ",", 0, ",", 0, ")"]; - -class Util { - static makeCssRgb(r, g, b) { - rgbBuf[1] = r; - rgbBuf[3] = g; - rgbBuf[5] = b; - return rgbBuf.join(""); - } - - static transform(m1, m2) { - return [m1[0] * m2[0] + m1[2] * m2[1], m1[1] * m2[0] + m1[3] * m2[1], m1[0] * m2[2] + m1[2] * m2[3], m1[1] * m2[2] + m1[3] * m2[3], m1[0] * m2[4] + m1[2] * m2[5] + m1[4], m1[1] * m2[4] + m1[3] * m2[5] + m1[5]]; - } - - static applyTransform(p, m) { - const xt = p[0] * m[0] + p[1] * m[2] + m[4]; - const yt = p[0] * m[1] + p[1] * m[3] + m[5]; - return [xt, yt]; - } - - static applyInverseTransform(p, m) { - const d = m[0] * m[3] - m[1] * m[2]; - const xt = (p[0] * m[3] - p[1] * m[2] + m[2] * m[5] - m[4] * m[3]) / d; - const yt = (-p[0] * m[1] + p[1] * m[0] + m[4] * m[1] - m[5] * m[0]) / d; - return [xt, yt]; - } - - static getAxialAlignedBoundingBox(r, m) { - const p1 = Util.applyTransform(r, m); - const p2 = Util.applyTransform(r.slice(2, 4), m); - const p3 = Util.applyTransform([r[0], r[3]], m); - const p4 = Util.applyTransform([r[2], r[1]], m); - return [Math.min(p1[0], p2[0], p3[0], p4[0]), Math.min(p1[1], p2[1], p3[1], p4[1]), Math.max(p1[0], p2[0], p3[0], p4[0]), Math.max(p1[1], p2[1], p3[1], p4[1])]; - } - - static inverseTransform(m) { - const d = m[0] * m[3] - m[1] * m[2]; - return [m[3] / d, -m[1] / d, -m[2] / d, m[0] / d, (m[2] * m[5] - m[4] * m[3]) / d, (m[4] * m[1] - m[5] * m[0]) / d]; - } - - static apply3dTransform(m, v) { - return [m[0] * v[0] + m[1] * v[1] + m[2] * v[2], m[3] * v[0] + m[4] * v[1] + m[5] * v[2], m[6] * v[0] + m[7] * v[1] + m[8] * v[2]]; - } - - static singularValueDecompose2dScale(m) { - const transpose = [m[0], m[2], m[1], m[3]]; - const a = m[0] * transpose[0] + m[1] * transpose[2]; - const b = m[0] * transpose[1] + m[1] * transpose[3]; - const c = m[2] * transpose[0] + m[3] * transpose[2]; - const d = m[2] * transpose[1] + m[3] * transpose[3]; - const first = (a + d) / 2; - const second = Math.sqrt((a + d) * (a + d) - 4 * (a * d - c * b)) / 2; - const sx = first + second || 1; - const sy = first - second || 1; - return [Math.sqrt(sx), Math.sqrt(sy)]; - } - - static normalizeRect(rect) { - const r = rect.slice(0); - - if (rect[0] > rect[2]) { - r[0] = rect[2]; - r[2] = rect[0]; - } - - if (rect[1] > rect[3]) { - r[1] = rect[3]; - r[3] = rect[1]; - } - - return r; - } - - static intersect(rect1, rect2) { - function compare(a, b) { - return a - b; - } - - const orderedX = [rect1[0], rect1[2], rect2[0], rect2[2]].sort(compare); - const orderedY = [rect1[1], rect1[3], rect2[1], rect2[3]].sort(compare); - const result = []; - rect1 = Util.normalizeRect(rect1); - rect2 = Util.normalizeRect(rect2); +var rgbBuf = ["rgb(", 0, ",", 0, ",", 0, ")"]; + +var Util = /*#__PURE__*/function () { + function Util() { + _classCallCheck(this, Util); + } + + _createClass(Util, null, [{ + key: "makeCssRgb", + value: function makeCssRgb(r, g, b) { + rgbBuf[1] = r; + rgbBuf[3] = g; + rgbBuf[5] = b; + return rgbBuf.join(""); + } + }, { + key: "transform", + value: function transform(m1, m2) { + return [m1[0] * m2[0] + m1[2] * m2[1], m1[1] * m2[0] + m1[3] * m2[1], m1[0] * m2[2] + m1[2] * m2[3], m1[1] * m2[2] + m1[3] * m2[3], m1[0] * m2[4] + m1[2] * m2[5] + m1[4], m1[1] * m2[4] + m1[3] * m2[5] + m1[5]]; + } + }, { + key: "applyTransform", + value: function applyTransform(p, m) { + var xt = p[0] * m[0] + p[1] * m[2] + m[4]; + var yt = p[0] * m[1] + p[1] * m[3] + m[5]; + return [xt, yt]; + } + }, { + key: "applyInverseTransform", + value: function applyInverseTransform(p, m) { + var d = m[0] * m[3] - m[1] * m[2]; + var xt = (p[0] * m[3] - p[1] * m[2] + m[2] * m[5] - m[4] * m[3]) / d; + var yt = (-p[0] * m[1] + p[1] * m[0] + m[4] * m[1] - m[5] * m[0]) / d; + return [xt, yt]; + } + }, { + key: "getAxialAlignedBoundingBox", + value: function getAxialAlignedBoundingBox(r, m) { + var p1 = Util.applyTransform(r, m); + var p2 = Util.applyTransform(r.slice(2, 4), m); + var p3 = Util.applyTransform([r[0], r[3]], m); + var p4 = Util.applyTransform([r[2], r[1]], m); + return [Math.min(p1[0], p2[0], p3[0], p4[0]), Math.min(p1[1], p2[1], p3[1], p4[1]), Math.max(p1[0], p2[0], p3[0], p4[0]), Math.max(p1[1], p2[1], p3[1], p4[1])]; + } + }, { + key: "inverseTransform", + value: function inverseTransform(m) { + var d = m[0] * m[3] - m[1] * m[2]; + return [m[3] / d, -m[1] / d, -m[2] / d, m[0] / d, (m[2] * m[5] - m[4] * m[3]) / d, (m[4] * m[1] - m[5] * m[0]) / d]; + } + }, { + key: "apply3dTransform", + value: function apply3dTransform(m, v) { + return [m[0] * v[0] + m[1] * v[1] + m[2] * v[2], m[3] * v[0] + m[4] * v[1] + m[5] * v[2], m[6] * v[0] + m[7] * v[1] + m[8] * v[2]]; + } + }, { + key: "singularValueDecompose2dScale", + value: function singularValueDecompose2dScale(m) { + var transpose = [m[0], m[2], m[1], m[3]]; + var a = m[0] * transpose[0] + m[1] * transpose[2]; + var b = m[0] * transpose[1] + m[1] * transpose[3]; + var c = m[2] * transpose[0] + m[3] * transpose[2]; + var d = m[2] * transpose[1] + m[3] * transpose[3]; + var first = (a + d) / 2; + var second = Math.sqrt((a + d) * (a + d) - 4 * (a * d - c * b)) / 2; + var sx = first + second || 1; + var sy = first - second || 1; + return [Math.sqrt(sx), Math.sqrt(sy)]; + } + }, { + key: "normalizeRect", + value: function normalizeRect(rect) { + var r = rect.slice(0); + + if (rect[0] > rect[2]) { + r[0] = rect[2]; + r[2] = rect[0]; + } + + if (rect[1] > rect[3]) { + r[1] = rect[3]; + r[3] = rect[1]; + } + + return r; + } + }, { + key: "intersect", + value: function intersect(rect1, rect2) { + function compare(a, b) { + return a - b; + } + + var orderedX = [rect1[0], rect1[2], rect2[0], rect2[2]].sort(compare); + var orderedY = [rect1[1], rect1[3], rect2[1], rect2[3]].sort(compare); + var result = []; + rect1 = Util.normalizeRect(rect1); + rect2 = Util.normalizeRect(rect2); + + if (orderedX[0] === rect1[0] && orderedX[1] === rect2[0] || orderedX[0] === rect2[0] && orderedX[1] === rect1[0]) { + result[0] = orderedX[1]; + result[2] = orderedX[2]; + } else { + return null; + } - if (orderedX[0] === rect1[0] && orderedX[1] === rect2[0] || orderedX[0] === rect2[0] && orderedX[1] === rect1[0]) { - result[0] = orderedX[1]; - result[2] = orderedX[2]; - } else { - return null; - } + if (orderedY[0] === rect1[1] && orderedY[1] === rect2[1] || orderedY[0] === rect2[1] && orderedY[1] === rect1[1]) { + result[1] = orderedY[1]; + result[3] = orderedY[2]; + } else { + return null; + } - if (orderedY[0] === rect1[1] && orderedY[1] === rect2[1] || orderedY[0] === rect2[1] && orderedY[1] === rect1[1]) { - result[1] = orderedY[1]; - result[3] = orderedY[2]; - } else { - return null; + return result; } + }]); - return result; - } - -} + return Util; +}(); exports.Util = Util; -const PDFStringTranslateTable = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x2D8, 0x2C7, 0x2C6, 0x2D9, 0x2DD, 0x2DB, 0x2DA, 0x2DC, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x2022, 0x2020, 0x2021, 0x2026, 0x2014, 0x2013, 0x192, 0x2044, 0x2039, 0x203A, 0x2212, 0x2030, 0x201E, 0x201C, 0x201D, 0x2018, 0x2019, 0x201A, 0x2122, 0xFB01, 0xFB02, 0x141, 0x152, 0x160, 0x178, 0x17D, 0x131, 0x142, 0x153, 0x161, 0x17E, 0, 0x20AC]; +var PDFStringTranslateTable = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x2D8, 0x2C7, 0x2C6, 0x2D9, 0x2DD, 0x2DB, 0x2DA, 0x2DC, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x2022, 0x2020, 0x2021, 0x2026, 0x2014, 0x2013, 0x192, 0x2044, 0x2039, 0x203A, 0x2212, 0x2030, 0x201E, 0x201C, 0x201D, 0x2018, 0x2019, 0x201A, 0x2122, 0xFB01, 0xFB02, 0x141, 0x152, 0x160, 0x178, 0x17D, 0x131, 0x142, 0x153, 0x161, 0x17E, 0, 0x20AC]; function stringToPDFString(str) { - const length = str.length, - strBuf = []; + var length = str.length, + strBuf = []; if (str[0] === "\xFE" && str[1] === "\xFF") { - for (let i = 2; i < length; i += 2) { + for (var i = 2; i < length; i += 2) { strBuf.push(String.fromCharCode(str.charCodeAt(i) << 8 | str.charCodeAt(i + 1))); } } else if (str[0] === "\xFF" && str[1] === "\xFE") { - for (let i = 2; i < length; i += 2) { - strBuf.push(String.fromCharCode(str.charCodeAt(i + 1) << 8 | str.charCodeAt(i))); + for (var _i2 = 2; _i2 < length; _i2 += 2) { + strBuf.push(String.fromCharCode(str.charCodeAt(_i2 + 1) << 8 | str.charCodeAt(_i2))); } } else { - for (let i = 0; i < length; ++i) { - const code = PDFStringTranslateTable[str.charCodeAt(i)]; - strBuf.push(code ? String.fromCharCode(code) : str.charAt(i)); + for (var _i3 = 0; _i3 < length; ++_i3) { + var code = PDFStringTranslateTable[str.charCodeAt(_i3)]; + strBuf.push(code ? String.fromCharCode(code) : str.charAt(_i3)); } } @@ -1610,7 +2558,7 @@ function utf8StringToString(str) { } function isEmptyObj(obj) { - for (const key in obj) { + for (var key in obj) { return false; } @@ -1630,7 +2578,7 @@ function isString(v) { } function isArrayBuffer(v) { - return typeof v === "object" && v !== null && v.byteLength !== undefined; + return _typeof(v) === "object" && v !== null && v.byteLength !== undefined; } function isArrayEqual(arr1, arr2) { @@ -1644,13 +2592,12 @@ function isArrayEqual(arr1, arr2) { } function createPromiseCapability() { - const capability = Object.create(null); - let isSettled = false; + var capability = Object.create(null); + var isSettled = false; Object.defineProperty(capability, "settled", { - get() { + get: function get() { return isSettled; } - }); capability.promise = new Promise(function (resolve, reject) { capability.resolve = function (data) { @@ -1666,26 +2613,28 @@ function createPromiseCapability() { return capability; } -const createObjectURL = function createObjectURLClosure() { - const digits = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="; - return function createObjectURL(data, contentType, forceDataSchema = false) { +var createObjectURL = function createObjectURLClosure() { + var digits = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="; + return function createObjectURL(data, contentType) { + var forceDataSchema = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + if (!forceDataSchema && URL.createObjectURL) { - const blob = new Blob([data], { + var blob = new Blob([data], { type: contentType }); return URL.createObjectURL(blob); } - let buffer = `data:${contentType};base64,`; + var buffer = "data:".concat(contentType, ";base64,"); - for (let i = 0, ii = data.length; i < ii; i += 3) { - const b1 = data[i] & 0xff; - const b2 = data[i + 1] & 0xff; - const b3 = data[i + 2] & 0xff; - const d1 = b1 >> 2, - d2 = (b1 & 3) << 4 | b2 >> 4; - const d3 = i + 1 < ii ? (b2 & 0xf) << 2 | b3 >> 6 : 64; - const d4 = i + 2 < ii ? b3 & 0x3f : 64; + for (var i = 0, ii = data.length; i < ii; i += 3) { + var b1 = data[i] & 0xff; + var b2 = data[i + 1] & 0xff; + var b3 = data[i + 2] & 0xff; + var d1 = b1 >> 2, + d2 = (b1 & 3) << 4 | b2 >> 4; + var d3 = i + 1 < ii ? (b2 & 0xf) << 2 | b3 >> 6 : 64; + var d4 = i + 2 < ii ? b3 & 0x3f : 64; buffer += digits[d1] + digits[d2] + digits[d3] + digits[d4]; } @@ -1696,18 +2645,332 @@ const createObjectURL = function createObjectURLClosure() { exports.createObjectURL = createObjectURL; /***/ }), -/* 3 */ +/* 6 */ /***/ (function(module, exports, __w_pdfjs_require__) { "use strict"; -var _is_node = __w_pdfjs_require__(4); +var _is_node = __w_pdfjs_require__(7); -; +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +if (typeof globalThis === "undefined" || !globalThis._pdfjsCompatibilityChecked) { + if (typeof globalThis === "undefined" || globalThis.Math !== Math) { + globalThis = __w_pdfjs_require__(8); + } + + globalThis._pdfjsCompatibilityChecked = true; + var hasDOM = (typeof window === "undefined" ? "undefined" : _typeof(window)) === "object" && (typeof document === "undefined" ? "undefined" : _typeof(document)) === "object"; + var userAgent = typeof navigator !== "undefined" && navigator.userAgent || ""; + var isIE = /Trident/.test(userAgent); + + (function checkNodeBtoa() { + if (globalThis.btoa || !_is_node.isNodeJS) { + return; + } + + globalThis.btoa = function (chars) { + return Buffer.from(chars, "binary").toString("base64"); + }; + })(); + + (function checkNodeAtob() { + if (globalThis.atob || !_is_node.isNodeJS) { + return; + } + + globalThis.atob = function (input) { + return Buffer.from(input, "base64").toString("binary"); + }; + })(); + + (function checkChildNodeRemove() { + if (!hasDOM) { + return; + } + + if (typeof Element.prototype.remove !== "undefined") { + return; + } + + Element.prototype.remove = function () { + if (this.parentNode) { + this.parentNode.removeChild(this); + } + }; + })(); + + (function checkDOMTokenListAddRemove() { + if (!hasDOM || _is_node.isNodeJS) { + return; + } + + var div = document.createElement("div"); + div.classList.add("testOne", "testTwo"); + + if (div.classList.contains("testOne") === true && div.classList.contains("testTwo") === true) { + return; + } + + var OriginalDOMTokenListAdd = DOMTokenList.prototype.add; + var OriginalDOMTokenListRemove = DOMTokenList.prototype.remove; + + DOMTokenList.prototype.add = function () { + for (var _len = arguments.length, tokens = new Array(_len), _key = 0; _key < _len; _key++) { + tokens[_key] = arguments[_key]; + } + + for (var _i = 0, _tokens = tokens; _i < _tokens.length; _i++) { + var token = _tokens[_i]; + OriginalDOMTokenListAdd.call(this, token); + } + }; + + DOMTokenList.prototype.remove = function () { + for (var _len2 = arguments.length, tokens = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { + tokens[_key2] = arguments[_key2]; + } + + for (var _i2 = 0, _tokens2 = tokens; _i2 < _tokens2.length; _i2++) { + var token = _tokens2[_i2]; + OriginalDOMTokenListRemove.call(this, token); + } + }; + })(); + + (function checkDOMTokenListToggle() { + if (!hasDOM || _is_node.isNodeJS) { + return; + } + + var div = document.createElement("div"); + + if (div.classList.toggle("test", 0) === false) { + return; + } + + DOMTokenList.prototype.toggle = function (token) { + var force = arguments.length > 1 ? !!arguments[1] : !this.contains(token); + return this[force ? "add" : "remove"](token), force; + }; + })(); + + (function checkWindowHistoryPushStateReplaceState() { + if (!hasDOM || !isIE) { + return; + } + + var OriginalPushState = window.history.pushState; + var OriginalReplaceState = window.history.replaceState; + + window.history.pushState = function (state, title, url) { + var args = url === undefined ? [state, title] : [state, title, url]; + OriginalPushState.apply(this, args); + }; + + window.history.replaceState = function (state, title, url) { + var args = url === undefined ? [state, title] : [state, title, url]; + OriginalReplaceState.apply(this, args); + }; + })(); + + (function checkStringStartsWith() { + if (String.prototype.startsWith) { + return; + } + + __w_pdfjs_require__(53); + })(); + + (function checkStringEndsWith() { + if (String.prototype.endsWith) { + return; + } + + __w_pdfjs_require__(64); + })(); + + (function checkStringIncludes() { + if (String.prototype.includes) { + return; + } + + __w_pdfjs_require__(66); + })(); + + (function checkArrayIncludes() { + if (Array.prototype.includes) { + return; + } + + __w_pdfjs_require__(68); + })(); + + (function checkArrayFrom() { + if (Array.from) { + return; + } + + __w_pdfjs_require__(76); + })(); + + (function checkObjectAssign() { + if (Object.assign) { + return; + } + + __w_pdfjs_require__(98); + })(); + + (function checkMathLog2() { + if (Math.log2) { + return; + } + + Math.log2 = __w_pdfjs_require__(101); + })(); + + (function checkNumberIsNaN() { + if (Number.isNaN) { + return; + } + + Number.isNaN = __w_pdfjs_require__(103); + })(); + + (function checkNumberIsInteger() { + if (Number.isInteger) { + return; + } + + Number.isInteger = __w_pdfjs_require__(105); + })(); + + (function checkTypedArraySlice() { + if (Uint8Array.prototype.slice) { + return; + } + + __w_pdfjs_require__(108); + })(); + + (function checkPromise() { + if (globalThis.Promise && globalThis.Promise.allSettled) { + return; + } + + globalThis.Promise = __w_pdfjs_require__(113); + })(); + + (function checkURL() { + globalThis.URL = __w_pdfjs_require__(136); + })(); + + (function checkReadableStream() { + var isReadableStreamSupported = false; + + if (typeof ReadableStream !== "undefined") { + try { + new ReadableStream({ + start: function start(controller) { + controller.close(); + } + }); + isReadableStreamSupported = true; + } catch (e) {} + } + + if (isReadableStreamSupported) { + return; + } + + globalThis.ReadableStream = __w_pdfjs_require__(143).ReadableStream; + })(); + + (function checkMapEntries() { + if (globalThis.Map && globalThis.Map.prototype.entries) { + return; + } + + globalThis.Map = __w_pdfjs_require__(144); + })(); + + (function checkSetEntries() { + if (globalThis.Set && globalThis.Set.prototype.entries) { + return; + } + + globalThis.Set = __w_pdfjs_require__(151); + })(); + + (function checkWeakMap() { + if (globalThis.WeakMap) { + return; + } + + globalThis.WeakMap = __w_pdfjs_require__(153); + })(); + + (function checkWeakSet() { + if (globalThis.WeakSet) { + return; + } + + globalThis.WeakSet = __w_pdfjs_require__(159); + })(); + + (function checkStringCodePointAt() { + if (String.prototype.codePointAt) { + return; + } + + __w_pdfjs_require__(161); + })(); + + (function checkStringFromCodePoint() { + if (String.fromCodePoint) { + return; + } + + String.fromCodePoint = __w_pdfjs_require__(163); + })(); + + (function checkSymbol() { + if (globalThis.Symbol) { + return; + } + + __w_pdfjs_require__(165); + })(); + + (function checkStringPadStart() { + if (String.prototype.padStart) { + return; + } + + __w_pdfjs_require__(188); + })(); + + (function checkStringPadEnd() { + if (String.prototype.padEnd) { + return; + } + + __w_pdfjs_require__(193); + })(); + + (function checkObjectValues() { + if (Object.values) { + return; + } + + Object.values = __w_pdfjs_require__(195); + })(); +} /***/ }), -/* 4 */ +/* 7 */ /***/ (function(module, exports, __w_pdfjs_require__) { "use strict"; @@ -1717,11 +2980,9087 @@ Object.defineProperty(exports, "__esModule", { value: true }); exports.isNodeJS = void 0; -const isNodeJS = typeof process === "object" && process + "" === "[object process]" && !process.versions.nw && !process.versions.electron; + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +var isNodeJS = (typeof process === "undefined" ? "undefined" : _typeof(process)) === "object" && process + "" === "[object process]" && !process.versions.nw && !process.versions.electron; exports.isNodeJS = isNodeJS; /***/ }), -/* 5 */ +/* 8 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +__w_pdfjs_require__(9); +module.exports = __w_pdfjs_require__(11); + +/***/ }), +/* 9 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var $ = __w_pdfjs_require__(10); +var global = __w_pdfjs_require__(11); +$({ global: true }, { globalThis: global }); + +/***/ }), +/* 10 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var global = __w_pdfjs_require__(11); +var getOwnPropertyDescriptor = __w_pdfjs_require__(12).f; +var createNonEnumerableProperty = __w_pdfjs_require__(26); +var redefine = __w_pdfjs_require__(29); +var setGlobal = __w_pdfjs_require__(30); +var copyConstructorProperties = __w_pdfjs_require__(40); +var isForced = __w_pdfjs_require__(52); +module.exports = function (options, source) { + var TARGET = options.target; + var GLOBAL = options.global; + var STATIC = options.stat; + var FORCED, target, key, targetProperty, sourceProperty, descriptor; + if (GLOBAL) { + target = global; + } else if (STATIC) { + target = global[TARGET] || setGlobal(TARGET, {}); + } else { + target = (global[TARGET] || {}).prototype; + } + if (target) + for (key in source) { + sourceProperty = source[key]; + if (options.noTargetGet) { + descriptor = getOwnPropertyDescriptor(target, key); + targetProperty = descriptor && descriptor.value; + } else + targetProperty = target[key]; + FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced); + if (!FORCED && targetProperty !== undefined) { + if (typeof sourceProperty === typeof targetProperty) + continue; + copyConstructorProperties(sourceProperty, targetProperty); + } + if (options.sham || targetProperty && targetProperty.sham) { + createNonEnumerableProperty(sourceProperty, 'sham', true); + } + redefine(target, key, sourceProperty, options); + } +}; + +/***/ }), +/* 11 */ +/***/ (function(module, exports) { + +var check = function (it) { + return it && it.Math == Math && it; +}; +module.exports = check(typeof globalThis == 'object' && globalThis) || check(typeof window == 'object' && window) || check(typeof self == 'object' && self) || check(typeof global == 'object' && global) || Function('return this')(); + +/***/ }), +/* 12 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var DESCRIPTORS = __w_pdfjs_require__(13); +var propertyIsEnumerableModule = __w_pdfjs_require__(15); +var createPropertyDescriptor = __w_pdfjs_require__(16); +var toIndexedObject = __w_pdfjs_require__(17); +var toPrimitive = __w_pdfjs_require__(21); +var has = __w_pdfjs_require__(23); +var IE8_DOM_DEFINE = __w_pdfjs_require__(24); +var nativeGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; +exports.f = DESCRIPTORS ? nativeGetOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) { + O = toIndexedObject(O); + P = toPrimitive(P, true); + if (IE8_DOM_DEFINE) + try { + return nativeGetOwnPropertyDescriptor(O, P); + } catch (error) { + } + if (has(O, P)) + return createPropertyDescriptor(!propertyIsEnumerableModule.f.call(O, P), O[P]); +}; + +/***/ }), +/* 13 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var fails = __w_pdfjs_require__(14); +module.exports = !fails(function () { + return Object.defineProperty({}, 1, { + get: function () { + return 7; + } + })[1] != 7; +}); + +/***/ }), +/* 14 */ +/***/ (function(module, exports) { + +module.exports = function (exec) { + try { + return !!exec(); + } catch (error) { + return true; + } +}; + +/***/ }), +/* 15 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + +var nativePropertyIsEnumerable = {}.propertyIsEnumerable; +var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; +var NASHORN_BUG = getOwnPropertyDescriptor && !nativePropertyIsEnumerable.call({ 1: 2 }, 1); +exports.f = NASHORN_BUG ? function propertyIsEnumerable(V) { + var descriptor = getOwnPropertyDescriptor(this, V); + return !!descriptor && descriptor.enumerable; +} : nativePropertyIsEnumerable; + +/***/ }), +/* 16 */ +/***/ (function(module, exports) { + +module.exports = function (bitmap, value) { + return { + enumerable: !(bitmap & 1), + configurable: !(bitmap & 2), + writable: !(bitmap & 4), + value: value + }; +}; + +/***/ }), +/* 17 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var IndexedObject = __w_pdfjs_require__(18); +var requireObjectCoercible = __w_pdfjs_require__(20); +module.exports = function (it) { + return IndexedObject(requireObjectCoercible(it)); +}; + +/***/ }), +/* 18 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var fails = __w_pdfjs_require__(14); +var classof = __w_pdfjs_require__(19); +var split = ''.split; +module.exports = fails(function () { + return !Object('z').propertyIsEnumerable(0); +}) ? function (it) { + return classof(it) == 'String' ? split.call(it, '') : Object(it); +} : Object; + +/***/ }), +/* 19 */ +/***/ (function(module, exports) { + +var toString = {}.toString; +module.exports = function (it) { + return toString.call(it).slice(8, -1); +}; + +/***/ }), +/* 20 */ +/***/ (function(module, exports) { + +module.exports = function (it) { + if (it == undefined) + throw TypeError("Can't call method on " + it); + return it; +}; + +/***/ }), +/* 21 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var isObject = __w_pdfjs_require__(22); +module.exports = function (input, PREFERRED_STRING) { + if (!isObject(input)) + return input; + var fn, val; + if (PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input))) + return val; + if (typeof (fn = input.valueOf) == 'function' && !isObject(val = fn.call(input))) + return val; + if (!PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input))) + return val; + throw TypeError("Can't convert object to primitive value"); +}; + +/***/ }), +/* 22 */ +/***/ (function(module, exports) { + +module.exports = function (it) { + return typeof it === 'object' ? it !== null : typeof it === 'function'; +}; + +/***/ }), +/* 23 */ +/***/ (function(module, exports) { + +var hasOwnProperty = {}.hasOwnProperty; +module.exports = function (it, key) { + return hasOwnProperty.call(it, key); +}; + +/***/ }), +/* 24 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var DESCRIPTORS = __w_pdfjs_require__(13); +var fails = __w_pdfjs_require__(14); +var createElement = __w_pdfjs_require__(25); +module.exports = !DESCRIPTORS && !fails(function () { + return Object.defineProperty(createElement('div'), 'a', { + get: function () { + return 7; + } + }).a != 7; +}); + +/***/ }), +/* 25 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var global = __w_pdfjs_require__(11); +var isObject = __w_pdfjs_require__(22); +var document = global.document; +var EXISTS = isObject(document) && isObject(document.createElement); +module.exports = function (it) { + return EXISTS ? document.createElement(it) : {}; +}; + +/***/ }), +/* 26 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var DESCRIPTORS = __w_pdfjs_require__(13); +var definePropertyModule = __w_pdfjs_require__(27); +var createPropertyDescriptor = __w_pdfjs_require__(16); +module.exports = DESCRIPTORS ? function (object, key, value) { + return definePropertyModule.f(object, key, createPropertyDescriptor(1, value)); +} : function (object, key, value) { + object[key] = value; + return object; +}; + +/***/ }), +/* 27 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var DESCRIPTORS = __w_pdfjs_require__(13); +var IE8_DOM_DEFINE = __w_pdfjs_require__(24); +var anObject = __w_pdfjs_require__(28); +var toPrimitive = __w_pdfjs_require__(21); +var nativeDefineProperty = Object.defineProperty; +exports.f = DESCRIPTORS ? nativeDefineProperty : function defineProperty(O, P, Attributes) { + anObject(O); + P = toPrimitive(P, true); + anObject(Attributes); + if (IE8_DOM_DEFINE) + try { + return nativeDefineProperty(O, P, Attributes); + } catch (error) { + } + if ('get' in Attributes || 'set' in Attributes) + throw TypeError('Accessors not supported'); + if ('value' in Attributes) + O[P] = Attributes.value; + return O; +}; + +/***/ }), +/* 28 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var isObject = __w_pdfjs_require__(22); +module.exports = function (it) { + if (!isObject(it)) { + throw TypeError(String(it) + ' is not an object'); + } + return it; +}; + +/***/ }), +/* 29 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var global = __w_pdfjs_require__(11); +var createNonEnumerableProperty = __w_pdfjs_require__(26); +var has = __w_pdfjs_require__(23); +var setGlobal = __w_pdfjs_require__(30); +var inspectSource = __w_pdfjs_require__(31); +var InternalStateModule = __w_pdfjs_require__(33); +var getInternalState = InternalStateModule.get; +var enforceInternalState = InternalStateModule.enforce; +var TEMPLATE = String(String).split('String'); +(module.exports = function (O, key, value, options) { + var unsafe = options ? !!options.unsafe : false; + var simple = options ? !!options.enumerable : false; + var noTargetGet = options ? !!options.noTargetGet : false; + if (typeof value == 'function') { + if (typeof key == 'string' && !has(value, 'name')) + createNonEnumerableProperty(value, 'name', key); + enforceInternalState(value).source = TEMPLATE.join(typeof key == 'string' ? key : ''); + } + if (O === global) { + if (simple) + O[key] = value; + else + setGlobal(key, value); + return; + } else if (!unsafe) { + delete O[key]; + } else if (!noTargetGet && O[key]) { + simple = true; + } + if (simple) + O[key] = value; + else + createNonEnumerableProperty(O, key, value); +})(Function.prototype, 'toString', function toString() { + return typeof this == 'function' && getInternalState(this).source || inspectSource(this); +}); + +/***/ }), +/* 30 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var global = __w_pdfjs_require__(11); +var createNonEnumerableProperty = __w_pdfjs_require__(26); +module.exports = function (key, value) { + try { + createNonEnumerableProperty(global, key, value); + } catch (error) { + global[key] = value; + } + return value; +}; + +/***/ }), +/* 31 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var store = __w_pdfjs_require__(32); +var functionToString = Function.toString; +if (typeof store.inspectSource != 'function') { + store.inspectSource = function (it) { + return functionToString.call(it); + }; +} +module.exports = store.inspectSource; + +/***/ }), +/* 32 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var global = __w_pdfjs_require__(11); +var setGlobal = __w_pdfjs_require__(30); +var SHARED = '__core-js_shared__'; +var store = global[SHARED] || setGlobal(SHARED, {}); +module.exports = store; + +/***/ }), +/* 33 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var NATIVE_WEAK_MAP = __w_pdfjs_require__(34); +var global = __w_pdfjs_require__(11); +var isObject = __w_pdfjs_require__(22); +var createNonEnumerableProperty = __w_pdfjs_require__(26); +var objectHas = __w_pdfjs_require__(23); +var sharedKey = __w_pdfjs_require__(35); +var hiddenKeys = __w_pdfjs_require__(39); +var WeakMap = global.WeakMap; +var set, get, has; +var enforce = function (it) { + return has(it) ? get(it) : set(it, {}); +}; +var getterFor = function (TYPE) { + return function (it) { + var state; + if (!isObject(it) || (state = get(it)).type !== TYPE) { + throw TypeError('Incompatible receiver, ' + TYPE + ' required'); + } + return state; + }; +}; +if (NATIVE_WEAK_MAP) { + var store = new WeakMap(); + var wmget = store.get; + var wmhas = store.has; + var wmset = store.set; + set = function (it, metadata) { + wmset.call(store, it, metadata); + return metadata; + }; + get = function (it) { + return wmget.call(store, it) || {}; + }; + has = function (it) { + return wmhas.call(store, it); + }; +} else { + var STATE = sharedKey('state'); + hiddenKeys[STATE] = true; + set = function (it, metadata) { + createNonEnumerableProperty(it, STATE, metadata); + return metadata; + }; + get = function (it) { + return objectHas(it, STATE) ? it[STATE] : {}; + }; + has = function (it) { + return objectHas(it, STATE); + }; +} +module.exports = { + set: set, + get: get, + has: has, + enforce: enforce, + getterFor: getterFor +}; + +/***/ }), +/* 34 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var global = __w_pdfjs_require__(11); +var inspectSource = __w_pdfjs_require__(31); +var WeakMap = global.WeakMap; +module.exports = typeof WeakMap === 'function' && /native code/.test(inspectSource(WeakMap)); + +/***/ }), +/* 35 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var shared = __w_pdfjs_require__(36); +var uid = __w_pdfjs_require__(38); +var keys = shared('keys'); +module.exports = function (key) { + return keys[key] || (keys[key] = uid(key)); +}; + +/***/ }), +/* 36 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var IS_PURE = __w_pdfjs_require__(37); +var store = __w_pdfjs_require__(32); +(module.exports = function (key, value) { + return store[key] || (store[key] = value !== undefined ? value : {}); +})('versions', []).push({ + version: '3.6.5', + mode: IS_PURE ? 'pure' : 'global', + copyright: '© 2020 Denis Pushkarev (zloirock.ru)' +}); + +/***/ }), +/* 37 */ +/***/ (function(module, exports) { + +module.exports = false; + +/***/ }), +/* 38 */ +/***/ (function(module, exports) { + +var id = 0; +var postfix = Math.random(); +module.exports = function (key) { + return 'Symbol(' + String(key === undefined ? '' : key) + ')_' + (++id + postfix).toString(36); +}; + +/***/ }), +/* 39 */ +/***/ (function(module, exports) { + +module.exports = {}; + +/***/ }), +/* 40 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var has = __w_pdfjs_require__(23); +var ownKeys = __w_pdfjs_require__(41); +var getOwnPropertyDescriptorModule = __w_pdfjs_require__(12); +var definePropertyModule = __w_pdfjs_require__(27); +module.exports = function (target, source) { + var keys = ownKeys(source); + var defineProperty = definePropertyModule.f; + var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f; + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + if (!has(target, key)) + defineProperty(target, key, getOwnPropertyDescriptor(source, key)); + } +}; + +/***/ }), +/* 41 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var getBuiltIn = __w_pdfjs_require__(42); +var getOwnPropertyNamesModule = __w_pdfjs_require__(44); +var getOwnPropertySymbolsModule = __w_pdfjs_require__(51); +var anObject = __w_pdfjs_require__(28); +module.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) { + var keys = getOwnPropertyNamesModule.f(anObject(it)); + var getOwnPropertySymbols = getOwnPropertySymbolsModule.f; + return getOwnPropertySymbols ? keys.concat(getOwnPropertySymbols(it)) : keys; +}; + +/***/ }), +/* 42 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var path = __w_pdfjs_require__(43); +var global = __w_pdfjs_require__(11); +var aFunction = function (variable) { + return typeof variable == 'function' ? variable : undefined; +}; +module.exports = function (namespace, method) { + return arguments.length < 2 ? aFunction(path[namespace]) || aFunction(global[namespace]) : path[namespace] && path[namespace][method] || global[namespace] && global[namespace][method]; +}; + +/***/ }), +/* 43 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var global = __w_pdfjs_require__(11); +module.exports = global; + +/***/ }), +/* 44 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var internalObjectKeys = __w_pdfjs_require__(45); +var enumBugKeys = __w_pdfjs_require__(50); +var hiddenKeys = enumBugKeys.concat('length', 'prototype'); +exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) { + return internalObjectKeys(O, hiddenKeys); +}; + +/***/ }), +/* 45 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var has = __w_pdfjs_require__(23); +var toIndexedObject = __w_pdfjs_require__(17); +var indexOf = __w_pdfjs_require__(46).indexOf; +var hiddenKeys = __w_pdfjs_require__(39); +module.exports = function (object, names) { + var O = toIndexedObject(object); + var i = 0; + var result = []; + var key; + for (key in O) + !has(hiddenKeys, key) && has(O, key) && result.push(key); + while (names.length > i) + if (has(O, key = names[i++])) { + ~indexOf(result, key) || result.push(key); + } + return result; +}; + +/***/ }), +/* 46 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var toIndexedObject = __w_pdfjs_require__(17); +var toLength = __w_pdfjs_require__(47); +var toAbsoluteIndex = __w_pdfjs_require__(49); +var createMethod = function (IS_INCLUDES) { + return function ($this, el, fromIndex) { + var O = toIndexedObject($this); + var length = toLength(O.length); + var index = toAbsoluteIndex(fromIndex, length); + var value; + if (IS_INCLUDES && el != el) + while (length > index) { + value = O[index++]; + if (value != value) + return true; + } + else + for (; length > index; index++) { + if ((IS_INCLUDES || index in O) && O[index] === el) + return IS_INCLUDES || index || 0; + } + return !IS_INCLUDES && -1; + }; +}; +module.exports = { + includes: createMethod(true), + indexOf: createMethod(false) +}; + +/***/ }), +/* 47 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var toInteger = __w_pdfjs_require__(48); +var min = Math.min; +module.exports = function (argument) { + return argument > 0 ? min(toInteger(argument), 0x1FFFFFFFFFFFFF) : 0; +}; + +/***/ }), +/* 48 */ +/***/ (function(module, exports) { + +var ceil = Math.ceil; +var floor = Math.floor; +module.exports = function (argument) { + return isNaN(argument = +argument) ? 0 : (argument > 0 ? floor : ceil)(argument); +}; + +/***/ }), +/* 49 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var toInteger = __w_pdfjs_require__(48); +var max = Math.max; +var min = Math.min; +module.exports = function (index, length) { + var integer = toInteger(index); + return integer < 0 ? max(integer + length, 0) : min(integer, length); +}; + +/***/ }), +/* 50 */ +/***/ (function(module, exports) { + +module.exports = [ + 'constructor', + 'hasOwnProperty', + 'isPrototypeOf', + 'propertyIsEnumerable', + 'toLocaleString', + 'toString', + 'valueOf' +]; + +/***/ }), +/* 51 */ +/***/ (function(module, exports) { + +exports.f = Object.getOwnPropertySymbols; + +/***/ }), +/* 52 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var fails = __w_pdfjs_require__(14); +var replacement = /#|\.prototype\./; +var isForced = function (feature, detection) { + var value = data[normalize(feature)]; + return value == POLYFILL ? true : value == NATIVE ? false : typeof detection == 'function' ? fails(detection) : !!detection; +}; +var normalize = isForced.normalize = function (string) { + return String(string).replace(replacement, '.').toLowerCase(); +}; +var data = isForced.data = {}; +var NATIVE = isForced.NATIVE = 'N'; +var POLYFILL = isForced.POLYFILL = 'P'; +module.exports = isForced; + +/***/ }), +/* 53 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +__w_pdfjs_require__(54); +var entryUnbind = __w_pdfjs_require__(61); +module.exports = entryUnbind('String', 'startsWith'); + +/***/ }), +/* 54 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + +var $ = __w_pdfjs_require__(10); +var getOwnPropertyDescriptor = __w_pdfjs_require__(12).f; +var toLength = __w_pdfjs_require__(47); +var notARegExp = __w_pdfjs_require__(55); +var requireObjectCoercible = __w_pdfjs_require__(20); +var correctIsRegExpLogic = __w_pdfjs_require__(60); +var IS_PURE = __w_pdfjs_require__(37); +var nativeStartsWith = ''.startsWith; +var min = Math.min; +var CORRECT_IS_REGEXP_LOGIC = correctIsRegExpLogic('startsWith'); +var MDN_POLYFILL_BUG = !IS_PURE && !CORRECT_IS_REGEXP_LOGIC && !!function () { + var descriptor = getOwnPropertyDescriptor(String.prototype, 'startsWith'); + return descriptor && !descriptor.writable; +}(); +$({ + target: 'String', + proto: true, + forced: !MDN_POLYFILL_BUG && !CORRECT_IS_REGEXP_LOGIC +}, { + startsWith: function startsWith(searchString) { + var that = String(requireObjectCoercible(this)); + notARegExp(searchString); + var index = toLength(min(arguments.length > 1 ? arguments[1] : undefined, that.length)); + var search = String(searchString); + return nativeStartsWith ? nativeStartsWith.call(that, search, index) : that.slice(index, index + search.length) === search; + } +}); + +/***/ }), +/* 55 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var isRegExp = __w_pdfjs_require__(56); +module.exports = function (it) { + if (isRegExp(it)) { + throw TypeError("The method doesn't accept regular expressions"); + } + return it; +}; + +/***/ }), +/* 56 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var isObject = __w_pdfjs_require__(22); +var classof = __w_pdfjs_require__(19); +var wellKnownSymbol = __w_pdfjs_require__(57); +var MATCH = wellKnownSymbol('match'); +module.exports = function (it) { + var isRegExp; + return isObject(it) && ((isRegExp = it[MATCH]) !== undefined ? !!isRegExp : classof(it) == 'RegExp'); +}; + +/***/ }), +/* 57 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var global = __w_pdfjs_require__(11); +var shared = __w_pdfjs_require__(36); +var has = __w_pdfjs_require__(23); +var uid = __w_pdfjs_require__(38); +var NATIVE_SYMBOL = __w_pdfjs_require__(58); +var USE_SYMBOL_AS_UID = __w_pdfjs_require__(59); +var WellKnownSymbolsStore = shared('wks'); +var Symbol = global.Symbol; +var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol : Symbol && Symbol.withoutSetter || uid; +module.exports = function (name) { + if (!has(WellKnownSymbolsStore, name)) { + if (NATIVE_SYMBOL && has(Symbol, name)) + WellKnownSymbolsStore[name] = Symbol[name]; + else + WellKnownSymbolsStore[name] = createWellKnownSymbol('Symbol.' + name); + } + return WellKnownSymbolsStore[name]; +}; + +/***/ }), +/* 58 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var fails = __w_pdfjs_require__(14); +module.exports = !!Object.getOwnPropertySymbols && !fails(function () { + return !String(Symbol()); +}); + +/***/ }), +/* 59 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var NATIVE_SYMBOL = __w_pdfjs_require__(58); +module.exports = NATIVE_SYMBOL && !Symbol.sham && typeof Symbol.iterator == 'symbol'; + +/***/ }), +/* 60 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var wellKnownSymbol = __w_pdfjs_require__(57); +var MATCH = wellKnownSymbol('match'); +module.exports = function (METHOD_NAME) { + var regexp = /./; + try { + '/./'[METHOD_NAME](regexp); + } catch (e) { + try { + regexp[MATCH] = false; + return '/./'[METHOD_NAME](regexp); + } catch (f) { + } + } + return false; +}; + +/***/ }), +/* 61 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var global = __w_pdfjs_require__(11); +var bind = __w_pdfjs_require__(62); +var call = Function.call; +module.exports = function (CONSTRUCTOR, METHOD, length) { + return bind(call, global[CONSTRUCTOR].prototype[METHOD], length); +}; + +/***/ }), +/* 62 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var aFunction = __w_pdfjs_require__(63); +module.exports = function (fn, that, length) { + aFunction(fn); + if (that === undefined) + return fn; + switch (length) { + case 0: + return function () { + return fn.call(that); + }; + case 1: + return function (a) { + return fn.call(that, a); + }; + case 2: + return function (a, b) { + return fn.call(that, a, b); + }; + case 3: + return function (a, b, c) { + return fn.call(that, a, b, c); + }; + } + return function () { + return fn.apply(that, arguments); + }; +}; + +/***/ }), +/* 63 */ +/***/ (function(module, exports) { + +module.exports = function (it) { + if (typeof it != 'function') { + throw TypeError(String(it) + ' is not a function'); + } + return it; +}; + +/***/ }), +/* 64 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +__w_pdfjs_require__(65); +var entryUnbind = __w_pdfjs_require__(61); +module.exports = entryUnbind('String', 'endsWith'); + +/***/ }), +/* 65 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + +var $ = __w_pdfjs_require__(10); +var getOwnPropertyDescriptor = __w_pdfjs_require__(12).f; +var toLength = __w_pdfjs_require__(47); +var notARegExp = __w_pdfjs_require__(55); +var requireObjectCoercible = __w_pdfjs_require__(20); +var correctIsRegExpLogic = __w_pdfjs_require__(60); +var IS_PURE = __w_pdfjs_require__(37); +var nativeEndsWith = ''.endsWith; +var min = Math.min; +var CORRECT_IS_REGEXP_LOGIC = correctIsRegExpLogic('endsWith'); +var MDN_POLYFILL_BUG = !IS_PURE && !CORRECT_IS_REGEXP_LOGIC && !!function () { + var descriptor = getOwnPropertyDescriptor(String.prototype, 'endsWith'); + return descriptor && !descriptor.writable; +}(); +$({ + target: 'String', + proto: true, + forced: !MDN_POLYFILL_BUG && !CORRECT_IS_REGEXP_LOGIC +}, { + endsWith: function endsWith(searchString) { + var that = String(requireObjectCoercible(this)); + notARegExp(searchString); + var endPosition = arguments.length > 1 ? arguments[1] : undefined; + var len = toLength(that.length); + var end = endPosition === undefined ? len : min(toLength(endPosition), len); + var search = String(searchString); + return nativeEndsWith ? nativeEndsWith.call(that, search, end) : that.slice(end - search.length, end) === search; + } +}); + +/***/ }), +/* 66 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +__w_pdfjs_require__(67); +var entryUnbind = __w_pdfjs_require__(61); +module.exports = entryUnbind('String', 'includes'); + +/***/ }), +/* 67 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + +var $ = __w_pdfjs_require__(10); +var notARegExp = __w_pdfjs_require__(55); +var requireObjectCoercible = __w_pdfjs_require__(20); +var correctIsRegExpLogic = __w_pdfjs_require__(60); +$({ + target: 'String', + proto: true, + forced: !correctIsRegExpLogic('includes') +}, { + includes: function includes(searchString) { + return !!~String(requireObjectCoercible(this)).indexOf(notARegExp(searchString), arguments.length > 1 ? arguments[1] : undefined); + } +}); + +/***/ }), +/* 68 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +__w_pdfjs_require__(69); +var entryUnbind = __w_pdfjs_require__(61); +module.exports = entryUnbind('Array', 'includes'); + +/***/ }), +/* 69 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + +var $ = __w_pdfjs_require__(10); +var $includes = __w_pdfjs_require__(46).includes; +var addToUnscopables = __w_pdfjs_require__(70); +var arrayMethodUsesToLength = __w_pdfjs_require__(75); +var USES_TO_LENGTH = arrayMethodUsesToLength('indexOf', { + ACCESSORS: true, + 1: 0 +}); +$({ + target: 'Array', + proto: true, + forced: !USES_TO_LENGTH +}, { + includes: function includes(el) { + return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined); + } +}); +addToUnscopables('includes'); + +/***/ }), +/* 70 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var wellKnownSymbol = __w_pdfjs_require__(57); +var create = __w_pdfjs_require__(71); +var definePropertyModule = __w_pdfjs_require__(27); +var UNSCOPABLES = wellKnownSymbol('unscopables'); +var ArrayPrototype = Array.prototype; +if (ArrayPrototype[UNSCOPABLES] == undefined) { + definePropertyModule.f(ArrayPrototype, UNSCOPABLES, { + configurable: true, + value: create(null) + }); +} +module.exports = function (key) { + ArrayPrototype[UNSCOPABLES][key] = true; +}; + +/***/ }), +/* 71 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var anObject = __w_pdfjs_require__(28); +var defineProperties = __w_pdfjs_require__(72); +var enumBugKeys = __w_pdfjs_require__(50); +var hiddenKeys = __w_pdfjs_require__(39); +var html = __w_pdfjs_require__(74); +var documentCreateElement = __w_pdfjs_require__(25); +var sharedKey = __w_pdfjs_require__(35); +var GT = '>'; +var LT = '<'; +var PROTOTYPE = 'prototype'; +var SCRIPT = 'script'; +var IE_PROTO = sharedKey('IE_PROTO'); +var EmptyConstructor = function () { +}; +var scriptTag = function (content) { + return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT; +}; +var NullProtoObjectViaActiveX = function (activeXDocument) { + activeXDocument.write(scriptTag('')); + activeXDocument.close(); + var temp = activeXDocument.parentWindow.Object; + activeXDocument = null; + return temp; +}; +var NullProtoObjectViaIFrame = function () { + var iframe = documentCreateElement('iframe'); + var JS = 'java' + SCRIPT + ':'; + var iframeDocument; + iframe.style.display = 'none'; + html.appendChild(iframe); + iframe.src = String(JS); + iframeDocument = iframe.contentWindow.document; + iframeDocument.open(); + iframeDocument.write(scriptTag('document.F=Object')); + iframeDocument.close(); + return iframeDocument.F; +}; +var activeXDocument; +var NullProtoObject = function () { + try { + activeXDocument = document.domain && new ActiveXObject('htmlfile'); + } catch (error) { + } + NullProtoObject = activeXDocument ? NullProtoObjectViaActiveX(activeXDocument) : NullProtoObjectViaIFrame(); + var length = enumBugKeys.length; + while (length--) + delete NullProtoObject[PROTOTYPE][enumBugKeys[length]]; + return NullProtoObject(); +}; +hiddenKeys[IE_PROTO] = true; +module.exports = Object.create || function create(O, Properties) { + var result; + if (O !== null) { + EmptyConstructor[PROTOTYPE] = anObject(O); + result = new EmptyConstructor(); + EmptyConstructor[PROTOTYPE] = null; + result[IE_PROTO] = O; + } else + result = NullProtoObject(); + return Properties === undefined ? result : defineProperties(result, Properties); +}; + +/***/ }), +/* 72 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var DESCRIPTORS = __w_pdfjs_require__(13); +var definePropertyModule = __w_pdfjs_require__(27); +var anObject = __w_pdfjs_require__(28); +var objectKeys = __w_pdfjs_require__(73); +module.exports = DESCRIPTORS ? Object.defineProperties : function defineProperties(O, Properties) { + anObject(O); + var keys = objectKeys(Properties); + var length = keys.length; + var index = 0; + var key; + while (length > index) + definePropertyModule.f(O, key = keys[index++], Properties[key]); + return O; +}; + +/***/ }), +/* 73 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var internalObjectKeys = __w_pdfjs_require__(45); +var enumBugKeys = __w_pdfjs_require__(50); +module.exports = Object.keys || function keys(O) { + return internalObjectKeys(O, enumBugKeys); +}; + +/***/ }), +/* 74 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var getBuiltIn = __w_pdfjs_require__(42); +module.exports = getBuiltIn('document', 'documentElement'); + +/***/ }), +/* 75 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var DESCRIPTORS = __w_pdfjs_require__(13); +var fails = __w_pdfjs_require__(14); +var has = __w_pdfjs_require__(23); +var defineProperty = Object.defineProperty; +var cache = {}; +var thrower = function (it) { + throw it; +}; +module.exports = function (METHOD_NAME, options) { + if (has(cache, METHOD_NAME)) + return cache[METHOD_NAME]; + if (!options) + options = {}; + var method = [][METHOD_NAME]; + var ACCESSORS = has(options, 'ACCESSORS') ? options.ACCESSORS : false; + var argument0 = has(options, 0) ? options[0] : thrower; + var argument1 = has(options, 1) ? options[1] : undefined; + return cache[METHOD_NAME] = !!method && !fails(function () { + if (ACCESSORS && !DESCRIPTORS) + return true; + var O = { length: -1 }; + if (ACCESSORS) + defineProperty(O, 1, { + enumerable: true, + get: thrower + }); + else + O[1] = 1; + method.call(O, argument0, argument1); + }); +}; + +/***/ }), +/* 76 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +__w_pdfjs_require__(77); +__w_pdfjs_require__(89); +var path = __w_pdfjs_require__(43); +module.exports = path.Array.from; + +/***/ }), +/* 77 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + +var charAt = __w_pdfjs_require__(78).charAt; +var InternalStateModule = __w_pdfjs_require__(33); +var defineIterator = __w_pdfjs_require__(79); +var STRING_ITERATOR = 'String Iterator'; +var setInternalState = InternalStateModule.set; +var getInternalState = InternalStateModule.getterFor(STRING_ITERATOR); +defineIterator(String, 'String', function (iterated) { + setInternalState(this, { + type: STRING_ITERATOR, + string: String(iterated), + index: 0 + }); +}, function next() { + var state = getInternalState(this); + var string = state.string; + var index = state.index; + var point; + if (index >= string.length) + return { + value: undefined, + done: true + }; + point = charAt(string, index); + state.index += point.length; + return { + value: point, + done: false + }; +}); + +/***/ }), +/* 78 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var toInteger = __w_pdfjs_require__(48); +var requireObjectCoercible = __w_pdfjs_require__(20); +var createMethod = function (CONVERT_TO_STRING) { + return function ($this, pos) { + var S = String(requireObjectCoercible($this)); + var position = toInteger(pos); + var size = S.length; + var first, second; + if (position < 0 || position >= size) + return CONVERT_TO_STRING ? '' : undefined; + first = S.charCodeAt(position); + return first < 0xD800 || first > 0xDBFF || position + 1 === size || (second = S.charCodeAt(position + 1)) < 0xDC00 || second > 0xDFFF ? CONVERT_TO_STRING ? S.charAt(position) : first : CONVERT_TO_STRING ? S.slice(position, position + 2) : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000; + }; +}; +module.exports = { + codeAt: createMethod(false), + charAt: createMethod(true) +}; + +/***/ }), +/* 79 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + +var $ = __w_pdfjs_require__(10); +var createIteratorConstructor = __w_pdfjs_require__(80); +var getPrototypeOf = __w_pdfjs_require__(82); +var setPrototypeOf = __w_pdfjs_require__(87); +var setToStringTag = __w_pdfjs_require__(85); +var createNonEnumerableProperty = __w_pdfjs_require__(26); +var redefine = __w_pdfjs_require__(29); +var wellKnownSymbol = __w_pdfjs_require__(57); +var IS_PURE = __w_pdfjs_require__(37); +var Iterators = __w_pdfjs_require__(86); +var IteratorsCore = __w_pdfjs_require__(81); +var IteratorPrototype = IteratorsCore.IteratorPrototype; +var BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS; +var ITERATOR = wellKnownSymbol('iterator'); +var KEYS = 'keys'; +var VALUES = 'values'; +var ENTRIES = 'entries'; +var returnThis = function () { + return this; +}; +module.exports = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) { + createIteratorConstructor(IteratorConstructor, NAME, next); + var getIterationMethod = function (KIND) { + if (KIND === DEFAULT && defaultIterator) + return defaultIterator; + if (!BUGGY_SAFARI_ITERATORS && KIND in IterablePrototype) + return IterablePrototype[KIND]; + switch (KIND) { + case KEYS: + return function keys() { + return new IteratorConstructor(this, KIND); + }; + case VALUES: + return function values() { + return new IteratorConstructor(this, KIND); + }; + case ENTRIES: + return function entries() { + return new IteratorConstructor(this, KIND); + }; + } + return function () { + return new IteratorConstructor(this); + }; + }; + var TO_STRING_TAG = NAME + ' Iterator'; + var INCORRECT_VALUES_NAME = false; + var IterablePrototype = Iterable.prototype; + var nativeIterator = IterablePrototype[ITERATOR] || IterablePrototype['@@iterator'] || DEFAULT && IterablePrototype[DEFAULT]; + var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT); + var anyNativeIterator = NAME == 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator; + var CurrentIteratorPrototype, methods, KEY; + if (anyNativeIterator) { + CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable())); + if (IteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) { + if (!IS_PURE && getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) { + if (setPrototypeOf) { + setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype); + } else if (typeof CurrentIteratorPrototype[ITERATOR] != 'function') { + createNonEnumerableProperty(CurrentIteratorPrototype, ITERATOR, returnThis); + } + } + setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true, true); + if (IS_PURE) + Iterators[TO_STRING_TAG] = returnThis; + } + } + if (DEFAULT == VALUES && nativeIterator && nativeIterator.name !== VALUES) { + INCORRECT_VALUES_NAME = true; + defaultIterator = function values() { + return nativeIterator.call(this); + }; + } + if ((!IS_PURE || FORCED) && IterablePrototype[ITERATOR] !== defaultIterator) { + createNonEnumerableProperty(IterablePrototype, ITERATOR, defaultIterator); + } + Iterators[NAME] = defaultIterator; + if (DEFAULT) { + methods = { + values: getIterationMethod(VALUES), + keys: IS_SET ? defaultIterator : getIterationMethod(KEYS), + entries: getIterationMethod(ENTRIES) + }; + if (FORCED) + for (KEY in methods) { + if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) { + redefine(IterablePrototype, KEY, methods[KEY]); + } + } + else + $({ + target: NAME, + proto: true, + forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME + }, methods); + } + return methods; +}; + +/***/ }), +/* 80 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + +var IteratorPrototype = __w_pdfjs_require__(81).IteratorPrototype; +var create = __w_pdfjs_require__(71); +var createPropertyDescriptor = __w_pdfjs_require__(16); +var setToStringTag = __w_pdfjs_require__(85); +var Iterators = __w_pdfjs_require__(86); +var returnThis = function () { + return this; +}; +module.exports = function (IteratorConstructor, NAME, next) { + var TO_STRING_TAG = NAME + ' Iterator'; + IteratorConstructor.prototype = create(IteratorPrototype, { next: createPropertyDescriptor(1, next) }); + setToStringTag(IteratorConstructor, TO_STRING_TAG, false, true); + Iterators[TO_STRING_TAG] = returnThis; + return IteratorConstructor; +}; + +/***/ }), +/* 81 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + +var getPrototypeOf = __w_pdfjs_require__(82); +var createNonEnumerableProperty = __w_pdfjs_require__(26); +var has = __w_pdfjs_require__(23); +var wellKnownSymbol = __w_pdfjs_require__(57); +var IS_PURE = __w_pdfjs_require__(37); +var ITERATOR = wellKnownSymbol('iterator'); +var BUGGY_SAFARI_ITERATORS = false; +var returnThis = function () { + return this; +}; +var IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator; +if ([].keys) { + arrayIterator = [].keys(); + if (!('next' in arrayIterator)) + BUGGY_SAFARI_ITERATORS = true; + else { + PrototypeOfArrayIteratorPrototype = getPrototypeOf(getPrototypeOf(arrayIterator)); + if (PrototypeOfArrayIteratorPrototype !== Object.prototype) + IteratorPrototype = PrototypeOfArrayIteratorPrototype; + } +} +if (IteratorPrototype == undefined) + IteratorPrototype = {}; +if (!IS_PURE && !has(IteratorPrototype, ITERATOR)) { + createNonEnumerableProperty(IteratorPrototype, ITERATOR, returnThis); +} +module.exports = { + IteratorPrototype: IteratorPrototype, + BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS +}; + +/***/ }), +/* 82 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var has = __w_pdfjs_require__(23); +var toObject = __w_pdfjs_require__(83); +var sharedKey = __w_pdfjs_require__(35); +var CORRECT_PROTOTYPE_GETTER = __w_pdfjs_require__(84); +var IE_PROTO = sharedKey('IE_PROTO'); +var ObjectPrototype = Object.prototype; +module.exports = CORRECT_PROTOTYPE_GETTER ? Object.getPrototypeOf : function (O) { + O = toObject(O); + if (has(O, IE_PROTO)) + return O[IE_PROTO]; + if (typeof O.constructor == 'function' && O instanceof O.constructor) { + return O.constructor.prototype; + } + return O instanceof Object ? ObjectPrototype : null; +}; + +/***/ }), +/* 83 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var requireObjectCoercible = __w_pdfjs_require__(20); +module.exports = function (argument) { + return Object(requireObjectCoercible(argument)); +}; + +/***/ }), +/* 84 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var fails = __w_pdfjs_require__(14); +module.exports = !fails(function () { + function F() { + } + F.prototype.constructor = null; + return Object.getPrototypeOf(new F()) !== F.prototype; +}); + +/***/ }), +/* 85 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var defineProperty = __w_pdfjs_require__(27).f; +var has = __w_pdfjs_require__(23); +var wellKnownSymbol = __w_pdfjs_require__(57); +var TO_STRING_TAG = wellKnownSymbol('toStringTag'); +module.exports = function (it, TAG, STATIC) { + if (it && !has(it = STATIC ? it : it.prototype, TO_STRING_TAG)) { + defineProperty(it, TO_STRING_TAG, { + configurable: true, + value: TAG + }); + } +}; + +/***/ }), +/* 86 */ +/***/ (function(module, exports) { + +module.exports = {}; + +/***/ }), +/* 87 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var anObject = __w_pdfjs_require__(28); +var aPossiblePrototype = __w_pdfjs_require__(88); +module.exports = Object.setPrototypeOf || ('__proto__' in {} ? function () { + var CORRECT_SETTER = false; + var test = {}; + var setter; + try { + setter = Object.getOwnPropertyDescriptor(Object.prototype, '__proto__').set; + setter.call(test, []); + CORRECT_SETTER = test instanceof Array; + } catch (error) { + } + return function setPrototypeOf(O, proto) { + anObject(O); + aPossiblePrototype(proto); + if (CORRECT_SETTER) + setter.call(O, proto); + else + O.__proto__ = proto; + return O; + }; +}() : undefined); + +/***/ }), +/* 88 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var isObject = __w_pdfjs_require__(22); +module.exports = function (it) { + if (!isObject(it) && it !== null) { + throw TypeError("Can't set " + String(it) + ' as a prototype'); + } + return it; +}; + +/***/ }), +/* 89 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var $ = __w_pdfjs_require__(10); +var from = __w_pdfjs_require__(90); +var checkCorrectnessOfIteration = __w_pdfjs_require__(97); +var INCORRECT_ITERATION = !checkCorrectnessOfIteration(function (iterable) { + Array.from(iterable); +}); +$({ + target: 'Array', + stat: true, + forced: INCORRECT_ITERATION +}, { from: from }); + +/***/ }), +/* 90 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + +var bind = __w_pdfjs_require__(62); +var toObject = __w_pdfjs_require__(83); +var callWithSafeIterationClosing = __w_pdfjs_require__(91); +var isArrayIteratorMethod = __w_pdfjs_require__(92); +var toLength = __w_pdfjs_require__(47); +var createProperty = __w_pdfjs_require__(93); +var getIteratorMethod = __w_pdfjs_require__(94); +module.exports = function from(arrayLike) { + var O = toObject(arrayLike); + var C = typeof this == 'function' ? this : Array; + var argumentsLength = arguments.length; + var mapfn = argumentsLength > 1 ? arguments[1] : undefined; + var mapping = mapfn !== undefined; + var iteratorMethod = getIteratorMethod(O); + var index = 0; + var length, result, step, iterator, next, value; + if (mapping) + mapfn = bind(mapfn, argumentsLength > 2 ? arguments[2] : undefined, 2); + if (iteratorMethod != undefined && !(C == Array && isArrayIteratorMethod(iteratorMethod))) { + iterator = iteratorMethod.call(O); + next = iterator.next; + result = new C(); + for (; !(step = next.call(iterator)).done; index++) { + value = mapping ? callWithSafeIterationClosing(iterator, mapfn, [ + step.value, + index + ], true) : step.value; + createProperty(result, index, value); + } + } else { + length = toLength(O.length); + result = new C(length); + for (; length > index; index++) { + value = mapping ? mapfn(O[index], index) : O[index]; + createProperty(result, index, value); + } + } + result.length = index; + return result; +}; + +/***/ }), +/* 91 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var anObject = __w_pdfjs_require__(28); +module.exports = function (iterator, fn, value, ENTRIES) { + try { + return ENTRIES ? fn(anObject(value)[0], value[1]) : fn(value); + } catch (error) { + var returnMethod = iterator['return']; + if (returnMethod !== undefined) + anObject(returnMethod.call(iterator)); + throw error; + } +}; + +/***/ }), +/* 92 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var wellKnownSymbol = __w_pdfjs_require__(57); +var Iterators = __w_pdfjs_require__(86); +var ITERATOR = wellKnownSymbol('iterator'); +var ArrayPrototype = Array.prototype; +module.exports = function (it) { + return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it); +}; + +/***/ }), +/* 93 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + +var toPrimitive = __w_pdfjs_require__(21); +var definePropertyModule = __w_pdfjs_require__(27); +var createPropertyDescriptor = __w_pdfjs_require__(16); +module.exports = function (object, key, value) { + var propertyKey = toPrimitive(key); + if (propertyKey in object) + definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value)); + else + object[propertyKey] = value; +}; + +/***/ }), +/* 94 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var classof = __w_pdfjs_require__(95); +var Iterators = __w_pdfjs_require__(86); +var wellKnownSymbol = __w_pdfjs_require__(57); +var ITERATOR = wellKnownSymbol('iterator'); +module.exports = function (it) { + if (it != undefined) + return it[ITERATOR] || it['@@iterator'] || Iterators[classof(it)]; +}; + +/***/ }), +/* 95 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var TO_STRING_TAG_SUPPORT = __w_pdfjs_require__(96); +var classofRaw = __w_pdfjs_require__(19); +var wellKnownSymbol = __w_pdfjs_require__(57); +var TO_STRING_TAG = wellKnownSymbol('toStringTag'); +var CORRECT_ARGUMENTS = classofRaw(function () { + return arguments; +}()) == 'Arguments'; +var tryGet = function (it, key) { + try { + return it[key]; + } catch (error) { + } +}; +module.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) { + var O, tag, result; + return it === undefined ? 'Undefined' : it === null ? 'Null' : typeof (tag = tryGet(O = Object(it), TO_STRING_TAG)) == 'string' ? tag : CORRECT_ARGUMENTS ? classofRaw(O) : (result = classofRaw(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : result; +}; + +/***/ }), +/* 96 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var wellKnownSymbol = __w_pdfjs_require__(57); +var TO_STRING_TAG = wellKnownSymbol('toStringTag'); +var test = {}; +test[TO_STRING_TAG] = 'z'; +module.exports = String(test) === '[object z]'; + +/***/ }), +/* 97 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var wellKnownSymbol = __w_pdfjs_require__(57); +var ITERATOR = wellKnownSymbol('iterator'); +var SAFE_CLOSING = false; +try { + var called = 0; + var iteratorWithReturn = { + next: function () { + return { done: !!called++ }; + }, + 'return': function () { + SAFE_CLOSING = true; + } + }; + iteratorWithReturn[ITERATOR] = function () { + return this; + }; + Array.from(iteratorWithReturn, function () { + throw 2; + }); +} catch (error) { +} +module.exports = function (exec, SKIP_CLOSING) { + if (!SKIP_CLOSING && !SAFE_CLOSING) + return false; + var ITERATION_SUPPORT = false; + try { + var object = {}; + object[ITERATOR] = function () { + return { + next: function () { + return { done: ITERATION_SUPPORT = true }; + } + }; + }; + exec(object); + } catch (error) { + } + return ITERATION_SUPPORT; +}; + +/***/ }), +/* 98 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +__w_pdfjs_require__(99); +var path = __w_pdfjs_require__(43); +module.exports = path.Object.assign; + +/***/ }), +/* 99 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var $ = __w_pdfjs_require__(10); +var assign = __w_pdfjs_require__(100); +$({ + target: 'Object', + stat: true, + forced: Object.assign !== assign +}, { assign: assign }); + +/***/ }), +/* 100 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + +var DESCRIPTORS = __w_pdfjs_require__(13); +var fails = __w_pdfjs_require__(14); +var objectKeys = __w_pdfjs_require__(73); +var getOwnPropertySymbolsModule = __w_pdfjs_require__(51); +var propertyIsEnumerableModule = __w_pdfjs_require__(15); +var toObject = __w_pdfjs_require__(83); +var IndexedObject = __w_pdfjs_require__(18); +var nativeAssign = Object.assign; +var defineProperty = Object.defineProperty; +module.exports = !nativeAssign || fails(function () { + if (DESCRIPTORS && nativeAssign({ b: 1 }, nativeAssign(defineProperty({}, 'a', { + enumerable: true, + get: function () { + defineProperty(this, 'b', { + value: 3, + enumerable: false + }); + } + }), { b: 2 })).b !== 1) + return true; + var A = {}; + var B = {}; + var symbol = Symbol(); + var alphabet = 'abcdefghijklmnopqrst'; + A[symbol] = 7; + alphabet.split('').forEach(function (chr) { + B[chr] = chr; + }); + return nativeAssign({}, A)[symbol] != 7 || objectKeys(nativeAssign({}, B)).join('') != alphabet; +}) ? function assign(target, source) { + var T = toObject(target); + var argumentsLength = arguments.length; + var index = 1; + var getOwnPropertySymbols = getOwnPropertySymbolsModule.f; + var propertyIsEnumerable = propertyIsEnumerableModule.f; + while (argumentsLength > index) { + var S = IndexedObject(arguments[index++]); + var keys = getOwnPropertySymbols ? objectKeys(S).concat(getOwnPropertySymbols(S)) : objectKeys(S); + var length = keys.length; + var j = 0; + var key; + while (length > j) { + key = keys[j++]; + if (!DESCRIPTORS || propertyIsEnumerable.call(S, key)) + T[key] = S[key]; + } + } + return T; +} : nativeAssign; + +/***/ }), +/* 101 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +__w_pdfjs_require__(102); +var path = __w_pdfjs_require__(43); +module.exports = path.Math.log2; + +/***/ }), +/* 102 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var $ = __w_pdfjs_require__(10); +var log = Math.log; +var LN2 = Math.LN2; +$({ + target: 'Math', + stat: true +}, { + log2: function log2(x) { + return log(x) / LN2; + } +}); + +/***/ }), +/* 103 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +__w_pdfjs_require__(104); +var path = __w_pdfjs_require__(43); +module.exports = path.Number.isNaN; + +/***/ }), +/* 104 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var $ = __w_pdfjs_require__(10); +$({ + target: 'Number', + stat: true +}, { + isNaN: function isNaN(number) { + return number != number; + } +}); + +/***/ }), +/* 105 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +__w_pdfjs_require__(106); +var path = __w_pdfjs_require__(43); +module.exports = path.Number.isInteger; + +/***/ }), +/* 106 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var $ = __w_pdfjs_require__(10); +var isInteger = __w_pdfjs_require__(107); +$({ + target: 'Number', + stat: true +}, { isInteger: isInteger }); + +/***/ }), +/* 107 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var isObject = __w_pdfjs_require__(22); +var floor = Math.floor; +module.exports = function isInteger(it) { + return !isObject(it) && isFinite(it) && floor(it) === it; +}; + +/***/ }), +/* 108 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +__w_pdfjs_require__(109); + +/***/ }), +/* 109 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + +var ArrayBufferViewCore = __w_pdfjs_require__(110); +var speciesConstructor = __w_pdfjs_require__(112); +var fails = __w_pdfjs_require__(14); +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var aTypedArrayConstructor = ArrayBufferViewCore.aTypedArrayConstructor; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; +var $slice = [].slice; +var FORCED = fails(function () { + new Int8Array(1).slice(); +}); +exportTypedArrayMethod('slice', function slice(start, end) { + var list = $slice.call(aTypedArray(this), start, end); + var C = speciesConstructor(this, this.constructor); + var index = 0; + var length = list.length; + var result = new (aTypedArrayConstructor(C))(length); + while (length > index) + result[index] = list[index++]; + return result; +}, FORCED); + +/***/ }), +/* 110 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + +var NATIVE_ARRAY_BUFFER = __w_pdfjs_require__(111); +var DESCRIPTORS = __w_pdfjs_require__(13); +var global = __w_pdfjs_require__(11); +var isObject = __w_pdfjs_require__(22); +var has = __w_pdfjs_require__(23); +var classof = __w_pdfjs_require__(95); +var createNonEnumerableProperty = __w_pdfjs_require__(26); +var redefine = __w_pdfjs_require__(29); +var defineProperty = __w_pdfjs_require__(27).f; +var getPrototypeOf = __w_pdfjs_require__(82); +var setPrototypeOf = __w_pdfjs_require__(87); +var wellKnownSymbol = __w_pdfjs_require__(57); +var uid = __w_pdfjs_require__(38); +var Int8Array = global.Int8Array; +var Int8ArrayPrototype = Int8Array && Int8Array.prototype; +var Uint8ClampedArray = global.Uint8ClampedArray; +var Uint8ClampedArrayPrototype = Uint8ClampedArray && Uint8ClampedArray.prototype; +var TypedArray = Int8Array && getPrototypeOf(Int8Array); +var TypedArrayPrototype = Int8ArrayPrototype && getPrototypeOf(Int8ArrayPrototype); +var ObjectPrototype = Object.prototype; +var isPrototypeOf = ObjectPrototype.isPrototypeOf; +var TO_STRING_TAG = wellKnownSymbol('toStringTag'); +var TYPED_ARRAY_TAG = uid('TYPED_ARRAY_TAG'); +var NATIVE_ARRAY_BUFFER_VIEWS = NATIVE_ARRAY_BUFFER && !!setPrototypeOf && classof(global.opera) !== 'Opera'; +var TYPED_ARRAY_TAG_REQIRED = false; +var NAME; +var TypedArrayConstructorsList = { + Int8Array: 1, + Uint8Array: 1, + Uint8ClampedArray: 1, + Int16Array: 2, + Uint16Array: 2, + Int32Array: 4, + Uint32Array: 4, + Float32Array: 4, + Float64Array: 8 +}; +var isView = function isView(it) { + var klass = classof(it); + return klass === 'DataView' || has(TypedArrayConstructorsList, klass); +}; +var isTypedArray = function (it) { + return isObject(it) && has(TypedArrayConstructorsList, classof(it)); +}; +var aTypedArray = function (it) { + if (isTypedArray(it)) + return it; + throw TypeError('Target is not a typed array'); +}; +var aTypedArrayConstructor = function (C) { + if (setPrototypeOf) { + if (isPrototypeOf.call(TypedArray, C)) + return C; + } else + for (var ARRAY in TypedArrayConstructorsList) + if (has(TypedArrayConstructorsList, NAME)) { + var TypedArrayConstructor = global[ARRAY]; + if (TypedArrayConstructor && (C === TypedArrayConstructor || isPrototypeOf.call(TypedArrayConstructor, C))) { + return C; + } + } + throw TypeError('Target is not a typed array constructor'); +}; +var exportTypedArrayMethod = function (KEY, property, forced) { + if (!DESCRIPTORS) + return; + if (forced) + for (var ARRAY in TypedArrayConstructorsList) { + var TypedArrayConstructor = global[ARRAY]; + if (TypedArrayConstructor && has(TypedArrayConstructor.prototype, KEY)) { + delete TypedArrayConstructor.prototype[KEY]; + } + } + if (!TypedArrayPrototype[KEY] || forced) { + redefine(TypedArrayPrototype, KEY, forced ? property : NATIVE_ARRAY_BUFFER_VIEWS && Int8ArrayPrototype[KEY] || property); + } +}; +var exportTypedArrayStaticMethod = function (KEY, property, forced) { + var ARRAY, TypedArrayConstructor; + if (!DESCRIPTORS) + return; + if (setPrototypeOf) { + if (forced) + for (ARRAY in TypedArrayConstructorsList) { + TypedArrayConstructor = global[ARRAY]; + if (TypedArrayConstructor && has(TypedArrayConstructor, KEY)) { + delete TypedArrayConstructor[KEY]; + } + } + if (!TypedArray[KEY] || forced) { + try { + return redefine(TypedArray, KEY, forced ? property : NATIVE_ARRAY_BUFFER_VIEWS && Int8Array[KEY] || property); + } catch (error) { + } + } else + return; + } + for (ARRAY in TypedArrayConstructorsList) { + TypedArrayConstructor = global[ARRAY]; + if (TypedArrayConstructor && (!TypedArrayConstructor[KEY] || forced)) { + redefine(TypedArrayConstructor, KEY, property); + } + } +}; +for (NAME in TypedArrayConstructorsList) { + if (!global[NAME]) + NATIVE_ARRAY_BUFFER_VIEWS = false; +} +if (!NATIVE_ARRAY_BUFFER_VIEWS || typeof TypedArray != 'function' || TypedArray === Function.prototype) { + TypedArray = function TypedArray() { + throw TypeError('Incorrect invocation'); + }; + if (NATIVE_ARRAY_BUFFER_VIEWS) + for (NAME in TypedArrayConstructorsList) { + if (global[NAME]) + setPrototypeOf(global[NAME], TypedArray); + } +} +if (!NATIVE_ARRAY_BUFFER_VIEWS || !TypedArrayPrototype || TypedArrayPrototype === ObjectPrototype) { + TypedArrayPrototype = TypedArray.prototype; + if (NATIVE_ARRAY_BUFFER_VIEWS) + for (NAME in TypedArrayConstructorsList) { + if (global[NAME]) + setPrototypeOf(global[NAME].prototype, TypedArrayPrototype); + } +} +if (NATIVE_ARRAY_BUFFER_VIEWS && getPrototypeOf(Uint8ClampedArrayPrototype) !== TypedArrayPrototype) { + setPrototypeOf(Uint8ClampedArrayPrototype, TypedArrayPrototype); +} +if (DESCRIPTORS && !has(TypedArrayPrototype, TO_STRING_TAG)) { + TYPED_ARRAY_TAG_REQIRED = true; + defineProperty(TypedArrayPrototype, TO_STRING_TAG, { + get: function () { + return isObject(this) ? this[TYPED_ARRAY_TAG] : undefined; + } + }); + for (NAME in TypedArrayConstructorsList) + if (global[NAME]) { + createNonEnumerableProperty(global[NAME], TYPED_ARRAY_TAG, NAME); + } +} +module.exports = { + NATIVE_ARRAY_BUFFER_VIEWS: NATIVE_ARRAY_BUFFER_VIEWS, + TYPED_ARRAY_TAG: TYPED_ARRAY_TAG_REQIRED && TYPED_ARRAY_TAG, + aTypedArray: aTypedArray, + aTypedArrayConstructor: aTypedArrayConstructor, + exportTypedArrayMethod: exportTypedArrayMethod, + exportTypedArrayStaticMethod: exportTypedArrayStaticMethod, + isView: isView, + isTypedArray: isTypedArray, + TypedArray: TypedArray, + TypedArrayPrototype: TypedArrayPrototype +}; + +/***/ }), +/* 111 */ +/***/ (function(module, exports) { + +module.exports = typeof ArrayBuffer !== 'undefined' && typeof DataView !== 'undefined'; + +/***/ }), +/* 112 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var anObject = __w_pdfjs_require__(28); +var aFunction = __w_pdfjs_require__(63); +var wellKnownSymbol = __w_pdfjs_require__(57); +var SPECIES = wellKnownSymbol('species'); +module.exports = function (O, defaultConstructor) { + var C = anObject(O).constructor; + var S; + return C === undefined || (S = anObject(C)[SPECIES]) == undefined ? defaultConstructor : aFunction(S); +}; + +/***/ }), +/* 113 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +__w_pdfjs_require__(114); +__w_pdfjs_require__(77); +__w_pdfjs_require__(116); +__w_pdfjs_require__(119); +__w_pdfjs_require__(134); +__w_pdfjs_require__(135); +var path = __w_pdfjs_require__(43); +module.exports = path.Promise; + +/***/ }), +/* 114 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var TO_STRING_TAG_SUPPORT = __w_pdfjs_require__(96); +var redefine = __w_pdfjs_require__(29); +var toString = __w_pdfjs_require__(115); +if (!TO_STRING_TAG_SUPPORT) { + redefine(Object.prototype, 'toString', toString, { unsafe: true }); +} + +/***/ }), +/* 115 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + +var TO_STRING_TAG_SUPPORT = __w_pdfjs_require__(96); +var classof = __w_pdfjs_require__(95); +module.exports = TO_STRING_TAG_SUPPORT ? {}.toString : function toString() { + return '[object ' + classof(this) + ']'; +}; + +/***/ }), +/* 116 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var global = __w_pdfjs_require__(11); +var DOMIterables = __w_pdfjs_require__(117); +var ArrayIteratorMethods = __w_pdfjs_require__(118); +var createNonEnumerableProperty = __w_pdfjs_require__(26); +var wellKnownSymbol = __w_pdfjs_require__(57); +var ITERATOR = wellKnownSymbol('iterator'); +var TO_STRING_TAG = wellKnownSymbol('toStringTag'); +var ArrayValues = ArrayIteratorMethods.values; +for (var COLLECTION_NAME in DOMIterables) { + var Collection = global[COLLECTION_NAME]; + var CollectionPrototype = Collection && Collection.prototype; + if (CollectionPrototype) { + if (CollectionPrototype[ITERATOR] !== ArrayValues) + try { + createNonEnumerableProperty(CollectionPrototype, ITERATOR, ArrayValues); + } catch (error) { + CollectionPrototype[ITERATOR] = ArrayValues; + } + if (!CollectionPrototype[TO_STRING_TAG]) { + createNonEnumerableProperty(CollectionPrototype, TO_STRING_TAG, COLLECTION_NAME); + } + if (DOMIterables[COLLECTION_NAME]) + for (var METHOD_NAME in ArrayIteratorMethods) { + if (CollectionPrototype[METHOD_NAME] !== ArrayIteratorMethods[METHOD_NAME]) + try { + createNonEnumerableProperty(CollectionPrototype, METHOD_NAME, ArrayIteratorMethods[METHOD_NAME]); + } catch (error) { + CollectionPrototype[METHOD_NAME] = ArrayIteratorMethods[METHOD_NAME]; + } + } + } +} + +/***/ }), +/* 117 */ +/***/ (function(module, exports) { + +module.exports = { + CSSRuleList: 0, + CSSStyleDeclaration: 0, + CSSValueList: 0, + ClientRectList: 0, + DOMRectList: 0, + DOMStringList: 0, + DOMTokenList: 1, + DataTransferItemList: 0, + FileList: 0, + HTMLAllCollection: 0, + HTMLCollection: 0, + HTMLFormElement: 0, + HTMLSelectElement: 0, + MediaList: 0, + MimeTypeArray: 0, + NamedNodeMap: 0, + NodeList: 1, + PaintRequestList: 0, + Plugin: 0, + PluginArray: 0, + SVGLengthList: 0, + SVGNumberList: 0, + SVGPathSegList: 0, + SVGPointList: 0, + SVGStringList: 0, + SVGTransformList: 0, + SourceBufferList: 0, + StyleSheetList: 0, + TextTrackCueList: 0, + TextTrackList: 0, + TouchList: 0 +}; + +/***/ }), +/* 118 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + +var toIndexedObject = __w_pdfjs_require__(17); +var addToUnscopables = __w_pdfjs_require__(70); +var Iterators = __w_pdfjs_require__(86); +var InternalStateModule = __w_pdfjs_require__(33); +var defineIterator = __w_pdfjs_require__(79); +var ARRAY_ITERATOR = 'Array Iterator'; +var setInternalState = InternalStateModule.set; +var getInternalState = InternalStateModule.getterFor(ARRAY_ITERATOR); +module.exports = defineIterator(Array, 'Array', function (iterated, kind) { + setInternalState(this, { + type: ARRAY_ITERATOR, + target: toIndexedObject(iterated), + index: 0, + kind: kind + }); +}, function () { + var state = getInternalState(this); + var target = state.target; + var kind = state.kind; + var index = state.index++; + if (!target || index >= target.length) { + state.target = undefined; + return { + value: undefined, + done: true + }; + } + if (kind == 'keys') + return { + value: index, + done: false + }; + if (kind == 'values') + return { + value: target[index], + done: false + }; + return { + value: [ + index, + target[index] + ], + done: false + }; +}, 'values'); +Iterators.Arguments = Iterators.Array; +addToUnscopables('keys'); +addToUnscopables('values'); +addToUnscopables('entries'); + +/***/ }), +/* 119 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + +var $ = __w_pdfjs_require__(10); +var IS_PURE = __w_pdfjs_require__(37); +var global = __w_pdfjs_require__(11); +var getBuiltIn = __w_pdfjs_require__(42); +var NativePromise = __w_pdfjs_require__(120); +var redefine = __w_pdfjs_require__(29); +var redefineAll = __w_pdfjs_require__(121); +var setToStringTag = __w_pdfjs_require__(85); +var setSpecies = __w_pdfjs_require__(122); +var isObject = __w_pdfjs_require__(22); +var aFunction = __w_pdfjs_require__(63); +var anInstance = __w_pdfjs_require__(123); +var classof = __w_pdfjs_require__(19); +var inspectSource = __w_pdfjs_require__(31); +var iterate = __w_pdfjs_require__(124); +var checkCorrectnessOfIteration = __w_pdfjs_require__(97); +var speciesConstructor = __w_pdfjs_require__(112); +var task = __w_pdfjs_require__(125).set; +var microtask = __w_pdfjs_require__(128); +var promiseResolve = __w_pdfjs_require__(129); +var hostReportErrors = __w_pdfjs_require__(131); +var newPromiseCapabilityModule = __w_pdfjs_require__(130); +var perform = __w_pdfjs_require__(132); +var InternalStateModule = __w_pdfjs_require__(33); +var isForced = __w_pdfjs_require__(52); +var wellKnownSymbol = __w_pdfjs_require__(57); +var V8_VERSION = __w_pdfjs_require__(133); +var SPECIES = wellKnownSymbol('species'); +var PROMISE = 'Promise'; +var getInternalState = InternalStateModule.get; +var setInternalState = InternalStateModule.set; +var getInternalPromiseState = InternalStateModule.getterFor(PROMISE); +var PromiseConstructor = NativePromise; +var TypeError = global.TypeError; +var document = global.document; +var process = global.process; +var $fetch = getBuiltIn('fetch'); +var newPromiseCapability = newPromiseCapabilityModule.f; +var newGenericPromiseCapability = newPromiseCapability; +var IS_NODE = classof(process) == 'process'; +var DISPATCH_EVENT = !!(document && document.createEvent && global.dispatchEvent); +var UNHANDLED_REJECTION = 'unhandledrejection'; +var REJECTION_HANDLED = 'rejectionhandled'; +var PENDING = 0; +var FULFILLED = 1; +var REJECTED = 2; +var HANDLED = 1; +var UNHANDLED = 2; +var Internal, OwnPromiseCapability, PromiseWrapper, nativeThen; +var FORCED = isForced(PROMISE, function () { + var GLOBAL_CORE_JS_PROMISE = inspectSource(PromiseConstructor) !== String(PromiseConstructor); + if (!GLOBAL_CORE_JS_PROMISE) { + if (V8_VERSION === 66) + return true; + if (!IS_NODE && typeof PromiseRejectionEvent != 'function') + return true; + } + if (IS_PURE && !PromiseConstructor.prototype['finally']) + return true; + if (V8_VERSION >= 51 && /native code/.test(PromiseConstructor)) + return false; + var promise = PromiseConstructor.resolve(1); + var FakePromise = function (exec) { + exec(function () { + }, function () { + }); + }; + var constructor = promise.constructor = {}; + constructor[SPECIES] = FakePromise; + return !(promise.then(function () { + }) instanceof FakePromise); +}); +var INCORRECT_ITERATION = FORCED || !checkCorrectnessOfIteration(function (iterable) { + PromiseConstructor.all(iterable)['catch'](function () { + }); +}); +var isThenable = function (it) { + var then; + return isObject(it) && typeof (then = it.then) == 'function' ? then : false; +}; +var notify = function (promise, state, isReject) { + if (state.notified) + return; + state.notified = true; + var chain = state.reactions; + microtask(function () { + var value = state.value; + var ok = state.state == FULFILLED; + var index = 0; + while (chain.length > index) { + var reaction = chain[index++]; + var handler = ok ? reaction.ok : reaction.fail; + var resolve = reaction.resolve; + var reject = reaction.reject; + var domain = reaction.domain; + var result, then, exited; + try { + if (handler) { + if (!ok) { + if (state.rejection === UNHANDLED) + onHandleUnhandled(promise, state); + state.rejection = HANDLED; + } + if (handler === true) + result = value; + else { + if (domain) + domain.enter(); + result = handler(value); + if (domain) { + domain.exit(); + exited = true; + } + } + if (result === reaction.promise) { + reject(TypeError('Promise-chain cycle')); + } else if (then = isThenable(result)) { + then.call(result, resolve, reject); + } else + resolve(result); + } else + reject(value); + } catch (error) { + if (domain && !exited) + domain.exit(); + reject(error); + } + } + state.reactions = []; + state.notified = false; + if (isReject && !state.rejection) + onUnhandled(promise, state); + }); +}; +var dispatchEvent = function (name, promise, reason) { + var event, handler; + if (DISPATCH_EVENT) { + event = document.createEvent('Event'); + event.promise = promise; + event.reason = reason; + event.initEvent(name, false, true); + global.dispatchEvent(event); + } else + event = { + promise: promise, + reason: reason + }; + if (handler = global['on' + name]) + handler(event); + else if (name === UNHANDLED_REJECTION) + hostReportErrors('Unhandled promise rejection', reason); +}; +var onUnhandled = function (promise, state) { + task.call(global, function () { + var value = state.value; + var IS_UNHANDLED = isUnhandled(state); + var result; + if (IS_UNHANDLED) { + result = perform(function () { + if (IS_NODE) { + process.emit('unhandledRejection', value, promise); + } else + dispatchEvent(UNHANDLED_REJECTION, promise, value); + }); + state.rejection = IS_NODE || isUnhandled(state) ? UNHANDLED : HANDLED; + if (result.error) + throw result.value; + } + }); +}; +var isUnhandled = function (state) { + return state.rejection !== HANDLED && !state.parent; +}; +var onHandleUnhandled = function (promise, state) { + task.call(global, function () { + if (IS_NODE) { + process.emit('rejectionHandled', promise); + } else + dispatchEvent(REJECTION_HANDLED, promise, state.value); + }); +}; +var bind = function (fn, promise, state, unwrap) { + return function (value) { + fn(promise, state, value, unwrap); + }; +}; +var internalReject = function (promise, state, value, unwrap) { + if (state.done) + return; + state.done = true; + if (unwrap) + state = unwrap; + state.value = value; + state.state = REJECTED; + notify(promise, state, true); +}; +var internalResolve = function (promise, state, value, unwrap) { + if (state.done) + return; + state.done = true; + if (unwrap) + state = unwrap; + try { + if (promise === value) + throw TypeError("Promise can't be resolved itself"); + var then = isThenable(value); + if (then) { + microtask(function () { + var wrapper = { done: false }; + try { + then.call(value, bind(internalResolve, promise, wrapper, state), bind(internalReject, promise, wrapper, state)); + } catch (error) { + internalReject(promise, wrapper, error, state); + } + }); + } else { + state.value = value; + state.state = FULFILLED; + notify(promise, state, false); + } + } catch (error) { + internalReject(promise, { done: false }, error, state); + } +}; +if (FORCED) { + PromiseConstructor = function Promise(executor) { + anInstance(this, PromiseConstructor, PROMISE); + aFunction(executor); + Internal.call(this); + var state = getInternalState(this); + try { + executor(bind(internalResolve, this, state), bind(internalReject, this, state)); + } catch (error) { + internalReject(this, state, error); + } + }; + Internal = function Promise(executor) { + setInternalState(this, { + type: PROMISE, + done: false, + notified: false, + parent: false, + reactions: [], + rejection: false, + state: PENDING, + value: undefined + }); + }; + Internal.prototype = redefineAll(PromiseConstructor.prototype, { + then: function then(onFulfilled, onRejected) { + var state = getInternalPromiseState(this); + var reaction = newPromiseCapability(speciesConstructor(this, PromiseConstructor)); + reaction.ok = typeof onFulfilled == 'function' ? onFulfilled : true; + reaction.fail = typeof onRejected == 'function' && onRejected; + reaction.domain = IS_NODE ? process.domain : undefined; + state.parent = true; + state.reactions.push(reaction); + if (state.state != PENDING) + notify(this, state, false); + return reaction.promise; + }, + 'catch': function (onRejected) { + return this.then(undefined, onRejected); + } + }); + OwnPromiseCapability = function () { + var promise = new Internal(); + var state = getInternalState(promise); + this.promise = promise; + this.resolve = bind(internalResolve, promise, state); + this.reject = bind(internalReject, promise, state); + }; + newPromiseCapabilityModule.f = newPromiseCapability = function (C) { + return C === PromiseConstructor || C === PromiseWrapper ? new OwnPromiseCapability(C) : newGenericPromiseCapability(C); + }; + if (!IS_PURE && typeof NativePromise == 'function') { + nativeThen = NativePromise.prototype.then; + redefine(NativePromise.prototype, 'then', function then(onFulfilled, onRejected) { + var that = this; + return new PromiseConstructor(function (resolve, reject) { + nativeThen.call(that, resolve, reject); + }).then(onFulfilled, onRejected); + }, { unsafe: true }); + if (typeof $fetch == 'function') + $({ + global: true, + enumerable: true, + forced: true + }, { + fetch: function fetch(input) { + return promiseResolve(PromiseConstructor, $fetch.apply(global, arguments)); + } + }); + } +} +$({ + global: true, + wrap: true, + forced: FORCED +}, { Promise: PromiseConstructor }); +setToStringTag(PromiseConstructor, PROMISE, false, true); +setSpecies(PROMISE); +PromiseWrapper = getBuiltIn(PROMISE); +$({ + target: PROMISE, + stat: true, + forced: FORCED +}, { + reject: function reject(r) { + var capability = newPromiseCapability(this); + capability.reject.call(undefined, r); + return capability.promise; + } +}); +$({ + target: PROMISE, + stat: true, + forced: IS_PURE || FORCED +}, { + resolve: function resolve(x) { + return promiseResolve(IS_PURE && this === PromiseWrapper ? PromiseConstructor : this, x); + } +}); +$({ + target: PROMISE, + stat: true, + forced: INCORRECT_ITERATION +}, { + all: function all(iterable) { + var C = this; + var capability = newPromiseCapability(C); + var resolve = capability.resolve; + var reject = capability.reject; + var result = perform(function () { + var $promiseResolve = aFunction(C.resolve); + var values = []; + var counter = 0; + var remaining = 1; + iterate(iterable, function (promise) { + var index = counter++; + var alreadyCalled = false; + values.push(undefined); + remaining++; + $promiseResolve.call(C, promise).then(function (value) { + if (alreadyCalled) + return; + alreadyCalled = true; + values[index] = value; + --remaining || resolve(values); + }, reject); + }); + --remaining || resolve(values); + }); + if (result.error) + reject(result.value); + return capability.promise; + }, + race: function race(iterable) { + var C = this; + var capability = newPromiseCapability(C); + var reject = capability.reject; + var result = perform(function () { + var $promiseResolve = aFunction(C.resolve); + iterate(iterable, function (promise) { + $promiseResolve.call(C, promise).then(capability.resolve, reject); + }); + }); + if (result.error) + reject(result.value); + return capability.promise; + } +}); + +/***/ }), +/* 120 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var global = __w_pdfjs_require__(11); +module.exports = global.Promise; + +/***/ }), +/* 121 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var redefine = __w_pdfjs_require__(29); +module.exports = function (target, src, options) { + for (var key in src) + redefine(target, key, src[key], options); + return target; +}; + +/***/ }), +/* 122 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + +var getBuiltIn = __w_pdfjs_require__(42); +var definePropertyModule = __w_pdfjs_require__(27); +var wellKnownSymbol = __w_pdfjs_require__(57); +var DESCRIPTORS = __w_pdfjs_require__(13); +var SPECIES = wellKnownSymbol('species'); +module.exports = function (CONSTRUCTOR_NAME) { + var Constructor = getBuiltIn(CONSTRUCTOR_NAME); + var defineProperty = definePropertyModule.f; + if (DESCRIPTORS && Constructor && !Constructor[SPECIES]) { + defineProperty(Constructor, SPECIES, { + configurable: true, + get: function () { + return this; + } + }); + } +}; + +/***/ }), +/* 123 */ +/***/ (function(module, exports) { + +module.exports = function (it, Constructor, name) { + if (!(it instanceof Constructor)) { + throw TypeError('Incorrect ' + (name ? name + ' ' : '') + 'invocation'); + } + return it; +}; + +/***/ }), +/* 124 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var anObject = __w_pdfjs_require__(28); +var isArrayIteratorMethod = __w_pdfjs_require__(92); +var toLength = __w_pdfjs_require__(47); +var bind = __w_pdfjs_require__(62); +var getIteratorMethod = __w_pdfjs_require__(94); +var callWithSafeIterationClosing = __w_pdfjs_require__(91); +var Result = function (stopped, result) { + this.stopped = stopped; + this.result = result; +}; +var iterate = module.exports = function (iterable, fn, that, AS_ENTRIES, IS_ITERATOR) { + var boundFunction = bind(fn, that, AS_ENTRIES ? 2 : 1); + var iterator, iterFn, index, length, result, next, step; + if (IS_ITERATOR) { + iterator = iterable; + } else { + iterFn = getIteratorMethod(iterable); + if (typeof iterFn != 'function') + throw TypeError('Target is not iterable'); + if (isArrayIteratorMethod(iterFn)) { + for (index = 0, length = toLength(iterable.length); length > index; index++) { + result = AS_ENTRIES ? boundFunction(anObject(step = iterable[index])[0], step[1]) : boundFunction(iterable[index]); + if (result && result instanceof Result) + return result; + } + return new Result(false); + } + iterator = iterFn.call(iterable); + } + next = iterator.next; + while (!(step = next.call(iterator)).done) { + result = callWithSafeIterationClosing(iterator, boundFunction, step.value, AS_ENTRIES); + if (typeof result == 'object' && result && result instanceof Result) + return result; + } + return new Result(false); +}; +iterate.stop = function (result) { + return new Result(true, result); +}; + +/***/ }), +/* 125 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var global = __w_pdfjs_require__(11); +var fails = __w_pdfjs_require__(14); +var classof = __w_pdfjs_require__(19); +var bind = __w_pdfjs_require__(62); +var html = __w_pdfjs_require__(74); +var createElement = __w_pdfjs_require__(25); +var IS_IOS = __w_pdfjs_require__(126); +var location = global.location; +var set = global.setImmediate; +var clear = global.clearImmediate; +var process = global.process; +var MessageChannel = global.MessageChannel; +var Dispatch = global.Dispatch; +var counter = 0; +var queue = {}; +var ONREADYSTATECHANGE = 'onreadystatechange'; +var defer, channel, port; +var run = function (id) { + if (queue.hasOwnProperty(id)) { + var fn = queue[id]; + delete queue[id]; + fn(); + } +}; +var runner = function (id) { + return function () { + run(id); + }; +}; +var listener = function (event) { + run(event.data); +}; +var post = function (id) { + global.postMessage(id + '', location.protocol + '//' + location.host); +}; +if (!set || !clear) { + set = function setImmediate(fn) { + var args = []; + var i = 1; + while (arguments.length > i) + args.push(arguments[i++]); + queue[++counter] = function () { + (typeof fn == 'function' ? fn : Function(fn)).apply(undefined, args); + }; + defer(counter); + return counter; + }; + clear = function clearImmediate(id) { + delete queue[id]; + }; + if (classof(process) == 'process') { + defer = function (id) { + process.nextTick(runner(id)); + }; + } else if (Dispatch && Dispatch.now) { + defer = function (id) { + Dispatch.now(runner(id)); + }; + } else if (MessageChannel && !IS_IOS) { + channel = new MessageChannel(); + port = channel.port2; + channel.port1.onmessage = listener; + defer = bind(port.postMessage, port, 1); + } else if (global.addEventListener && typeof postMessage == 'function' && !global.importScripts && !fails(post) && location.protocol !== 'file:') { + defer = post; + global.addEventListener('message', listener, false); + } else if (ONREADYSTATECHANGE in createElement('script')) { + defer = function (id) { + html.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () { + html.removeChild(this); + run(id); + }; + }; + } else { + defer = function (id) { + setTimeout(runner(id), 0); + }; + } +} +module.exports = { + set: set, + clear: clear +}; + +/***/ }), +/* 126 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var userAgent = __w_pdfjs_require__(127); +module.exports = /(iphone|ipod|ipad).*applewebkit/i.test(userAgent); + +/***/ }), +/* 127 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var getBuiltIn = __w_pdfjs_require__(42); +module.exports = getBuiltIn('navigator', 'userAgent') || ''; + +/***/ }), +/* 128 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var global = __w_pdfjs_require__(11); +var getOwnPropertyDescriptor = __w_pdfjs_require__(12).f; +var classof = __w_pdfjs_require__(19); +var macrotask = __w_pdfjs_require__(125).set; +var IS_IOS = __w_pdfjs_require__(126); +var MutationObserver = global.MutationObserver || global.WebKitMutationObserver; +var process = global.process; +var Promise = global.Promise; +var IS_NODE = classof(process) == 'process'; +var queueMicrotaskDescriptor = getOwnPropertyDescriptor(global, 'queueMicrotask'); +var queueMicrotask = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value; +var flush, head, last, notify, toggle, node, promise, then; +if (!queueMicrotask) { + flush = function () { + var parent, fn; + if (IS_NODE && (parent = process.domain)) + parent.exit(); + while (head) { + fn = head.fn; + head = head.next; + try { + fn(); + } catch (error) { + if (head) + notify(); + else + last = undefined; + throw error; + } + } + last = undefined; + if (parent) + parent.enter(); + }; + if (IS_NODE) { + notify = function () { + process.nextTick(flush); + }; + } else if (MutationObserver && !IS_IOS) { + toggle = true; + node = document.createTextNode(''); + new MutationObserver(flush).observe(node, { characterData: true }); + notify = function () { + node.data = toggle = !toggle; + }; + } else if (Promise && Promise.resolve) { + promise = Promise.resolve(undefined); + then = promise.then; + notify = function () { + then.call(promise, flush); + }; + } else { + notify = function () { + macrotask.call(global, flush); + }; + } +} +module.exports = queueMicrotask || function (fn) { + var task = { + fn: fn, + next: undefined + }; + if (last) + last.next = task; + if (!head) { + head = task; + notify(); + } + last = task; +}; + +/***/ }), +/* 129 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var anObject = __w_pdfjs_require__(28); +var isObject = __w_pdfjs_require__(22); +var newPromiseCapability = __w_pdfjs_require__(130); +module.exports = function (C, x) { + anObject(C); + if (isObject(x) && x.constructor === C) + return x; + var promiseCapability = newPromiseCapability.f(C); + var resolve = promiseCapability.resolve; + resolve(x); + return promiseCapability.promise; +}; + +/***/ }), +/* 130 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + +var aFunction = __w_pdfjs_require__(63); +var PromiseCapability = function (C) { + var resolve, reject; + this.promise = new C(function ($$resolve, $$reject) { + if (resolve !== undefined || reject !== undefined) + throw TypeError('Bad Promise constructor'); + resolve = $$resolve; + reject = $$reject; + }); + this.resolve = aFunction(resolve); + this.reject = aFunction(reject); +}; +module.exports.f = function (C) { + return new PromiseCapability(C); +}; + +/***/ }), +/* 131 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var global = __w_pdfjs_require__(11); +module.exports = function (a, b) { + var console = global.console; + if (console && console.error) { + arguments.length === 1 ? console.error(a) : console.error(a, b); + } +}; + +/***/ }), +/* 132 */ +/***/ (function(module, exports) { + +module.exports = function (exec) { + try { + return { + error: false, + value: exec() + }; + } catch (error) { + return { + error: true, + value: error + }; + } +}; + +/***/ }), +/* 133 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var global = __w_pdfjs_require__(11); +var userAgent = __w_pdfjs_require__(127); +var process = global.process; +var versions = process && process.versions; +var v8 = versions && versions.v8; +var match, version; +if (v8) { + match = v8.split('.'); + version = match[0] + match[1]; +} else if (userAgent) { + match = userAgent.match(/Edge\/(\d+)/); + if (!match || match[1] >= 74) { + match = userAgent.match(/Chrome\/(\d+)/); + if (match) + version = match[1]; + } +} +module.exports = version && +version; + +/***/ }), +/* 134 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + +var $ = __w_pdfjs_require__(10); +var aFunction = __w_pdfjs_require__(63); +var newPromiseCapabilityModule = __w_pdfjs_require__(130); +var perform = __w_pdfjs_require__(132); +var iterate = __w_pdfjs_require__(124); +$({ + target: 'Promise', + stat: true +}, { + allSettled: function allSettled(iterable) { + var C = this; + var capability = newPromiseCapabilityModule.f(C); + var resolve = capability.resolve; + var reject = capability.reject; + var result = perform(function () { + var promiseResolve = aFunction(C.resolve); + var values = []; + var counter = 0; + var remaining = 1; + iterate(iterable, function (promise) { + var index = counter++; + var alreadyCalled = false; + values.push(undefined); + remaining++; + promiseResolve.call(C, promise).then(function (value) { + if (alreadyCalled) + return; + alreadyCalled = true; + values[index] = { + status: 'fulfilled', + value: value + }; + --remaining || resolve(values); + }, function (e) { + if (alreadyCalled) + return; + alreadyCalled = true; + values[index] = { + status: 'rejected', + reason: e + }; + --remaining || resolve(values); + }); + }); + --remaining || resolve(values); + }); + if (result.error) + reject(result.value); + return capability.promise; + } +}); + +/***/ }), +/* 135 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + +var $ = __w_pdfjs_require__(10); +var IS_PURE = __w_pdfjs_require__(37); +var NativePromise = __w_pdfjs_require__(120); +var fails = __w_pdfjs_require__(14); +var getBuiltIn = __w_pdfjs_require__(42); +var speciesConstructor = __w_pdfjs_require__(112); +var promiseResolve = __w_pdfjs_require__(129); +var redefine = __w_pdfjs_require__(29); +var NON_GENERIC = !!NativePromise && fails(function () { + NativePromise.prototype['finally'].call({ + then: function () { + } + }, function () { + }); +}); +$({ + target: 'Promise', + proto: true, + real: true, + forced: NON_GENERIC +}, { + 'finally': function (onFinally) { + var C = speciesConstructor(this, getBuiltIn('Promise')); + var isFunction = typeof onFinally == 'function'; + return this.then(isFunction ? function (x) { + return promiseResolve(C, onFinally()).then(function () { + return x; + }); + } : onFinally, isFunction ? function (e) { + return promiseResolve(C, onFinally()).then(function () { + throw e; + }); + } : onFinally); + } +}); +if (!IS_PURE && typeof NativePromise == 'function' && !NativePromise.prototype['finally']) { + redefine(NativePromise.prototype, 'finally', getBuiltIn('Promise').prototype['finally']); +} + +/***/ }), +/* 136 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +__w_pdfjs_require__(137); +__w_pdfjs_require__(142); +__w_pdfjs_require__(140); +var path = __w_pdfjs_require__(43); +module.exports = path.URL; + +/***/ }), +/* 137 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + +__w_pdfjs_require__(77); +var $ = __w_pdfjs_require__(10); +var DESCRIPTORS = __w_pdfjs_require__(13); +var USE_NATIVE_URL = __w_pdfjs_require__(138); +var global = __w_pdfjs_require__(11); +var defineProperties = __w_pdfjs_require__(72); +var redefine = __w_pdfjs_require__(29); +var anInstance = __w_pdfjs_require__(123); +var has = __w_pdfjs_require__(23); +var assign = __w_pdfjs_require__(100); +var arrayFrom = __w_pdfjs_require__(90); +var codeAt = __w_pdfjs_require__(78).codeAt; +var toASCII = __w_pdfjs_require__(139); +var setToStringTag = __w_pdfjs_require__(85); +var URLSearchParamsModule = __w_pdfjs_require__(140); +var InternalStateModule = __w_pdfjs_require__(33); +var NativeURL = global.URL; +var URLSearchParams = URLSearchParamsModule.URLSearchParams; +var getInternalSearchParamsState = URLSearchParamsModule.getState; +var setInternalState = InternalStateModule.set; +var getInternalURLState = InternalStateModule.getterFor('URL'); +var floor = Math.floor; +var pow = Math.pow; +var INVALID_AUTHORITY = 'Invalid authority'; +var INVALID_SCHEME = 'Invalid scheme'; +var INVALID_HOST = 'Invalid host'; +var INVALID_PORT = 'Invalid port'; +var ALPHA = /[A-Za-z]/; +var ALPHANUMERIC = /[\d+-.A-Za-z]/; +var DIGIT = /\d/; +var HEX_START = /^(0x|0X)/; +var OCT = /^[0-7]+$/; +var DEC = /^\d+$/; +var HEX = /^[\dA-Fa-f]+$/; +var FORBIDDEN_HOST_CODE_POINT = /[\u0000\u0009\u000A\u000D #%/:?@[\\]]/; +var FORBIDDEN_HOST_CODE_POINT_EXCLUDING_PERCENT = /[\u0000\u0009\u000A\u000D #/:?@[\\]]/; +var LEADING_AND_TRAILING_C0_CONTROL_OR_SPACE = /^[\u0000-\u001F ]+|[\u0000-\u001F ]+$/g; +var TAB_AND_NEW_LINE = /[\u0009\u000A\u000D]/g; +var EOF; +var parseHost = function (url, input) { + var result, codePoints, index; + if (input.charAt(0) == '[') { + if (input.charAt(input.length - 1) != ']') + return INVALID_HOST; + result = parseIPv6(input.slice(1, -1)); + if (!result) + return INVALID_HOST; + url.host = result; + } else if (!isSpecial(url)) { + if (FORBIDDEN_HOST_CODE_POINT_EXCLUDING_PERCENT.test(input)) + return INVALID_HOST; + result = ''; + codePoints = arrayFrom(input); + for (index = 0; index < codePoints.length; index++) { + result += percentEncode(codePoints[index], C0ControlPercentEncodeSet); + } + url.host = result; + } else { + input = toASCII(input); + if (FORBIDDEN_HOST_CODE_POINT.test(input)) + return INVALID_HOST; + result = parseIPv4(input); + if (result === null) + return INVALID_HOST; + url.host = result; + } +}; +var parseIPv4 = function (input) { + var parts = input.split('.'); + var partsLength, numbers, index, part, radix, number, ipv4; + if (parts.length && parts[parts.length - 1] == '') { + parts.pop(); + } + partsLength = parts.length; + if (partsLength > 4) + return input; + numbers = []; + for (index = 0; index < partsLength; index++) { + part = parts[index]; + if (part == '') + return input; + radix = 10; + if (part.length > 1 && part.charAt(0) == '0') { + radix = HEX_START.test(part) ? 16 : 8; + part = part.slice(radix == 8 ? 1 : 2); + } + if (part === '') { + number = 0; + } else { + if (!(radix == 10 ? DEC : radix == 8 ? OCT : HEX).test(part)) + return input; + number = parseInt(part, radix); + } + numbers.push(number); + } + for (index = 0; index < partsLength; index++) { + number = numbers[index]; + if (index == partsLength - 1) { + if (number >= pow(256, 5 - partsLength)) + return null; + } else if (number > 255) + return null; + } + ipv4 = numbers.pop(); + for (index = 0; index < numbers.length; index++) { + ipv4 += numbers[index] * pow(256, 3 - index); + } + return ipv4; +}; +var parseIPv6 = function (input) { + var address = [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ]; + var pieceIndex = 0; + var compress = null; + var pointer = 0; + var value, length, numbersSeen, ipv4Piece, number, swaps, swap; + var char = function () { + return input.charAt(pointer); + }; + if (char() == ':') { + if (input.charAt(1) != ':') + return; + pointer += 2; + pieceIndex++; + compress = pieceIndex; + } + while (char()) { + if (pieceIndex == 8) + return; + if (char() == ':') { + if (compress !== null) + return; + pointer++; + pieceIndex++; + compress = pieceIndex; + continue; + } + value = length = 0; + while (length < 4 && HEX.test(char())) { + value = value * 16 + parseInt(char(), 16); + pointer++; + length++; + } + if (char() == '.') { + if (length == 0) + return; + pointer -= length; + if (pieceIndex > 6) + return; + numbersSeen = 0; + while (char()) { + ipv4Piece = null; + if (numbersSeen > 0) { + if (char() == '.' && numbersSeen < 4) + pointer++; + else + return; + } + if (!DIGIT.test(char())) + return; + while (DIGIT.test(char())) { + number = parseInt(char(), 10); + if (ipv4Piece === null) + ipv4Piece = number; + else if (ipv4Piece == 0) + return; + else + ipv4Piece = ipv4Piece * 10 + number; + if (ipv4Piece > 255) + return; + pointer++; + } + address[pieceIndex] = address[pieceIndex] * 256 + ipv4Piece; + numbersSeen++; + if (numbersSeen == 2 || numbersSeen == 4) + pieceIndex++; + } + if (numbersSeen != 4) + return; + break; + } else if (char() == ':') { + pointer++; + if (!char()) + return; + } else if (char()) + return; + address[pieceIndex++] = value; + } + if (compress !== null) { + swaps = pieceIndex - compress; + pieceIndex = 7; + while (pieceIndex != 0 && swaps > 0) { + swap = address[pieceIndex]; + address[pieceIndex--] = address[compress + swaps - 1]; + address[compress + --swaps] = swap; + } + } else if (pieceIndex != 8) + return; + return address; +}; +var findLongestZeroSequence = function (ipv6) { + var maxIndex = null; + var maxLength = 1; + var currStart = null; + var currLength = 0; + var index = 0; + for (; index < 8; index++) { + if (ipv6[index] !== 0) { + if (currLength > maxLength) { + maxIndex = currStart; + maxLength = currLength; + } + currStart = null; + currLength = 0; + } else { + if (currStart === null) + currStart = index; + ++currLength; + } + } + if (currLength > maxLength) { + maxIndex = currStart; + maxLength = currLength; + } + return maxIndex; +}; +var serializeHost = function (host) { + var result, index, compress, ignore0; + if (typeof host == 'number') { + result = []; + for (index = 0; index < 4; index++) { + result.unshift(host % 256); + host = floor(host / 256); + } + return result.join('.'); + } else if (typeof host == 'object') { + result = ''; + compress = findLongestZeroSequence(host); + for (index = 0; index < 8; index++) { + if (ignore0 && host[index] === 0) + continue; + if (ignore0) + ignore0 = false; + if (compress === index) { + result += index ? ':' : '::'; + ignore0 = true; + } else { + result += host[index].toString(16); + if (index < 7) + result += ':'; + } + } + return '[' + result + ']'; + } + return host; +}; +var C0ControlPercentEncodeSet = {}; +var fragmentPercentEncodeSet = assign({}, C0ControlPercentEncodeSet, { + ' ': 1, + '"': 1, + '<': 1, + '>': 1, + '`': 1 +}); +var pathPercentEncodeSet = assign({}, fragmentPercentEncodeSet, { + '#': 1, + '?': 1, + '{': 1, + '}': 1 +}); +var userinfoPercentEncodeSet = assign({}, pathPercentEncodeSet, { + '/': 1, + ':': 1, + ';': 1, + '=': 1, + '@': 1, + '[': 1, + '\\': 1, + ']': 1, + '^': 1, + '|': 1 +}); +var percentEncode = function (char, set) { + var code = codeAt(char, 0); + return code > 0x20 && code < 0x7F && !has(set, char) ? char : encodeURIComponent(char); +}; +var specialSchemes = { + ftp: 21, + file: null, + http: 80, + https: 443, + ws: 80, + wss: 443 +}; +var isSpecial = function (url) { + return has(specialSchemes, url.scheme); +}; +var includesCredentials = function (url) { + return url.username != '' || url.password != ''; +}; +var cannotHaveUsernamePasswordPort = function (url) { + return !url.host || url.cannotBeABaseURL || url.scheme == 'file'; +}; +var isWindowsDriveLetter = function (string, normalized) { + var second; + return string.length == 2 && ALPHA.test(string.charAt(0)) && ((second = string.charAt(1)) == ':' || !normalized && second == '|'); +}; +var startsWithWindowsDriveLetter = function (string) { + var third; + return string.length > 1 && isWindowsDriveLetter(string.slice(0, 2)) && (string.length == 2 || ((third = string.charAt(2)) === '/' || third === '\\' || third === '?' || third === '#')); +}; +var shortenURLsPath = function (url) { + var path = url.path; + var pathSize = path.length; + if (pathSize && (url.scheme != 'file' || pathSize != 1 || !isWindowsDriveLetter(path[0], true))) { + path.pop(); + } +}; +var isSingleDot = function (segment) { + return segment === '.' || segment.toLowerCase() === '%2e'; +}; +var isDoubleDot = function (segment) { + segment = segment.toLowerCase(); + return segment === '..' || segment === '%2e.' || segment === '.%2e' || segment === '%2e%2e'; +}; +var SCHEME_START = {}; +var SCHEME = {}; +var NO_SCHEME = {}; +var SPECIAL_RELATIVE_OR_AUTHORITY = {}; +var PATH_OR_AUTHORITY = {}; +var RELATIVE = {}; +var RELATIVE_SLASH = {}; +var SPECIAL_AUTHORITY_SLASHES = {}; +var SPECIAL_AUTHORITY_IGNORE_SLASHES = {}; +var AUTHORITY = {}; +var HOST = {}; +var HOSTNAME = {}; +var PORT = {}; +var FILE = {}; +var FILE_SLASH = {}; +var FILE_HOST = {}; +var PATH_START = {}; +var PATH = {}; +var CANNOT_BE_A_BASE_URL_PATH = {}; +var QUERY = {}; +var FRAGMENT = {}; +var parseURL = function (url, input, stateOverride, base) { + var state = stateOverride || SCHEME_START; + var pointer = 0; + var buffer = ''; + var seenAt = false; + var seenBracket = false; + var seenPasswordToken = false; + var codePoints, char, bufferCodePoints, failure; + if (!stateOverride) { + url.scheme = ''; + url.username = ''; + url.password = ''; + url.host = null; + url.port = null; + url.path = []; + url.query = null; + url.fragment = null; + url.cannotBeABaseURL = false; + input = input.replace(LEADING_AND_TRAILING_C0_CONTROL_OR_SPACE, ''); + } + input = input.replace(TAB_AND_NEW_LINE, ''); + codePoints = arrayFrom(input); + while (pointer <= codePoints.length) { + char = codePoints[pointer]; + switch (state) { + case SCHEME_START: + if (char && ALPHA.test(char)) { + buffer += char.toLowerCase(); + state = SCHEME; + } else if (!stateOverride) { + state = NO_SCHEME; + continue; + } else + return INVALID_SCHEME; + break; + case SCHEME: + if (char && (ALPHANUMERIC.test(char) || char == '+' || char == '-' || char == '.')) { + buffer += char.toLowerCase(); + } else if (char == ':') { + if (stateOverride && (isSpecial(url) != has(specialSchemes, buffer) || buffer == 'file' && (includesCredentials(url) || url.port !== null) || url.scheme == 'file' && !url.host)) + return; + url.scheme = buffer; + if (stateOverride) { + if (isSpecial(url) && specialSchemes[url.scheme] == url.port) + url.port = null; + return; + } + buffer = ''; + if (url.scheme == 'file') { + state = FILE; + } else if (isSpecial(url) && base && base.scheme == url.scheme) { + state = SPECIAL_RELATIVE_OR_AUTHORITY; + } else if (isSpecial(url)) { + state = SPECIAL_AUTHORITY_SLASHES; + } else if (codePoints[pointer + 1] == '/') { + state = PATH_OR_AUTHORITY; + pointer++; + } else { + url.cannotBeABaseURL = true; + url.path.push(''); + state = CANNOT_BE_A_BASE_URL_PATH; + } + } else if (!stateOverride) { + buffer = ''; + state = NO_SCHEME; + pointer = 0; + continue; + } else + return INVALID_SCHEME; + break; + case NO_SCHEME: + if (!base || base.cannotBeABaseURL && char != '#') + return INVALID_SCHEME; + if (base.cannotBeABaseURL && char == '#') { + url.scheme = base.scheme; + url.path = base.path.slice(); + url.query = base.query; + url.fragment = ''; + url.cannotBeABaseURL = true; + state = FRAGMENT; + break; + } + state = base.scheme == 'file' ? FILE : RELATIVE; + continue; + case SPECIAL_RELATIVE_OR_AUTHORITY: + if (char == '/' && codePoints[pointer + 1] == '/') { + state = SPECIAL_AUTHORITY_IGNORE_SLASHES; + pointer++; + } else { + state = RELATIVE; + continue; + } + break; + case PATH_OR_AUTHORITY: + if (char == '/') { + state = AUTHORITY; + break; + } else { + state = PATH; + continue; + } + case RELATIVE: + url.scheme = base.scheme; + if (char == EOF) { + url.username = base.username; + url.password = base.password; + url.host = base.host; + url.port = base.port; + url.path = base.path.slice(); + url.query = base.query; + } else if (char == '/' || char == '\\' && isSpecial(url)) { + state = RELATIVE_SLASH; + } else if (char == '?') { + url.username = base.username; + url.password = base.password; + url.host = base.host; + url.port = base.port; + url.path = base.path.slice(); + url.query = ''; + state = QUERY; + } else if (char == '#') { + url.username = base.username; + url.password = base.password; + url.host = base.host; + url.port = base.port; + url.path = base.path.slice(); + url.query = base.query; + url.fragment = ''; + state = FRAGMENT; + } else { + url.username = base.username; + url.password = base.password; + url.host = base.host; + url.port = base.port; + url.path = base.path.slice(); + url.path.pop(); + state = PATH; + continue; + } + break; + case RELATIVE_SLASH: + if (isSpecial(url) && (char == '/' || char == '\\')) { + state = SPECIAL_AUTHORITY_IGNORE_SLASHES; + } else if (char == '/') { + state = AUTHORITY; + } else { + url.username = base.username; + url.password = base.password; + url.host = base.host; + url.port = base.port; + state = PATH; + continue; + } + break; + case SPECIAL_AUTHORITY_SLASHES: + state = SPECIAL_AUTHORITY_IGNORE_SLASHES; + if (char != '/' || buffer.charAt(pointer + 1) != '/') + continue; + pointer++; + break; + case SPECIAL_AUTHORITY_IGNORE_SLASHES: + if (char != '/' && char != '\\') { + state = AUTHORITY; + continue; + } + break; + case AUTHORITY: + if (char == '@') { + if (seenAt) + buffer = '%40' + buffer; + seenAt = true; + bufferCodePoints = arrayFrom(buffer); + for (var i = 0; i < bufferCodePoints.length; i++) { + var codePoint = bufferCodePoints[i]; + if (codePoint == ':' && !seenPasswordToken) { + seenPasswordToken = true; + continue; + } + var encodedCodePoints = percentEncode(codePoint, userinfoPercentEncodeSet); + if (seenPasswordToken) + url.password += encodedCodePoints; + else + url.username += encodedCodePoints; + } + buffer = ''; + } else if (char == EOF || char == '/' || char == '?' || char == '#' || char == '\\' && isSpecial(url)) { + if (seenAt && buffer == '') + return INVALID_AUTHORITY; + pointer -= arrayFrom(buffer).length + 1; + buffer = ''; + state = HOST; + } else + buffer += char; + break; + case HOST: + case HOSTNAME: + if (stateOverride && url.scheme == 'file') { + state = FILE_HOST; + continue; + } else if (char == ':' && !seenBracket) { + if (buffer == '') + return INVALID_HOST; + failure = parseHost(url, buffer); + if (failure) + return failure; + buffer = ''; + state = PORT; + if (stateOverride == HOSTNAME) + return; + } else if (char == EOF || char == '/' || char == '?' || char == '#' || char == '\\' && isSpecial(url)) { + if (isSpecial(url) && buffer == '') + return INVALID_HOST; + if (stateOverride && buffer == '' && (includesCredentials(url) || url.port !== null)) + return; + failure = parseHost(url, buffer); + if (failure) + return failure; + buffer = ''; + state = PATH_START; + if (stateOverride) + return; + continue; + } else { + if (char == '[') + seenBracket = true; + else if (char == ']') + seenBracket = false; + buffer += char; + } + break; + case PORT: + if (DIGIT.test(char)) { + buffer += char; + } else if (char == EOF || char == '/' || char == '?' || char == '#' || char == '\\' && isSpecial(url) || stateOverride) { + if (buffer != '') { + var port = parseInt(buffer, 10); + if (port > 0xFFFF) + return INVALID_PORT; + url.port = isSpecial(url) && port === specialSchemes[url.scheme] ? null : port; + buffer = ''; + } + if (stateOverride) + return; + state = PATH_START; + continue; + } else + return INVALID_PORT; + break; + case FILE: + url.scheme = 'file'; + if (char == '/' || char == '\\') + state = FILE_SLASH; + else if (base && base.scheme == 'file') { + if (char == EOF) { + url.host = base.host; + url.path = base.path.slice(); + url.query = base.query; + } else if (char == '?') { + url.host = base.host; + url.path = base.path.slice(); + url.query = ''; + state = QUERY; + } else if (char == '#') { + url.host = base.host; + url.path = base.path.slice(); + url.query = base.query; + url.fragment = ''; + state = FRAGMENT; + } else { + if (!startsWithWindowsDriveLetter(codePoints.slice(pointer).join(''))) { + url.host = base.host; + url.path = base.path.slice(); + shortenURLsPath(url); + } + state = PATH; + continue; + } + } else { + state = PATH; + continue; + } + break; + case FILE_SLASH: + if (char == '/' || char == '\\') { + state = FILE_HOST; + break; + } + if (base && base.scheme == 'file' && !startsWithWindowsDriveLetter(codePoints.slice(pointer).join(''))) { + if (isWindowsDriveLetter(base.path[0], true)) + url.path.push(base.path[0]); + else + url.host = base.host; + } + state = PATH; + continue; + case FILE_HOST: + if (char == EOF || char == '/' || char == '\\' || char == '?' || char == '#') { + if (!stateOverride && isWindowsDriveLetter(buffer)) { + state = PATH; + } else if (buffer == '') { + url.host = ''; + if (stateOverride) + return; + state = PATH_START; + } else { + failure = parseHost(url, buffer); + if (failure) + return failure; + if (url.host == 'localhost') + url.host = ''; + if (stateOverride) + return; + buffer = ''; + state = PATH_START; + } + continue; + } else + buffer += char; + break; + case PATH_START: + if (isSpecial(url)) { + state = PATH; + if (char != '/' && char != '\\') + continue; + } else if (!stateOverride && char == '?') { + url.query = ''; + state = QUERY; + } else if (!stateOverride && char == '#') { + url.fragment = ''; + state = FRAGMENT; + } else if (char != EOF) { + state = PATH; + if (char != '/') + continue; + } + break; + case PATH: + if (char == EOF || char == '/' || char == '\\' && isSpecial(url) || !stateOverride && (char == '?' || char == '#')) { + if (isDoubleDot(buffer)) { + shortenURLsPath(url); + if (char != '/' && !(char == '\\' && isSpecial(url))) { + url.path.push(''); + } + } else if (isSingleDot(buffer)) { + if (char != '/' && !(char == '\\' && isSpecial(url))) { + url.path.push(''); + } + } else { + if (url.scheme == 'file' && !url.path.length && isWindowsDriveLetter(buffer)) { + if (url.host) + url.host = ''; + buffer = buffer.charAt(0) + ':'; + } + url.path.push(buffer); + } + buffer = ''; + if (url.scheme == 'file' && (char == EOF || char == '?' || char == '#')) { + while (url.path.length > 1 && url.path[0] === '') { + url.path.shift(); + } + } + if (char == '?') { + url.query = ''; + state = QUERY; + } else if (char == '#') { + url.fragment = ''; + state = FRAGMENT; + } + } else { + buffer += percentEncode(char, pathPercentEncodeSet); + } + break; + case CANNOT_BE_A_BASE_URL_PATH: + if (char == '?') { + url.query = ''; + state = QUERY; + } else if (char == '#') { + url.fragment = ''; + state = FRAGMENT; + } else if (char != EOF) { + url.path[0] += percentEncode(char, C0ControlPercentEncodeSet); + } + break; + case QUERY: + if (!stateOverride && char == '#') { + url.fragment = ''; + state = FRAGMENT; + } else if (char != EOF) { + if (char == "'" && isSpecial(url)) + url.query += '%27'; + else if (char == '#') + url.query += '%23'; + else + url.query += percentEncode(char, C0ControlPercentEncodeSet); + } + break; + case FRAGMENT: + if (char != EOF) + url.fragment += percentEncode(char, fragmentPercentEncodeSet); + break; + } + pointer++; + } +}; +var URLConstructor = function URL(url) { + var that = anInstance(this, URLConstructor, 'URL'); + var base = arguments.length > 1 ? arguments[1] : undefined; + var urlString = String(url); + var state = setInternalState(that, { type: 'URL' }); + var baseState, failure; + if (base !== undefined) { + if (base instanceof URLConstructor) + baseState = getInternalURLState(base); + else { + failure = parseURL(baseState = {}, String(base)); + if (failure) + throw TypeError(failure); + } + } + failure = parseURL(state, urlString, null, baseState); + if (failure) + throw TypeError(failure); + var searchParams = state.searchParams = new URLSearchParams(); + var searchParamsState = getInternalSearchParamsState(searchParams); + searchParamsState.updateSearchParams(state.query); + searchParamsState.updateURL = function () { + state.query = String(searchParams) || null; + }; + if (!DESCRIPTORS) { + that.href = serializeURL.call(that); + that.origin = getOrigin.call(that); + that.protocol = getProtocol.call(that); + that.username = getUsername.call(that); + that.password = getPassword.call(that); + that.host = getHost.call(that); + that.hostname = getHostname.call(that); + that.port = getPort.call(that); + that.pathname = getPathname.call(that); + that.search = getSearch.call(that); + that.searchParams = getSearchParams.call(that); + that.hash = getHash.call(that); + } +}; +var URLPrototype = URLConstructor.prototype; +var serializeURL = function () { + var url = getInternalURLState(this); + var scheme = url.scheme; + var username = url.username; + var password = url.password; + var host = url.host; + var port = url.port; + var path = url.path; + var query = url.query; + var fragment = url.fragment; + var output = scheme + ':'; + if (host !== null) { + output += '//'; + if (includesCredentials(url)) { + output += username + (password ? ':' + password : '') + '@'; + } + output += serializeHost(host); + if (port !== null) + output += ':' + port; + } else if (scheme == 'file') + output += '//'; + output += url.cannotBeABaseURL ? path[0] : path.length ? '/' + path.join('/') : ''; + if (query !== null) + output += '?' + query; + if (fragment !== null) + output += '#' + fragment; + return output; +}; +var getOrigin = function () { + var url = getInternalURLState(this); + var scheme = url.scheme; + var port = url.port; + if (scheme == 'blob') + try { + return new URL(scheme.path[0]).origin; + } catch (error) { + return 'null'; + } + if (scheme == 'file' || !isSpecial(url)) + return 'null'; + return scheme + '://' + serializeHost(url.host) + (port !== null ? ':' + port : ''); +}; +var getProtocol = function () { + return getInternalURLState(this).scheme + ':'; +}; +var getUsername = function () { + return getInternalURLState(this).username; +}; +var getPassword = function () { + return getInternalURLState(this).password; +}; +var getHost = function () { + var url = getInternalURLState(this); + var host = url.host; + var port = url.port; + return host === null ? '' : port === null ? serializeHost(host) : serializeHost(host) + ':' + port; +}; +var getHostname = function () { + var host = getInternalURLState(this).host; + return host === null ? '' : serializeHost(host); +}; +var getPort = function () { + var port = getInternalURLState(this).port; + return port === null ? '' : String(port); +}; +var getPathname = function () { + var url = getInternalURLState(this); + var path = url.path; + return url.cannotBeABaseURL ? path[0] : path.length ? '/' + path.join('/') : ''; +}; +var getSearch = function () { + var query = getInternalURLState(this).query; + return query ? '?' + query : ''; +}; +var getSearchParams = function () { + return getInternalURLState(this).searchParams; +}; +var getHash = function () { + var fragment = getInternalURLState(this).fragment; + return fragment ? '#' + fragment : ''; +}; +var accessorDescriptor = function (getter, setter) { + return { + get: getter, + set: setter, + configurable: true, + enumerable: true + }; +}; +if (DESCRIPTORS) { + defineProperties(URLPrototype, { + href: accessorDescriptor(serializeURL, function (href) { + var url = getInternalURLState(this); + var urlString = String(href); + var failure = parseURL(url, urlString); + if (failure) + throw TypeError(failure); + getInternalSearchParamsState(url.searchParams).updateSearchParams(url.query); + }), + origin: accessorDescriptor(getOrigin), + protocol: accessorDescriptor(getProtocol, function (protocol) { + var url = getInternalURLState(this); + parseURL(url, String(protocol) + ':', SCHEME_START); + }), + username: accessorDescriptor(getUsername, function (username) { + var url = getInternalURLState(this); + var codePoints = arrayFrom(String(username)); + if (cannotHaveUsernamePasswordPort(url)) + return; + url.username = ''; + for (var i = 0; i < codePoints.length; i++) { + url.username += percentEncode(codePoints[i], userinfoPercentEncodeSet); + } + }), + password: accessorDescriptor(getPassword, function (password) { + var url = getInternalURLState(this); + var codePoints = arrayFrom(String(password)); + if (cannotHaveUsernamePasswordPort(url)) + return; + url.password = ''; + for (var i = 0; i < codePoints.length; i++) { + url.password += percentEncode(codePoints[i], userinfoPercentEncodeSet); + } + }), + host: accessorDescriptor(getHost, function (host) { + var url = getInternalURLState(this); + if (url.cannotBeABaseURL) + return; + parseURL(url, String(host), HOST); + }), + hostname: accessorDescriptor(getHostname, function (hostname) { + var url = getInternalURLState(this); + if (url.cannotBeABaseURL) + return; + parseURL(url, String(hostname), HOSTNAME); + }), + port: accessorDescriptor(getPort, function (port) { + var url = getInternalURLState(this); + if (cannotHaveUsernamePasswordPort(url)) + return; + port = String(port); + if (port == '') + url.port = null; + else + parseURL(url, port, PORT); + }), + pathname: accessorDescriptor(getPathname, function (pathname) { + var url = getInternalURLState(this); + if (url.cannotBeABaseURL) + return; + url.path = []; + parseURL(url, pathname + '', PATH_START); + }), + search: accessorDescriptor(getSearch, function (search) { + var url = getInternalURLState(this); + search = String(search); + if (search == '') { + url.query = null; + } else { + if ('?' == search.charAt(0)) + search = search.slice(1); + url.query = ''; + parseURL(url, search, QUERY); + } + getInternalSearchParamsState(url.searchParams).updateSearchParams(url.query); + }), + searchParams: accessorDescriptor(getSearchParams), + hash: accessorDescriptor(getHash, function (hash) { + var url = getInternalURLState(this); + hash = String(hash); + if (hash == '') { + url.fragment = null; + return; + } + if ('#' == hash.charAt(0)) + hash = hash.slice(1); + url.fragment = ''; + parseURL(url, hash, FRAGMENT); + }) + }); +} +redefine(URLPrototype, 'toJSON', function toJSON() { + return serializeURL.call(this); +}, { enumerable: true }); +redefine(URLPrototype, 'toString', function toString() { + return serializeURL.call(this); +}, { enumerable: true }); +if (NativeURL) { + var nativeCreateObjectURL = NativeURL.createObjectURL; + var nativeRevokeObjectURL = NativeURL.revokeObjectURL; + if (nativeCreateObjectURL) + redefine(URLConstructor, 'createObjectURL', function createObjectURL(blob) { + return nativeCreateObjectURL.apply(NativeURL, arguments); + }); + if (nativeRevokeObjectURL) + redefine(URLConstructor, 'revokeObjectURL', function revokeObjectURL(url) { + return nativeRevokeObjectURL.apply(NativeURL, arguments); + }); +} +setToStringTag(URLConstructor, 'URL'); +$({ + global: true, + forced: !USE_NATIVE_URL, + sham: !DESCRIPTORS +}, { URL: URLConstructor }); + +/***/ }), +/* 138 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var fails = __w_pdfjs_require__(14); +var wellKnownSymbol = __w_pdfjs_require__(57); +var IS_PURE = __w_pdfjs_require__(37); +var ITERATOR = wellKnownSymbol('iterator'); +module.exports = !fails(function () { + var url = new URL('b?a=1&b=2&c=3', 'http://a'); + var searchParams = url.searchParams; + var result = ''; + url.pathname = 'c%20d'; + searchParams.forEach(function (value, key) { + searchParams['delete']('b'); + result += key + value; + }); + return IS_PURE && !url.toJSON || !searchParams.sort || url.href !== 'http://a/c%20d?a=1&c=3' || searchParams.get('c') !== '3' || String(new URLSearchParams('?a=1')) !== 'a=1' || !searchParams[ITERATOR] || new URL('https://a@b').username !== 'a' || new URLSearchParams(new URLSearchParams('a=b')).get('a') !== 'b' || new URL('http://тест').host !== 'xn--e1aybc' || new URL('http://a#б').hash !== '#%D0%B1' || result !== 'a1c3' || new URL('http://x', undefined).host !== 'x'; +}); + +/***/ }), +/* 139 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + +var maxInt = 2147483647; +var base = 36; +var tMin = 1; +var tMax = 26; +var skew = 38; +var damp = 700; +var initialBias = 72; +var initialN = 128; +var delimiter = '-'; +var regexNonASCII = /[^\0-\u007E]/; +var regexSeparators = /[.\u3002\uFF0E\uFF61]/g; +var OVERFLOW_ERROR = 'Overflow: input needs wider integers to process'; +var baseMinusTMin = base - tMin; +var floor = Math.floor; +var stringFromCharCode = String.fromCharCode; +var ucs2decode = function (string) { + var output = []; + var counter = 0; + var length = string.length; + while (counter < length) { + var value = string.charCodeAt(counter++); + if (value >= 0xD800 && value <= 0xDBFF && counter < length) { + var extra = string.charCodeAt(counter++); + if ((extra & 0xFC00) == 0xDC00) { + output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000); + } else { + output.push(value); + counter--; + } + } else { + output.push(value); + } + } + return output; +}; +var digitToBasic = function (digit) { + return digit + 22 + 75 * (digit < 26); +}; +var adapt = function (delta, numPoints, firstTime) { + var k = 0; + delta = firstTime ? floor(delta / damp) : delta >> 1; + delta += floor(delta / numPoints); + for (; delta > baseMinusTMin * tMax >> 1; k += base) { + delta = floor(delta / baseMinusTMin); + } + return floor(k + (baseMinusTMin + 1) * delta / (delta + skew)); +}; +var encode = function (input) { + var output = []; + input = ucs2decode(input); + var inputLength = input.length; + var n = initialN; + var delta = 0; + var bias = initialBias; + var i, currentValue; + for (i = 0; i < input.length; i++) { + currentValue = input[i]; + if (currentValue < 0x80) { + output.push(stringFromCharCode(currentValue)); + } + } + var basicLength = output.length; + var handledCPCount = basicLength; + if (basicLength) { + output.push(delimiter); + } + while (handledCPCount < inputLength) { + var m = maxInt; + for (i = 0; i < input.length; i++) { + currentValue = input[i]; + if (currentValue >= n && currentValue < m) { + m = currentValue; + } + } + var handledCPCountPlusOne = handledCPCount + 1; + if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) { + throw RangeError(OVERFLOW_ERROR); + } + delta += (m - n) * handledCPCountPlusOne; + n = m; + for (i = 0; i < input.length; i++) { + currentValue = input[i]; + if (currentValue < n && ++delta > maxInt) { + throw RangeError(OVERFLOW_ERROR); + } + if (currentValue == n) { + var q = delta; + for (var k = base;; k += base) { + var t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias; + if (q < t) + break; + var qMinusT = q - t; + var baseMinusT = base - t; + output.push(stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT))); + q = floor(qMinusT / baseMinusT); + } + output.push(stringFromCharCode(digitToBasic(q))); + bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength); + delta = 0; + ++handledCPCount; + } + } + ++delta; + ++n; + } + return output.join(''); +}; +module.exports = function (input) { + var encoded = []; + var labels = input.toLowerCase().replace(regexSeparators, '\u002E').split('.'); + var i, label; + for (i = 0; i < labels.length; i++) { + label = labels[i]; + encoded.push(regexNonASCII.test(label) ? 'xn--' + encode(label) : label); + } + return encoded.join('.'); +}; + +/***/ }), +/* 140 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + +__w_pdfjs_require__(118); +var $ = __w_pdfjs_require__(10); +var getBuiltIn = __w_pdfjs_require__(42); +var USE_NATIVE_URL = __w_pdfjs_require__(138); +var redefine = __w_pdfjs_require__(29); +var redefineAll = __w_pdfjs_require__(121); +var setToStringTag = __w_pdfjs_require__(85); +var createIteratorConstructor = __w_pdfjs_require__(80); +var InternalStateModule = __w_pdfjs_require__(33); +var anInstance = __w_pdfjs_require__(123); +var hasOwn = __w_pdfjs_require__(23); +var bind = __w_pdfjs_require__(62); +var classof = __w_pdfjs_require__(95); +var anObject = __w_pdfjs_require__(28); +var isObject = __w_pdfjs_require__(22); +var create = __w_pdfjs_require__(71); +var createPropertyDescriptor = __w_pdfjs_require__(16); +var getIterator = __w_pdfjs_require__(141); +var getIteratorMethod = __w_pdfjs_require__(94); +var wellKnownSymbol = __w_pdfjs_require__(57); +var $fetch = getBuiltIn('fetch'); +var Headers = getBuiltIn('Headers'); +var ITERATOR = wellKnownSymbol('iterator'); +var URL_SEARCH_PARAMS = 'URLSearchParams'; +var URL_SEARCH_PARAMS_ITERATOR = URL_SEARCH_PARAMS + 'Iterator'; +var setInternalState = InternalStateModule.set; +var getInternalParamsState = InternalStateModule.getterFor(URL_SEARCH_PARAMS); +var getInternalIteratorState = InternalStateModule.getterFor(URL_SEARCH_PARAMS_ITERATOR); +var plus = /\+/g; +var sequences = Array(4); +var percentSequence = function (bytes) { + return sequences[bytes - 1] || (sequences[bytes - 1] = RegExp('((?:%[\\da-f]{2}){' + bytes + '})', 'gi')); +}; +var percentDecode = function (sequence) { + try { + return decodeURIComponent(sequence); + } catch (error) { + return sequence; + } +}; +var deserialize = function (it) { + var result = it.replace(plus, ' '); + var bytes = 4; + try { + return decodeURIComponent(result); + } catch (error) { + while (bytes) { + result = result.replace(percentSequence(bytes--), percentDecode); + } + return result; + } +}; +var find = /[!'()~]|%20/g; +var replace = { + '!': '%21', + "'": '%27', + '(': '%28', + ')': '%29', + '~': '%7E', + '%20': '+' +}; +var replacer = function (match) { + return replace[match]; +}; +var serialize = function (it) { + return encodeURIComponent(it).replace(find, replacer); +}; +var parseSearchParams = function (result, query) { + if (query) { + var attributes = query.split('&'); + var index = 0; + var attribute, entry; + while (index < attributes.length) { + attribute = attributes[index++]; + if (attribute.length) { + entry = attribute.split('='); + result.push({ + key: deserialize(entry.shift()), + value: deserialize(entry.join('=')) + }); + } + } + } +}; +var updateSearchParams = function (query) { + this.entries.length = 0; + parseSearchParams(this.entries, query); +}; +var validateArgumentsLength = function (passed, required) { + if (passed < required) + throw TypeError('Not enough arguments'); +}; +var URLSearchParamsIterator = createIteratorConstructor(function Iterator(params, kind) { + setInternalState(this, { + type: URL_SEARCH_PARAMS_ITERATOR, + iterator: getIterator(getInternalParamsState(params).entries), + kind: kind + }); +}, 'Iterator', function next() { + var state = getInternalIteratorState(this); + var kind = state.kind; + var step = state.iterator.next(); + var entry = step.value; + if (!step.done) { + step.value = kind === 'keys' ? entry.key : kind === 'values' ? entry.value : [ + entry.key, + entry.value + ]; + } + return step; +}); +var URLSearchParamsConstructor = function URLSearchParams() { + anInstance(this, URLSearchParamsConstructor, URL_SEARCH_PARAMS); + var init = arguments.length > 0 ? arguments[0] : undefined; + var that = this; + var entries = []; + var iteratorMethod, iterator, next, step, entryIterator, entryNext, first, second, key; + setInternalState(that, { + type: URL_SEARCH_PARAMS, + entries: entries, + updateURL: function () { + }, + updateSearchParams: updateSearchParams + }); + if (init !== undefined) { + if (isObject(init)) { + iteratorMethod = getIteratorMethod(init); + if (typeof iteratorMethod === 'function') { + iterator = iteratorMethod.call(init); + next = iterator.next; + while (!(step = next.call(iterator)).done) { + entryIterator = getIterator(anObject(step.value)); + entryNext = entryIterator.next; + if ((first = entryNext.call(entryIterator)).done || (second = entryNext.call(entryIterator)).done || !entryNext.call(entryIterator).done) + throw TypeError('Expected sequence with length 2'); + entries.push({ + key: first.value + '', + value: second.value + '' + }); + } + } else + for (key in init) + if (hasOwn(init, key)) + entries.push({ + key: key, + value: init[key] + '' + }); + } else { + parseSearchParams(entries, typeof init === 'string' ? init.charAt(0) === '?' ? init.slice(1) : init : init + ''); + } + } +}; +var URLSearchParamsPrototype = URLSearchParamsConstructor.prototype; +redefineAll(URLSearchParamsPrototype, { + append: function append(name, value) { + validateArgumentsLength(arguments.length, 2); + var state = getInternalParamsState(this); + state.entries.push({ + key: name + '', + value: value + '' + }); + state.updateURL(); + }, + 'delete': function (name) { + validateArgumentsLength(arguments.length, 1); + var state = getInternalParamsState(this); + var entries = state.entries; + var key = name + ''; + var index = 0; + while (index < entries.length) { + if (entries[index].key === key) + entries.splice(index, 1); + else + index++; + } + state.updateURL(); + }, + get: function get(name) { + validateArgumentsLength(arguments.length, 1); + var entries = getInternalParamsState(this).entries; + var key = name + ''; + var index = 0; + for (; index < entries.length; index++) { + if (entries[index].key === key) + return entries[index].value; + } + return null; + }, + getAll: function getAll(name) { + validateArgumentsLength(arguments.length, 1); + var entries = getInternalParamsState(this).entries; + var key = name + ''; + var result = []; + var index = 0; + for (; index < entries.length; index++) { + if (entries[index].key === key) + result.push(entries[index].value); + } + return result; + }, + has: function has(name) { + validateArgumentsLength(arguments.length, 1); + var entries = getInternalParamsState(this).entries; + var key = name + ''; + var index = 0; + while (index < entries.length) { + if (entries[index++].key === key) + return true; + } + return false; + }, + set: function set(name, value) { + validateArgumentsLength(arguments.length, 1); + var state = getInternalParamsState(this); + var entries = state.entries; + var found = false; + var key = name + ''; + var val = value + ''; + var index = 0; + var entry; + for (; index < entries.length; index++) { + entry = entries[index]; + if (entry.key === key) { + if (found) + entries.splice(index--, 1); + else { + found = true; + entry.value = val; + } + } + } + if (!found) + entries.push({ + key: key, + value: val + }); + state.updateURL(); + }, + sort: function sort() { + var state = getInternalParamsState(this); + var entries = state.entries; + var slice = entries.slice(); + var entry, entriesIndex, sliceIndex; + entries.length = 0; + for (sliceIndex = 0; sliceIndex < slice.length; sliceIndex++) { + entry = slice[sliceIndex]; + for (entriesIndex = 0; entriesIndex < sliceIndex; entriesIndex++) { + if (entries[entriesIndex].key > entry.key) { + entries.splice(entriesIndex, 0, entry); + break; + } + } + if (entriesIndex === sliceIndex) + entries.push(entry); + } + state.updateURL(); + }, + forEach: function forEach(callback) { + var entries = getInternalParamsState(this).entries; + var boundFunction = bind(callback, arguments.length > 1 ? arguments[1] : undefined, 3); + var index = 0; + var entry; + while (index < entries.length) { + entry = entries[index++]; + boundFunction(entry.value, entry.key, this); + } + }, + keys: function keys() { + return new URLSearchParamsIterator(this, 'keys'); + }, + values: function values() { + return new URLSearchParamsIterator(this, 'values'); + }, + entries: function entries() { + return new URLSearchParamsIterator(this, 'entries'); + } +}, { enumerable: true }); +redefine(URLSearchParamsPrototype, ITERATOR, URLSearchParamsPrototype.entries); +redefine(URLSearchParamsPrototype, 'toString', function toString() { + var entries = getInternalParamsState(this).entries; + var result = []; + var index = 0; + var entry; + while (index < entries.length) { + entry = entries[index++]; + result.push(serialize(entry.key) + '=' + serialize(entry.value)); + } + return result.join('&'); +}, { enumerable: true }); +setToStringTag(URLSearchParamsConstructor, URL_SEARCH_PARAMS); +$({ + global: true, + forced: !USE_NATIVE_URL +}, { URLSearchParams: URLSearchParamsConstructor }); +if (!USE_NATIVE_URL && typeof $fetch == 'function' && typeof Headers == 'function') { + $({ + global: true, + enumerable: true, + forced: true + }, { + fetch: function fetch(input) { + var args = [input]; + var init, body, headers; + if (arguments.length > 1) { + init = arguments[1]; + if (isObject(init)) { + body = init.body; + if (classof(body) === URL_SEARCH_PARAMS) { + headers = init.headers ? new Headers(init.headers) : new Headers(); + if (!headers.has('content-type')) { + headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8'); + } + init = create(init, { + body: createPropertyDescriptor(0, String(body)), + headers: createPropertyDescriptor(0, headers) + }); + } + } + args.push(init); + } + return $fetch.apply(this, args); + } + }); +} +module.exports = { + URLSearchParams: URLSearchParamsConstructor, + getState: getInternalParamsState +}; + +/***/ }), +/* 141 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var anObject = __w_pdfjs_require__(28); +var getIteratorMethod = __w_pdfjs_require__(94); +module.exports = function (it) { + var iteratorMethod = getIteratorMethod(it); + if (typeof iteratorMethod != 'function') { + throw TypeError(String(it) + ' is not iterable'); + } + return anObject(iteratorMethod.call(it)); +}; + +/***/ }), +/* 142 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + +var $ = __w_pdfjs_require__(10); +$({ + target: 'URL', + proto: true, + enumerable: true +}, { + toJSON: function toJSON() { + return URL.prototype.toString.call(this); + } +}); + +/***/ }), +/* 143 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +(function (global, factory) { + true ? factory(exports) : undefined; +}(this, function (exports) { + 'use strict'; + var SymbolPolyfill = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol' ? Symbol : function (description) { + return "Symbol(" + description + ")"; + }; + function noop() { + } + var NumberIsNaN = Number.isNaN || function (x) { + return x !== x; + }; + var rethrowAssertionErrorRejection = noop; + function typeIsObject(x) { + return typeof x === 'object' && x !== null || typeof x === 'function'; + } + function createArrayFromList(elements) { + return elements.slice(); + } + function ArrayBufferCopy(dest, destOffset, src, srcOffset, n) { + new Uint8Array(dest).set(new Uint8Array(src, srcOffset, n), destOffset); + } + function IsFiniteNonNegativeNumber(v) { + if (IsNonNegativeNumber(v) === false) { + return false; + } + if (v === Infinity) { + return false; + } + return true; + } + function IsNonNegativeNumber(v) { + if (typeof v !== 'number') { + return false; + } + if (NumberIsNaN(v)) { + return false; + } + if (v < 0) { + return false; + } + return true; + } + function Call(F, V, args) { + if (typeof F !== 'function') { + throw new TypeError('Argument is not a function'); + } + return Function.prototype.apply.call(F, V, args); + } + function CreateAlgorithmFromUnderlyingMethod(underlyingObject, methodName, algoArgCount, extraArgs) { + var method = underlyingObject[methodName]; + if (method !== undefined) { + if (typeof method !== 'function') { + throw new TypeError(method + " is not a method"); + } + switch (algoArgCount) { + case 0: { + return function () { + return PromiseCall(method, underlyingObject, extraArgs); + }; + } + case 1: { + return function (arg) { + var fullArgs = [arg].concat(extraArgs); + return PromiseCall(method, underlyingObject, fullArgs); + }; + } + } + } + return function () { + return promiseResolvedWith(undefined); + }; + } + function InvokeOrNoop(O, P, args) { + var method = O[P]; + if (method === undefined) { + return undefined; + } + return Call(method, O, args); + } + function PromiseCall(F, V, args) { + try { + return promiseResolvedWith(Call(F, V, args)); + } catch (value) { + return promiseRejectedWith(value); + } + } + function TransferArrayBuffer(O) { + return O; + } + function IsDetachedBuffer(O) { + return false; + } + function ValidateAndNormalizeHighWaterMark(highWaterMark) { + highWaterMark = Number(highWaterMark); + if (NumberIsNaN(highWaterMark) || highWaterMark < 0) { + throw new RangeError('highWaterMark property of a queuing strategy must be non-negative and non-NaN'); + } + return highWaterMark; + } + function MakeSizeAlgorithmFromSizeFunction(size) { + if (size === undefined) { + return function () { + return 1; + }; + } + if (typeof size !== 'function') { + throw new TypeError('size property of a queuing strategy must be a function'); + } + return function (chunk) { + return size(chunk); + }; + } + var originalPromise = Promise; + var originalPromiseThen = Promise.prototype.then; + var originalPromiseResolve = Promise.resolve.bind(originalPromise); + var originalPromiseReject = Promise.reject.bind(originalPromise); + function newPromise(executor) { + return new originalPromise(executor); + } + function promiseResolvedWith(value) { + return originalPromiseResolve(value); + } + function promiseRejectedWith(reason) { + return originalPromiseReject(reason); + } + function PerformPromiseThen(promise, onFulfilled, onRejected) { + return originalPromiseThen.call(promise, onFulfilled, onRejected); + } + function uponPromise(promise, onFulfilled, onRejected) { + PerformPromiseThen(PerformPromiseThen(promise, onFulfilled, onRejected), undefined, rethrowAssertionErrorRejection); + } + function uponFulfillment(promise, onFulfilled) { + uponPromise(promise, onFulfilled); + } + function uponRejection(promise, onRejected) { + uponPromise(promise, undefined, onRejected); + } + function transformPromiseWith(promise, fulfillmentHandler, rejectionHandler) { + return PerformPromiseThen(promise, fulfillmentHandler, rejectionHandler); + } + function setPromiseIsHandledToTrue(promise) { + PerformPromiseThen(promise, undefined, rethrowAssertionErrorRejection); + } + var QUEUE_MAX_ARRAY_SIZE = 16384; + var SimpleQueue = function () { + function SimpleQueue() { + this._cursor = 0; + this._size = 0; + this._front = { + _elements: [], + _next: undefined + }; + this._back = this._front; + this._cursor = 0; + this._size = 0; + } + Object.defineProperty(SimpleQueue.prototype, "length", { + get: function () { + return this._size; + }, + enumerable: true, + configurable: true + }); + SimpleQueue.prototype.push = function (element) { + var oldBack = this._back; + var newBack = oldBack; + if (oldBack._elements.length === QUEUE_MAX_ARRAY_SIZE - 1) { + newBack = { + _elements: [], + _next: undefined + }; + } + oldBack._elements.push(element); + if (newBack !== oldBack) { + this._back = newBack; + oldBack._next = newBack; + } + ++this._size; + }; + SimpleQueue.prototype.shift = function () { + var oldFront = this._front; + var newFront = oldFront; + var oldCursor = this._cursor; + var newCursor = oldCursor + 1; + var elements = oldFront._elements; + var element = elements[oldCursor]; + if (newCursor === QUEUE_MAX_ARRAY_SIZE) { + newFront = oldFront._next; + newCursor = 0; + } + --this._size; + this._cursor = newCursor; + if (oldFront !== newFront) { + this._front = newFront; + } + elements[oldCursor] = undefined; + return element; + }; + SimpleQueue.prototype.forEach = function (callback) { + var i = this._cursor; + var node = this._front; + var elements = node._elements; + while (i !== elements.length || node._next !== undefined) { + if (i === elements.length) { + node = node._next; + elements = node._elements; + i = 0; + if (elements.length === 0) { + break; + } + } + callback(elements[i]); + ++i; + } + }; + SimpleQueue.prototype.peek = function () { + var front = this._front; + var cursor = this._cursor; + return front._elements[cursor]; + }; + return SimpleQueue; + }(); + function ReadableStreamCreateReadResult(value, done, forAuthorCode) { + var prototype = null; + if (forAuthorCode === true) { + prototype = Object.prototype; + } + var obj = Object.create(prototype); + obj.value = value; + obj.done = done; + return obj; + } + function ReadableStreamReaderGenericInitialize(reader, stream) { + reader._forAuthorCode = true; + reader._ownerReadableStream = stream; + stream._reader = reader; + if (stream._state === 'readable') { + defaultReaderClosedPromiseInitialize(reader); + } else if (stream._state === 'closed') { + defaultReaderClosedPromiseInitializeAsResolved(reader); + } else { + defaultReaderClosedPromiseInitializeAsRejected(reader, stream._storedError); + } + } + function ReadableStreamReaderGenericCancel(reader, reason) { + var stream = reader._ownerReadableStream; + return ReadableStreamCancel(stream, reason); + } + function ReadableStreamReaderGenericRelease(reader) { + if (reader._ownerReadableStream._state === 'readable') { + defaultReaderClosedPromiseReject(reader, new TypeError('Reader was released and can no longer be used to monitor the stream\'s closedness')); + } else { + defaultReaderClosedPromiseResetToRejected(reader, new TypeError('Reader was released and can no longer be used to monitor the stream\'s closedness')); + } + reader._ownerReadableStream._reader = undefined; + reader._ownerReadableStream = undefined; + } + function readerLockException(name) { + return new TypeError('Cannot ' + name + ' a stream using a released reader'); + } + function defaultReaderClosedPromiseInitialize(reader) { + reader._closedPromise = newPromise(function (resolve, reject) { + reader._closedPromise_resolve = resolve; + reader._closedPromise_reject = reject; + }); + } + function defaultReaderClosedPromiseInitializeAsRejected(reader, reason) { + defaultReaderClosedPromiseInitialize(reader); + defaultReaderClosedPromiseReject(reader, reason); + } + function defaultReaderClosedPromiseInitializeAsResolved(reader) { + defaultReaderClosedPromiseInitialize(reader); + defaultReaderClosedPromiseResolve(reader); + } + function defaultReaderClosedPromiseReject(reader, reason) { + setPromiseIsHandledToTrue(reader._closedPromise); + reader._closedPromise_reject(reason); + reader._closedPromise_resolve = undefined; + reader._closedPromise_reject = undefined; + } + function defaultReaderClosedPromiseResetToRejected(reader, reason) { + defaultReaderClosedPromiseInitializeAsRejected(reader, reason); + } + function defaultReaderClosedPromiseResolve(reader) { + reader._closedPromise_resolve(undefined); + reader._closedPromise_resolve = undefined; + reader._closedPromise_reject = undefined; + } + var CancelSteps = SymbolPolyfill('[[CancelSteps]]'); + var PullSteps = SymbolPolyfill('[[PullSteps]]'); + function AcquireReadableStreamDefaultReader(stream, forAuthorCode) { + if (forAuthorCode === void 0) { + forAuthorCode = false; + } + var reader = new ReadableStreamDefaultReader(stream); + reader._forAuthorCode = forAuthorCode; + return reader; + } + function ReadableStreamAddReadRequest(stream) { + var promise = newPromise(function (resolve, reject) { + var readRequest = { + _resolve: resolve, + _reject: reject + }; + stream._reader._readRequests.push(readRequest); + }); + return promise; + } + function ReadableStreamFulfillReadRequest(stream, chunk, done) { + var reader = stream._reader; + var readRequest = reader._readRequests.shift(); + readRequest._resolve(ReadableStreamCreateReadResult(chunk, done, reader._forAuthorCode)); + } + function ReadableStreamGetNumReadRequests(stream) { + return stream._reader._readRequests.length; + } + function ReadableStreamHasDefaultReader(stream) { + var reader = stream._reader; + if (reader === undefined) { + return false; + } + if (!IsReadableStreamDefaultReader(reader)) { + return false; + } + return true; + } + var ReadableStreamDefaultReader = function () { + function ReadableStreamDefaultReader(stream) { + if (IsReadableStream(stream) === false) { + throw new TypeError('ReadableStreamDefaultReader can only be constructed with a ReadableStream instance'); + } + if (IsReadableStreamLocked(stream) === true) { + throw new TypeError('This stream has already been locked for exclusive reading by another reader'); + } + ReadableStreamReaderGenericInitialize(this, stream); + this._readRequests = new SimpleQueue(); + } + Object.defineProperty(ReadableStreamDefaultReader.prototype, "closed", { + get: function () { + if (!IsReadableStreamDefaultReader(this)) { + return promiseRejectedWith(defaultReaderBrandCheckException('closed')); + } + return this._closedPromise; + }, + enumerable: true, + configurable: true + }); + ReadableStreamDefaultReader.prototype.cancel = function (reason) { + if (!IsReadableStreamDefaultReader(this)) { + return promiseRejectedWith(defaultReaderBrandCheckException('cancel')); + } + if (this._ownerReadableStream === undefined) { + return promiseRejectedWith(readerLockException('cancel')); + } + return ReadableStreamReaderGenericCancel(this, reason); + }; + ReadableStreamDefaultReader.prototype.read = function () { + if (!IsReadableStreamDefaultReader(this)) { + return promiseRejectedWith(defaultReaderBrandCheckException('read')); + } + if (this._ownerReadableStream === undefined) { + return promiseRejectedWith(readerLockException('read from')); + } + return ReadableStreamDefaultReaderRead(this); + }; + ReadableStreamDefaultReader.prototype.releaseLock = function () { + if (!IsReadableStreamDefaultReader(this)) { + throw defaultReaderBrandCheckException('releaseLock'); + } + if (this._ownerReadableStream === undefined) { + return; + } + if (this._readRequests.length > 0) { + throw new TypeError('Tried to release a reader lock when that reader has pending read() calls un-settled'); + } + ReadableStreamReaderGenericRelease(this); + }; + return ReadableStreamDefaultReader; + }(); + function IsReadableStreamDefaultReader(x) { + if (!typeIsObject(x)) { + return false; + } + if (!Object.prototype.hasOwnProperty.call(x, '_readRequests')) { + return false; + } + return true; + } + function ReadableStreamDefaultReaderRead(reader) { + var stream = reader._ownerReadableStream; + stream._disturbed = true; + if (stream._state === 'closed') { + return promiseResolvedWith(ReadableStreamCreateReadResult(undefined, true, reader._forAuthorCode)); + } + if (stream._state === 'errored') { + return promiseRejectedWith(stream._storedError); + } + return stream._readableStreamController[PullSteps](); + } + function defaultReaderBrandCheckException(name) { + return new TypeError("ReadableStreamDefaultReader.prototype." + name + " can only be used on a ReadableStreamDefaultReader"); + } + var _a; + var AsyncIteratorPrototype; + if (typeof SymbolPolyfill.asyncIterator === 'symbol') { + AsyncIteratorPrototype = (_a = {}, _a[SymbolPolyfill.asyncIterator] = function () { + return this; + }, _a); + Object.defineProperty(AsyncIteratorPrototype, SymbolPolyfill.asyncIterator, { enumerable: false }); + } + var ReadableStreamAsyncIteratorPrototype = { + next: function () { + if (IsReadableStreamAsyncIterator(this) === false) { + return promiseRejectedWith(streamAsyncIteratorBrandCheckException('next')); + } + var reader = this._asyncIteratorReader; + if (reader._ownerReadableStream === undefined) { + return promiseRejectedWith(readerLockException('iterate')); + } + return transformPromiseWith(ReadableStreamDefaultReaderRead(reader), function (result) { + var done = result.done; + if (done) { + ReadableStreamReaderGenericRelease(reader); + } + var value = result.value; + return ReadableStreamCreateReadResult(value, done, true); + }); + }, + return: function (value) { + if (IsReadableStreamAsyncIterator(this) === false) { + return promiseRejectedWith(streamAsyncIteratorBrandCheckException('next')); + } + var reader = this._asyncIteratorReader; + if (reader._ownerReadableStream === undefined) { + return promiseRejectedWith(readerLockException('finish iterating')); + } + if (reader._readRequests.length > 0) { + return promiseRejectedWith(new TypeError('Tried to release a reader lock when that reader has pending read() calls un-settled')); + } + if (this._preventCancel === false) { + var result = ReadableStreamReaderGenericCancel(reader, value); + ReadableStreamReaderGenericRelease(reader); + return transformPromiseWith(result, function () { + return ReadableStreamCreateReadResult(value, true, true); + }); + } + ReadableStreamReaderGenericRelease(reader); + return promiseResolvedWith(ReadableStreamCreateReadResult(value, true, true)); + } + }; + if (AsyncIteratorPrototype !== undefined) { + Object.setPrototypeOf(ReadableStreamAsyncIteratorPrototype, AsyncIteratorPrototype); + } + Object.defineProperty(ReadableStreamAsyncIteratorPrototype, 'next', { enumerable: false }); + Object.defineProperty(ReadableStreamAsyncIteratorPrototype, 'return', { enumerable: false }); + function AcquireReadableStreamAsyncIterator(stream, preventCancel) { + if (preventCancel === void 0) { + preventCancel = false; + } + var reader = AcquireReadableStreamDefaultReader(stream); + var iterator = Object.create(ReadableStreamAsyncIteratorPrototype); + iterator._asyncIteratorReader = reader; + iterator._preventCancel = Boolean(preventCancel); + return iterator; + } + function IsReadableStreamAsyncIterator(x) { + if (!typeIsObject(x)) { + return false; + } + if (!Object.prototype.hasOwnProperty.call(x, '_asyncIteratorReader')) { + return false; + } + return true; + } + function streamAsyncIteratorBrandCheckException(name) { + return new TypeError("ReadableStreamAsyncIterator." + name + " can only be used on a ReadableSteamAsyncIterator"); + } + function DequeueValue(container) { + var pair = container._queue.shift(); + container._queueTotalSize -= pair.size; + if (container._queueTotalSize < 0) { + container._queueTotalSize = 0; + } + return pair.value; + } + function EnqueueValueWithSize(container, value, size) { + size = Number(size); + if (!IsFiniteNonNegativeNumber(size)) { + throw new RangeError('Size must be a finite, non-NaN, non-negative number.'); + } + container._queue.push({ + value: value, + size: size + }); + container._queueTotalSize += size; + } + function PeekQueueValue(container) { + var pair = container._queue.peek(); + return pair.value; + } + function ResetQueue(container) { + container._queue = new SimpleQueue(); + container._queueTotalSize = 0; + } + var AbortSteps = SymbolPolyfill('[[AbortSteps]]'); + var ErrorSteps = SymbolPolyfill('[[ErrorSteps]]'); + var WritableStream = function () { + function WritableStream(underlyingSink, strategy) { + if (underlyingSink === void 0) { + underlyingSink = {}; + } + if (strategy === void 0) { + strategy = {}; + } + InitializeWritableStream(this); + var size = strategy.size; + var highWaterMark = strategy.highWaterMark; + var type = underlyingSink.type; + if (type !== undefined) { + throw new RangeError('Invalid type is specified'); + } + var sizeAlgorithm = MakeSizeAlgorithmFromSizeFunction(size); + if (highWaterMark === undefined) { + highWaterMark = 1; + } + highWaterMark = ValidateAndNormalizeHighWaterMark(highWaterMark); + SetUpWritableStreamDefaultControllerFromUnderlyingSink(this, underlyingSink, highWaterMark, sizeAlgorithm); + } + Object.defineProperty(WritableStream.prototype, "locked", { + get: function () { + if (IsWritableStream(this) === false) { + throw streamBrandCheckException('locked'); + } + return IsWritableStreamLocked(this); + }, + enumerable: true, + configurable: true + }); + WritableStream.prototype.abort = function (reason) { + if (IsWritableStream(this) === false) { + return promiseRejectedWith(streamBrandCheckException('abort')); + } + if (IsWritableStreamLocked(this) === true) { + return promiseRejectedWith(new TypeError('Cannot abort a stream that already has a writer')); + } + return WritableStreamAbort(this, reason); + }; + WritableStream.prototype.close = function () { + if (IsWritableStream(this) === false) { + return promiseRejectedWith(streamBrandCheckException('close')); + } + if (IsWritableStreamLocked(this) === true) { + return promiseRejectedWith(new TypeError('Cannot close a stream that already has a writer')); + } + if (WritableStreamCloseQueuedOrInFlight(this) === true) { + return promiseRejectedWith(new TypeError('Cannot close an already-closing stream')); + } + return WritableStreamClose(this); + }; + WritableStream.prototype.getWriter = function () { + if (IsWritableStream(this) === false) { + throw streamBrandCheckException('getWriter'); + } + return AcquireWritableStreamDefaultWriter(this); + }; + return WritableStream; + }(); + function AcquireWritableStreamDefaultWriter(stream) { + return new WritableStreamDefaultWriter(stream); + } + function CreateWritableStream(startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm) { + if (highWaterMark === void 0) { + highWaterMark = 1; + } + if (sizeAlgorithm === void 0) { + sizeAlgorithm = function () { + return 1; + }; + } + var stream = Object.create(WritableStream.prototype); + InitializeWritableStream(stream); + var controller = Object.create(WritableStreamDefaultController.prototype); + SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm); + return stream; + } + function InitializeWritableStream(stream) { + stream._state = 'writable'; + stream._storedError = undefined; + stream._writer = undefined; + stream._writableStreamController = undefined; + stream._writeRequests = new SimpleQueue(); + stream._inFlightWriteRequest = undefined; + stream._closeRequest = undefined; + stream._inFlightCloseRequest = undefined; + stream._pendingAbortRequest = undefined; + stream._backpressure = false; + } + function IsWritableStream(x) { + if (!typeIsObject(x)) { + return false; + } + if (!Object.prototype.hasOwnProperty.call(x, '_writableStreamController')) { + return false; + } + return true; + } + function IsWritableStreamLocked(stream) { + if (stream._writer === undefined) { + return false; + } + return true; + } + function WritableStreamAbort(stream, reason) { + var state = stream._state; + if (state === 'closed' || state === 'errored') { + return promiseResolvedWith(undefined); + } + if (stream._pendingAbortRequest !== undefined) { + return stream._pendingAbortRequest._promise; + } + var wasAlreadyErroring = false; + if (state === 'erroring') { + wasAlreadyErroring = true; + reason = undefined; + } + var promise = newPromise(function (resolve, reject) { + stream._pendingAbortRequest = { + _promise: undefined, + _resolve: resolve, + _reject: reject, + _reason: reason, + _wasAlreadyErroring: wasAlreadyErroring + }; + }); + stream._pendingAbortRequest._promise = promise; + if (wasAlreadyErroring === false) { + WritableStreamStartErroring(stream, reason); + } + return promise; + } + function WritableStreamClose(stream) { + var state = stream._state; + if (state === 'closed' || state === 'errored') { + return promiseRejectedWith(new TypeError("The stream (in " + state + " state) is not in the writable state and cannot be closed")); + } + var promise = newPromise(function (resolve, reject) { + var closeRequest = { + _resolve: resolve, + _reject: reject + }; + stream._closeRequest = closeRequest; + }); + var writer = stream._writer; + if (writer !== undefined && stream._backpressure === true && state === 'writable') { + defaultWriterReadyPromiseResolve(writer); + } + WritableStreamDefaultControllerClose(stream._writableStreamController); + return promise; + } + function WritableStreamAddWriteRequest(stream) { + var promise = newPromise(function (resolve, reject) { + var writeRequest = { + _resolve: resolve, + _reject: reject + }; + stream._writeRequests.push(writeRequest); + }); + return promise; + } + function WritableStreamDealWithRejection(stream, error) { + var state = stream._state; + if (state === 'writable') { + WritableStreamStartErroring(stream, error); + return; + } + WritableStreamFinishErroring(stream); + } + function WritableStreamStartErroring(stream, reason) { + var controller = stream._writableStreamController; + stream._state = 'erroring'; + stream._storedError = reason; + var writer = stream._writer; + if (writer !== undefined) { + WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, reason); + } + if (WritableStreamHasOperationMarkedInFlight(stream) === false && controller._started === true) { + WritableStreamFinishErroring(stream); + } + } + function WritableStreamFinishErroring(stream) { + stream._state = 'errored'; + stream._writableStreamController[ErrorSteps](); + var storedError = stream._storedError; + stream._writeRequests.forEach(function (writeRequest) { + writeRequest._reject(storedError); + }); + stream._writeRequests = new SimpleQueue(); + if (stream._pendingAbortRequest === undefined) { + WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream); + return; + } + var abortRequest = stream._pendingAbortRequest; + stream._pendingAbortRequest = undefined; + if (abortRequest._wasAlreadyErroring === true) { + abortRequest._reject(storedError); + WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream); + return; + } + var promise = stream._writableStreamController[AbortSteps](abortRequest._reason); + uponPromise(promise, function () { + abortRequest._resolve(); + WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream); + }, function (reason) { + abortRequest._reject(reason); + WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream); + }); + } + function WritableStreamFinishInFlightWrite(stream) { + stream._inFlightWriteRequest._resolve(undefined); + stream._inFlightWriteRequest = undefined; + } + function WritableStreamFinishInFlightWriteWithError(stream, error) { + stream._inFlightWriteRequest._reject(error); + stream._inFlightWriteRequest = undefined; + WritableStreamDealWithRejection(stream, error); + } + function WritableStreamFinishInFlightClose(stream) { + stream._inFlightCloseRequest._resolve(undefined); + stream._inFlightCloseRequest = undefined; + var state = stream._state; + if (state === 'erroring') { + stream._storedError = undefined; + if (stream._pendingAbortRequest !== undefined) { + stream._pendingAbortRequest._resolve(); + stream._pendingAbortRequest = undefined; + } + } + stream._state = 'closed'; + var writer = stream._writer; + if (writer !== undefined) { + defaultWriterClosedPromiseResolve(writer); + } + } + function WritableStreamFinishInFlightCloseWithError(stream, error) { + stream._inFlightCloseRequest._reject(error); + stream._inFlightCloseRequest = undefined; + if (stream._pendingAbortRequest !== undefined) { + stream._pendingAbortRequest._reject(error); + stream._pendingAbortRequest = undefined; + } + WritableStreamDealWithRejection(stream, error); + } + function WritableStreamCloseQueuedOrInFlight(stream) { + if (stream._closeRequest === undefined && stream._inFlightCloseRequest === undefined) { + return false; + } + return true; + } + function WritableStreamHasOperationMarkedInFlight(stream) { + if (stream._inFlightWriteRequest === undefined && stream._inFlightCloseRequest === undefined) { + return false; + } + return true; + } + function WritableStreamMarkCloseRequestInFlight(stream) { + stream._inFlightCloseRequest = stream._closeRequest; + stream._closeRequest = undefined; + } + function WritableStreamMarkFirstWriteRequestInFlight(stream) { + stream._inFlightWriteRequest = stream._writeRequests.shift(); + } + function WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream) { + if (stream._closeRequest !== undefined) { + stream._closeRequest._reject(stream._storedError); + stream._closeRequest = undefined; + } + var writer = stream._writer; + if (writer !== undefined) { + defaultWriterClosedPromiseReject(writer, stream._storedError); + } + } + function WritableStreamUpdateBackpressure(stream, backpressure) { + var writer = stream._writer; + if (writer !== undefined && backpressure !== stream._backpressure) { + if (backpressure === true) { + defaultWriterReadyPromiseReset(writer); + } else { + defaultWriterReadyPromiseResolve(writer); + } + } + stream._backpressure = backpressure; + } + var WritableStreamDefaultWriter = function () { + function WritableStreamDefaultWriter(stream) { + if (IsWritableStream(stream) === false) { + throw new TypeError('WritableStreamDefaultWriter can only be constructed with a WritableStream instance'); + } + if (IsWritableStreamLocked(stream) === true) { + throw new TypeError('This stream has already been locked for exclusive writing by another writer'); + } + this._ownerWritableStream = stream; + stream._writer = this; + var state = stream._state; + if (state === 'writable') { + if (WritableStreamCloseQueuedOrInFlight(stream) === false && stream._backpressure === true) { + defaultWriterReadyPromiseInitialize(this); + } else { + defaultWriterReadyPromiseInitializeAsResolved(this); + } + defaultWriterClosedPromiseInitialize(this); + } else if (state === 'erroring') { + defaultWriterReadyPromiseInitializeAsRejected(this, stream._storedError); + defaultWriterClosedPromiseInitialize(this); + } else if (state === 'closed') { + defaultWriterReadyPromiseInitializeAsResolved(this); + defaultWriterClosedPromiseInitializeAsResolved(this); + } else { + var storedError = stream._storedError; + defaultWriterReadyPromiseInitializeAsRejected(this, storedError); + defaultWriterClosedPromiseInitializeAsRejected(this, storedError); + } + } + Object.defineProperty(WritableStreamDefaultWriter.prototype, "closed", { + get: function () { + if (IsWritableStreamDefaultWriter(this) === false) { + return promiseRejectedWith(defaultWriterBrandCheckException('closed')); + } + return this._closedPromise; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(WritableStreamDefaultWriter.prototype, "desiredSize", { + get: function () { + if (IsWritableStreamDefaultWriter(this) === false) { + throw defaultWriterBrandCheckException('desiredSize'); + } + if (this._ownerWritableStream === undefined) { + throw defaultWriterLockException('desiredSize'); + } + return WritableStreamDefaultWriterGetDesiredSize(this); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(WritableStreamDefaultWriter.prototype, "ready", { + get: function () { + if (IsWritableStreamDefaultWriter(this) === false) { + return promiseRejectedWith(defaultWriterBrandCheckException('ready')); + } + return this._readyPromise; + }, + enumerable: true, + configurable: true + }); + WritableStreamDefaultWriter.prototype.abort = function (reason) { + if (IsWritableStreamDefaultWriter(this) === false) { + return promiseRejectedWith(defaultWriterBrandCheckException('abort')); + } + if (this._ownerWritableStream === undefined) { + return promiseRejectedWith(defaultWriterLockException('abort')); + } + return WritableStreamDefaultWriterAbort(this, reason); + }; + WritableStreamDefaultWriter.prototype.close = function () { + if (IsWritableStreamDefaultWriter(this) === false) { + return promiseRejectedWith(defaultWriterBrandCheckException('close')); + } + var stream = this._ownerWritableStream; + if (stream === undefined) { + return promiseRejectedWith(defaultWriterLockException('close')); + } + if (WritableStreamCloseQueuedOrInFlight(stream) === true) { + return promiseRejectedWith(new TypeError('Cannot close an already-closing stream')); + } + return WritableStreamDefaultWriterClose(this); + }; + WritableStreamDefaultWriter.prototype.releaseLock = function () { + if (IsWritableStreamDefaultWriter(this) === false) { + throw defaultWriterBrandCheckException('releaseLock'); + } + var stream = this._ownerWritableStream; + if (stream === undefined) { + return; + } + WritableStreamDefaultWriterRelease(this); + }; + WritableStreamDefaultWriter.prototype.write = function (chunk) { + if (IsWritableStreamDefaultWriter(this) === false) { + return promiseRejectedWith(defaultWriterBrandCheckException('write')); + } + if (this._ownerWritableStream === undefined) { + return promiseRejectedWith(defaultWriterLockException('write to')); + } + return WritableStreamDefaultWriterWrite(this, chunk); + }; + return WritableStreamDefaultWriter; + }(); + function IsWritableStreamDefaultWriter(x) { + if (!typeIsObject(x)) { + return false; + } + if (!Object.prototype.hasOwnProperty.call(x, '_ownerWritableStream')) { + return false; + } + return true; + } + function WritableStreamDefaultWriterAbort(writer, reason) { + var stream = writer._ownerWritableStream; + return WritableStreamAbort(stream, reason); + } + function WritableStreamDefaultWriterClose(writer) { + var stream = writer._ownerWritableStream; + return WritableStreamClose(stream); + } + function WritableStreamDefaultWriterCloseWithErrorPropagation(writer) { + var stream = writer._ownerWritableStream; + var state = stream._state; + if (WritableStreamCloseQueuedOrInFlight(stream) === true || state === 'closed') { + return promiseResolvedWith(undefined); + } + if (state === 'errored') { + return promiseRejectedWith(stream._storedError); + } + return WritableStreamDefaultWriterClose(writer); + } + function WritableStreamDefaultWriterEnsureClosedPromiseRejected(writer, error) { + if (writer._closedPromiseState === 'pending') { + defaultWriterClosedPromiseReject(writer, error); + } else { + defaultWriterClosedPromiseResetToRejected(writer, error); + } + } + function WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, error) { + if (writer._readyPromiseState === 'pending') { + defaultWriterReadyPromiseReject(writer, error); + } else { + defaultWriterReadyPromiseResetToRejected(writer, error); + } + } + function WritableStreamDefaultWriterGetDesiredSize(writer) { + var stream = writer._ownerWritableStream; + var state = stream._state; + if (state === 'errored' || state === 'erroring') { + return null; + } + if (state === 'closed') { + return 0; + } + return WritableStreamDefaultControllerGetDesiredSize(stream._writableStreamController); + } + function WritableStreamDefaultWriterRelease(writer) { + var stream = writer._ownerWritableStream; + var releasedError = new TypeError('Writer was released and can no longer be used to monitor the stream\'s closedness'); + WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, releasedError); + WritableStreamDefaultWriterEnsureClosedPromiseRejected(writer, releasedError); + stream._writer = undefined; + writer._ownerWritableStream = undefined; + } + function WritableStreamDefaultWriterWrite(writer, chunk) { + var stream = writer._ownerWritableStream; + var controller = stream._writableStreamController; + var chunkSize = WritableStreamDefaultControllerGetChunkSize(controller, chunk); + if (stream !== writer._ownerWritableStream) { + return promiseRejectedWith(defaultWriterLockException('write to')); + } + var state = stream._state; + if (state === 'errored') { + return promiseRejectedWith(stream._storedError); + } + if (WritableStreamCloseQueuedOrInFlight(stream) === true || state === 'closed') { + return promiseRejectedWith(new TypeError('The stream is closing or closed and cannot be written to')); + } + if (state === 'erroring') { + return promiseRejectedWith(stream._storedError); + } + var promise = WritableStreamAddWriteRequest(stream); + WritableStreamDefaultControllerWrite(controller, chunk, chunkSize); + return promise; + } + var WritableStreamDefaultController = function () { + function WritableStreamDefaultController() { + throw new TypeError('WritableStreamDefaultController cannot be constructed explicitly'); + } + WritableStreamDefaultController.prototype.error = function (e) { + if (IsWritableStreamDefaultController(this) === false) { + throw new TypeError('WritableStreamDefaultController.prototype.error can only be used on a WritableStreamDefaultController'); + } + var state = this._controlledWritableStream._state; + if (state !== 'writable') { + return; + } + WritableStreamDefaultControllerError(this, e); + }; + WritableStreamDefaultController.prototype[AbortSteps] = function (reason) { + var result = this._abortAlgorithm(reason); + WritableStreamDefaultControllerClearAlgorithms(this); + return result; + }; + WritableStreamDefaultController.prototype[ErrorSteps] = function () { + ResetQueue(this); + }; + return WritableStreamDefaultController; + }(); + function IsWritableStreamDefaultController(x) { + if (!typeIsObject(x)) { + return false; + } + if (!Object.prototype.hasOwnProperty.call(x, '_controlledWritableStream')) { + return false; + } + return true; + } + function SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm) { + controller._controlledWritableStream = stream; + stream._writableStreamController = controller; + controller._queue = undefined; + controller._queueTotalSize = undefined; + ResetQueue(controller); + controller._started = false; + controller._strategySizeAlgorithm = sizeAlgorithm; + controller._strategyHWM = highWaterMark; + controller._writeAlgorithm = writeAlgorithm; + controller._closeAlgorithm = closeAlgorithm; + controller._abortAlgorithm = abortAlgorithm; + var backpressure = WritableStreamDefaultControllerGetBackpressure(controller); + WritableStreamUpdateBackpressure(stream, backpressure); + var startResult = startAlgorithm(); + var startPromise = promiseResolvedWith(startResult); + uponPromise(startPromise, function () { + controller._started = true; + WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller); + }, function (r) { + controller._started = true; + WritableStreamDealWithRejection(stream, r); + }); + } + function SetUpWritableStreamDefaultControllerFromUnderlyingSink(stream, underlyingSink, highWaterMark, sizeAlgorithm) { + var controller = Object.create(WritableStreamDefaultController.prototype); + function startAlgorithm() { + return InvokeOrNoop(underlyingSink, 'start', [controller]); + } + var writeAlgorithm = CreateAlgorithmFromUnderlyingMethod(underlyingSink, 'write', 1, [controller]); + var closeAlgorithm = CreateAlgorithmFromUnderlyingMethod(underlyingSink, 'close', 0, []); + var abortAlgorithm = CreateAlgorithmFromUnderlyingMethod(underlyingSink, 'abort', 1, []); + SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm); + } + function WritableStreamDefaultControllerClearAlgorithms(controller) { + controller._writeAlgorithm = undefined; + controller._closeAlgorithm = undefined; + controller._abortAlgorithm = undefined; + controller._strategySizeAlgorithm = undefined; + } + function WritableStreamDefaultControllerClose(controller) { + EnqueueValueWithSize(controller, 'close', 0); + WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller); + } + function WritableStreamDefaultControllerGetChunkSize(controller, chunk) { + try { + return controller._strategySizeAlgorithm(chunk); + } catch (chunkSizeE) { + WritableStreamDefaultControllerErrorIfNeeded(controller, chunkSizeE); + return 1; + } + } + function WritableStreamDefaultControllerGetDesiredSize(controller) { + return controller._strategyHWM - controller._queueTotalSize; + } + function WritableStreamDefaultControllerWrite(controller, chunk, chunkSize) { + var writeRecord = { chunk: chunk }; + try { + EnqueueValueWithSize(controller, writeRecord, chunkSize); + } catch (enqueueE) { + WritableStreamDefaultControllerErrorIfNeeded(controller, enqueueE); + return; + } + var stream = controller._controlledWritableStream; + if (WritableStreamCloseQueuedOrInFlight(stream) === false && stream._state === 'writable') { + var backpressure = WritableStreamDefaultControllerGetBackpressure(controller); + WritableStreamUpdateBackpressure(stream, backpressure); + } + WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller); + } + function WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller) { + var stream = controller._controlledWritableStream; + if (controller._started === false) { + return; + } + if (stream._inFlightWriteRequest !== undefined) { + return; + } + var state = stream._state; + if (state === 'erroring') { + WritableStreamFinishErroring(stream); + return; + } + if (controller._queue.length === 0) { + return; + } + var writeRecord = PeekQueueValue(controller); + if (writeRecord === 'close') { + WritableStreamDefaultControllerProcessClose(controller); + } else { + WritableStreamDefaultControllerProcessWrite(controller, writeRecord.chunk); + } + } + function WritableStreamDefaultControllerErrorIfNeeded(controller, error) { + if (controller._controlledWritableStream._state === 'writable') { + WritableStreamDefaultControllerError(controller, error); + } + } + function WritableStreamDefaultControllerProcessClose(controller) { + var stream = controller._controlledWritableStream; + WritableStreamMarkCloseRequestInFlight(stream); + DequeueValue(controller); + var sinkClosePromise = controller._closeAlgorithm(); + WritableStreamDefaultControllerClearAlgorithms(controller); + uponPromise(sinkClosePromise, function () { + WritableStreamFinishInFlightClose(stream); + }, function (reason) { + WritableStreamFinishInFlightCloseWithError(stream, reason); + }); + } + function WritableStreamDefaultControllerProcessWrite(controller, chunk) { + var stream = controller._controlledWritableStream; + WritableStreamMarkFirstWriteRequestInFlight(stream); + var sinkWritePromise = controller._writeAlgorithm(chunk); + uponPromise(sinkWritePromise, function () { + WritableStreamFinishInFlightWrite(stream); + var state = stream._state; + DequeueValue(controller); + if (WritableStreamCloseQueuedOrInFlight(stream) === false && state === 'writable') { + var backpressure = WritableStreamDefaultControllerGetBackpressure(controller); + WritableStreamUpdateBackpressure(stream, backpressure); + } + WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller); + }, function (reason) { + if (stream._state === 'writable') { + WritableStreamDefaultControllerClearAlgorithms(controller); + } + WritableStreamFinishInFlightWriteWithError(stream, reason); + }); + } + function WritableStreamDefaultControllerGetBackpressure(controller) { + var desiredSize = WritableStreamDefaultControllerGetDesiredSize(controller); + return desiredSize <= 0; + } + function WritableStreamDefaultControllerError(controller, error) { + var stream = controller._controlledWritableStream; + WritableStreamDefaultControllerClearAlgorithms(controller); + WritableStreamStartErroring(stream, error); + } + function streamBrandCheckException(name) { + return new TypeError("WritableStream.prototype." + name + " can only be used on a WritableStream"); + } + function defaultWriterBrandCheckException(name) { + return new TypeError("WritableStreamDefaultWriter.prototype." + name + " can only be used on a WritableStreamDefaultWriter"); + } + function defaultWriterLockException(name) { + return new TypeError('Cannot ' + name + ' a stream using a released writer'); + } + function defaultWriterClosedPromiseInitialize(writer) { + writer._closedPromise = newPromise(function (resolve, reject) { + writer._closedPromise_resolve = resolve; + writer._closedPromise_reject = reject; + writer._closedPromiseState = 'pending'; + }); + } + function defaultWriterClosedPromiseInitializeAsRejected(writer, reason) { + defaultWriterClosedPromiseInitialize(writer); + defaultWriterClosedPromiseReject(writer, reason); + } + function defaultWriterClosedPromiseInitializeAsResolved(writer) { + defaultWriterClosedPromiseInitialize(writer); + defaultWriterClosedPromiseResolve(writer); + } + function defaultWriterClosedPromiseReject(writer, reason) { + setPromiseIsHandledToTrue(writer._closedPromise); + writer._closedPromise_reject(reason); + writer._closedPromise_resolve = undefined; + writer._closedPromise_reject = undefined; + writer._closedPromiseState = 'rejected'; + } + function defaultWriterClosedPromiseResetToRejected(writer, reason) { + defaultWriterClosedPromiseInitializeAsRejected(writer, reason); + } + function defaultWriterClosedPromiseResolve(writer) { + writer._closedPromise_resolve(undefined); + writer._closedPromise_resolve = undefined; + writer._closedPromise_reject = undefined; + writer._closedPromiseState = 'resolved'; + } + function defaultWriterReadyPromiseInitialize(writer) { + writer._readyPromise = newPromise(function (resolve, reject) { + writer._readyPromise_resolve = resolve; + writer._readyPromise_reject = reject; + }); + writer._readyPromiseState = 'pending'; + } + function defaultWriterReadyPromiseInitializeAsRejected(writer, reason) { + defaultWriterReadyPromiseInitialize(writer); + defaultWriterReadyPromiseReject(writer, reason); + } + function defaultWriterReadyPromiseInitializeAsResolved(writer) { + defaultWriterReadyPromiseInitialize(writer); + defaultWriterReadyPromiseResolve(writer); + } + function defaultWriterReadyPromiseReject(writer, reason) { + setPromiseIsHandledToTrue(writer._readyPromise); + writer._readyPromise_reject(reason); + writer._readyPromise_resolve = undefined; + writer._readyPromise_reject = undefined; + writer._readyPromiseState = 'rejected'; + } + function defaultWriterReadyPromiseReset(writer) { + defaultWriterReadyPromiseInitialize(writer); + } + function defaultWriterReadyPromiseResetToRejected(writer, reason) { + defaultWriterReadyPromiseInitializeAsRejected(writer, reason); + } + function defaultWriterReadyPromiseResolve(writer) { + writer._readyPromise_resolve(undefined); + writer._readyPromise_resolve = undefined; + writer._readyPromise_reject = undefined; + writer._readyPromiseState = 'fulfilled'; + } + function isAbortSignal(value) { + if (typeof value !== 'object' || value === null) { + return false; + } + try { + return typeof value.aborted === 'boolean'; + } catch (_a) { + return false; + } + } + var NativeDOMException = typeof DOMException !== 'undefined' ? DOMException : undefined; + function isDOMExceptionConstructor(ctor) { + if (!(typeof ctor === 'function' || typeof ctor === 'object')) { + return false; + } + try { + new ctor(); + return true; + } catch (_a) { + return false; + } + } + function createDOMExceptionPolyfill() { + var ctor = function DOMException(message, name) { + this.message = message || ''; + this.name = name || 'Error'; + if (Error.captureStackTrace) { + Error.captureStackTrace(this, this.constructor); + } + }; + ctor.prototype = Object.create(Error.prototype); + Object.defineProperty(ctor.prototype, 'constructor', { + value: ctor, + writable: true, + configurable: true + }); + return ctor; + } + var DOMException$1 = isDOMExceptionConstructor(NativeDOMException) ? NativeDOMException : createDOMExceptionPolyfill(); + function ReadableStreamPipeTo(source, dest, preventClose, preventAbort, preventCancel, signal) { + var reader = AcquireReadableStreamDefaultReader(source); + var writer = AcquireWritableStreamDefaultWriter(dest); + source._disturbed = true; + var shuttingDown = false; + var currentWrite = promiseResolvedWith(undefined); + return newPromise(function (resolve, reject) { + var abortAlgorithm; + if (signal !== undefined) { + abortAlgorithm = function () { + var error = new DOMException$1('Aborted', 'AbortError'); + var actions = []; + if (preventAbort === false) { + actions.push(function () { + if (dest._state === 'writable') { + return WritableStreamAbort(dest, error); + } + return promiseResolvedWith(undefined); + }); + } + if (preventCancel === false) { + actions.push(function () { + if (source._state === 'readable') { + return ReadableStreamCancel(source, error); + } + return promiseResolvedWith(undefined); + }); + } + shutdownWithAction(function () { + return Promise.all(actions.map(function (action) { + return action(); + })); + }, true, error); + }; + if (signal.aborted === true) { + abortAlgorithm(); + return; + } + signal.addEventListener('abort', abortAlgorithm); + } + function pipeLoop() { + return newPromise(function (resolveLoop, rejectLoop) { + function next(done) { + if (done) { + resolveLoop(); + } else { + PerformPromiseThen(pipeStep(), next, rejectLoop); + } + } + next(false); + }); + } + function pipeStep() { + if (shuttingDown === true) { + return promiseResolvedWith(true); + } + return PerformPromiseThen(writer._readyPromise, function () { + return PerformPromiseThen(ReadableStreamDefaultReaderRead(reader), function (result) { + if (result.done === true) { + return true; + } + currentWrite = PerformPromiseThen(WritableStreamDefaultWriterWrite(writer, result.value), undefined, noop); + return false; + }); + }); + } + isOrBecomesErrored(source, reader._closedPromise, function (storedError) { + if (preventAbort === false) { + shutdownWithAction(function () { + return WritableStreamAbort(dest, storedError); + }, true, storedError); + } else { + shutdown(true, storedError); + } + }); + isOrBecomesErrored(dest, writer._closedPromise, function (storedError) { + if (preventCancel === false) { + shutdownWithAction(function () { + return ReadableStreamCancel(source, storedError); + }, true, storedError); + } else { + shutdown(true, storedError); + } + }); + isOrBecomesClosed(source, reader._closedPromise, function () { + if (preventClose === false) { + shutdownWithAction(function () { + return WritableStreamDefaultWriterCloseWithErrorPropagation(writer); + }); + } else { + shutdown(); + } + }); + if (WritableStreamCloseQueuedOrInFlight(dest) === true || dest._state === 'closed') { + var destClosed_1 = new TypeError('the destination writable stream closed before all data could be piped to it'); + if (preventCancel === false) { + shutdownWithAction(function () { + return ReadableStreamCancel(source, destClosed_1); + }, true, destClosed_1); + } else { + shutdown(true, destClosed_1); + } + } + setPromiseIsHandledToTrue(pipeLoop()); + function waitForWritesToFinish() { + var oldCurrentWrite = currentWrite; + return PerformPromiseThen(currentWrite, function () { + return oldCurrentWrite !== currentWrite ? waitForWritesToFinish() : undefined; + }); + } + function isOrBecomesErrored(stream, promise, action) { + if (stream._state === 'errored') { + action(stream._storedError); + } else { + uponRejection(promise, action); + } + } + function isOrBecomesClosed(stream, promise, action) { + if (stream._state === 'closed') { + action(); + } else { + uponFulfillment(promise, action); + } + } + function shutdownWithAction(action, originalIsError, originalError) { + if (shuttingDown === true) { + return; + } + shuttingDown = true; + if (dest._state === 'writable' && WritableStreamCloseQueuedOrInFlight(dest) === false) { + uponFulfillment(waitForWritesToFinish(), doTheRest); + } else { + doTheRest(); + } + function doTheRest() { + uponPromise(action(), function () { + return finalize(originalIsError, originalError); + }, function (newError) { + return finalize(true, newError); + }); + } + } + function shutdown(isError, error) { + if (shuttingDown === true) { + return; + } + shuttingDown = true; + if (dest._state === 'writable' && WritableStreamCloseQueuedOrInFlight(dest) === false) { + uponFulfillment(waitForWritesToFinish(), function () { + return finalize(isError, error); + }); + } else { + finalize(isError, error); + } + } + function finalize(isError, error) { + WritableStreamDefaultWriterRelease(writer); + ReadableStreamReaderGenericRelease(reader); + if (signal !== undefined) { + signal.removeEventListener('abort', abortAlgorithm); + } + if (isError) { + reject(error); + } else { + resolve(undefined); + } + } + }); + } + var ReadableStreamDefaultController = function () { + function ReadableStreamDefaultController() { + throw new TypeError(); + } + Object.defineProperty(ReadableStreamDefaultController.prototype, "desiredSize", { + get: function () { + if (IsReadableStreamDefaultController(this) === false) { + throw defaultControllerBrandCheckException('desiredSize'); + } + return ReadableStreamDefaultControllerGetDesiredSize(this); + }, + enumerable: true, + configurable: true + }); + ReadableStreamDefaultController.prototype.close = function () { + if (IsReadableStreamDefaultController(this) === false) { + throw defaultControllerBrandCheckException('close'); + } + if (ReadableStreamDefaultControllerCanCloseOrEnqueue(this) === false) { + throw new TypeError('The stream is not in a state that permits close'); + } + ReadableStreamDefaultControllerClose(this); + }; + ReadableStreamDefaultController.prototype.enqueue = function (chunk) { + if (IsReadableStreamDefaultController(this) === false) { + throw defaultControllerBrandCheckException('enqueue'); + } + if (ReadableStreamDefaultControllerCanCloseOrEnqueue(this) === false) { + throw new TypeError('The stream is not in a state that permits enqueue'); + } + return ReadableStreamDefaultControllerEnqueue(this, chunk); + }; + ReadableStreamDefaultController.prototype.error = function (e) { + if (IsReadableStreamDefaultController(this) === false) { + throw defaultControllerBrandCheckException('error'); + } + ReadableStreamDefaultControllerError(this, e); + }; + ReadableStreamDefaultController.prototype[CancelSteps] = function (reason) { + ResetQueue(this); + var result = this._cancelAlgorithm(reason); + ReadableStreamDefaultControllerClearAlgorithms(this); + return result; + }; + ReadableStreamDefaultController.prototype[PullSteps] = function () { + var stream = this._controlledReadableStream; + if (this._queue.length > 0) { + var chunk = DequeueValue(this); + if (this._closeRequested === true && this._queue.length === 0) { + ReadableStreamDefaultControllerClearAlgorithms(this); + ReadableStreamClose(stream); + } else { + ReadableStreamDefaultControllerCallPullIfNeeded(this); + } + return promiseResolvedWith(ReadableStreamCreateReadResult(chunk, false, stream._reader._forAuthorCode)); + } + var pendingPromise = ReadableStreamAddReadRequest(stream); + ReadableStreamDefaultControllerCallPullIfNeeded(this); + return pendingPromise; + }; + return ReadableStreamDefaultController; + }(); + function IsReadableStreamDefaultController(x) { + if (!typeIsObject(x)) { + return false; + } + if (!Object.prototype.hasOwnProperty.call(x, '_controlledReadableStream')) { + return false; + } + return true; + } + function ReadableStreamDefaultControllerCallPullIfNeeded(controller) { + var shouldPull = ReadableStreamDefaultControllerShouldCallPull(controller); + if (shouldPull === false) { + return; + } + if (controller._pulling === true) { + controller._pullAgain = true; + return; + } + controller._pulling = true; + var pullPromise = controller._pullAlgorithm(); + uponPromise(pullPromise, function () { + controller._pulling = false; + if (controller._pullAgain === true) { + controller._pullAgain = false; + ReadableStreamDefaultControllerCallPullIfNeeded(controller); + } + }, function (e) { + ReadableStreamDefaultControllerError(controller, e); + }); + } + function ReadableStreamDefaultControllerShouldCallPull(controller) { + var stream = controller._controlledReadableStream; + if (ReadableStreamDefaultControllerCanCloseOrEnqueue(controller) === false) { + return false; + } + if (controller._started === false) { + return false; + } + if (IsReadableStreamLocked(stream) === true && ReadableStreamGetNumReadRequests(stream) > 0) { + return true; + } + var desiredSize = ReadableStreamDefaultControllerGetDesiredSize(controller); + if (desiredSize > 0) { + return true; + } + return false; + } + function ReadableStreamDefaultControllerClearAlgorithms(controller) { + controller._pullAlgorithm = undefined; + controller._cancelAlgorithm = undefined; + controller._strategySizeAlgorithm = undefined; + } + function ReadableStreamDefaultControllerClose(controller) { + var stream = controller._controlledReadableStream; + controller._closeRequested = true; + if (controller._queue.length === 0) { + ReadableStreamDefaultControllerClearAlgorithms(controller); + ReadableStreamClose(stream); + } + } + function ReadableStreamDefaultControllerEnqueue(controller, chunk) { + var stream = controller._controlledReadableStream; + if (IsReadableStreamLocked(stream) === true && ReadableStreamGetNumReadRequests(stream) > 0) { + ReadableStreamFulfillReadRequest(stream, chunk, false); + } else { + var chunkSize = void 0; + try { + chunkSize = controller._strategySizeAlgorithm(chunk); + } catch (chunkSizeE) { + ReadableStreamDefaultControllerError(controller, chunkSizeE); + throw chunkSizeE; + } + try { + EnqueueValueWithSize(controller, chunk, chunkSize); + } catch (enqueueE) { + ReadableStreamDefaultControllerError(controller, enqueueE); + throw enqueueE; + } + } + ReadableStreamDefaultControllerCallPullIfNeeded(controller); + } + function ReadableStreamDefaultControllerError(controller, e) { + var stream = controller._controlledReadableStream; + if (stream._state !== 'readable') { + return; + } + ResetQueue(controller); + ReadableStreamDefaultControllerClearAlgorithms(controller); + ReadableStreamError(stream, e); + } + function ReadableStreamDefaultControllerGetDesiredSize(controller) { + var stream = controller._controlledReadableStream; + var state = stream._state; + if (state === 'errored') { + return null; + } + if (state === 'closed') { + return 0; + } + return controller._strategyHWM - controller._queueTotalSize; + } + function ReadableStreamDefaultControllerHasBackpressure(controller) { + if (ReadableStreamDefaultControllerShouldCallPull(controller) === true) { + return false; + } + return true; + } + function ReadableStreamDefaultControllerCanCloseOrEnqueue(controller) { + var state = controller._controlledReadableStream._state; + if (controller._closeRequested === false && state === 'readable') { + return true; + } + return false; + } + function SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm) { + controller._controlledReadableStream = stream; + controller._queue = undefined; + controller._queueTotalSize = undefined; + ResetQueue(controller); + controller._started = false; + controller._closeRequested = false; + controller._pullAgain = false; + controller._pulling = false; + controller._strategySizeAlgorithm = sizeAlgorithm; + controller._strategyHWM = highWaterMark; + controller._pullAlgorithm = pullAlgorithm; + controller._cancelAlgorithm = cancelAlgorithm; + stream._readableStreamController = controller; + var startResult = startAlgorithm(); + uponPromise(promiseResolvedWith(startResult), function () { + controller._started = true; + ReadableStreamDefaultControllerCallPullIfNeeded(controller); + }, function (r) { + ReadableStreamDefaultControllerError(controller, r); + }); + } + function SetUpReadableStreamDefaultControllerFromUnderlyingSource(stream, underlyingSource, highWaterMark, sizeAlgorithm) { + var controller = Object.create(ReadableStreamDefaultController.prototype); + function startAlgorithm() { + return InvokeOrNoop(underlyingSource, 'start', [controller]); + } + var pullAlgorithm = CreateAlgorithmFromUnderlyingMethod(underlyingSource, 'pull', 0, [controller]); + var cancelAlgorithm = CreateAlgorithmFromUnderlyingMethod(underlyingSource, 'cancel', 1, []); + SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm); + } + function defaultControllerBrandCheckException(name) { + return new TypeError("ReadableStreamDefaultController.prototype." + name + " can only be used on a ReadableStreamDefaultController"); + } + function ReadableStreamTee(stream, cloneForBranch2) { + var reader = AcquireReadableStreamDefaultReader(stream); + var reading = false; + var canceled1 = false; + var canceled2 = false; + var reason1; + var reason2; + var branch1; + var branch2; + var resolveCancelPromise; + var cancelPromise = newPromise(function (resolve) { + resolveCancelPromise = resolve; + }); + function pullAlgorithm() { + if (reading === true) { + return promiseResolvedWith(undefined); + } + reading = true; + var readPromise = transformPromiseWith(ReadableStreamDefaultReaderRead(reader), function (result) { + reading = false; + var done = result.done; + if (done === true) { + if (canceled1 === false) { + ReadableStreamDefaultControllerClose(branch1._readableStreamController); + } + if (canceled2 === false) { + ReadableStreamDefaultControllerClose(branch2._readableStreamController); + } + return; + } + var value = result.value; + var value1 = value; + var value2 = value; + if (canceled1 === false) { + ReadableStreamDefaultControllerEnqueue(branch1._readableStreamController, value1); + } + if (canceled2 === false) { + ReadableStreamDefaultControllerEnqueue(branch2._readableStreamController, value2); + } + }); + setPromiseIsHandledToTrue(readPromise); + return promiseResolvedWith(undefined); + } + function cancel1Algorithm(reason) { + canceled1 = true; + reason1 = reason; + if (canceled2 === true) { + var compositeReason = createArrayFromList([ + reason1, + reason2 + ]); + var cancelResult = ReadableStreamCancel(stream, compositeReason); + resolveCancelPromise(cancelResult); + } + return cancelPromise; + } + function cancel2Algorithm(reason) { + canceled2 = true; + reason2 = reason; + if (canceled1 === true) { + var compositeReason = createArrayFromList([ + reason1, + reason2 + ]); + var cancelResult = ReadableStreamCancel(stream, compositeReason); + resolveCancelPromise(cancelResult); + } + return cancelPromise; + } + function startAlgorithm() { + } + branch1 = CreateReadableStream(startAlgorithm, pullAlgorithm, cancel1Algorithm); + branch2 = CreateReadableStream(startAlgorithm, pullAlgorithm, cancel2Algorithm); + uponRejection(reader._closedPromise, function (r) { + ReadableStreamDefaultControllerError(branch1._readableStreamController, r); + ReadableStreamDefaultControllerError(branch2._readableStreamController, r); + }); + return [ + branch1, + branch2 + ]; + } + var NumberIsInteger = Number.isInteger || function (value) { + return typeof value === 'number' && isFinite(value) && Math.floor(value) === value; + }; + var ReadableStreamBYOBRequest = function () { + function ReadableStreamBYOBRequest() { + throw new TypeError('ReadableStreamBYOBRequest cannot be used directly'); + } + Object.defineProperty(ReadableStreamBYOBRequest.prototype, "view", { + get: function () { + if (IsReadableStreamBYOBRequest(this) === false) { + throw byobRequestBrandCheckException('view'); + } + return this._view; + }, + enumerable: true, + configurable: true + }); + ReadableStreamBYOBRequest.prototype.respond = function (bytesWritten) { + if (IsReadableStreamBYOBRequest(this) === false) { + throw byobRequestBrandCheckException('respond'); + } + if (this._associatedReadableByteStreamController === undefined) { + throw new TypeError('This BYOB request has been invalidated'); + } + if (IsDetachedBuffer(this._view.buffer) === true); + ReadableByteStreamControllerRespond(this._associatedReadableByteStreamController, bytesWritten); + }; + ReadableStreamBYOBRequest.prototype.respondWithNewView = function (view) { + if (IsReadableStreamBYOBRequest(this) === false) { + throw byobRequestBrandCheckException('respond'); + } + if (this._associatedReadableByteStreamController === undefined) { + throw new TypeError('This BYOB request has been invalidated'); + } + if (!ArrayBuffer.isView(view)) { + throw new TypeError('You can only respond with array buffer views'); + } + if (IsDetachedBuffer(view.buffer) === true); + ReadableByteStreamControllerRespondWithNewView(this._associatedReadableByteStreamController, view); + }; + return ReadableStreamBYOBRequest; + }(); + var ReadableByteStreamController = function () { + function ReadableByteStreamController() { + throw new TypeError('ReadableByteStreamController constructor cannot be used directly'); + } + Object.defineProperty(ReadableByteStreamController.prototype, "byobRequest", { + get: function () { + if (IsReadableByteStreamController(this) === false) { + throw byteStreamControllerBrandCheckException('byobRequest'); + } + if (this._byobRequest === undefined && this._pendingPullIntos.length > 0) { + var firstDescriptor = this._pendingPullIntos.peek(); + var view = new Uint8Array(firstDescriptor.buffer, firstDescriptor.byteOffset + firstDescriptor.bytesFilled, firstDescriptor.byteLength - firstDescriptor.bytesFilled); + var byobRequest = Object.create(ReadableStreamBYOBRequest.prototype); + SetUpReadableStreamBYOBRequest(byobRequest, this, view); + this._byobRequest = byobRequest; + } + return this._byobRequest; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ReadableByteStreamController.prototype, "desiredSize", { + get: function () { + if (IsReadableByteStreamController(this) === false) { + throw byteStreamControllerBrandCheckException('desiredSize'); + } + return ReadableByteStreamControllerGetDesiredSize(this); + }, + enumerable: true, + configurable: true + }); + ReadableByteStreamController.prototype.close = function () { + if (IsReadableByteStreamController(this) === false) { + throw byteStreamControllerBrandCheckException('close'); + } + if (this._closeRequested === true) { + throw new TypeError('The stream has already been closed; do not close it again!'); + } + var state = this._controlledReadableByteStream._state; + if (state !== 'readable') { + throw new TypeError("The stream (in " + state + " state) is not in the readable state and cannot be closed"); + } + ReadableByteStreamControllerClose(this); + }; + ReadableByteStreamController.prototype.enqueue = function (chunk) { + if (IsReadableByteStreamController(this) === false) { + throw byteStreamControllerBrandCheckException('enqueue'); + } + if (this._closeRequested === true) { + throw new TypeError('stream is closed or draining'); + } + var state = this._controlledReadableByteStream._state; + if (state !== 'readable') { + throw new TypeError("The stream (in " + state + " state) is not in the readable state and cannot be enqueued to"); + } + if (!ArrayBuffer.isView(chunk)) { + throw new TypeError('You can only enqueue array buffer views when using a ReadableByteStreamController'); + } + if (IsDetachedBuffer(chunk.buffer) === true); + ReadableByteStreamControllerEnqueue(this, chunk); + }; + ReadableByteStreamController.prototype.error = function (e) { + if (IsReadableByteStreamController(this) === false) { + throw byteStreamControllerBrandCheckException('error'); + } + ReadableByteStreamControllerError(this, e); + }; + ReadableByteStreamController.prototype[CancelSteps] = function (reason) { + if (this._pendingPullIntos.length > 0) { + var firstDescriptor = this._pendingPullIntos.peek(); + firstDescriptor.bytesFilled = 0; + } + ResetQueue(this); + var result = this._cancelAlgorithm(reason); + ReadableByteStreamControllerClearAlgorithms(this); + return result; + }; + ReadableByteStreamController.prototype[PullSteps] = function () { + var stream = this._controlledReadableByteStream; + if (this._queueTotalSize > 0) { + var entry = this._queue.shift(); + this._queueTotalSize -= entry.byteLength; + ReadableByteStreamControllerHandleQueueDrain(this); + var view = void 0; + try { + view = new Uint8Array(entry.buffer, entry.byteOffset, entry.byteLength); + } catch (viewE) { + return promiseRejectedWith(viewE); + } + return promiseResolvedWith(ReadableStreamCreateReadResult(view, false, stream._reader._forAuthorCode)); + } + var autoAllocateChunkSize = this._autoAllocateChunkSize; + if (autoAllocateChunkSize !== undefined) { + var buffer = void 0; + try { + buffer = new ArrayBuffer(autoAllocateChunkSize); + } catch (bufferE) { + return promiseRejectedWith(bufferE); + } + var pullIntoDescriptor = { + buffer: buffer, + byteOffset: 0, + byteLength: autoAllocateChunkSize, + bytesFilled: 0, + elementSize: 1, + ctor: Uint8Array, + readerType: 'default' + }; + this._pendingPullIntos.push(pullIntoDescriptor); + } + var promise = ReadableStreamAddReadRequest(stream); + ReadableByteStreamControllerCallPullIfNeeded(this); + return promise; + }; + return ReadableByteStreamController; + }(); + function IsReadableByteStreamController(x) { + if (!typeIsObject(x)) { + return false; + } + if (!Object.prototype.hasOwnProperty.call(x, '_controlledReadableByteStream')) { + return false; + } + return true; + } + function IsReadableStreamBYOBRequest(x) { + if (!typeIsObject(x)) { + return false; + } + if (!Object.prototype.hasOwnProperty.call(x, '_associatedReadableByteStreamController')) { + return false; + } + return true; + } + function ReadableByteStreamControllerCallPullIfNeeded(controller) { + var shouldPull = ReadableByteStreamControllerShouldCallPull(controller); + if (shouldPull === false) { + return; + } + if (controller._pulling === true) { + controller._pullAgain = true; + return; + } + controller._pulling = true; + var pullPromise = controller._pullAlgorithm(); + uponPromise(pullPromise, function () { + controller._pulling = false; + if (controller._pullAgain === true) { + controller._pullAgain = false; + ReadableByteStreamControllerCallPullIfNeeded(controller); + } + }, function (e) { + ReadableByteStreamControllerError(controller, e); + }); + } + function ReadableByteStreamControllerClearPendingPullIntos(controller) { + ReadableByteStreamControllerInvalidateBYOBRequest(controller); + controller._pendingPullIntos = new SimpleQueue(); + } + function ReadableByteStreamControllerCommitPullIntoDescriptor(stream, pullIntoDescriptor) { + var done = false; + if (stream._state === 'closed') { + done = true; + } + var filledView = ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor); + if (pullIntoDescriptor.readerType === 'default') { + ReadableStreamFulfillReadRequest(stream, filledView, done); + } else { + ReadableStreamFulfillReadIntoRequest(stream, filledView, done); + } + } + function ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor) { + var bytesFilled = pullIntoDescriptor.bytesFilled; + var elementSize = pullIntoDescriptor.elementSize; + return new pullIntoDescriptor.ctor(pullIntoDescriptor.buffer, pullIntoDescriptor.byteOffset, bytesFilled / elementSize); + } + function ReadableByteStreamControllerEnqueueChunkToQueue(controller, buffer, byteOffset, byteLength) { + controller._queue.push({ + buffer: buffer, + byteOffset: byteOffset, + byteLength: byteLength + }); + controller._queueTotalSize += byteLength; + } + function ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) { + var elementSize = pullIntoDescriptor.elementSize; + var currentAlignedBytes = pullIntoDescriptor.bytesFilled - pullIntoDescriptor.bytesFilled % elementSize; + var maxBytesToCopy = Math.min(controller._queueTotalSize, pullIntoDescriptor.byteLength - pullIntoDescriptor.bytesFilled); + var maxBytesFilled = pullIntoDescriptor.bytesFilled + maxBytesToCopy; + var maxAlignedBytes = maxBytesFilled - maxBytesFilled % elementSize; + var totalBytesToCopyRemaining = maxBytesToCopy; + var ready = false; + if (maxAlignedBytes > currentAlignedBytes) { + totalBytesToCopyRemaining = maxAlignedBytes - pullIntoDescriptor.bytesFilled; + ready = true; + } + var queue = controller._queue; + while (totalBytesToCopyRemaining > 0) { + var headOfQueue = queue.peek(); + var bytesToCopy = Math.min(totalBytesToCopyRemaining, headOfQueue.byteLength); + var destStart = pullIntoDescriptor.byteOffset + pullIntoDescriptor.bytesFilled; + ArrayBufferCopy(pullIntoDescriptor.buffer, destStart, headOfQueue.buffer, headOfQueue.byteOffset, bytesToCopy); + if (headOfQueue.byteLength === bytesToCopy) { + queue.shift(); + } else { + headOfQueue.byteOffset += bytesToCopy; + headOfQueue.byteLength -= bytesToCopy; + } + controller._queueTotalSize -= bytesToCopy; + ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesToCopy, pullIntoDescriptor); + totalBytesToCopyRemaining -= bytesToCopy; + } + return ready; + } + function ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, size, pullIntoDescriptor) { + ReadableByteStreamControllerInvalidateBYOBRequest(controller); + pullIntoDescriptor.bytesFilled += size; + } + function ReadableByteStreamControllerHandleQueueDrain(controller) { + if (controller._queueTotalSize === 0 && controller._closeRequested === true) { + ReadableByteStreamControllerClearAlgorithms(controller); + ReadableStreamClose(controller._controlledReadableByteStream); + } else { + ReadableByteStreamControllerCallPullIfNeeded(controller); + } + } + function ReadableByteStreamControllerInvalidateBYOBRequest(controller) { + if (controller._byobRequest === undefined) { + return; + } + controller._byobRequest._associatedReadableByteStreamController = undefined; + controller._byobRequest._view = undefined; + controller._byobRequest = undefined; + } + function ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller) { + while (controller._pendingPullIntos.length > 0) { + if (controller._queueTotalSize === 0) { + return; + } + var pullIntoDescriptor = controller._pendingPullIntos.peek(); + if (ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) === true) { + ReadableByteStreamControllerShiftPendingPullInto(controller); + ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadableByteStream, pullIntoDescriptor); + } + } + } + function ReadableByteStreamControllerPullInto(controller, view) { + var stream = controller._controlledReadableByteStream; + var elementSize = 1; + if (view.constructor !== DataView) { + elementSize = view.constructor.BYTES_PER_ELEMENT; + } + var ctor = view.constructor; + var buffer = TransferArrayBuffer(view.buffer); + var pullIntoDescriptor = { + buffer: buffer, + byteOffset: view.byteOffset, + byteLength: view.byteLength, + bytesFilled: 0, + elementSize: elementSize, + ctor: ctor, + readerType: 'byob' + }; + if (controller._pendingPullIntos.length > 0) { + controller._pendingPullIntos.push(pullIntoDescriptor); + return ReadableStreamAddReadIntoRequest(stream); + } + if (stream._state === 'closed') { + var emptyView = new ctor(pullIntoDescriptor.buffer, pullIntoDescriptor.byteOffset, 0); + return promiseResolvedWith(ReadableStreamCreateReadResult(emptyView, true, stream._reader._forAuthorCode)); + } + if (controller._queueTotalSize > 0) { + if (ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) === true) { + var filledView = ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor); + ReadableByteStreamControllerHandleQueueDrain(controller); + return promiseResolvedWith(ReadableStreamCreateReadResult(filledView, false, stream._reader._forAuthorCode)); + } + if (controller._closeRequested === true) { + var e = new TypeError('Insufficient bytes to fill elements in the given buffer'); + ReadableByteStreamControllerError(controller, e); + return promiseRejectedWith(e); + } + } + controller._pendingPullIntos.push(pullIntoDescriptor); + var promise = ReadableStreamAddReadIntoRequest(stream); + ReadableByteStreamControllerCallPullIfNeeded(controller); + return promise; + } + function ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor) { + firstDescriptor.buffer = TransferArrayBuffer(firstDescriptor.buffer); + var stream = controller._controlledReadableByteStream; + if (ReadableStreamHasBYOBReader(stream) === true) { + while (ReadableStreamGetNumReadIntoRequests(stream) > 0) { + var pullIntoDescriptor = ReadableByteStreamControllerShiftPendingPullInto(controller); + ReadableByteStreamControllerCommitPullIntoDescriptor(stream, pullIntoDescriptor); + } + } + } + function ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, pullIntoDescriptor) { + if (pullIntoDescriptor.bytesFilled + bytesWritten > pullIntoDescriptor.byteLength) { + throw new RangeError('bytesWritten out of range'); + } + ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesWritten, pullIntoDescriptor); + if (pullIntoDescriptor.bytesFilled < pullIntoDescriptor.elementSize) { + return; + } + ReadableByteStreamControllerShiftPendingPullInto(controller); + var remainderSize = pullIntoDescriptor.bytesFilled % pullIntoDescriptor.elementSize; + if (remainderSize > 0) { + var end = pullIntoDescriptor.byteOffset + pullIntoDescriptor.bytesFilled; + var remainder = pullIntoDescriptor.buffer.slice(end - remainderSize, end); + ReadableByteStreamControllerEnqueueChunkToQueue(controller, remainder, 0, remainder.byteLength); + } + pullIntoDescriptor.buffer = TransferArrayBuffer(pullIntoDescriptor.buffer); + pullIntoDescriptor.bytesFilled -= remainderSize; + ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadableByteStream, pullIntoDescriptor); + ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller); + } + function ReadableByteStreamControllerRespondInternal(controller, bytesWritten) { + var firstDescriptor = controller._pendingPullIntos.peek(); + var stream = controller._controlledReadableByteStream; + if (stream._state === 'closed') { + if (bytesWritten !== 0) { + throw new TypeError('bytesWritten must be 0 when calling respond() on a closed stream'); + } + ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor); + } else { + ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, firstDescriptor); + } + ReadableByteStreamControllerCallPullIfNeeded(controller); + } + function ReadableByteStreamControllerShiftPendingPullInto(controller) { + var descriptor = controller._pendingPullIntos.shift(); + ReadableByteStreamControllerInvalidateBYOBRequest(controller); + return descriptor; + } + function ReadableByteStreamControllerShouldCallPull(controller) { + var stream = controller._controlledReadableByteStream; + if (stream._state !== 'readable') { + return false; + } + if (controller._closeRequested === true) { + return false; + } + if (controller._started === false) { + return false; + } + if (ReadableStreamHasDefaultReader(stream) === true && ReadableStreamGetNumReadRequests(stream) > 0) { + return true; + } + if (ReadableStreamHasBYOBReader(stream) === true && ReadableStreamGetNumReadIntoRequests(stream) > 0) { + return true; + } + var desiredSize = ReadableByteStreamControllerGetDesiredSize(controller); + if (desiredSize > 0) { + return true; + } + return false; + } + function ReadableByteStreamControllerClearAlgorithms(controller) { + controller._pullAlgorithm = undefined; + controller._cancelAlgorithm = undefined; + } + function ReadableByteStreamControllerClose(controller) { + var stream = controller._controlledReadableByteStream; + if (controller._queueTotalSize > 0) { + controller._closeRequested = true; + return; + } + if (controller._pendingPullIntos.length > 0) { + var firstPendingPullInto = controller._pendingPullIntos.peek(); + if (firstPendingPullInto.bytesFilled > 0) { + var e = new TypeError('Insufficient bytes to fill elements in the given buffer'); + ReadableByteStreamControllerError(controller, e); + throw e; + } + } + ReadableByteStreamControllerClearAlgorithms(controller); + ReadableStreamClose(stream); + } + function ReadableByteStreamControllerEnqueue(controller, chunk) { + var stream = controller._controlledReadableByteStream; + var buffer = chunk.buffer; + var byteOffset = chunk.byteOffset; + var byteLength = chunk.byteLength; + var transferredBuffer = TransferArrayBuffer(buffer); + if (ReadableStreamHasDefaultReader(stream) === true) { + if (ReadableStreamGetNumReadRequests(stream) === 0) { + ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength); + } else { + var transferredView = new Uint8Array(transferredBuffer, byteOffset, byteLength); + ReadableStreamFulfillReadRequest(stream, transferredView, false); + } + } else if (ReadableStreamHasBYOBReader(stream) === true) { + ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength); + ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller); + } else { + ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength); + } + ReadableByteStreamControllerCallPullIfNeeded(controller); + } + function ReadableByteStreamControllerError(controller, e) { + var stream = controller._controlledReadableByteStream; + if (stream._state !== 'readable') { + return; + } + ReadableByteStreamControllerClearPendingPullIntos(controller); + ResetQueue(controller); + ReadableByteStreamControllerClearAlgorithms(controller); + ReadableStreamError(stream, e); + } + function ReadableByteStreamControllerGetDesiredSize(controller) { + var stream = controller._controlledReadableByteStream; + var state = stream._state; + if (state === 'errored') { + return null; + } + if (state === 'closed') { + return 0; + } + return controller._strategyHWM - controller._queueTotalSize; + } + function ReadableByteStreamControllerRespond(controller, bytesWritten) { + bytesWritten = Number(bytesWritten); + if (IsFiniteNonNegativeNumber(bytesWritten) === false) { + throw new RangeError('bytesWritten must be a finite'); + } + ReadableByteStreamControllerRespondInternal(controller, bytesWritten); + } + function ReadableByteStreamControllerRespondWithNewView(controller, view) { + var firstDescriptor = controller._pendingPullIntos.peek(); + if (firstDescriptor.byteOffset + firstDescriptor.bytesFilled !== view.byteOffset) { + throw new RangeError('The region specified by view does not match byobRequest'); + } + if (firstDescriptor.byteLength !== view.byteLength) { + throw new RangeError('The buffer of view has different capacity than byobRequest'); + } + firstDescriptor.buffer = view.buffer; + ReadableByteStreamControllerRespondInternal(controller, view.byteLength); + } + function SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, autoAllocateChunkSize) { + controller._controlledReadableByteStream = stream; + controller._pullAgain = false; + controller._pulling = false; + controller._byobRequest = undefined; + controller._queue = controller._queueTotalSize = undefined; + ResetQueue(controller); + controller._closeRequested = false; + controller._started = false; + controller._strategyHWM = ValidateAndNormalizeHighWaterMark(highWaterMark); + controller._pullAlgorithm = pullAlgorithm; + controller._cancelAlgorithm = cancelAlgorithm; + controller._autoAllocateChunkSize = autoAllocateChunkSize; + controller._pendingPullIntos = new SimpleQueue(); + stream._readableStreamController = controller; + var startResult = startAlgorithm(); + uponPromise(promiseResolvedWith(startResult), function () { + controller._started = true; + ReadableByteStreamControllerCallPullIfNeeded(controller); + }, function (r) { + ReadableByteStreamControllerError(controller, r); + }); + } + function SetUpReadableByteStreamControllerFromUnderlyingSource(stream, underlyingByteSource, highWaterMark) { + var controller = Object.create(ReadableByteStreamController.prototype); + function startAlgorithm() { + return InvokeOrNoop(underlyingByteSource, 'start', [controller]); + } + var pullAlgorithm = CreateAlgorithmFromUnderlyingMethod(underlyingByteSource, 'pull', 0, [controller]); + var cancelAlgorithm = CreateAlgorithmFromUnderlyingMethod(underlyingByteSource, 'cancel', 1, []); + var autoAllocateChunkSize = underlyingByteSource.autoAllocateChunkSize; + if (autoAllocateChunkSize !== undefined) { + autoAllocateChunkSize = Number(autoAllocateChunkSize); + if (NumberIsInteger(autoAllocateChunkSize) === false || autoAllocateChunkSize <= 0) { + throw new RangeError('autoAllocateChunkSize must be a positive integer'); + } + } + SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, autoAllocateChunkSize); + } + function SetUpReadableStreamBYOBRequest(request, controller, view) { + request._associatedReadableByteStreamController = controller; + request._view = view; + } + function byobRequestBrandCheckException(name) { + return new TypeError("ReadableStreamBYOBRequest.prototype." + name + " can only be used on a ReadableStreamBYOBRequest"); + } + function byteStreamControllerBrandCheckException(name) { + return new TypeError("ReadableByteStreamController.prototype." + name + " can only be used on a ReadableByteStreamController"); + } + function AcquireReadableStreamBYOBReader(stream, forAuthorCode) { + if (forAuthorCode === void 0) { + forAuthorCode = false; + } + var reader = new ReadableStreamBYOBReader(stream); + reader._forAuthorCode = forAuthorCode; + return reader; + } + function ReadableStreamAddReadIntoRequest(stream) { + var promise = newPromise(function (resolve, reject) { + var readIntoRequest = { + _resolve: resolve, + _reject: reject + }; + stream._reader._readIntoRequests.push(readIntoRequest); + }); + return promise; + } + function ReadableStreamFulfillReadIntoRequest(stream, chunk, done) { + var reader = stream._reader; + var readIntoRequest = reader._readIntoRequests.shift(); + readIntoRequest._resolve(ReadableStreamCreateReadResult(chunk, done, reader._forAuthorCode)); + } + function ReadableStreamGetNumReadIntoRequests(stream) { + return stream._reader._readIntoRequests.length; + } + function ReadableStreamHasBYOBReader(stream) { + var reader = stream._reader; + if (reader === undefined) { + return false; + } + if (!IsReadableStreamBYOBReader(reader)) { + return false; + } + return true; + } + var ReadableStreamBYOBReader = function () { + function ReadableStreamBYOBReader(stream) { + if (!IsReadableStream(stream)) { + throw new TypeError('ReadableStreamBYOBReader can only be constructed with a ReadableStream instance given a ' + 'byte source'); + } + if (IsReadableByteStreamController(stream._readableStreamController) === false) { + throw new TypeError('Cannot construct a ReadableStreamBYOBReader for a stream not constructed with a byte ' + 'source'); + } + if (IsReadableStreamLocked(stream)) { + throw new TypeError('This stream has already been locked for exclusive reading by another reader'); + } + ReadableStreamReaderGenericInitialize(this, stream); + this._readIntoRequests = new SimpleQueue(); + } + Object.defineProperty(ReadableStreamBYOBReader.prototype, "closed", { + get: function () { + if (!IsReadableStreamBYOBReader(this)) { + return promiseRejectedWith(byobReaderBrandCheckException('closed')); + } + return this._closedPromise; + }, + enumerable: true, + configurable: true + }); + ReadableStreamBYOBReader.prototype.cancel = function (reason) { + if (!IsReadableStreamBYOBReader(this)) { + return promiseRejectedWith(byobReaderBrandCheckException('cancel')); + } + if (this._ownerReadableStream === undefined) { + return promiseRejectedWith(readerLockException('cancel')); + } + return ReadableStreamReaderGenericCancel(this, reason); + }; + ReadableStreamBYOBReader.prototype.read = function (view) { + if (!IsReadableStreamBYOBReader(this)) { + return promiseRejectedWith(byobReaderBrandCheckException('read')); + } + if (this._ownerReadableStream === undefined) { + return promiseRejectedWith(readerLockException('read from')); + } + if (!ArrayBuffer.isView(view)) { + return promiseRejectedWith(new TypeError('view must be an array buffer view')); + } + if (IsDetachedBuffer(view.buffer) === true); + if (view.byteLength === 0) { + return promiseRejectedWith(new TypeError('view must have non-zero byteLength')); + } + return ReadableStreamBYOBReaderRead(this, view); + }; + ReadableStreamBYOBReader.prototype.releaseLock = function () { + if (!IsReadableStreamBYOBReader(this)) { + throw byobReaderBrandCheckException('releaseLock'); + } + if (this._ownerReadableStream === undefined) { + return; + } + if (this._readIntoRequests.length > 0) { + throw new TypeError('Tried to release a reader lock when that reader has pending read() calls un-settled'); + } + ReadableStreamReaderGenericRelease(this); + }; + return ReadableStreamBYOBReader; + }(); + function IsReadableStreamBYOBReader(x) { + if (!typeIsObject(x)) { + return false; + } + if (!Object.prototype.hasOwnProperty.call(x, '_readIntoRequests')) { + return false; + } + return true; + } + function ReadableStreamBYOBReaderRead(reader, view) { + var stream = reader._ownerReadableStream; + stream._disturbed = true; + if (stream._state === 'errored') { + return promiseRejectedWith(stream._storedError); + } + return ReadableByteStreamControllerPullInto(stream._readableStreamController, view); + } + function byobReaderBrandCheckException(name) { + return new TypeError("ReadableStreamBYOBReader.prototype." + name + " can only be used on a ReadableStreamBYOBReader"); + } + var ReadableStream = function () { + function ReadableStream(underlyingSource, strategy) { + if (underlyingSource === void 0) { + underlyingSource = {}; + } + if (strategy === void 0) { + strategy = {}; + } + InitializeReadableStream(this); + var size = strategy.size; + var highWaterMark = strategy.highWaterMark; + var type = underlyingSource.type; + var typeString = String(type); + if (typeString === 'bytes') { + if (size !== undefined) { + throw new RangeError('The strategy for a byte stream cannot have a size function'); + } + if (highWaterMark === undefined) { + highWaterMark = 0; + } + highWaterMark = ValidateAndNormalizeHighWaterMark(highWaterMark); + SetUpReadableByteStreamControllerFromUnderlyingSource(this, underlyingSource, highWaterMark); + } else if (type === undefined) { + var sizeAlgorithm = MakeSizeAlgorithmFromSizeFunction(size); + if (highWaterMark === undefined) { + highWaterMark = 1; + } + highWaterMark = ValidateAndNormalizeHighWaterMark(highWaterMark); + SetUpReadableStreamDefaultControllerFromUnderlyingSource(this, underlyingSource, highWaterMark, sizeAlgorithm); + } else { + throw new RangeError('Invalid type is specified'); + } + } + Object.defineProperty(ReadableStream.prototype, "locked", { + get: function () { + if (IsReadableStream(this) === false) { + throw streamBrandCheckException$1('locked'); + } + return IsReadableStreamLocked(this); + }, + enumerable: true, + configurable: true + }); + ReadableStream.prototype.cancel = function (reason) { + if (IsReadableStream(this) === false) { + return promiseRejectedWith(streamBrandCheckException$1('cancel')); + } + if (IsReadableStreamLocked(this) === true) { + return promiseRejectedWith(new TypeError('Cannot cancel a stream that already has a reader')); + } + return ReadableStreamCancel(this, reason); + }; + ReadableStream.prototype.getReader = function (_a) { + var mode = (_a === void 0 ? {} : _a).mode; + if (IsReadableStream(this) === false) { + throw streamBrandCheckException$1('getReader'); + } + if (mode === undefined) { + return AcquireReadableStreamDefaultReader(this, true); + } + mode = String(mode); + if (mode === 'byob') { + return AcquireReadableStreamBYOBReader(this, true); + } + throw new RangeError('Invalid mode is specified'); + }; + ReadableStream.prototype.pipeThrough = function (_a, _b) { + var writable = _a.writable, readable = _a.readable; + var _c = _b === void 0 ? {} : _b, preventClose = _c.preventClose, preventAbort = _c.preventAbort, preventCancel = _c.preventCancel, signal = _c.signal; + if (IsReadableStream(this) === false) { + throw streamBrandCheckException$1('pipeThrough'); + } + if (IsWritableStream(writable) === false) { + throw new TypeError('writable argument to pipeThrough must be a WritableStream'); + } + if (IsReadableStream(readable) === false) { + throw new TypeError('readable argument to pipeThrough must be a ReadableStream'); + } + preventClose = Boolean(preventClose); + preventAbort = Boolean(preventAbort); + preventCancel = Boolean(preventCancel); + if (signal !== undefined && !isAbortSignal(signal)) { + throw new TypeError('ReadableStream.prototype.pipeThrough\'s signal option must be an AbortSignal'); + } + if (IsReadableStreamLocked(this) === true) { + throw new TypeError('ReadableStream.prototype.pipeThrough cannot be used on a locked ReadableStream'); + } + if (IsWritableStreamLocked(writable) === true) { + throw new TypeError('ReadableStream.prototype.pipeThrough cannot be used on a locked WritableStream'); + } + var promise = ReadableStreamPipeTo(this, writable, preventClose, preventAbort, preventCancel, signal); + setPromiseIsHandledToTrue(promise); + return readable; + }; + ReadableStream.prototype.pipeTo = function (dest, _a) { + var _b = _a === void 0 ? {} : _a, preventClose = _b.preventClose, preventAbort = _b.preventAbort, preventCancel = _b.preventCancel, signal = _b.signal; + if (IsReadableStream(this) === false) { + return promiseRejectedWith(streamBrandCheckException$1('pipeTo')); + } + if (IsWritableStream(dest) === false) { + return promiseRejectedWith(new TypeError('ReadableStream.prototype.pipeTo\'s first argument must be a WritableStream')); + } + preventClose = Boolean(preventClose); + preventAbort = Boolean(preventAbort); + preventCancel = Boolean(preventCancel); + if (signal !== undefined && !isAbortSignal(signal)) { + return promiseRejectedWith(new TypeError('ReadableStream.prototype.pipeTo\'s signal option must be an AbortSignal')); + } + if (IsReadableStreamLocked(this) === true) { + return promiseRejectedWith(new TypeError('ReadableStream.prototype.pipeTo cannot be used on a locked ReadableStream')); + } + if (IsWritableStreamLocked(dest) === true) { + return promiseRejectedWith(new TypeError('ReadableStream.prototype.pipeTo cannot be used on a locked WritableStream')); + } + return ReadableStreamPipeTo(this, dest, preventClose, preventAbort, preventCancel, signal); + }; + ReadableStream.prototype.tee = function () { + if (IsReadableStream(this) === false) { + throw streamBrandCheckException$1('tee'); + } + var branches = ReadableStreamTee(this); + return createArrayFromList(branches); + }; + ReadableStream.prototype.getIterator = function (_a) { + var _b = (_a === void 0 ? {} : _a).preventCancel, preventCancel = _b === void 0 ? false : _b; + if (IsReadableStream(this) === false) { + throw streamBrandCheckException$1('getIterator'); + } + return AcquireReadableStreamAsyncIterator(this, preventCancel); + }; + return ReadableStream; + }(); + if (typeof SymbolPolyfill.asyncIterator === 'symbol') { + Object.defineProperty(ReadableStream.prototype, SymbolPolyfill.asyncIterator, { + value: ReadableStream.prototype.getIterator, + enumerable: false, + writable: true, + configurable: true + }); + } + function CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm) { + if (highWaterMark === void 0) { + highWaterMark = 1; + } + if (sizeAlgorithm === void 0) { + sizeAlgorithm = function () { + return 1; + }; + } + var stream = Object.create(ReadableStream.prototype); + InitializeReadableStream(stream); + var controller = Object.create(ReadableStreamDefaultController.prototype); + SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm); + return stream; + } + function InitializeReadableStream(stream) { + stream._state = 'readable'; + stream._reader = undefined; + stream._storedError = undefined; + stream._disturbed = false; + } + function IsReadableStream(x) { + if (!typeIsObject(x)) { + return false; + } + if (!Object.prototype.hasOwnProperty.call(x, '_readableStreamController')) { + return false; + } + return true; + } + function IsReadableStreamLocked(stream) { + if (stream._reader === undefined) { + return false; + } + return true; + } + function ReadableStreamCancel(stream, reason) { + stream._disturbed = true; + if (stream._state === 'closed') { + return promiseResolvedWith(undefined); + } + if (stream._state === 'errored') { + return promiseRejectedWith(stream._storedError); + } + ReadableStreamClose(stream); + var sourceCancelPromise = stream._readableStreamController[CancelSteps](reason); + return transformPromiseWith(sourceCancelPromise, noop); + } + function ReadableStreamClose(stream) { + stream._state = 'closed'; + var reader = stream._reader; + if (reader === undefined) { + return; + } + if (IsReadableStreamDefaultReader(reader)) { + reader._readRequests.forEach(function (readRequest) { + readRequest._resolve(ReadableStreamCreateReadResult(undefined, true, reader._forAuthorCode)); + }); + reader._readRequests = new SimpleQueue(); + } + defaultReaderClosedPromiseResolve(reader); + } + function ReadableStreamError(stream, e) { + stream._state = 'errored'; + stream._storedError = e; + var reader = stream._reader; + if (reader === undefined) { + return; + } + if (IsReadableStreamDefaultReader(reader)) { + reader._readRequests.forEach(function (readRequest) { + readRequest._reject(e); + }); + reader._readRequests = new SimpleQueue(); + } else { + reader._readIntoRequests.forEach(function (readIntoRequest) { + readIntoRequest._reject(e); + }); + reader._readIntoRequests = new SimpleQueue(); + } + defaultReaderClosedPromiseReject(reader, e); + } + function streamBrandCheckException$1(name) { + return new TypeError("ReadableStream.prototype." + name + " can only be used on a ReadableStream"); + } + var ByteLengthQueuingStrategy = function () { + function ByteLengthQueuingStrategy(_a) { + var highWaterMark = _a.highWaterMark; + this.highWaterMark = highWaterMark; + } + ByteLengthQueuingStrategy.prototype.size = function (chunk) { + return chunk.byteLength; + }; + return ByteLengthQueuingStrategy; + }(); + var CountQueuingStrategy = function () { + function CountQueuingStrategy(_a) { + var highWaterMark = _a.highWaterMark; + this.highWaterMark = highWaterMark; + } + CountQueuingStrategy.prototype.size = function () { + return 1; + }; + return CountQueuingStrategy; + }(); + var TransformStream = function () { + function TransformStream(transformer, writableStrategy, readableStrategy) { + if (transformer === void 0) { + transformer = {}; + } + if (writableStrategy === void 0) { + writableStrategy = {}; + } + if (readableStrategy === void 0) { + readableStrategy = {}; + } + var writableSizeFunction = writableStrategy.size; + var writableHighWaterMark = writableStrategy.highWaterMark; + var readableSizeFunction = readableStrategy.size; + var readableHighWaterMark = readableStrategy.highWaterMark; + var writableType = transformer.writableType; + if (writableType !== undefined) { + throw new RangeError('Invalid writable type specified'); + } + var writableSizeAlgorithm = MakeSizeAlgorithmFromSizeFunction(writableSizeFunction); + if (writableHighWaterMark === undefined) { + writableHighWaterMark = 1; + } + writableHighWaterMark = ValidateAndNormalizeHighWaterMark(writableHighWaterMark); + var readableType = transformer.readableType; + if (readableType !== undefined) { + throw new RangeError('Invalid readable type specified'); + } + var readableSizeAlgorithm = MakeSizeAlgorithmFromSizeFunction(readableSizeFunction); + if (readableHighWaterMark === undefined) { + readableHighWaterMark = 0; + } + readableHighWaterMark = ValidateAndNormalizeHighWaterMark(readableHighWaterMark); + var startPromise_resolve; + var startPromise = newPromise(function (resolve) { + startPromise_resolve = resolve; + }); + InitializeTransformStream(this, startPromise, writableHighWaterMark, writableSizeAlgorithm, readableHighWaterMark, readableSizeAlgorithm); + SetUpTransformStreamDefaultControllerFromTransformer(this, transformer); + var startResult = InvokeOrNoop(transformer, 'start', [this._transformStreamController]); + startPromise_resolve(startResult); + } + Object.defineProperty(TransformStream.prototype, "readable", { + get: function () { + if (IsTransformStream(this) === false) { + throw streamBrandCheckException$2('readable'); + } + return this._readable; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(TransformStream.prototype, "writable", { + get: function () { + if (IsTransformStream(this) === false) { + throw streamBrandCheckException$2('writable'); + } + return this._writable; + }, + enumerable: true, + configurable: true + }); + return TransformStream; + }(); + function InitializeTransformStream(stream, startPromise, writableHighWaterMark, writableSizeAlgorithm, readableHighWaterMark, readableSizeAlgorithm) { + function startAlgorithm() { + return startPromise; + } + function writeAlgorithm(chunk) { + return TransformStreamDefaultSinkWriteAlgorithm(stream, chunk); + } + function abortAlgorithm(reason) { + return TransformStreamDefaultSinkAbortAlgorithm(stream, reason); + } + function closeAlgorithm() { + return TransformStreamDefaultSinkCloseAlgorithm(stream); + } + stream._writable = CreateWritableStream(startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, writableHighWaterMark, writableSizeAlgorithm); + function pullAlgorithm() { + return TransformStreamDefaultSourcePullAlgorithm(stream); + } + function cancelAlgorithm(reason) { + TransformStreamErrorWritableAndUnblockWrite(stream, reason); + return promiseResolvedWith(undefined); + } + stream._readable = CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, readableHighWaterMark, readableSizeAlgorithm); + stream._backpressure = undefined; + stream._backpressureChangePromise = undefined; + stream._backpressureChangePromise_resolve = undefined; + TransformStreamSetBackpressure(stream, true); + stream._transformStreamController = undefined; + } + function IsTransformStream(x) { + if (!typeIsObject(x)) { + return false; + } + if (!Object.prototype.hasOwnProperty.call(x, '_transformStreamController')) { + return false; + } + return true; + } + function TransformStreamError(stream, e) { + ReadableStreamDefaultControllerError(stream._readable._readableStreamController, e); + TransformStreamErrorWritableAndUnblockWrite(stream, e); + } + function TransformStreamErrorWritableAndUnblockWrite(stream, e) { + TransformStreamDefaultControllerClearAlgorithms(stream._transformStreamController); + WritableStreamDefaultControllerErrorIfNeeded(stream._writable._writableStreamController, e); + if (stream._backpressure === true) { + TransformStreamSetBackpressure(stream, false); + } + } + function TransformStreamSetBackpressure(stream, backpressure) { + if (stream._backpressureChangePromise !== undefined) { + stream._backpressureChangePromise_resolve(); + } + stream._backpressureChangePromise = newPromise(function (resolve) { + stream._backpressureChangePromise_resolve = resolve; + }); + stream._backpressure = backpressure; + } + var TransformStreamDefaultController = function () { + function TransformStreamDefaultController() { + throw new TypeError('TransformStreamDefaultController instances cannot be created directly'); + } + Object.defineProperty(TransformStreamDefaultController.prototype, "desiredSize", { + get: function () { + if (IsTransformStreamDefaultController(this) === false) { + throw defaultControllerBrandCheckException$1('desiredSize'); + } + var readableController = this._controlledTransformStream._readable._readableStreamController; + return ReadableStreamDefaultControllerGetDesiredSize(readableController); + }, + enumerable: true, + configurable: true + }); + TransformStreamDefaultController.prototype.enqueue = function (chunk) { + if (IsTransformStreamDefaultController(this) === false) { + throw defaultControllerBrandCheckException$1('enqueue'); + } + TransformStreamDefaultControllerEnqueue(this, chunk); + }; + TransformStreamDefaultController.prototype.error = function (reason) { + if (IsTransformStreamDefaultController(this) === false) { + throw defaultControllerBrandCheckException$1('error'); + } + TransformStreamDefaultControllerError(this, reason); + }; + TransformStreamDefaultController.prototype.terminate = function () { + if (IsTransformStreamDefaultController(this) === false) { + throw defaultControllerBrandCheckException$1('terminate'); + } + TransformStreamDefaultControllerTerminate(this); + }; + return TransformStreamDefaultController; + }(); + function IsTransformStreamDefaultController(x) { + if (!typeIsObject(x)) { + return false; + } + if (!Object.prototype.hasOwnProperty.call(x, '_controlledTransformStream')) { + return false; + } + return true; + } + function SetUpTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm) { + controller._controlledTransformStream = stream; + stream._transformStreamController = controller; + controller._transformAlgorithm = transformAlgorithm; + controller._flushAlgorithm = flushAlgorithm; + } + function SetUpTransformStreamDefaultControllerFromTransformer(stream, transformer) { + var controller = Object.create(TransformStreamDefaultController.prototype); + var transformAlgorithm = function (chunk) { + try { + TransformStreamDefaultControllerEnqueue(controller, chunk); + return promiseResolvedWith(undefined); + } catch (transformResultE) { + return promiseRejectedWith(transformResultE); + } + }; + var transformMethod = transformer.transform; + if (transformMethod !== undefined) { + if (typeof transformMethod !== 'function') { + throw new TypeError('transform is not a method'); + } + transformAlgorithm = function (chunk) { + return PromiseCall(transformMethod, transformer, [ + chunk, + controller + ]); + }; + } + var flushAlgorithm = CreateAlgorithmFromUnderlyingMethod(transformer, 'flush', 0, [controller]); + SetUpTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm); + } + function TransformStreamDefaultControllerClearAlgorithms(controller) { + controller._transformAlgorithm = undefined; + controller._flushAlgorithm = undefined; + } + function TransformStreamDefaultControllerEnqueue(controller, chunk) { + var stream = controller._controlledTransformStream; + var readableController = stream._readable._readableStreamController; + if (ReadableStreamDefaultControllerCanCloseOrEnqueue(readableController) === false) { + throw new TypeError('Readable side is not in a state that permits enqueue'); + } + try { + ReadableStreamDefaultControllerEnqueue(readableController, chunk); + } catch (e) { + TransformStreamErrorWritableAndUnblockWrite(stream, e); + throw stream._readable._storedError; + } + var backpressure = ReadableStreamDefaultControllerHasBackpressure(readableController); + if (backpressure !== stream._backpressure) { + TransformStreamSetBackpressure(stream, true); + } + } + function TransformStreamDefaultControllerError(controller, e) { + TransformStreamError(controller._controlledTransformStream, e); + } + function TransformStreamDefaultControllerPerformTransform(controller, chunk) { + var transformPromise = controller._transformAlgorithm(chunk); + return transformPromiseWith(transformPromise, undefined, function (r) { + TransformStreamError(controller._controlledTransformStream, r); + throw r; + }); + } + function TransformStreamDefaultControllerTerminate(controller) { + var stream = controller._controlledTransformStream; + var readableController = stream._readable._readableStreamController; + if (ReadableStreamDefaultControllerCanCloseOrEnqueue(readableController) === true) { + ReadableStreamDefaultControllerClose(readableController); + } + var error = new TypeError('TransformStream terminated'); + TransformStreamErrorWritableAndUnblockWrite(stream, error); + } + function TransformStreamDefaultSinkWriteAlgorithm(stream, chunk) { + var controller = stream._transformStreamController; + if (stream._backpressure === true) { + var backpressureChangePromise = stream._backpressureChangePromise; + return transformPromiseWith(backpressureChangePromise, function () { + var writable = stream._writable; + var state = writable._state; + if (state === 'erroring') { + throw writable._storedError; + } + return TransformStreamDefaultControllerPerformTransform(controller, chunk); + }); + } + return TransformStreamDefaultControllerPerformTransform(controller, chunk); + } + function TransformStreamDefaultSinkAbortAlgorithm(stream, reason) { + TransformStreamError(stream, reason); + return promiseResolvedWith(undefined); + } + function TransformStreamDefaultSinkCloseAlgorithm(stream) { + var readable = stream._readable; + var controller = stream._transformStreamController; + var flushPromise = controller._flushAlgorithm(); + TransformStreamDefaultControllerClearAlgorithms(controller); + return transformPromiseWith(flushPromise, function () { + if (readable._state === 'errored') { + throw readable._storedError; + } + var readableController = readable._readableStreamController; + if (ReadableStreamDefaultControllerCanCloseOrEnqueue(readableController) === true) { + ReadableStreamDefaultControllerClose(readableController); + } + }, function (r) { + TransformStreamError(stream, r); + throw readable._storedError; + }); + } + function TransformStreamDefaultSourcePullAlgorithm(stream) { + TransformStreamSetBackpressure(stream, false); + return stream._backpressureChangePromise; + } + function defaultControllerBrandCheckException$1(name) { + return new TypeError("TransformStreamDefaultController.prototype." + name + " can only be used on a TransformStreamDefaultController"); + } + function streamBrandCheckException$2(name) { + return new TypeError("TransformStream.prototype." + name + " can only be used on a TransformStream"); + } + exports.ByteLengthQueuingStrategy = ByteLengthQueuingStrategy; + exports.CountQueuingStrategy = CountQueuingStrategy; + exports.ReadableStream = ReadableStream; + exports.TransformStream = TransformStream; + exports.WritableStream = WritableStream; + Object.defineProperty(exports, '__esModule', { value: true }); +})); + +/***/ }), +/* 144 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +__w_pdfjs_require__(145); +__w_pdfjs_require__(114); +__w_pdfjs_require__(77); +__w_pdfjs_require__(116); +var path = __w_pdfjs_require__(43); +module.exports = path.Map; + +/***/ }), +/* 145 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + +var collection = __w_pdfjs_require__(146); +var collectionStrong = __w_pdfjs_require__(150); +module.exports = collection('Map', function (init) { + return function Map() { + return init(this, arguments.length ? arguments[0] : undefined); + }; +}, collectionStrong); + +/***/ }), +/* 146 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + +var $ = __w_pdfjs_require__(10); +var global = __w_pdfjs_require__(11); +var isForced = __w_pdfjs_require__(52); +var redefine = __w_pdfjs_require__(29); +var InternalMetadataModule = __w_pdfjs_require__(147); +var iterate = __w_pdfjs_require__(124); +var anInstance = __w_pdfjs_require__(123); +var isObject = __w_pdfjs_require__(22); +var fails = __w_pdfjs_require__(14); +var checkCorrectnessOfIteration = __w_pdfjs_require__(97); +var setToStringTag = __w_pdfjs_require__(85); +var inheritIfRequired = __w_pdfjs_require__(149); +module.exports = function (CONSTRUCTOR_NAME, wrapper, common) { + var IS_MAP = CONSTRUCTOR_NAME.indexOf('Map') !== -1; + var IS_WEAK = CONSTRUCTOR_NAME.indexOf('Weak') !== -1; + var ADDER = IS_MAP ? 'set' : 'add'; + var NativeConstructor = global[CONSTRUCTOR_NAME]; + var NativePrototype = NativeConstructor && NativeConstructor.prototype; + var Constructor = NativeConstructor; + var exported = {}; + var fixMethod = function (KEY) { + var nativeMethod = NativePrototype[KEY]; + redefine(NativePrototype, KEY, KEY == 'add' ? function add(value) { + nativeMethod.call(this, value === 0 ? 0 : value); + return this; + } : KEY == 'delete' ? function (key) { + return IS_WEAK && !isObject(key) ? false : nativeMethod.call(this, key === 0 ? 0 : key); + } : KEY == 'get' ? function get(key) { + return IS_WEAK && !isObject(key) ? undefined : nativeMethod.call(this, key === 0 ? 0 : key); + } : KEY == 'has' ? function has(key) { + return IS_WEAK && !isObject(key) ? false : nativeMethod.call(this, key === 0 ? 0 : key); + } : function set(key, value) { + nativeMethod.call(this, key === 0 ? 0 : key, value); + return this; + }); + }; + if (isForced(CONSTRUCTOR_NAME, typeof NativeConstructor != 'function' || !(IS_WEAK || NativePrototype.forEach && !fails(function () { + new NativeConstructor().entries().next(); + })))) { + Constructor = common.getConstructor(wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER); + InternalMetadataModule.REQUIRED = true; + } else if (isForced(CONSTRUCTOR_NAME, true)) { + var instance = new Constructor(); + var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) != instance; + var THROWS_ON_PRIMITIVES = fails(function () { + instance.has(1); + }); + var ACCEPT_ITERABLES = checkCorrectnessOfIteration(function (iterable) { + new NativeConstructor(iterable); + }); + var BUGGY_ZERO = !IS_WEAK && fails(function () { + var $instance = new NativeConstructor(); + var index = 5; + while (index--) + $instance[ADDER](index, index); + return !$instance.has(-0); + }); + if (!ACCEPT_ITERABLES) { + Constructor = wrapper(function (dummy, iterable) { + anInstance(dummy, Constructor, CONSTRUCTOR_NAME); + var that = inheritIfRequired(new NativeConstructor(), dummy, Constructor); + if (iterable != undefined) + iterate(iterable, that[ADDER], that, IS_MAP); + return that; + }); + Constructor.prototype = NativePrototype; + NativePrototype.constructor = Constructor; + } + if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) { + fixMethod('delete'); + fixMethod('has'); + IS_MAP && fixMethod('get'); + } + if (BUGGY_ZERO || HASNT_CHAINING) + fixMethod(ADDER); + if (IS_WEAK && NativePrototype.clear) + delete NativePrototype.clear; + } + exported[CONSTRUCTOR_NAME] = Constructor; + $({ + global: true, + forced: Constructor != NativeConstructor + }, exported); + setToStringTag(Constructor, CONSTRUCTOR_NAME); + if (!IS_WEAK) + common.setStrong(Constructor, CONSTRUCTOR_NAME, IS_MAP); + return Constructor; +}; + +/***/ }), +/* 147 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var hiddenKeys = __w_pdfjs_require__(39); +var isObject = __w_pdfjs_require__(22); +var has = __w_pdfjs_require__(23); +var defineProperty = __w_pdfjs_require__(27).f; +var uid = __w_pdfjs_require__(38); +var FREEZING = __w_pdfjs_require__(148); +var METADATA = uid('meta'); +var id = 0; +var isExtensible = Object.isExtensible || function () { + return true; +}; +var setMetadata = function (it) { + defineProperty(it, METADATA, { + value: { + objectID: 'O' + ++id, + weakData: {} + } + }); +}; +var fastKey = function (it, create) { + if (!isObject(it)) + return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it; + if (!has(it, METADATA)) { + if (!isExtensible(it)) + return 'F'; + if (!create) + return 'E'; + setMetadata(it); + } + return it[METADATA].objectID; +}; +var getWeakData = function (it, create) { + if (!has(it, METADATA)) { + if (!isExtensible(it)) + return true; + if (!create) + return false; + setMetadata(it); + } + return it[METADATA].weakData; +}; +var onFreeze = function (it) { + if (FREEZING && meta.REQUIRED && isExtensible(it) && !has(it, METADATA)) + setMetadata(it); + return it; +}; +var meta = module.exports = { + REQUIRED: false, + fastKey: fastKey, + getWeakData: getWeakData, + onFreeze: onFreeze +}; +hiddenKeys[METADATA] = true; + +/***/ }), +/* 148 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var fails = __w_pdfjs_require__(14); +module.exports = !fails(function () { + return Object.isExtensible(Object.preventExtensions({})); +}); + +/***/ }), +/* 149 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var isObject = __w_pdfjs_require__(22); +var setPrototypeOf = __w_pdfjs_require__(87); +module.exports = function ($this, dummy, Wrapper) { + var NewTarget, NewTargetPrototype; + if (setPrototypeOf && typeof (NewTarget = dummy.constructor) == 'function' && NewTarget !== Wrapper && isObject(NewTargetPrototype = NewTarget.prototype) && NewTargetPrototype !== Wrapper.prototype) + setPrototypeOf($this, NewTargetPrototype); + return $this; +}; + +/***/ }), +/* 150 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + +var defineProperty = __w_pdfjs_require__(27).f; +var create = __w_pdfjs_require__(71); +var redefineAll = __w_pdfjs_require__(121); +var bind = __w_pdfjs_require__(62); +var anInstance = __w_pdfjs_require__(123); +var iterate = __w_pdfjs_require__(124); +var defineIterator = __w_pdfjs_require__(79); +var setSpecies = __w_pdfjs_require__(122); +var DESCRIPTORS = __w_pdfjs_require__(13); +var fastKey = __w_pdfjs_require__(147).fastKey; +var InternalStateModule = __w_pdfjs_require__(33); +var setInternalState = InternalStateModule.set; +var internalStateGetterFor = InternalStateModule.getterFor; +module.exports = { + getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) { + var C = wrapper(function (that, iterable) { + anInstance(that, C, CONSTRUCTOR_NAME); + setInternalState(that, { + type: CONSTRUCTOR_NAME, + index: create(null), + first: undefined, + last: undefined, + size: 0 + }); + if (!DESCRIPTORS) + that.size = 0; + if (iterable != undefined) + iterate(iterable, that[ADDER], that, IS_MAP); + }); + var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME); + var define = function (that, key, value) { + var state = getInternalState(that); + var entry = getEntry(that, key); + var previous, index; + if (entry) { + entry.value = value; + } else { + state.last = entry = { + index: index = fastKey(key, true), + key: key, + value: value, + previous: previous = state.last, + next: undefined, + removed: false + }; + if (!state.first) + state.first = entry; + if (previous) + previous.next = entry; + if (DESCRIPTORS) + state.size++; + else + that.size++; + if (index !== 'F') + state.index[index] = entry; + } + return that; + }; + var getEntry = function (that, key) { + var state = getInternalState(that); + var index = fastKey(key); + var entry; + if (index !== 'F') + return state.index[index]; + for (entry = state.first; entry; entry = entry.next) { + if (entry.key == key) + return entry; + } + }; + redefineAll(C.prototype, { + clear: function clear() { + var that = this; + var state = getInternalState(that); + var data = state.index; + var entry = state.first; + while (entry) { + entry.removed = true; + if (entry.previous) + entry.previous = entry.previous.next = undefined; + delete data[entry.index]; + entry = entry.next; + } + state.first = state.last = undefined; + if (DESCRIPTORS) + state.size = 0; + else + that.size = 0; + }, + 'delete': function (key) { + var that = this; + var state = getInternalState(that); + var entry = getEntry(that, key); + if (entry) { + var next = entry.next; + var prev = entry.previous; + delete state.index[entry.index]; + entry.removed = true; + if (prev) + prev.next = next; + if (next) + next.previous = prev; + if (state.first == entry) + state.first = next; + if (state.last == entry) + state.last = prev; + if (DESCRIPTORS) + state.size--; + else + that.size--; + } + return !!entry; + }, + forEach: function forEach(callbackfn) { + var state = getInternalState(this); + var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3); + var entry; + while (entry = entry ? entry.next : state.first) { + boundFunction(entry.value, entry.key, this); + while (entry && entry.removed) + entry = entry.previous; + } + }, + has: function has(key) { + return !!getEntry(this, key); + } + }); + redefineAll(C.prototype, IS_MAP ? { + get: function get(key) { + var entry = getEntry(this, key); + return entry && entry.value; + }, + set: function set(key, value) { + return define(this, key === 0 ? 0 : key, value); + } + } : { + add: function add(value) { + return define(this, value = value === 0 ? 0 : value, value); + } + }); + if (DESCRIPTORS) + defineProperty(C.prototype, 'size', { + get: function () { + return getInternalState(this).size; + } + }); + return C; + }, + setStrong: function (C, CONSTRUCTOR_NAME, IS_MAP) { + var ITERATOR_NAME = CONSTRUCTOR_NAME + ' Iterator'; + var getInternalCollectionState = internalStateGetterFor(CONSTRUCTOR_NAME); + var getInternalIteratorState = internalStateGetterFor(ITERATOR_NAME); + defineIterator(C, CONSTRUCTOR_NAME, function (iterated, kind) { + setInternalState(this, { + type: ITERATOR_NAME, + target: iterated, + state: getInternalCollectionState(iterated), + kind: kind, + last: undefined + }); + }, function () { + var state = getInternalIteratorState(this); + var kind = state.kind; + var entry = state.last; + while (entry && entry.removed) + entry = entry.previous; + if (!state.target || !(state.last = entry = entry ? entry.next : state.state.first)) { + state.target = undefined; + return { + value: undefined, + done: true + }; + } + if (kind == 'keys') + return { + value: entry.key, + done: false + }; + if (kind == 'values') + return { + value: entry.value, + done: false + }; + return { + value: [ + entry.key, + entry.value + ], + done: false + }; + }, IS_MAP ? 'entries' : 'values', !IS_MAP, true); + setSpecies(CONSTRUCTOR_NAME); + } +}; + +/***/ }), +/* 151 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +__w_pdfjs_require__(152); +__w_pdfjs_require__(114); +__w_pdfjs_require__(77); +__w_pdfjs_require__(116); +var path = __w_pdfjs_require__(43); +module.exports = path.Set; + +/***/ }), +/* 152 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + +var collection = __w_pdfjs_require__(146); +var collectionStrong = __w_pdfjs_require__(150); +module.exports = collection('Set', function (init) { + return function Set() { + return init(this, arguments.length ? arguments[0] : undefined); + }; +}, collectionStrong); + +/***/ }), +/* 153 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +__w_pdfjs_require__(114); +__w_pdfjs_require__(154); +__w_pdfjs_require__(116); +var path = __w_pdfjs_require__(43); +module.exports = path.WeakMap; + +/***/ }), +/* 154 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + +var global = __w_pdfjs_require__(11); +var redefineAll = __w_pdfjs_require__(121); +var InternalMetadataModule = __w_pdfjs_require__(147); +var collection = __w_pdfjs_require__(146); +var collectionWeak = __w_pdfjs_require__(155); +var isObject = __w_pdfjs_require__(22); +var enforceIternalState = __w_pdfjs_require__(33).enforce; +var NATIVE_WEAK_MAP = __w_pdfjs_require__(34); +var IS_IE11 = !global.ActiveXObject && 'ActiveXObject' in global; +var isExtensible = Object.isExtensible; +var InternalWeakMap; +var wrapper = function (init) { + return function WeakMap() { + return init(this, arguments.length ? arguments[0] : undefined); + }; +}; +var $WeakMap = module.exports = collection('WeakMap', wrapper, collectionWeak); +if (NATIVE_WEAK_MAP && IS_IE11) { + InternalWeakMap = collectionWeak.getConstructor(wrapper, 'WeakMap', true); + InternalMetadataModule.REQUIRED = true; + var WeakMapPrototype = $WeakMap.prototype; + var nativeDelete = WeakMapPrototype['delete']; + var nativeHas = WeakMapPrototype.has; + var nativeGet = WeakMapPrototype.get; + var nativeSet = WeakMapPrototype.set; + redefineAll(WeakMapPrototype, { + 'delete': function (key) { + if (isObject(key) && !isExtensible(key)) { + var state = enforceIternalState(this); + if (!state.frozen) + state.frozen = new InternalWeakMap(); + return nativeDelete.call(this, key) || state.frozen['delete'](key); + } + return nativeDelete.call(this, key); + }, + has: function has(key) { + if (isObject(key) && !isExtensible(key)) { + var state = enforceIternalState(this); + if (!state.frozen) + state.frozen = new InternalWeakMap(); + return nativeHas.call(this, key) || state.frozen.has(key); + } + return nativeHas.call(this, key); + }, + get: function get(key) { + if (isObject(key) && !isExtensible(key)) { + var state = enforceIternalState(this); + if (!state.frozen) + state.frozen = new InternalWeakMap(); + return nativeHas.call(this, key) ? nativeGet.call(this, key) : state.frozen.get(key); + } + return nativeGet.call(this, key); + }, + set: function set(key, value) { + if (isObject(key) && !isExtensible(key)) { + var state = enforceIternalState(this); + if (!state.frozen) + state.frozen = new InternalWeakMap(); + nativeHas.call(this, key) ? nativeSet.call(this, key, value) : state.frozen.set(key, value); + } else + nativeSet.call(this, key, value); + return this; + } + }); +} + +/***/ }), +/* 155 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + +var redefineAll = __w_pdfjs_require__(121); +var getWeakData = __w_pdfjs_require__(147).getWeakData; +var anObject = __w_pdfjs_require__(28); +var isObject = __w_pdfjs_require__(22); +var anInstance = __w_pdfjs_require__(123); +var iterate = __w_pdfjs_require__(124); +var ArrayIterationModule = __w_pdfjs_require__(156); +var $has = __w_pdfjs_require__(23); +var InternalStateModule = __w_pdfjs_require__(33); +var setInternalState = InternalStateModule.set; +var internalStateGetterFor = InternalStateModule.getterFor; +var find = ArrayIterationModule.find; +var findIndex = ArrayIterationModule.findIndex; +var id = 0; +var uncaughtFrozenStore = function (store) { + return store.frozen || (store.frozen = new UncaughtFrozenStore()); +}; +var UncaughtFrozenStore = function () { + this.entries = []; +}; +var findUncaughtFrozen = function (store, key) { + return find(store.entries, function (it) { + return it[0] === key; + }); +}; +UncaughtFrozenStore.prototype = { + get: function (key) { + var entry = findUncaughtFrozen(this, key); + if (entry) + return entry[1]; + }, + has: function (key) { + return !!findUncaughtFrozen(this, key); + }, + set: function (key, value) { + var entry = findUncaughtFrozen(this, key); + if (entry) + entry[1] = value; + else + this.entries.push([ + key, + value + ]); + }, + 'delete': function (key) { + var index = findIndex(this.entries, function (it) { + return it[0] === key; + }); + if (~index) + this.entries.splice(index, 1); + return !!~index; + } +}; +module.exports = { + getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) { + var C = wrapper(function (that, iterable) { + anInstance(that, C, CONSTRUCTOR_NAME); + setInternalState(that, { + type: CONSTRUCTOR_NAME, + id: id++, + frozen: undefined + }); + if (iterable != undefined) + iterate(iterable, that[ADDER], that, IS_MAP); + }); + var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME); + var define = function (that, key, value) { + var state = getInternalState(that); + var data = getWeakData(anObject(key), true); + if (data === true) + uncaughtFrozenStore(state).set(key, value); + else + data[state.id] = value; + return that; + }; + redefineAll(C.prototype, { + 'delete': function (key) { + var state = getInternalState(this); + if (!isObject(key)) + return false; + var data = getWeakData(key); + if (data === true) + return uncaughtFrozenStore(state)['delete'](key); + return data && $has(data, state.id) && delete data[state.id]; + }, + has: function has(key) { + var state = getInternalState(this); + if (!isObject(key)) + return false; + var data = getWeakData(key); + if (data === true) + return uncaughtFrozenStore(state).has(key); + return data && $has(data, state.id); + } + }); + redefineAll(C.prototype, IS_MAP ? { + get: function get(key) { + var state = getInternalState(this); + if (isObject(key)) { + var data = getWeakData(key); + if (data === true) + return uncaughtFrozenStore(state).get(key); + return data ? data[state.id] : undefined; + } + }, + set: function set(key, value) { + return define(this, key, value); + } + } : { + add: function add(value) { + return define(this, value, true); + } + }); + return C; + } +}; + +/***/ }), +/* 156 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var bind = __w_pdfjs_require__(62); +var IndexedObject = __w_pdfjs_require__(18); +var toObject = __w_pdfjs_require__(83); +var toLength = __w_pdfjs_require__(47); +var arraySpeciesCreate = __w_pdfjs_require__(157); +var push = [].push; +var createMethod = function (TYPE) { + var IS_MAP = TYPE == 1; + var IS_FILTER = TYPE == 2; + var IS_SOME = TYPE == 3; + var IS_EVERY = TYPE == 4; + var IS_FIND_INDEX = TYPE == 6; + var NO_HOLES = TYPE == 5 || IS_FIND_INDEX; + return function ($this, callbackfn, that, specificCreate) { + var O = toObject($this); + var self = IndexedObject(O); + var boundFunction = bind(callbackfn, that, 3); + var length = toLength(self.length); + var index = 0; + var create = specificCreate || arraySpeciesCreate; + var target = IS_MAP ? create($this, length) : IS_FILTER ? create($this, 0) : undefined; + var value, result; + for (; length > index; index++) + if (NO_HOLES || index in self) { + value = self[index]; + result = boundFunction(value, index, O); + if (TYPE) { + if (IS_MAP) + target[index] = result; + else if (result) + switch (TYPE) { + case 3: + return true; + case 5: + return value; + case 6: + return index; + case 2: + push.call(target, value); + } + else if (IS_EVERY) + return false; + } + } + return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target; + }; +}; +module.exports = { + forEach: createMethod(0), + map: createMethod(1), + filter: createMethod(2), + some: createMethod(3), + every: createMethod(4), + find: createMethod(5), + findIndex: createMethod(6) +}; + +/***/ }), +/* 157 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var isObject = __w_pdfjs_require__(22); +var isArray = __w_pdfjs_require__(158); +var wellKnownSymbol = __w_pdfjs_require__(57); +var SPECIES = wellKnownSymbol('species'); +module.exports = function (originalArray, length) { + var C; + if (isArray(originalArray)) { + C = originalArray.constructor; + if (typeof C == 'function' && (C === Array || isArray(C.prototype))) + C = undefined; + else if (isObject(C)) { + C = C[SPECIES]; + if (C === null) + C = undefined; + } + } + return new (C === undefined ? Array : C)(length === 0 ? 0 : length); +}; + +/***/ }), +/* 158 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var classof = __w_pdfjs_require__(19); +module.exports = Array.isArray || function isArray(arg) { + return classof(arg) == 'Array'; +}; + +/***/ }), +/* 159 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +__w_pdfjs_require__(114); +__w_pdfjs_require__(160); +__w_pdfjs_require__(116); +var path = __w_pdfjs_require__(43); +module.exports = path.WeakSet; + +/***/ }), +/* 160 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + +var collection = __w_pdfjs_require__(146); +var collectionWeak = __w_pdfjs_require__(155); +collection('WeakSet', function (init) { + return function WeakSet() { + return init(this, arguments.length ? arguments[0] : undefined); + }; +}, collectionWeak); + +/***/ }), +/* 161 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +__w_pdfjs_require__(162); +var entryUnbind = __w_pdfjs_require__(61); +module.exports = entryUnbind('String', 'codePointAt'); + +/***/ }), +/* 162 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + +var $ = __w_pdfjs_require__(10); +var codeAt = __w_pdfjs_require__(78).codeAt; +$({ + target: 'String', + proto: true +}, { + codePointAt: function codePointAt(pos) { + return codeAt(this, pos); + } +}); + +/***/ }), +/* 163 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +__w_pdfjs_require__(164); +var path = __w_pdfjs_require__(43); +module.exports = path.String.fromCodePoint; + +/***/ }), +/* 164 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var $ = __w_pdfjs_require__(10); +var toAbsoluteIndex = __w_pdfjs_require__(49); +var fromCharCode = String.fromCharCode; +var nativeFromCodePoint = String.fromCodePoint; +var INCORRECT_LENGTH = !!nativeFromCodePoint && nativeFromCodePoint.length != 1; +$({ + target: 'String', + stat: true, + forced: INCORRECT_LENGTH +}, { + fromCodePoint: function fromCodePoint(x) { + var elements = []; + var length = arguments.length; + var i = 0; + var code; + while (length > i) { + code = +arguments[i++]; + if (toAbsoluteIndex(code, 0x10FFFF) !== code) + throw RangeError(code + ' is not a valid code point'); + elements.push(code < 0x10000 ? fromCharCode(code) : fromCharCode(((code -= 0x10000) >> 10) + 0xD800, code % 0x400 + 0xDC00)); + } + return elements.join(''); + } +}); + +/***/ }), +/* 165 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +__w_pdfjs_require__(166); +__w_pdfjs_require__(114); +__w_pdfjs_require__(168); +__w_pdfjs_require__(172); +__w_pdfjs_require__(173); +__w_pdfjs_require__(174); +__w_pdfjs_require__(175); +__w_pdfjs_require__(176); +__w_pdfjs_require__(177); +__w_pdfjs_require__(178); +__w_pdfjs_require__(179); +__w_pdfjs_require__(180); +__w_pdfjs_require__(181); +__w_pdfjs_require__(182); +__w_pdfjs_require__(183); +__w_pdfjs_require__(184); +__w_pdfjs_require__(185); +__w_pdfjs_require__(186); +__w_pdfjs_require__(187); +var path = __w_pdfjs_require__(43); +module.exports = path.Symbol; + +/***/ }), +/* 166 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + +var $ = __w_pdfjs_require__(10); +var fails = __w_pdfjs_require__(14); +var isArray = __w_pdfjs_require__(158); +var isObject = __w_pdfjs_require__(22); +var toObject = __w_pdfjs_require__(83); +var toLength = __w_pdfjs_require__(47); +var createProperty = __w_pdfjs_require__(93); +var arraySpeciesCreate = __w_pdfjs_require__(157); +var arrayMethodHasSpeciesSupport = __w_pdfjs_require__(167); +var wellKnownSymbol = __w_pdfjs_require__(57); +var V8_VERSION = __w_pdfjs_require__(133); +var IS_CONCAT_SPREADABLE = wellKnownSymbol('isConcatSpreadable'); +var MAX_SAFE_INTEGER = 0x1FFFFFFFFFFFFF; +var MAXIMUM_ALLOWED_INDEX_EXCEEDED = 'Maximum allowed index exceeded'; +var IS_CONCAT_SPREADABLE_SUPPORT = V8_VERSION >= 51 || !fails(function () { + var array = []; + array[IS_CONCAT_SPREADABLE] = false; + return array.concat()[0] !== array; +}); +var SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('concat'); +var isConcatSpreadable = function (O) { + if (!isObject(O)) + return false; + var spreadable = O[IS_CONCAT_SPREADABLE]; + return spreadable !== undefined ? !!spreadable : isArray(O); +}; +var FORCED = !IS_CONCAT_SPREADABLE_SUPPORT || !SPECIES_SUPPORT; +$({ + target: 'Array', + proto: true, + forced: FORCED +}, { + concat: function concat(arg) { + var O = toObject(this); + var A = arraySpeciesCreate(O, 0); + var n = 0; + var i, k, length, len, E; + for (i = -1, length = arguments.length; i < length; i++) { + E = i === -1 ? O : arguments[i]; + if (isConcatSpreadable(E)) { + len = toLength(E.length); + if (n + len > MAX_SAFE_INTEGER) + throw TypeError(MAXIMUM_ALLOWED_INDEX_EXCEEDED); + for (k = 0; k < len; k++, n++) + if (k in E) + createProperty(A, n, E[k]); + } else { + if (n >= MAX_SAFE_INTEGER) + throw TypeError(MAXIMUM_ALLOWED_INDEX_EXCEEDED); + createProperty(A, n++, E); + } + } + A.length = n; + return A; + } +}); + +/***/ }), +/* 167 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var fails = __w_pdfjs_require__(14); +var wellKnownSymbol = __w_pdfjs_require__(57); +var V8_VERSION = __w_pdfjs_require__(133); +var SPECIES = wellKnownSymbol('species'); +module.exports = function (METHOD_NAME) { + return V8_VERSION >= 51 || !fails(function () { + var array = []; + var constructor = array.constructor = {}; + constructor[SPECIES] = function () { + return { foo: 1 }; + }; + return array[METHOD_NAME](Boolean).foo !== 1; + }); +}; + +/***/ }), +/* 168 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + +var $ = __w_pdfjs_require__(10); +var global = __w_pdfjs_require__(11); +var getBuiltIn = __w_pdfjs_require__(42); +var IS_PURE = __w_pdfjs_require__(37); +var DESCRIPTORS = __w_pdfjs_require__(13); +var NATIVE_SYMBOL = __w_pdfjs_require__(58); +var USE_SYMBOL_AS_UID = __w_pdfjs_require__(59); +var fails = __w_pdfjs_require__(14); +var has = __w_pdfjs_require__(23); +var isArray = __w_pdfjs_require__(158); +var isObject = __w_pdfjs_require__(22); +var anObject = __w_pdfjs_require__(28); +var toObject = __w_pdfjs_require__(83); +var toIndexedObject = __w_pdfjs_require__(17); +var toPrimitive = __w_pdfjs_require__(21); +var createPropertyDescriptor = __w_pdfjs_require__(16); +var nativeObjectCreate = __w_pdfjs_require__(71); +var objectKeys = __w_pdfjs_require__(73); +var getOwnPropertyNamesModule = __w_pdfjs_require__(44); +var getOwnPropertyNamesExternal = __w_pdfjs_require__(169); +var getOwnPropertySymbolsModule = __w_pdfjs_require__(51); +var getOwnPropertyDescriptorModule = __w_pdfjs_require__(12); +var definePropertyModule = __w_pdfjs_require__(27); +var propertyIsEnumerableModule = __w_pdfjs_require__(15); +var createNonEnumerableProperty = __w_pdfjs_require__(26); +var redefine = __w_pdfjs_require__(29); +var shared = __w_pdfjs_require__(36); +var sharedKey = __w_pdfjs_require__(35); +var hiddenKeys = __w_pdfjs_require__(39); +var uid = __w_pdfjs_require__(38); +var wellKnownSymbol = __w_pdfjs_require__(57); +var wrappedWellKnownSymbolModule = __w_pdfjs_require__(170); +var defineWellKnownSymbol = __w_pdfjs_require__(171); +var setToStringTag = __w_pdfjs_require__(85); +var InternalStateModule = __w_pdfjs_require__(33); +var $forEach = __w_pdfjs_require__(156).forEach; +var HIDDEN = sharedKey('hidden'); +var SYMBOL = 'Symbol'; +var PROTOTYPE = 'prototype'; +var TO_PRIMITIVE = wellKnownSymbol('toPrimitive'); +var setInternalState = InternalStateModule.set; +var getInternalState = InternalStateModule.getterFor(SYMBOL); +var ObjectPrototype = Object[PROTOTYPE]; +var $Symbol = global.Symbol; +var $stringify = getBuiltIn('JSON', 'stringify'); +var nativeGetOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f; +var nativeDefineProperty = definePropertyModule.f; +var nativeGetOwnPropertyNames = getOwnPropertyNamesExternal.f; +var nativePropertyIsEnumerable = propertyIsEnumerableModule.f; +var AllSymbols = shared('symbols'); +var ObjectPrototypeSymbols = shared('op-symbols'); +var StringToSymbolRegistry = shared('string-to-symbol-registry'); +var SymbolToStringRegistry = shared('symbol-to-string-registry'); +var WellKnownSymbolsStore = shared('wks'); +var QObject = global.QObject; +var USE_SETTER = !QObject || !QObject[PROTOTYPE] || !QObject[PROTOTYPE].findChild; +var setSymbolDescriptor = DESCRIPTORS && fails(function () { + return nativeObjectCreate(nativeDefineProperty({}, 'a', { + get: function () { + return nativeDefineProperty(this, 'a', { value: 7 }).a; + } + })).a != 7; +}) ? function (O, P, Attributes) { + var ObjectPrototypeDescriptor = nativeGetOwnPropertyDescriptor(ObjectPrototype, P); + if (ObjectPrototypeDescriptor) + delete ObjectPrototype[P]; + nativeDefineProperty(O, P, Attributes); + if (ObjectPrototypeDescriptor && O !== ObjectPrototype) { + nativeDefineProperty(ObjectPrototype, P, ObjectPrototypeDescriptor); + } +} : nativeDefineProperty; +var wrap = function (tag, description) { + var symbol = AllSymbols[tag] = nativeObjectCreate($Symbol[PROTOTYPE]); + setInternalState(symbol, { + type: SYMBOL, + tag: tag, + description: description + }); + if (!DESCRIPTORS) + symbol.description = description; + return symbol; +}; +var isSymbol = USE_SYMBOL_AS_UID ? function (it) { + return typeof it == 'symbol'; +} : function (it) { + return Object(it) instanceof $Symbol; +}; +var $defineProperty = function defineProperty(O, P, Attributes) { + if (O === ObjectPrototype) + $defineProperty(ObjectPrototypeSymbols, P, Attributes); + anObject(O); + var key = toPrimitive(P, true); + anObject(Attributes); + if (has(AllSymbols, key)) { + if (!Attributes.enumerable) { + if (!has(O, HIDDEN)) + nativeDefineProperty(O, HIDDEN, createPropertyDescriptor(1, {})); + O[HIDDEN][key] = true; + } else { + if (has(O, HIDDEN) && O[HIDDEN][key]) + O[HIDDEN][key] = false; + Attributes = nativeObjectCreate(Attributes, { enumerable: createPropertyDescriptor(0, false) }); + } + return setSymbolDescriptor(O, key, Attributes); + } + return nativeDefineProperty(O, key, Attributes); +}; +var $defineProperties = function defineProperties(O, Properties) { + anObject(O); + var properties = toIndexedObject(Properties); + var keys = objectKeys(properties).concat($getOwnPropertySymbols(properties)); + $forEach(keys, function (key) { + if (!DESCRIPTORS || $propertyIsEnumerable.call(properties, key)) + $defineProperty(O, key, properties[key]); + }); + return O; +}; +var $create = function create(O, Properties) { + return Properties === undefined ? nativeObjectCreate(O) : $defineProperties(nativeObjectCreate(O), Properties); +}; +var $propertyIsEnumerable = function propertyIsEnumerable(V) { + var P = toPrimitive(V, true); + var enumerable = nativePropertyIsEnumerable.call(this, P); + if (this === ObjectPrototype && has(AllSymbols, P) && !has(ObjectPrototypeSymbols, P)) + return false; + return enumerable || !has(this, P) || !has(AllSymbols, P) || has(this, HIDDEN) && this[HIDDEN][P] ? enumerable : true; +}; +var $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(O, P) { + var it = toIndexedObject(O); + var key = toPrimitive(P, true); + if (it === ObjectPrototype && has(AllSymbols, key) && !has(ObjectPrototypeSymbols, key)) + return; + var descriptor = nativeGetOwnPropertyDescriptor(it, key); + if (descriptor && has(AllSymbols, key) && !(has(it, HIDDEN) && it[HIDDEN][key])) { + descriptor.enumerable = true; + } + return descriptor; +}; +var $getOwnPropertyNames = function getOwnPropertyNames(O) { + var names = nativeGetOwnPropertyNames(toIndexedObject(O)); + var result = []; + $forEach(names, function (key) { + if (!has(AllSymbols, key) && !has(hiddenKeys, key)) + result.push(key); + }); + return result; +}; +var $getOwnPropertySymbols = function getOwnPropertySymbols(O) { + var IS_OBJECT_PROTOTYPE = O === ObjectPrototype; + var names = nativeGetOwnPropertyNames(IS_OBJECT_PROTOTYPE ? ObjectPrototypeSymbols : toIndexedObject(O)); + var result = []; + $forEach(names, function (key) { + if (has(AllSymbols, key) && (!IS_OBJECT_PROTOTYPE || has(ObjectPrototype, key))) { + result.push(AllSymbols[key]); + } + }); + return result; +}; +if (!NATIVE_SYMBOL) { + $Symbol = function Symbol() { + if (this instanceof $Symbol) + throw TypeError('Symbol is not a constructor'); + var description = !arguments.length || arguments[0] === undefined ? undefined : String(arguments[0]); + var tag = uid(description); + var setter = function (value) { + if (this === ObjectPrototype) + setter.call(ObjectPrototypeSymbols, value); + if (has(this, HIDDEN) && has(this[HIDDEN], tag)) + this[HIDDEN][tag] = false; + setSymbolDescriptor(this, tag, createPropertyDescriptor(1, value)); + }; + if (DESCRIPTORS && USE_SETTER) + setSymbolDescriptor(ObjectPrototype, tag, { + configurable: true, + set: setter + }); + return wrap(tag, description); + }; + redefine($Symbol[PROTOTYPE], 'toString', function toString() { + return getInternalState(this).tag; + }); + redefine($Symbol, 'withoutSetter', function (description) { + return wrap(uid(description), description); + }); + propertyIsEnumerableModule.f = $propertyIsEnumerable; + definePropertyModule.f = $defineProperty; + getOwnPropertyDescriptorModule.f = $getOwnPropertyDescriptor; + getOwnPropertyNamesModule.f = getOwnPropertyNamesExternal.f = $getOwnPropertyNames; + getOwnPropertySymbolsModule.f = $getOwnPropertySymbols; + wrappedWellKnownSymbolModule.f = function (name) { + return wrap(wellKnownSymbol(name), name); + }; + if (DESCRIPTORS) { + nativeDefineProperty($Symbol[PROTOTYPE], 'description', { + configurable: true, + get: function description() { + return getInternalState(this).description; + } + }); + if (!IS_PURE) { + redefine(ObjectPrototype, 'propertyIsEnumerable', $propertyIsEnumerable, { unsafe: true }); + } + } +} +$({ + global: true, + wrap: true, + forced: !NATIVE_SYMBOL, + sham: !NATIVE_SYMBOL +}, { Symbol: $Symbol }); +$forEach(objectKeys(WellKnownSymbolsStore), function (name) { + defineWellKnownSymbol(name); +}); +$({ + target: SYMBOL, + stat: true, + forced: !NATIVE_SYMBOL +}, { + 'for': function (key) { + var string = String(key); + if (has(StringToSymbolRegistry, string)) + return StringToSymbolRegistry[string]; + var symbol = $Symbol(string); + StringToSymbolRegistry[string] = symbol; + SymbolToStringRegistry[symbol] = string; + return symbol; + }, + keyFor: function keyFor(sym) { + if (!isSymbol(sym)) + throw TypeError(sym + ' is not a symbol'); + if (has(SymbolToStringRegistry, sym)) + return SymbolToStringRegistry[sym]; + }, + useSetter: function () { + USE_SETTER = true; + }, + useSimple: function () { + USE_SETTER = false; + } +}); +$({ + target: 'Object', + stat: true, + forced: !NATIVE_SYMBOL, + sham: !DESCRIPTORS +}, { + create: $create, + defineProperty: $defineProperty, + defineProperties: $defineProperties, + getOwnPropertyDescriptor: $getOwnPropertyDescriptor +}); +$({ + target: 'Object', + stat: true, + forced: !NATIVE_SYMBOL +}, { + getOwnPropertyNames: $getOwnPropertyNames, + getOwnPropertySymbols: $getOwnPropertySymbols +}); +$({ + target: 'Object', + stat: true, + forced: fails(function () { + getOwnPropertySymbolsModule.f(1); + }) +}, { + getOwnPropertySymbols: function getOwnPropertySymbols(it) { + return getOwnPropertySymbolsModule.f(toObject(it)); + } +}); +if ($stringify) { + var FORCED_JSON_STRINGIFY = !NATIVE_SYMBOL || fails(function () { + var symbol = $Symbol(); + return $stringify([symbol]) != '[null]' || $stringify({ a: symbol }) != '{}' || $stringify(Object(symbol)) != '{}'; + }); + $({ + target: 'JSON', + stat: true, + forced: FORCED_JSON_STRINGIFY + }, { + stringify: function stringify(it, replacer, space) { + var args = [it]; + var index = 1; + var $replacer; + while (arguments.length > index) + args.push(arguments[index++]); + $replacer = replacer; + if (!isObject(replacer) && it === undefined || isSymbol(it)) + return; + if (!isArray(replacer)) + replacer = function (key, value) { + if (typeof $replacer == 'function') + value = $replacer.call(this, key, value); + if (!isSymbol(value)) + return value; + }; + args[1] = replacer; + return $stringify.apply(null, args); + } + }); +} +if (!$Symbol[PROTOTYPE][TO_PRIMITIVE]) { + createNonEnumerableProperty($Symbol[PROTOTYPE], TO_PRIMITIVE, $Symbol[PROTOTYPE].valueOf); +} +setToStringTag($Symbol, SYMBOL); +hiddenKeys[HIDDEN] = true; + +/***/ }), +/* 169 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var toIndexedObject = __w_pdfjs_require__(17); +var nativeGetOwnPropertyNames = __w_pdfjs_require__(44).f; +var toString = {}.toString; +var windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames ? Object.getOwnPropertyNames(window) : []; +var getWindowNames = function (it) { + try { + return nativeGetOwnPropertyNames(it); + } catch (error) { + return windowNames.slice(); + } +}; +module.exports.f = function getOwnPropertyNames(it) { + return windowNames && toString.call(it) == '[object Window]' ? getWindowNames(it) : nativeGetOwnPropertyNames(toIndexedObject(it)); +}; + +/***/ }), +/* 170 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var wellKnownSymbol = __w_pdfjs_require__(57); +exports.f = wellKnownSymbol; + +/***/ }), +/* 171 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var path = __w_pdfjs_require__(43); +var has = __w_pdfjs_require__(23); +var wrappedWellKnownSymbolModule = __w_pdfjs_require__(170); +var defineProperty = __w_pdfjs_require__(27).f; +module.exports = function (NAME) { + var Symbol = path.Symbol || (path.Symbol = {}); + if (!has(Symbol, NAME)) + defineProperty(Symbol, NAME, { value: wrappedWellKnownSymbolModule.f(NAME) }); +}; + +/***/ }), +/* 172 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var defineWellKnownSymbol = __w_pdfjs_require__(171); +defineWellKnownSymbol('asyncIterator'); + +/***/ }), +/* 173 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + +var $ = __w_pdfjs_require__(10); +var DESCRIPTORS = __w_pdfjs_require__(13); +var global = __w_pdfjs_require__(11); +var has = __w_pdfjs_require__(23); +var isObject = __w_pdfjs_require__(22); +var defineProperty = __w_pdfjs_require__(27).f; +var copyConstructorProperties = __w_pdfjs_require__(40); +var NativeSymbol = global.Symbol; +if (DESCRIPTORS && typeof NativeSymbol == 'function' && (!('description' in NativeSymbol.prototype) || NativeSymbol().description !== undefined)) { + var EmptyStringDescriptionStore = {}; + var SymbolWrapper = function Symbol() { + var description = arguments.length < 1 || arguments[0] === undefined ? undefined : String(arguments[0]); + var result = this instanceof SymbolWrapper ? new NativeSymbol(description) : description === undefined ? NativeSymbol() : NativeSymbol(description); + if (description === '') + EmptyStringDescriptionStore[result] = true; + return result; + }; + copyConstructorProperties(SymbolWrapper, NativeSymbol); + var symbolPrototype = SymbolWrapper.prototype = NativeSymbol.prototype; + symbolPrototype.constructor = SymbolWrapper; + var symbolToString = symbolPrototype.toString; + var native = String(NativeSymbol('test')) == 'Symbol(test)'; + var regexp = /^Symbol\((.*)\)[^)]+$/; + defineProperty(symbolPrototype, 'description', { + configurable: true, + get: function description() { + var symbol = isObject(this) ? this.valueOf() : this; + var string = symbolToString.call(symbol); + if (has(EmptyStringDescriptionStore, symbol)) + return ''; + var desc = native ? string.slice(7, -1) : string.replace(regexp, '$1'); + return desc === '' ? undefined : desc; + } + }); + $({ + global: true, + forced: true + }, { Symbol: SymbolWrapper }); +} + +/***/ }), +/* 174 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var defineWellKnownSymbol = __w_pdfjs_require__(171); +defineWellKnownSymbol('hasInstance'); + +/***/ }), +/* 175 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var defineWellKnownSymbol = __w_pdfjs_require__(171); +defineWellKnownSymbol('isConcatSpreadable'); + +/***/ }), +/* 176 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var defineWellKnownSymbol = __w_pdfjs_require__(171); +defineWellKnownSymbol('iterator'); + +/***/ }), +/* 177 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var defineWellKnownSymbol = __w_pdfjs_require__(171); +defineWellKnownSymbol('match'); + +/***/ }), +/* 178 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var defineWellKnownSymbol = __w_pdfjs_require__(171); +defineWellKnownSymbol('matchAll'); + +/***/ }), +/* 179 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var defineWellKnownSymbol = __w_pdfjs_require__(171); +defineWellKnownSymbol('replace'); + +/***/ }), +/* 180 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var defineWellKnownSymbol = __w_pdfjs_require__(171); +defineWellKnownSymbol('search'); + +/***/ }), +/* 181 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var defineWellKnownSymbol = __w_pdfjs_require__(171); +defineWellKnownSymbol('species'); + +/***/ }), +/* 182 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var defineWellKnownSymbol = __w_pdfjs_require__(171); +defineWellKnownSymbol('split'); + +/***/ }), +/* 183 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var defineWellKnownSymbol = __w_pdfjs_require__(171); +defineWellKnownSymbol('toPrimitive'); + +/***/ }), +/* 184 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var defineWellKnownSymbol = __w_pdfjs_require__(171); +defineWellKnownSymbol('toStringTag'); + +/***/ }), +/* 185 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var defineWellKnownSymbol = __w_pdfjs_require__(171); +defineWellKnownSymbol('unscopables'); + +/***/ }), +/* 186 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var setToStringTag = __w_pdfjs_require__(85); +setToStringTag(Math, 'Math', true); + +/***/ }), +/* 187 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var global = __w_pdfjs_require__(11); +var setToStringTag = __w_pdfjs_require__(85); +setToStringTag(global.JSON, 'JSON', true); + +/***/ }), +/* 188 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +__w_pdfjs_require__(189); +var entryUnbind = __w_pdfjs_require__(61); +module.exports = entryUnbind('String', 'padStart'); + +/***/ }), +/* 189 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + +var $ = __w_pdfjs_require__(10); +var $padStart = __w_pdfjs_require__(190).start; +var WEBKIT_BUG = __w_pdfjs_require__(192); +$({ + target: 'String', + proto: true, + forced: WEBKIT_BUG +}, { + padStart: function padStart(maxLength) { + return $padStart(this, maxLength, arguments.length > 1 ? arguments[1] : undefined); + } +}); + +/***/ }), +/* 190 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var toLength = __w_pdfjs_require__(47); +var repeat = __w_pdfjs_require__(191); +var requireObjectCoercible = __w_pdfjs_require__(20); +var ceil = Math.ceil; +var createMethod = function (IS_END) { + return function ($this, maxLength, fillString) { + var S = String(requireObjectCoercible($this)); + var stringLength = S.length; + var fillStr = fillString === undefined ? ' ' : String(fillString); + var intMaxLength = toLength(maxLength); + var fillLen, stringFiller; + if (intMaxLength <= stringLength || fillStr == '') + return S; + fillLen = intMaxLength - stringLength; + stringFiller = repeat.call(fillStr, ceil(fillLen / fillStr.length)); + if (stringFiller.length > fillLen) + stringFiller = stringFiller.slice(0, fillLen); + return IS_END ? S + stringFiller : stringFiller + S; + }; +}; +module.exports = { + start: createMethod(false), + end: createMethod(true) +}; + +/***/ }), +/* 191 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + +var toInteger = __w_pdfjs_require__(48); +var requireObjectCoercible = __w_pdfjs_require__(20); +module.exports = ''.repeat || function repeat(count) { + var str = String(requireObjectCoercible(this)); + var result = ''; + var n = toInteger(count); + if (n < 0 || n == Infinity) + throw RangeError('Wrong number of repetitions'); + for (; n > 0; (n >>>= 1) && (str += str)) + if (n & 1) + result += str; + return result; +}; + +/***/ }), +/* 192 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var userAgent = __w_pdfjs_require__(127); +module.exports = /Version\/10\.\d+(\.\d+)?( Mobile\/\w+)? Safari\//.test(userAgent); + +/***/ }), +/* 193 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +__w_pdfjs_require__(194); +var entryUnbind = __w_pdfjs_require__(61); +module.exports = entryUnbind('String', 'padEnd'); + +/***/ }), +/* 194 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + +var $ = __w_pdfjs_require__(10); +var $padEnd = __w_pdfjs_require__(190).end; +var WEBKIT_BUG = __w_pdfjs_require__(192); +$({ + target: 'String', + proto: true, + forced: WEBKIT_BUG +}, { + padEnd: function padEnd(maxLength) { + return $padEnd(this, maxLength, arguments.length > 1 ? arguments[1] : undefined); + } +}); + +/***/ }), +/* 195 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +__w_pdfjs_require__(196); +var path = __w_pdfjs_require__(43); +module.exports = path.Object.values; + +/***/ }), +/* 196 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var $ = __w_pdfjs_require__(10); +var $values = __w_pdfjs_require__(197).values; +$({ + target: 'Object', + stat: true +}, { + values: function values(O) { + return $values(O); + } +}); + +/***/ }), +/* 197 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +var DESCRIPTORS = __w_pdfjs_require__(13); +var objectKeys = __w_pdfjs_require__(73); +var toIndexedObject = __w_pdfjs_require__(17); +var propertyIsEnumerable = __w_pdfjs_require__(15).f; +var createMethod = function (TO_ENTRIES) { + return function (it) { + var O = toIndexedObject(it); + var keys = objectKeys(O); + var length = keys.length; + var i = 0; + var result = []; + var key; + while (length > i) { + key = keys[i++]; + if (!DESCRIPTORS || propertyIsEnumerable.call(O, key)) { + result.push(TO_ENTRIES ? [ + key, + O[key] + ] : O[key]); + } + } + return result; + }; +}; +module.exports = { + entries: createMethod(true), + values: createMethod(false) +}; + +/***/ }), +/* 198 */ /***/ (function(module, exports, __w_pdfjs_require__) { "use strict"; @@ -1734,39 +12073,77 @@ exports.getDocument = getDocument; exports.setPDFNetworkStreamFactory = setPDFNetworkStreamFactory; exports.build = exports.version = exports.PDFPageProxy = exports.PDFDocumentProxy = exports.PDFWorker = exports.PDFDataRangeTransport = exports.LoopbackPort = void 0; -var _util = __w_pdfjs_require__(2); +var _regenerator = _interopRequireDefault(__w_pdfjs_require__(2)); + +var _util = __w_pdfjs_require__(5); var _display_utils = __w_pdfjs_require__(1); -var _font_loader = __w_pdfjs_require__(6); +var _font_loader = __w_pdfjs_require__(199); + +var _api_compatibility = __w_pdfjs_require__(200); -var _api_compatibility = __w_pdfjs_require__(7); +var _canvas = __w_pdfjs_require__(201); -var _canvas = __w_pdfjs_require__(8); +var _worker_options = __w_pdfjs_require__(203); -var _worker_options = __w_pdfjs_require__(10); +var _is_node = __w_pdfjs_require__(7); -var _is_node = __w_pdfjs_require__(4); +var _message_handler = __w_pdfjs_require__(204); -var _message_handler = __w_pdfjs_require__(11); +var _metadata = __w_pdfjs_require__(205); -var _metadata = __w_pdfjs_require__(12); +var _transport_stream = __w_pdfjs_require__(207); -var _transport_stream = __w_pdfjs_require__(14); +var _webgl = __w_pdfjs_require__(208); -var _webgl = __w_pdfjs_require__(15); +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } -const DEFAULT_RANGE_CHUNK_SIZE = 65536; -const RENDERING_CANCELLED_TIMEOUT = 100; -let createPDFNetworkStream; +function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } } + +function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; } + +function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); } + +function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); } + +function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); } + +function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e2) { throw _e2; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e3) { didErr = true; err = _e3; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); } + +function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); } + +function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; } + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +var DEFAULT_RANGE_CHUNK_SIZE = 65536; +var RENDERING_CANCELLED_TIMEOUT = 100; +var createPDFNetworkStream; function setPDFNetworkStreamFactory(pdfNetworkStreamFactory) { createPDFNetworkStream = pdfNetworkStreamFactory; } function getDocument(src) { - const task = new PDFDocumentLoadingTask(); - let source; + var task = new PDFDocumentLoadingTask(); + var source; if (typeof src === "string") { source = { @@ -1781,7 +12158,7 @@ function getDocument(src) { range: src }; } else { - if (typeof src !== "object") { + if (_typeof(src) !== "object") { throw new Error("Invalid parameter in getDocument, " + "need either Uint8Array, string or a parameter object"); } @@ -1792,11 +12169,11 @@ function getDocument(src) { source = src; } - const params = Object.create(null); - let rangeTransport = null, + var params = Object.create(null); + var rangeTransport = null, worker = null; - for (const key in source) { + for (var key in source) { if (key === "url" && typeof window !== "undefined") { params[key] = new URL(source[key], window.location).href; continue; @@ -1807,11 +12184,11 @@ function getDocument(src) { worker = source[key]; continue; } else if (key === "data" && !(source[key] instanceof Uint8Array)) { - const pdfBytes = source[key]; + var pdfBytes = source[key]; if (typeof pdfBytes === "string") { params[key] = (0, _util.stringToBytes)(pdfBytes); - } else if (typeof pdfBytes === "object" && pdfBytes !== null && !isNaN(pdfBytes.length)) { + } else if (_typeof(pdfBytes) === "object" && pdfBytes !== null && !isNaN(pdfBytes.length)) { params[key] = new Uint8Array(pdfBytes); } else if ((0, _util.isArrayBuffer)(pdfBytes)) { params[key] = new Uint8Array(pdfBytes); @@ -1858,7 +12235,7 @@ function getDocument(src) { (0, _util.setVerbosityLevel)(params.verbosity); if (!worker) { - const workerParams = { + var workerParams = { verbosity: params.verbosity, port: _worker_options.GlobalWorkerOptions.workerPort }; @@ -1866,16 +12243,16 @@ function getDocument(src) { task._worker = worker; } - const docId = task.docId; + var docId = task.docId; worker.promise.then(function () { if (task.destroyed) { throw new Error("Loading aborted"); } - const workerIdPromise = _fetchDocument(worker, params, rangeTransport, docId); + var workerIdPromise = _fetchDocument(worker, params, rangeTransport, docId); - const networkStreamPromise = new Promise(function (resolve) { - let networkStream; + var networkStreamPromise = new Promise(function (resolve) { + var networkStream; if (rangeTransport) { networkStream = new _transport_stream.PDFDataTransportStream({ @@ -1899,18 +12276,22 @@ function getDocument(src) { resolve(networkStream); }); - return Promise.all([workerIdPromise, networkStreamPromise]).then(function ([workerId, networkStream]) { + return Promise.all([workerIdPromise, networkStreamPromise]).then(function (_ref) { + var _ref2 = _slicedToArray(_ref, 2), + workerId = _ref2[0], + networkStream = _ref2[1]; + if (task.destroyed) { throw new Error("Loading aborted"); } - const messageHandler = new _message_handler.MessageHandler(docId, workerId, worker.port); + var messageHandler = new _message_handler.MessageHandler(docId, workerId, worker.port); messageHandler.postMessageTransfers = worker.postMessageTransfers; - const transport = new WorkerTransport(messageHandler, task, networkStream, params); + var transport = new WorkerTransport(messageHandler, task, networkStream, params); task._transport = transport; messageHandler.send("Ready", null); }); - }).catch(task._capability.reject); + })["catch"](task._capability.reject); return task; } @@ -1926,7 +12307,7 @@ function _fetchDocument(worker, source, pdfDataRangeTransport, docId) { } return worker.messageHandler.sendWithPromise("GetDocRequest", { - docId, + docId: docId, apiVersion: '2.5.207', source: { data: source.data, @@ -1952,11 +12333,13 @@ function _fetchDocument(worker, source, pdfDataRangeTransport, docId) { }); } -const PDFDocumentLoadingTask = function PDFDocumentLoadingTaskClosure() { - let nextDocumentId = 0; +var PDFDocumentLoadingTask = function PDFDocumentLoadingTaskClosure() { + var nextDocumentId = 0; + + var PDFDocumentLoadingTask = /*#__PURE__*/function () { + function PDFDocumentLoadingTask() { + _classCallCheck(this, PDFDocumentLoadingTask); - class PDFDocumentLoadingTask { - constructor() { this._capability = (0, _util.createPromiseCapability)(); this._transport = null; this._worker = null; @@ -1967,31 +12350,42 @@ const PDFDocumentLoadingTask = function PDFDocumentLoadingTaskClosure() { this.onUnsupportedFeature = null; } - get promise() { - return this._capability.promise; - } + _createClass(PDFDocumentLoadingTask, [{ + key: "destroy", + value: function destroy() { + var _this = this; - destroy() { - this.destroyed = true; - const transportDestroyed = !this._transport ? Promise.resolve() : this._transport.destroy(); - return transportDestroyed.then(() => { - this._transport = null; + this.destroyed = true; + var transportDestroyed = !this._transport ? Promise.resolve() : this._transport.destroy(); + return transportDestroyed.then(function () { + _this._transport = null; - if (this._worker) { - this._worker.destroy(); + if (_this._worker) { + _this._worker.destroy(); - this._worker = null; - } - }); - } + _this._worker = null; + } + }); + } + }, { + key: "promise", + get: function get() { + return this._capability.promise; + } + }]); - } + return PDFDocumentLoadingTask; + }(); return PDFDocumentLoadingTask; }(); -class PDFDataRangeTransport { - constructor(length, initialData, progressiveDone = false) { +var PDFDataRangeTransport = /*#__PURE__*/function () { + function PDFDataRangeTransport(length, initialData) { + var progressiveDone = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + + _classCallCheck(this, PDFDataRangeTransport); + this.length = length; this.initialData = initialData; this.progressiveDone = progressiveDone; @@ -2002,177 +12396,270 @@ class PDFDataRangeTransport { this._readyCapability = (0, _util.createPromiseCapability)(); } - addRangeListener(listener) { - this._rangeListeners.push(listener); - } - - addProgressListener(listener) { - this._progressListeners.push(listener); - } - - addProgressiveReadListener(listener) { - this._progressiveReadListeners.push(listener); - } - - addProgressiveDoneListener(listener) { - this._progressiveDoneListeners.push(listener); - } - - onDataRange(begin, chunk) { - for (const listener of this._rangeListeners) { - listener(begin, chunk); + _createClass(PDFDataRangeTransport, [{ + key: "addRangeListener", + value: function addRangeListener(listener) { + this._rangeListeners.push(listener); } - } + }, { + key: "addProgressListener", + value: function addProgressListener(listener) { + this._progressListeners.push(listener); + } + }, { + key: "addProgressiveReadListener", + value: function addProgressiveReadListener(listener) { + this._progressiveReadListeners.push(listener); + } + }, { + key: "addProgressiveDoneListener", + value: function addProgressiveDoneListener(listener) { + this._progressiveDoneListeners.push(listener); + } + }, { + key: "onDataRange", + value: function onDataRange(begin, chunk) { + var _iterator = _createForOfIteratorHelper(this._rangeListeners), + _step; - onDataProgress(loaded, total) { - this._readyCapability.promise.then(() => { - for (const listener of this._progressListeners) { - listener(loaded, total); + try { + for (_iterator.s(); !(_step = _iterator.n()).done;) { + var listener = _step.value; + listener(begin, chunk); + } + } catch (err) { + _iterator.e(err); + } finally { + _iterator.f(); } - }); - } + } + }, { + key: "onDataProgress", + value: function onDataProgress(loaded, total) { + var _this2 = this; - onDataProgressiveRead(chunk) { - this._readyCapability.promise.then(() => { - for (const listener of this._progressiveReadListeners) { - listener(chunk); - } - }); - } + this._readyCapability.promise.then(function () { + var _iterator2 = _createForOfIteratorHelper(_this2._progressListeners), + _step2; - onDataProgressiveDone() { - this._readyCapability.promise.then(() => { - for (const listener of this._progressiveDoneListeners) { - listener(); - } - }); - } + try { + for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) { + var listener = _step2.value; + listener(loaded, total); + } + } catch (err) { + _iterator2.e(err); + } finally { + _iterator2.f(); + } + }); + } + }, { + key: "onDataProgressiveRead", + value: function onDataProgressiveRead(chunk) { + var _this3 = this; - transportReady() { - this._readyCapability.resolve(); - } + this._readyCapability.promise.then(function () { + var _iterator3 = _createForOfIteratorHelper(_this3._progressiveReadListeners), + _step3; - requestDataRange(begin, end) { - (0, _util.unreachable)("Abstract method PDFDataRangeTransport.requestDataRange"); - } + try { + for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) { + var listener = _step3.value; + listener(chunk); + } + } catch (err) { + _iterator3.e(err); + } finally { + _iterator3.f(); + } + }); + } + }, { + key: "onDataProgressiveDone", + value: function onDataProgressiveDone() { + var _this4 = this; - abort() {} + this._readyCapability.promise.then(function () { + var _iterator4 = _createForOfIteratorHelper(_this4._progressiveDoneListeners), + _step4; -} + try { + for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) { + var listener = _step4.value; + listener(); + } + } catch (err) { + _iterator4.e(err); + } finally { + _iterator4.f(); + } + }); + } + }, { + key: "transportReady", + value: function transportReady() { + this._readyCapability.resolve(); + } + }, { + key: "requestDataRange", + value: function requestDataRange(begin, end) { + (0, _util.unreachable)("Abstract method PDFDataRangeTransport.requestDataRange"); + } + }, { + key: "abort", + value: function abort() {} + }]); + + return PDFDataRangeTransport; +}(); exports.PDFDataRangeTransport = PDFDataRangeTransport; -class PDFDocumentProxy { - constructor(pdfInfo, transport) { +var PDFDocumentProxy = /*#__PURE__*/function () { + function PDFDocumentProxy(pdfInfo, transport) { + _classCallCheck(this, PDFDocumentProxy); + this._pdfInfo = pdfInfo; this._transport = transport; } - get numPages() { - return this._pdfInfo.numPages; - } - - get fingerprint() { - return this._pdfInfo.fingerprint; - } - - getPage(pageNumber) { - return this._transport.getPage(pageNumber); - } - - getPageIndex(ref) { - return this._transport.getPageIndex(ref); - } - - getDestinations() { - return this._transport.getDestinations(); - } - - getDestination(id) { - return this._transport.getDestination(id); - } - - getPageLabels() { - return this._transport.getPageLabels(); - } - - getPageLayout() { - return this._transport.getPageLayout(); - } - - getPageMode() { - return this._transport.getPageMode(); - } - - getViewerPreferences() { - return this._transport.getViewerPreferences(); - } - - getOpenAction() { - return this._transport.getOpenAction(); - } - - getOpenActionDestination() { - (0, _display_utils.deprecated)("getOpenActionDestination, use getOpenAction instead."); - return this.getOpenAction().then(function (openAction) { - return openAction && openAction.dest ? openAction.dest : null; - }); - } - - getAttachments() { - return this._transport.getAttachments(); - } - - getJavaScript() { - return this._transport.getJavaScript(); - } - - getOutline() { - return this._transport.getOutline(); - } - - getPermissions() { - return this._transport.getPermissions(); - } - - getMetadata() { - return this._transport.getMetadata(); - } - - getData() { - return this._transport.getData(); - } - - getDownloadInfo() { - return this._transport.downloadInfoCapability.promise; - } - - getStats() { - return this._transport.getStats(); - } - - cleanup() { - return this._transport.startCleanup(); - } - - destroy() { - return this.loadingTask.destroy(); - } - - get loadingParams() { - return this._transport.loadingParams; - } + _createClass(PDFDocumentProxy, [{ + key: "getPage", + value: function getPage(pageNumber) { + return this._transport.getPage(pageNumber); + } + }, { + key: "getPageIndex", + value: function getPageIndex(ref) { + return this._transport.getPageIndex(ref); + } + }, { + key: "getDestinations", + value: function getDestinations() { + return this._transport.getDestinations(); + } + }, { + key: "getDestination", + value: function getDestination(id) { + return this._transport.getDestination(id); + } + }, { + key: "getPageLabels", + value: function getPageLabels() { + return this._transport.getPageLabels(); + } + }, { + key: "getPageLayout", + value: function getPageLayout() { + return this._transport.getPageLayout(); + } + }, { + key: "getPageMode", + value: function getPageMode() { + return this._transport.getPageMode(); + } + }, { + key: "getViewerPreferences", + value: function getViewerPreferences() { + return this._transport.getViewerPreferences(); + } + }, { + key: "getOpenAction", + value: function getOpenAction() { + return this._transport.getOpenAction(); + } + }, { + key: "getOpenActionDestination", + value: function getOpenActionDestination() { + (0, _display_utils.deprecated)("getOpenActionDestination, use getOpenAction instead."); + return this.getOpenAction().then(function (openAction) { + return openAction && openAction.dest ? openAction.dest : null; + }); + } + }, { + key: "getAttachments", + value: function getAttachments() { + return this._transport.getAttachments(); + } + }, { + key: "getJavaScript", + value: function getJavaScript() { + return this._transport.getJavaScript(); + } + }, { + key: "getOutline", + value: function getOutline() { + return this._transport.getOutline(); + } + }, { + key: "getPermissions", + value: function getPermissions() { + return this._transport.getPermissions(); + } + }, { + key: "getMetadata", + value: function getMetadata() { + return this._transport.getMetadata(); + } + }, { + key: "getData", + value: function getData() { + return this._transport.getData(); + } + }, { + key: "getDownloadInfo", + value: function getDownloadInfo() { + return this._transport.downloadInfoCapability.promise; + } + }, { + key: "getStats", + value: function getStats() { + return this._transport.getStats(); + } + }, { + key: "cleanup", + value: function cleanup() { + return this._transport.startCleanup(); + } + }, { + key: "destroy", + value: function destroy() { + return this.loadingTask.destroy(); + } + }, { + key: "numPages", + get: function get() { + return this._pdfInfo.numPages; + } + }, { + key: "fingerprint", + get: function get() { + return this._pdfInfo.fingerprint; + } + }, { + key: "loadingParams", + get: function get() { + return this._transport.loadingParams; + } + }, { + key: "loadingTask", + get: function get() { + return this._transport.loadingTask; + } + }]); + + return PDFDocumentProxy; +}(); - get loadingTask() { - return this._transport.loadingTask; - } +exports.PDFDocumentProxy = PDFDocumentProxy; -} +var PDFPageProxy = /*#__PURE__*/function () { + function PDFPageProxy(pageIndex, pageInfo, transport) { + var pdfBug = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false; -exports.PDFDocumentProxy = PDFDocumentProxy; + _classCallCheck(this, PDFPageProxy); -class PDFPageProxy { - constructor(pageIndex, pageInfo, transport, pdfBug = false) { this._pageIndex = pageIndex; this._pageInfo = pageInfo; this._transport = transport; @@ -2186,593 +12673,661 @@ class PDFPageProxy { this.destroyed = false; } - get pageNumber() { - return this._pageIndex + 1; - } + _createClass(PDFPageProxy, [{ + key: "getViewport", + value: function getViewport() { + var _ref3 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}, + scale = _ref3.scale, + _ref3$rotation = _ref3.rotation, + rotation = _ref3$rotation === void 0 ? this.rotate : _ref3$rotation, + _ref3$offsetX = _ref3.offsetX, + offsetX = _ref3$offsetX === void 0 ? 0 : _ref3$offsetX, + _ref3$offsetY = _ref3.offsetY, + offsetY = _ref3$offsetY === void 0 ? 0 : _ref3$offsetY, + _ref3$dontFlip = _ref3.dontFlip, + dontFlip = _ref3$dontFlip === void 0 ? false : _ref3$dontFlip; + + return new _display_utils.PageViewport({ + viewBox: this.view, + scale: scale, + rotation: rotation, + offsetX: offsetX, + offsetY: offsetY, + dontFlip: dontFlip + }); + } + }, { + key: "getAnnotations", + value: function getAnnotations() { + var _ref4 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}, + _ref4$intent = _ref4.intent, + intent = _ref4$intent === void 0 ? null : _ref4$intent; + + if (!this.annotationsPromise || this.annotationsIntent !== intent) { + this.annotationsPromise = this._transport.getAnnotations(this._pageIndex, intent); + this.annotationsIntent = intent; + } + + return this.annotationsPromise; + } + }, { + key: "render", + value: function render(_ref5) { + var _this5 = this; + + var canvasContext = _ref5.canvasContext, + viewport = _ref5.viewport, + _ref5$intent = _ref5.intent, + intent = _ref5$intent === void 0 ? "display" : _ref5$intent, + _ref5$enableWebGL = _ref5.enableWebGL, + enableWebGL = _ref5$enableWebGL === void 0 ? false : _ref5$enableWebGL, + _ref5$renderInteracti = _ref5.renderInteractiveForms, + renderInteractiveForms = _ref5$renderInteracti === void 0 ? false : _ref5$renderInteracti, + _ref5$transform = _ref5.transform, + transform = _ref5$transform === void 0 ? null : _ref5$transform, + _ref5$imageLayer = _ref5.imageLayer, + imageLayer = _ref5$imageLayer === void 0 ? null : _ref5$imageLayer, + _ref5$canvasFactory = _ref5.canvasFactory, + canvasFactory = _ref5$canvasFactory === void 0 ? null : _ref5$canvasFactory, + _ref5$background = _ref5.background, + background = _ref5$background === void 0 ? null : _ref5$background; - get rotate() { - return this._pageInfo.rotate; - } + if (this._stats) { + this._stats.time("Overall"); + } - get ref() { - return this._pageInfo.ref; - } + var renderingIntent = intent === "print" ? "print" : "display"; + this.pendingCleanup = false; - get userUnit() { - return this._pageInfo.userUnit; - } + if (!this.intentStates[renderingIntent]) { + this.intentStates[renderingIntent] = Object.create(null); + } - get view() { - return this._pageInfo.view; - } + var intentState = this.intentStates[renderingIntent]; - getViewport({ - scale, - rotation = this.rotate, - offsetX = 0, - offsetY = 0, - dontFlip = false - } = {}) { - return new _display_utils.PageViewport({ - viewBox: this.view, - scale, - rotation, - offsetX, - offsetY, - dontFlip - }); - } + if (intentState.streamReaderCancelTimeout) { + clearTimeout(intentState.streamReaderCancelTimeout); + intentState.streamReaderCancelTimeout = null; + } - getAnnotations({ - intent = null - } = {}) { - if (!this.annotationsPromise || this.annotationsIntent !== intent) { - this.annotationsPromise = this._transport.getAnnotations(this._pageIndex, intent); - this.annotationsIntent = intent; - } + var canvasFactoryInstance = canvasFactory || new _display_utils.DOMCanvasFactory(); + var webGLContext = new _webgl.WebGLContext({ + enable: enableWebGL + }); - return this.annotationsPromise; - } + if (!intentState.displayReadyCapability) { + intentState.displayReadyCapability = (0, _util.createPromiseCapability)(); + intentState.operatorList = { + fnArray: [], + argsArray: [], + lastChunk: false + }; - render({ - canvasContext, - viewport, - intent = "display", - enableWebGL = false, - renderInteractiveForms = false, - transform = null, - imageLayer = null, - canvasFactory = null, - background = null - }) { - if (this._stats) { - this._stats.time("Overall"); - } + if (this._stats) { + this._stats.time("Page Request"); + } - const renderingIntent = intent === "print" ? "print" : "display"; - this.pendingCleanup = false; + this._pumpOperatorList({ + pageIndex: this._pageIndex, + intent: renderingIntent, + renderInteractiveForms: renderInteractiveForms === true + }); + } - if (!this.intentStates[renderingIntent]) { - this.intentStates[renderingIntent] = Object.create(null); - } + var complete = function complete(error) { + var i = intentState.renderTasks.indexOf(internalRenderTask); - const intentState = this.intentStates[renderingIntent]; + if (i >= 0) { + intentState.renderTasks.splice(i, 1); + } - if (intentState.streamReaderCancelTimeout) { - clearTimeout(intentState.streamReaderCancelTimeout); - intentState.streamReaderCancelTimeout = null; - } + if (_this5.cleanupAfterRender || renderingIntent === "print") { + _this5.pendingCleanup = true; + } - const canvasFactoryInstance = canvasFactory || new _display_utils.DOMCanvasFactory(); - const webGLContext = new _webgl.WebGLContext({ - enable: enableWebGL - }); + _this5._tryCleanup(); - if (!intentState.displayReadyCapability) { - intentState.displayReadyCapability = (0, _util.createPromiseCapability)(); - intentState.operatorList = { - fnArray: [], - argsArray: [], - lastChunk: false - }; + if (error) { + internalRenderTask.capability.reject(error); - if (this._stats) { - this._stats.time("Page Request"); - } + _this5._abortOperatorList({ + intentState: intentState, + reason: error + }); + } else { + internalRenderTask.capability.resolve(); + } - this._pumpOperatorList({ - pageIndex: this._pageIndex, - intent: renderingIntent, - renderInteractiveForms: renderInteractiveForms === true - }); - } + if (_this5._stats) { + _this5._stats.timeEnd("Rendering"); - const complete = error => { - const i = intentState.renderTasks.indexOf(internalRenderTask); + _this5._stats.timeEnd("Overall"); + } + }; - if (i >= 0) { - intentState.renderTasks.splice(i, 1); - } + var internalRenderTask = new InternalRenderTask({ + callback: complete, + params: { + canvasContext: canvasContext, + viewport: viewport, + transform: transform, + imageLayer: imageLayer, + background: background + }, + objs: this.objs, + commonObjs: this.commonObjs, + operatorList: intentState.operatorList, + pageIndex: this._pageIndex, + canvasFactory: canvasFactoryInstance, + webGLContext: webGLContext, + useRequestAnimationFrame: renderingIntent !== "print", + pdfBug: this._pdfBug + }); - if (this.cleanupAfterRender || renderingIntent === "print") { - this.pendingCleanup = true; + if (!intentState.renderTasks) { + intentState.renderTasks = []; } - this._tryCleanup(); + intentState.renderTasks.push(internalRenderTask); + var renderTask = internalRenderTask.task; + intentState.displayReadyCapability.promise.then(function (transparency) { + if (_this5.pendingCleanup) { + complete(); + return; + } - if (error) { - internalRenderTask.capability.reject(error); + if (_this5._stats) { + _this5._stats.time("Rendering"); + } - this._abortOperatorList({ - intentState, - reason: error - }); - } else { - internalRenderTask.capability.resolve(); + internalRenderTask.initializeGraphics(transparency); + internalRenderTask.operatorListChanged(); + })["catch"](complete); + return renderTask; + } + }, { + key: "getOperatorList", + value: function getOperatorList() { + function operatorListChanged() { + if (intentState.operatorList.lastChunk) { + intentState.opListReadCapability.resolve(intentState.operatorList); + var i = intentState.renderTasks.indexOf(opListTask); + + if (i >= 0) { + intentState.renderTasks.splice(i, 1); + } + } } - if (this._stats) { - this._stats.timeEnd("Rendering"); + var renderingIntent = "oplist"; - this._stats.timeEnd("Overall"); + if (!this.intentStates[renderingIntent]) { + this.intentStates[renderingIntent] = Object.create(null); } - }; - const internalRenderTask = new InternalRenderTask({ - callback: complete, - params: { - canvasContext, - viewport, - transform, - imageLayer, - background - }, - objs: this.objs, - commonObjs: this.commonObjs, - operatorList: intentState.operatorList, - pageIndex: this._pageIndex, - canvasFactory: canvasFactoryInstance, - webGLContext, - useRequestAnimationFrame: renderingIntent !== "print", - pdfBug: this._pdfBug - }); + var intentState = this.intentStates[renderingIntent]; + var opListTask; - if (!intentState.renderTasks) { - intentState.renderTasks = []; - } + if (!intentState.opListReadCapability) { + opListTask = {}; + opListTask.operatorListChanged = operatorListChanged; + intentState.opListReadCapability = (0, _util.createPromiseCapability)(); + intentState.renderTasks = []; + intentState.renderTasks.push(opListTask); + intentState.operatorList = { + fnArray: [], + argsArray: [], + lastChunk: false + }; - intentState.renderTasks.push(internalRenderTask); - const renderTask = internalRenderTask.task; - intentState.displayReadyCapability.promise.then(transparency => { - if (this.pendingCleanup) { - complete(); - return; - } + if (this._stats) { + this._stats.time("Page Request"); + } - if (this._stats) { - this._stats.time("Rendering"); + this._pumpOperatorList({ + pageIndex: this._pageIndex, + intent: renderingIntent + }); } - internalRenderTask.initializeGraphics(transparency); - internalRenderTask.operatorListChanged(); - }).catch(complete); - return renderTask; - } - - getOperatorList() { - function operatorListChanged() { - if (intentState.operatorList.lastChunk) { - intentState.opListReadCapability.resolve(intentState.operatorList); - const i = intentState.renderTasks.indexOf(opListTask); + return intentState.opListReadCapability.promise; + } + }, { + key: "streamTextContent", + value: function streamTextContent() { + var _ref6 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}, + _ref6$normalizeWhites = _ref6.normalizeWhitespace, + normalizeWhitespace = _ref6$normalizeWhites === void 0 ? false : _ref6$normalizeWhites, + _ref6$disableCombineT = _ref6.disableCombineTextItems, + disableCombineTextItems = _ref6$disableCombineT === void 0 ? false : _ref6$disableCombineT; - if (i >= 0) { - intentState.renderTasks.splice(i, 1); + var TEXT_CONTENT_CHUNK_SIZE = 100; + return this._transport.messageHandler.sendWithStream("GetTextContent", { + pageIndex: this._pageIndex, + normalizeWhitespace: normalizeWhitespace === true, + combineTextItems: disableCombineTextItems !== true + }, { + highWaterMark: TEXT_CONTENT_CHUNK_SIZE, + size: function size(textContent) { + return textContent.items.length; } - } + }); } + }, { + key: "getTextContent", + value: function getTextContent() { + var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + var readableStream = this.streamTextContent(params); + return new Promise(function (resolve, reject) { + function pump() { + reader.read().then(function (_ref7) { + var _textContent$items; - const renderingIntent = "oplist"; + var value = _ref7.value, + done = _ref7.done; - if (!this.intentStates[renderingIntent]) { - this.intentStates[renderingIntent] = Object.create(null); - } + if (done) { + resolve(textContent); + return; + } - const intentState = this.intentStates[renderingIntent]; - let opListTask; + Object.assign(textContent.styles, value.styles); - if (!intentState.opListReadCapability) { - opListTask = {}; - opListTask.operatorListChanged = operatorListChanged; - intentState.opListReadCapability = (0, _util.createPromiseCapability)(); - intentState.renderTasks = []; - intentState.renderTasks.push(opListTask); - intentState.operatorList = { - fnArray: [], - argsArray: [], - lastChunk: false - }; + (_textContent$items = textContent.items).push.apply(_textContent$items, _toConsumableArray(value.items)); - if (this._stats) { - this._stats.time("Page Request"); - } + pump(); + }, reject); + } - this._pumpOperatorList({ - pageIndex: this._pageIndex, - intent: renderingIntent + var reader = readableStream.getReader(); + var textContent = { + items: [], + styles: Object.create(null) + }; + pump(); }); } + }, { + key: "_destroy", + value: function _destroy() { + var _this6 = this; - return intentState.opListReadCapability.promise; - } + this.destroyed = true; + this._transport.pageCache[this._pageIndex] = null; + var waitOn = []; + Object.keys(this.intentStates).forEach(function (intent) { + var intentState = _this6.intentStates[intent]; + + _this6._abortOperatorList({ + intentState: intentState, + reason: new Error("Page was destroyed."), + force: true + }); - streamTextContent({ - normalizeWhitespace = false, - disableCombineTextItems = false - } = {}) { - const TEXT_CONTENT_CHUNK_SIZE = 100; - return this._transport.messageHandler.sendWithStream("GetTextContent", { - pageIndex: this._pageIndex, - normalizeWhitespace: normalizeWhitespace === true, - combineTextItems: disableCombineTextItems !== true - }, { - highWaterMark: TEXT_CONTENT_CHUNK_SIZE, + if (intent === "oplist") { + return; + } + + intentState.renderTasks.forEach(function (renderTask) { + var renderCompleted = renderTask.capability.promise["catch"](function () {}); + waitOn.push(renderCompleted); + renderTask.cancel(); + }); + }); + this.objs.clear(); + this.annotationsPromise = null; + this.pendingCleanup = false; + return Promise.all(waitOn); + } + }, { + key: "cleanup", + value: function cleanup() { + var resetStats = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + this.pendingCleanup = true; + return this._tryCleanup(resetStats); + } + }, { + key: "_tryCleanup", + value: function _tryCleanup() { + var _this7 = this; + + var resetStats = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + + if (!this.pendingCleanup || Object.keys(this.intentStates).some(function (intent) { + var intentState = _this7.intentStates[intent]; + return intentState.renderTasks.length !== 0 || !intentState.operatorList.lastChunk; + })) { + return false; + } + + Object.keys(this.intentStates).forEach(function (intent) { + delete _this7.intentStates[intent]; + }); + this.objs.clear(); + this.annotationsPromise = null; - size(textContent) { - return textContent.items.length; + if (resetStats && this._stats) { + this._stats = new _display_utils.StatTimer(); } - }); - } + this.pendingCleanup = false; + return true; + } + }, { + key: "_startRenderPage", + value: function _startRenderPage(transparency, intent) { + var intentState = this.intentStates[intent]; - getTextContent(params = {}) { - const readableStream = this.streamTextContent(params); - return new Promise(function (resolve, reject) { - function pump() { - reader.read().then(function ({ - value, - done - }) { - if (done) { - resolve(textContent); - return; - } + if (!intentState) { + return; + } - Object.assign(textContent.styles, value.styles); - textContent.items.push(...value.items); - pump(); - }, reject); + if (this._stats) { + this._stats.timeEnd("Page Request"); } - const reader = readableStream.getReader(); - const textContent = { - items: [], - styles: Object.create(null) - }; - pump(); - }); - } + if (intentState.displayReadyCapability) { + intentState.displayReadyCapability.resolve(transparency); + } + } + }, { + key: "_renderPageChunk", + value: function _renderPageChunk(operatorListChunk, intentState) { + for (var i = 0, ii = operatorListChunk.length; i < ii; i++) { + intentState.operatorList.fnArray.push(operatorListChunk.fnArray[i]); + intentState.operatorList.argsArray.push(operatorListChunk.argsArray[i]); + } - _destroy() { - this.destroyed = true; - this._transport.pageCache[this._pageIndex] = null; - const waitOn = []; - Object.keys(this.intentStates).forEach(intent => { - const intentState = this.intentStates[intent]; + intentState.operatorList.lastChunk = operatorListChunk.lastChunk; - this._abortOperatorList({ - intentState, - reason: new Error("Page was destroyed."), - force: true - }); + for (var _i2 = 0; _i2 < intentState.renderTasks.length; _i2++) { + intentState.renderTasks[_i2].operatorListChanged(); + } - if (intent === "oplist") { - return; + if (operatorListChunk.lastChunk) { + this._tryCleanup(); } + } + }, { + key: "_pumpOperatorList", + value: function _pumpOperatorList(args) { + var _this8 = this; - intentState.renderTasks.forEach(function (renderTask) { - const renderCompleted = renderTask.capability.promise.catch(function () {}); - waitOn.push(renderCompleted); - renderTask.cancel(); - }); - }); - this.objs.clear(); - this.annotationsPromise = null; - this.pendingCleanup = false; - return Promise.all(waitOn); - } + (0, _util.assert)(args.intent, 'PDFPageProxy._pumpOperatorList: Expected "intent" argument.'); - cleanup(resetStats = false) { - this.pendingCleanup = true; - return this._tryCleanup(resetStats); - } + var readableStream = this._transport.messageHandler.sendWithStream("GetOperatorList", args); - _tryCleanup(resetStats = false) { - if (!this.pendingCleanup || Object.keys(this.intentStates).some(intent => { - const intentState = this.intentStates[intent]; - return intentState.renderTasks.length !== 0 || !intentState.operatorList.lastChunk; - })) { - return false; - } + var reader = readableStream.getReader(); + var intentState = this.intentStates[args.intent]; + intentState.streamReader = reader; - Object.keys(this.intentStates).forEach(intent => { - delete this.intentStates[intent]; - }); - this.objs.clear(); - this.annotationsPromise = null; + var pump = function pump() { + reader.read().then(function (_ref8) { + var value = _ref8.value, + done = _ref8.done; - if (resetStats && this._stats) { - this._stats = new _display_utils.StatTimer(); - } + if (done) { + intentState.streamReader = null; + return; + } - this.pendingCleanup = false; - return true; - } + if (_this8._transport.destroyed) { + return; + } - _startRenderPage(transparency, intent) { - const intentState = this.intentStates[intent]; + _this8._renderPageChunk(value, intentState); - if (!intentState) { - return; - } + pump(); + }, function (reason) { + intentState.streamReader = null; - if (this._stats) { - this._stats.timeEnd("Page Request"); - } + if (_this8._transport.destroyed) { + return; + } - if (intentState.displayReadyCapability) { - intentState.displayReadyCapability.resolve(transparency); - } - } + if (intentState.operatorList) { + intentState.operatorList.lastChunk = true; - _renderPageChunk(operatorListChunk, intentState) { - for (let i = 0, ii = operatorListChunk.length; i < ii; i++) { - intentState.operatorList.fnArray.push(operatorListChunk.fnArray[i]); - intentState.operatorList.argsArray.push(operatorListChunk.argsArray[i]); - } + for (var i = 0; i < intentState.renderTasks.length; i++) { + intentState.renderTasks[i].operatorListChanged(); + } - intentState.operatorList.lastChunk = operatorListChunk.lastChunk; + _this8._tryCleanup(); + } - for (let i = 0; i < intentState.renderTasks.length; i++) { - intentState.renderTasks[i].operatorListChanged(); - } + if (intentState.displayReadyCapability) { + intentState.displayReadyCapability.reject(reason); + } else if (intentState.opListReadCapability) { + intentState.opListReadCapability.reject(reason); + } else { + throw reason; + } + }); + }; - if (operatorListChunk.lastChunk) { - this._tryCleanup(); + pump(); } - } - - _pumpOperatorList(args) { - (0, _util.assert)(args.intent, 'PDFPageProxy._pumpOperatorList: Expected "intent" argument.'); + }, { + key: "_abortOperatorList", + value: function _abortOperatorList(_ref9) { + var _this9 = this; - const readableStream = this._transport.messageHandler.sendWithStream("GetOperatorList", args); + var intentState = _ref9.intentState, + reason = _ref9.reason, + _ref9$force = _ref9.force, + force = _ref9$force === void 0 ? false : _ref9$force; + (0, _util.assert)(reason instanceof Error || _typeof(reason) === "object" && reason !== null, 'PDFPageProxy._abortOperatorList: Expected "reason" argument.'); - const reader = readableStream.getReader(); - const intentState = this.intentStates[args.intent]; - intentState.streamReader = reader; - - const pump = () => { - reader.read().then(({ - value, - done - }) => { - if (done) { - intentState.streamReader = null; - return; - } + if (!intentState.streamReader) { + return; + } - if (this._transport.destroyed) { + if (!force) { + if (intentState.renderTasks.length !== 0) { return; } - this._renderPageChunk(value, intentState); - - pump(); - }, reason => { - intentState.streamReader = null; + if (reason instanceof _display_utils.RenderingCancelledException) { + intentState.streamReaderCancelTimeout = setTimeout(function () { + _this9._abortOperatorList({ + intentState: intentState, + reason: reason, + force: true + }); - if (this._transport.destroyed) { + intentState.streamReaderCancelTimeout = null; + }, RENDERING_CANCELLED_TIMEOUT); return; } + } - if (intentState.operatorList) { - intentState.operatorList.lastChunk = true; + intentState.streamReader.cancel(new _util.AbortException(reason && reason.message)); + intentState.streamReader = null; - for (let i = 0; i < intentState.renderTasks.length; i++) { - intentState.renderTasks[i].operatorListChanged(); - } + if (this._transport.destroyed) { + return; + } - this._tryCleanup(); + Object.keys(this.intentStates).some(function (intent) { + if (_this9.intentStates[intent] === intentState) { + delete _this9.intentStates[intent]; + return true; } - if (intentState.displayReadyCapability) { - intentState.displayReadyCapability.reject(reason); - } else if (intentState.opListReadCapability) { - intentState.opListReadCapability.reject(reason); - } else { - throw reason; - } + return false; }); - }; - - pump(); - } - - _abortOperatorList({ - intentState, - reason, - force = false - }) { - (0, _util.assert)(reason instanceof Error || typeof reason === "object" && reason !== null, 'PDFPageProxy._abortOperatorList: Expected "reason" argument.'); - - if (!intentState.streamReader) { - return; + this.cleanup(); } - - if (!force) { - if (intentState.renderTasks.length !== 0) { - return; - } - - if (reason instanceof _display_utils.RenderingCancelledException) { - intentState.streamReaderCancelTimeout = setTimeout(() => { - this._abortOperatorList({ - intentState, - reason, - force: true - }); - - intentState.streamReaderCancelTimeout = null; - }, RENDERING_CANCELLED_TIMEOUT); - return; - } + }, { + key: "pageNumber", + get: function get() { + return this._pageIndex + 1; } - - intentState.streamReader.cancel(new _util.AbortException(reason && reason.message)); - intentState.streamReader = null; - - if (this._transport.destroyed) { - return; + }, { + key: "rotate", + get: function get() { + return this._pageInfo.rotate; } + }, { + key: "ref", + get: function get() { + return this._pageInfo.ref; + } + }, { + key: "userUnit", + get: function get() { + return this._pageInfo.userUnit; + } + }, { + key: "view", + get: function get() { + return this._pageInfo.view; + } + }, { + key: "stats", + get: function get() { + return this._stats; + } + }]); - Object.keys(this.intentStates).some(intent => { - if (this.intentStates[intent] === intentState) { - delete this.intentStates[intent]; - return true; - } - - return false; - }); - this.cleanup(); - } + return PDFPageProxy; +}(); - get stats() { - return this._stats; - } +exports.PDFPageProxy = PDFPageProxy; -} +var LoopbackPort = /*#__PURE__*/function () { + function LoopbackPort() { + var defer = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true; -exports.PDFPageProxy = PDFPageProxy; + _classCallCheck(this, LoopbackPort); -class LoopbackPort { - constructor(defer = true) { this._listeners = []; this._defer = defer; this._deferred = Promise.resolve(undefined); } - postMessage(obj, transfers) { - function cloneValue(value) { - if (typeof value !== "object" || value === null) { - return value; - } + _createClass(LoopbackPort, [{ + key: "postMessage", + value: function postMessage(obj, transfers) { + var _this10 = this; - if (cloned.has(value)) { - return cloned.get(value); - } + function cloneValue(value) { + if (_typeof(value) !== "object" || value === null) { + return value; + } + + if (cloned.has(value)) { + return cloned.get(value); + } - let buffer, result; + var buffer, result; - if ((buffer = value.buffer) && (0, _util.isArrayBuffer)(buffer)) { - const transferable = transfers && transfers.includes(buffer); + if ((buffer = value.buffer) && (0, _util.isArrayBuffer)(buffer)) { + var transferable = transfers && transfers.includes(buffer); - if (transferable) { - result = new value.constructor(buffer, value.byteOffset, value.byteLength); - } else { - result = new value.constructor(value); + if (transferable) { + result = new value.constructor(buffer, value.byteOffset, value.byteLength); + } else { + result = new value.constructor(value); + } + + cloned.set(value, result); + return result; } + result = Array.isArray(value) ? [] : {}; cloned.set(value, result); - return result; - } - result = Array.isArray(value) ? [] : {}; - cloned.set(value, result); + for (var i in value) { + var desc = void 0, + p = value; - for (const i in value) { - let desc, - p = value; + while (!(desc = Object.getOwnPropertyDescriptor(p, i))) { + p = Object.getPrototypeOf(p); + } - while (!(desc = Object.getOwnPropertyDescriptor(p, i))) { - p = Object.getPrototypeOf(p); - } + if (typeof desc.value === "undefined") { + continue; + } - if (typeof desc.value === "undefined") { - continue; - } + if (typeof desc.value === "function") { + if (value.hasOwnProperty && value.hasOwnProperty(i)) { + throw new Error("LoopbackPort.postMessage - cannot clone: ".concat(value[i])); + } - if (typeof desc.value === "function") { - if (value.hasOwnProperty && value.hasOwnProperty(i)) { - throw new Error(`LoopbackPort.postMessage - cannot clone: ${value[i]}`); + continue; } - continue; + result[i] = cloneValue(desc.value); } - result[i] = cloneValue(desc.value); + return result; } - return result; - } - - if (!this._defer) { - this._listeners.forEach(listener => { - listener.call(this, { - data: obj + if (!this._defer) { + this._listeners.forEach(function (listener) { + listener.call(_this10, { + data: obj + }); }); - }); - return; - } + return; + } - const cloned = new WeakMap(); - const e = { - data: cloneValue(obj) - }; + var cloned = new WeakMap(); + var e = { + data: cloneValue(obj) + }; - this._deferred.then(() => { - this._listeners.forEach(listener => { - listener.call(this, e); + this._deferred.then(function () { + _this10._listeners.forEach(function (listener) { + listener.call(_this10, e); + }); }); - }); - } - - addEventListener(name, listener) { - this._listeners.push(listener); - } - - removeEventListener(name, listener) { - const i = this._listeners.indexOf(listener); - - this._listeners.splice(i, 1); - } + } + }, { + key: "addEventListener", + value: function addEventListener(name, listener) { + this._listeners.push(listener); + } + }, { + key: "removeEventListener", + value: function removeEventListener(name, listener) { + var i = this._listeners.indexOf(listener); - terminate() { - this._listeners.length = 0; - } + this._listeners.splice(i, 1); + } + }, { + key: "terminate", + value: function terminate() { + this._listeners.length = 0; + } + }]); -} + return LoopbackPort; +}(); exports.LoopbackPort = LoopbackPort; -const PDFWorker = function PDFWorkerClosure() { - const pdfWorkerPorts = new WeakMap(); - let isWorkerDisabled = false; - let fallbackWorkerSrc; - let nextFakeWorkerId = 0; - let fakeWorkerCapability; +var PDFWorker = function PDFWorkerClosure() { + var pdfWorkerPorts = new WeakMap(); + var isWorkerDisabled = false; + var fallbackWorkerSrc; + var nextFakeWorkerId = 0; + var fakeWorkerCapability; if (_is_node.isNodeJS && typeof require === "function") { isWorkerDisabled = true; fallbackWorkerSrc = "./pdf.worker.js"; - } else if (typeof document === "object" && "currentScript" in document) { - const pdfjsFilePath = document.currentScript && document.currentScript.src; + } else if ((typeof document === "undefined" ? "undefined" : _typeof(document)) === "object" && "currentScript" in document) { + var pdfjsFilePath = document.currentScript && document.currentScript.src; if (pdfjsFilePath) { fallbackWorkerSrc = pdfjsFilePath.replace(/(\.(?:min\.)?js)(\?.*)?$/i, ".worker$1$2"); } } - function getWorkerSrc() { + function _getWorkerSrc() { if (_worker_options.GlobalWorkerOptions.workerSrc) { return _worker_options.GlobalWorkerOptions.workerSrc; } @@ -2789,7 +13344,7 @@ const PDFWorker = function PDFWorkerClosure() { } function getMainThreadWorkerMessageHandler() { - let mainWorkerMessageHandler; + var mainWorkerMessageHandler; try { mainWorkerMessageHandler = globalThis.pdfjsWorker && globalThis.pdfjsWorker.WorkerMessageHandler; @@ -2805,37 +13360,72 @@ const PDFWorker = function PDFWorkerClosure() { fakeWorkerCapability = (0, _util.createPromiseCapability)(); - const loader = async function () { - const mainWorkerMessageHandler = getMainThreadWorkerMessageHandler(); + var loader = /*#__PURE__*/function () { + var _ref10 = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee() { + var mainWorkerMessageHandler, worker; + return _regenerator["default"].wrap(function _callee$(_context) { + while (1) { + switch (_context.prev = _context.next) { + case 0: + mainWorkerMessageHandler = getMainThreadWorkerMessageHandler(); + + if (!mainWorkerMessageHandler) { + _context.next = 3; + break; + } - if (mainWorkerMessageHandler) { - return mainWorkerMessageHandler; - } + return _context.abrupt("return", mainWorkerMessageHandler); - if (_is_node.isNodeJS && typeof require === "function") { - const worker = eval("require")(getWorkerSrc()); - return worker.WorkerMessageHandler; - } + case 3: + if (!(_is_node.isNodeJS && typeof require === "function")) { + _context.next = 6; + break; + } - await (0, _display_utils.loadScript)(getWorkerSrc()); - return window.pdfjsWorker.WorkerMessageHandler; - }; + worker = eval("require")(_getWorkerSrc()); + return _context.abrupt("return", worker.WorkerMessageHandler); + + case 6: + _context.next = 8; + return (0, _display_utils.loadScript)(_getWorkerSrc()); + + case 8: + return _context.abrupt("return", window.pdfjsWorker.WorkerMessageHandler); + + case 9: + case "end": + return _context.stop(); + } + } + }, _callee); + })); + + return function loader() { + return _ref10.apply(this, arguments); + }; + }(); loader().then(fakeWorkerCapability.resolve, fakeWorkerCapability.reject); return fakeWorkerCapability.promise; } function createCDNWrapper(url) { - const wrapper = "importScripts('" + url + "');"; + var wrapper = "importScripts('" + url + "');"; return URL.createObjectURL(new Blob([wrapper])); } - class PDFWorker { - constructor({ - name = null, - port = null, - verbosity = (0, _util.getVerbosityLevel)() - } = {}) { + var PDFWorker = /*#__PURE__*/function () { + function PDFWorker() { + var _ref11 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}, + _ref11$name = _ref11.name, + name = _ref11$name === void 0 ? null : _ref11$name, + _ref11$port = _ref11.port, + port = _ref11$port === void 0 ? null : _ref11$port, + _ref11$verbosity = _ref11.verbosity, + verbosity = _ref11$verbosity === void 0 ? (0, _util.getVerbosityLevel)() : _ref11$verbosity; + + _classCallCheck(this, PDFWorker); + if (port && pdfWorkerPorts.has(port)) { throw new Error("Cannot use more than one PDFWorker per port"); } @@ -2860,199 +13450,217 @@ const PDFWorker = function PDFWorkerClosure() { this._initialize(); } - get promise() { - return this._readyCapability.promise; - } + _createClass(PDFWorker, [{ + key: "_initializeFromPort", + value: function _initializeFromPort(port) { + this._port = port; + this._messageHandler = new _message_handler.MessageHandler("main", "worker", port); - get port() { - return this._port; - } + this._messageHandler.on("ready", function () {}); - get messageHandler() { - return this._messageHandler; - } + this._readyCapability.resolve(); + } + }, { + key: "_initialize", + value: function _initialize() { + var _this11 = this; - _initializeFromPort(port) { - this._port = port; - this._messageHandler = new _message_handler.MessageHandler("main", "worker", port); + if (typeof Worker !== "undefined" && !isWorkerDisabled && !getMainThreadWorkerMessageHandler()) { + var workerSrc = _getWorkerSrc(); - this._messageHandler.on("ready", function () {}); + try { + if (!(0, _util.isSameOrigin)(window.location.href, workerSrc)) { + workerSrc = createCDNWrapper(new URL(workerSrc, window.location).href); + } - this._readyCapability.resolve(); - } + var worker = new Worker(workerSrc); + var messageHandler = new _message_handler.MessageHandler("main", "worker", worker); - _initialize() { - if (typeof Worker !== "undefined" && !isWorkerDisabled && !getMainThreadWorkerMessageHandler()) { - let workerSrc = getWorkerSrc(); + var terminateEarly = function terminateEarly() { + worker.removeEventListener("error", onWorkerError); + messageHandler.destroy(); + worker.terminate(); - try { - if (!(0, _util.isSameOrigin)(window.location.href, workerSrc)) { - workerSrc = createCDNWrapper(new URL(workerSrc, window.location).href); - } + if (_this11.destroyed) { + _this11._readyCapability.reject(new Error("Worker was destroyed")); + } else { + _this11._setupFakeWorker(); + } + }; - const worker = new Worker(workerSrc); - const messageHandler = new _message_handler.MessageHandler("main", "worker", worker); + var onWorkerError = function onWorkerError() { + if (!_this11._webWorker) { + terminateEarly(); + } + }; - const terminateEarly = () => { - worker.removeEventListener("error", onWorkerError); - messageHandler.destroy(); - worker.terminate(); + worker.addEventListener("error", onWorkerError); + messageHandler.on("test", function (data) { + worker.removeEventListener("error", onWorkerError); - if (this.destroyed) { - this._readyCapability.reject(new Error("Worker was destroyed")); - } else { - this._setupFakeWorker(); - } - }; + if (_this11.destroyed) { + terminateEarly(); + return; + } - const onWorkerError = () => { - if (!this._webWorker) { - terminateEarly(); - } - }; + if (data) { + _this11._messageHandler = messageHandler; + _this11._port = worker; + _this11._webWorker = worker; - worker.addEventListener("error", onWorkerError); - messageHandler.on("test", data => { - worker.removeEventListener("error", onWorkerError); + if (!data.supportTransfers) { + _this11.postMessageTransfers = false; + } - if (this.destroyed) { - terminateEarly(); - return; - } + _this11._readyCapability.resolve(); - if (data) { - this._messageHandler = messageHandler; - this._port = worker; - this._webWorker = worker; + messageHandler.send("configure", { + verbosity: _this11.verbosity + }); + } else { + _this11._setupFakeWorker(); - if (!data.supportTransfers) { - this.postMessageTransfers = false; + messageHandler.destroy(); + worker.terminate(); } + }); + messageHandler.on("ready", function (data) { + worker.removeEventListener("error", onWorkerError); - this._readyCapability.resolve(); - - messageHandler.send("configure", { - verbosity: this.verbosity - }); - } else { - this._setupFakeWorker(); - - messageHandler.destroy(); - worker.terminate(); - } - }); - messageHandler.on("ready", data => { - worker.removeEventListener("error", onWorkerError); - - if (this.destroyed) { - terminateEarly(); - return; - } + if (_this11.destroyed) { + terminateEarly(); + return; + } - try { - sendTest(); - } catch (e) { - this._setupFakeWorker(); - } - }); + try { + sendTest(); + } catch (e) { + _this11._setupFakeWorker(); + } + }); - const sendTest = () => { - const testObj = new Uint8Array([this.postMessageTransfers ? 255 : 0]); + var sendTest = function sendTest() { + var testObj = new Uint8Array([_this11.postMessageTransfers ? 255 : 0]); - try { - messageHandler.send("test", testObj, [testObj.buffer]); - } catch (ex) { - (0, _util.warn)("Cannot use postMessage transfers."); - testObj[0] = 0; - messageHandler.send("test", testObj); - } - }; + try { + messageHandler.send("test", testObj, [testObj.buffer]); + } catch (ex) { + (0, _util.warn)("Cannot use postMessage transfers."); + testObj[0] = 0; + messageHandler.send("test", testObj); + } + }; - sendTest(); - return; - } catch (e) { - (0, _util.info)("The worker has been disabled."); + sendTest(); + return; + } catch (e) { + (0, _util.info)("The worker has been disabled."); + } } - } - this._setupFakeWorker(); - } - - _setupFakeWorker() { - if (!isWorkerDisabled) { - (0, _util.warn)("Setting up fake worker."); - isWorkerDisabled = true; + this._setupFakeWorker(); } + }, { + key: "_setupFakeWorker", + value: function _setupFakeWorker() { + var _this12 = this; - setupFakeWorkerGlobal().then(WorkerMessageHandler => { - if (this.destroyed) { - this._readyCapability.reject(new Error("Worker was destroyed")); - - return; + if (!isWorkerDisabled) { + (0, _util.warn)("Setting up fake worker."); + isWorkerDisabled = true; } - const port = new LoopbackPort(); - this._port = port; - const id = "fake" + nextFakeWorkerId++; - const workerHandler = new _message_handler.MessageHandler(id + "_worker", id, port); - WorkerMessageHandler.setup(workerHandler, port); - const messageHandler = new _message_handler.MessageHandler(id, id + "_worker", port); - this._messageHandler = messageHandler; - - this._readyCapability.resolve(); + setupFakeWorkerGlobal().then(function (WorkerMessageHandler) { + if (_this12.destroyed) { + _this12._readyCapability.reject(new Error("Worker was destroyed")); - messageHandler.send("configure", { - verbosity: this.verbosity - }); - }).catch(reason => { - this._readyCapability.reject(new Error(`Setting up fake worker failed: "${reason.message}".`)); - }); - } + return; + } - destroy() { - this.destroyed = true; + var port = new LoopbackPort(); + _this12._port = port; + var id = "fake" + nextFakeWorkerId++; + var workerHandler = new _message_handler.MessageHandler(id + "_worker", id, port); + WorkerMessageHandler.setup(workerHandler, port); + var messageHandler = new _message_handler.MessageHandler(id, id + "_worker", port); + _this12._messageHandler = messageHandler; - if (this._webWorker) { - this._webWorker.terminate(); + _this12._readyCapability.resolve(); - this._webWorker = null; + messageHandler.send("configure", { + verbosity: _this12.verbosity + }); + })["catch"](function (reason) { + _this12._readyCapability.reject(new Error("Setting up fake worker failed: \"".concat(reason.message, "\"."))); + }); } + }, { + key: "destroy", + value: function destroy() { + this.destroyed = true; - pdfWorkerPorts.delete(this._port); - this._port = null; + if (this._webWorker) { + this._webWorker.terminate(); - if (this._messageHandler) { - this._messageHandler.destroy(); + this._webWorker = null; + } - this._messageHandler = null; - } - } + pdfWorkerPorts["delete"](this._port); + this._port = null; - static fromPort(params) { - if (!params || !params.port) { - throw new Error("PDFWorker.fromPort - invalid method signature."); - } + if (this._messageHandler) { + this._messageHandler.destroy(); - if (pdfWorkerPorts.has(params.port)) { - return pdfWorkerPorts.get(params.port); + this._messageHandler = null; + } } + }, { + key: "promise", + get: function get() { + return this._readyCapability.promise; + } + }, { + key: "port", + get: function get() { + return this._port; + } + }, { + key: "messageHandler", + get: function get() { + return this._messageHandler; + } + }], [{ + key: "fromPort", + value: function fromPort(params) { + if (!params || !params.port) { + throw new Error("PDFWorker.fromPort - invalid method signature."); + } - return new PDFWorker(params); - } + if (pdfWorkerPorts.has(params.port)) { + return pdfWorkerPorts.get(params.port); + } - static getWorkerSrc() { - return getWorkerSrc(); - } + return new PDFWorker(params); + } + }, { + key: "getWorkerSrc", + value: function getWorkerSrc() { + return _getWorkerSrc(); + } + }]); - } + return PDFWorker; + }(); return PDFWorker; }(); exports.PDFWorker = PDFWorker; -class WorkerTransport { - constructor(messageHandler, loadingTask, networkStream, params) { +var WorkerTransport = /*#__PURE__*/function () { + function WorkerTransport(messageHandler, loadingTask, networkStream, params) { + _classCallCheck(this, WorkerTransport); + this.messageHandler = messageHandler; this.loadingTask = loadingTask; this.commonObjs = new PDFObjects(); @@ -3077,577 +13685,647 @@ class WorkerTransport { this.setupMessageHandler(); } - destroy() { - if (this.destroyCapability) { - return this.destroyCapability.promise; - } + _createClass(WorkerTransport, [{ + key: "destroy", + value: function destroy() { + var _this13 = this; - this.destroyed = true; - this.destroyCapability = (0, _util.createPromiseCapability)(); + if (this.destroyCapability) { + return this.destroyCapability.promise; + } - if (this._passwordCapability) { - this._passwordCapability.reject(new Error("Worker was destroyed during onPassword callback")); - } + this.destroyed = true; + this.destroyCapability = (0, _util.createPromiseCapability)(); - const waitOn = []; - this.pageCache.forEach(function (page) { - if (page) { - waitOn.push(page._destroy()); + if (this._passwordCapability) { + this._passwordCapability.reject(new Error("Worker was destroyed during onPassword callback")); } - }); - this.pageCache.length = 0; - this.pagePromises.length = 0; - const terminated = this.messageHandler.sendWithPromise("Terminate", null); - waitOn.push(terminated); - Promise.all(waitOn).then(() => { - this.fontLoader.clear(); - if (this._networkStream) { - this._networkStream.cancelAllRequests(new _util.AbortException("Worker was terminated.")); - } + var waitOn = []; + this.pageCache.forEach(function (page) { + if (page) { + waitOn.push(page._destroy()); + } + }); + this.pageCache.length = 0; + this.pagePromises.length = 0; + var terminated = this.messageHandler.sendWithPromise("Terminate", null); + waitOn.push(terminated); + Promise.all(waitOn).then(function () { + _this13.fontLoader.clear(); + + if (_this13._networkStream) { + _this13._networkStream.cancelAllRequests(new _util.AbortException("Worker was terminated.")); + } - if (this.messageHandler) { - this.messageHandler.destroy(); - this.messageHandler = null; - } + if (_this13.messageHandler) { + _this13.messageHandler.destroy(); - this.destroyCapability.resolve(); - }, this.destroyCapability.reject); - return this.destroyCapability.promise; - } + _this13.messageHandler = null; + } + + _this13.destroyCapability.resolve(); + }, this.destroyCapability.reject); + return this.destroyCapability.promise; + } + }, { + key: "setupMessageHandler", + value: function setupMessageHandler() { + var _this14 = this; + + var messageHandler = this.messageHandler, + loadingTask = this.loadingTask; + messageHandler.on("GetReader", function (data, sink) { + (0, _util.assert)(_this14._networkStream, "GetReader - no `IPDFStream` instance available."); + _this14._fullReader = _this14._networkStream.getFullReader(); + + _this14._fullReader.onProgress = function (evt) { + _this14._lastProgress = { + loaded: evt.loaded, + total: evt.total + }; + }; - setupMessageHandler() { - const { - messageHandler, - loadingTask - } = this; - messageHandler.on("GetReader", (data, sink) => { - (0, _util.assert)(this._networkStream, "GetReader - no `IPDFStream` instance available."); - this._fullReader = this._networkStream.getFullReader(); + sink.onPull = function () { + _this14._fullReader.read().then(function (_ref12) { + var value = _ref12.value, + done = _ref12.done; - this._fullReader.onProgress = evt => { - this._lastProgress = { - loaded: evt.loaded, - total: evt.total + if (done) { + sink.close(); + return; + } + + (0, _util.assert)((0, _util.isArrayBuffer)(value), "GetReader - expected an ArrayBuffer."); + sink.enqueue(new Uint8Array(value), 1, [value]); + })["catch"](function (reason) { + sink.error(reason); + }); }; - }; - sink.onPull = () => { - this._fullReader.read().then(function ({ - value, - done - }) { - if (done) { - sink.close(); - return; + sink.onCancel = function (reason) { + _this14._fullReader.cancel(reason); + }; + }); + messageHandler.on("ReaderHeadersReady", function (data) { + var headersCapability = (0, _util.createPromiseCapability)(); + var fullReader = _this14._fullReader; + fullReader.headersReady.then(function () { + if (!fullReader.isStreamingSupported || !fullReader.isRangeSupported) { + if (_this14._lastProgress && loadingTask.onProgress) { + loadingTask.onProgress(_this14._lastProgress); + } + + fullReader.onProgress = function (evt) { + if (loadingTask.onProgress) { + loadingTask.onProgress({ + loaded: evt.loaded, + total: evt.total + }); + } + }; } - (0, _util.assert)((0, _util.isArrayBuffer)(value), "GetReader - expected an ArrayBuffer."); - sink.enqueue(new Uint8Array(value), 1, [value]); - }).catch(reason => { - sink.error(reason); - }); - }; + headersCapability.resolve({ + isStreamingSupported: fullReader.isStreamingSupported, + isRangeSupported: fullReader.isRangeSupported, + contentLength: fullReader.contentLength + }); + }, headersCapability.reject); + return headersCapability.promise; + }); + messageHandler.on("GetRangeReader", function (data, sink) { + (0, _util.assert)(_this14._networkStream, "GetRangeReader - no `IPDFStream` instance available."); - sink.onCancel = reason => { - this._fullReader.cancel(reason); - }; - }); - messageHandler.on("ReaderHeadersReady", data => { - const headersCapability = (0, _util.createPromiseCapability)(); - const fullReader = this._fullReader; - fullReader.headersReady.then(() => { - if (!fullReader.isStreamingSupported || !fullReader.isRangeSupported) { - if (this._lastProgress && loadingTask.onProgress) { - loadingTask.onProgress(this._lastProgress); - } + var rangeReader = _this14._networkStream.getRangeReader(data.begin, data.end); - fullReader.onProgress = evt => { - if (loadingTask.onProgress) { - loadingTask.onProgress({ - loaded: evt.loaded, - total: evt.total - }); - } - }; + if (!rangeReader) { + sink.close(); + return; } - headersCapability.resolve({ - isStreamingSupported: fullReader.isStreamingSupported, - isRangeSupported: fullReader.isRangeSupported, - contentLength: fullReader.contentLength - }); - }, headersCapability.reject); - return headersCapability.promise; - }); - messageHandler.on("GetRangeReader", (data, sink) => { - (0, _util.assert)(this._networkStream, "GetRangeReader - no `IPDFStream` instance available."); + sink.onPull = function () { + rangeReader.read().then(function (_ref13) { + var value = _ref13.value, + done = _ref13.done; - const rangeReader = this._networkStream.getRangeReader(data.begin, data.end); + if (done) { + sink.close(); + return; + } - if (!rangeReader) { - sink.close(); - return; - } + (0, _util.assert)((0, _util.isArrayBuffer)(value), "GetRangeReader - expected an ArrayBuffer."); + sink.enqueue(new Uint8Array(value), 1, [value]); + })["catch"](function (reason) { + sink.error(reason); + }); + }; - sink.onPull = () => { - rangeReader.read().then(function ({ - value, - done - }) { - if (done) { - sink.close(); - return; - } + sink.onCancel = function (reason) { + rangeReader.cancel(reason); + }; + }); + messageHandler.on("GetDoc", function (_ref14) { + var pdfInfo = _ref14.pdfInfo; + _this14._numPages = pdfInfo.numPages; - (0, _util.assert)((0, _util.isArrayBuffer)(value), "GetRangeReader - expected an ArrayBuffer."); - sink.enqueue(new Uint8Array(value), 1, [value]); - }).catch(reason => { - sink.error(reason); - }); - }; + loadingTask._capability.resolve(new PDFDocumentProxy(pdfInfo, _this14)); + }); + messageHandler.on("DocException", function (ex) { + var reason; - sink.onCancel = reason => { - rangeReader.cancel(reason); - }; - }); - messageHandler.on("GetDoc", ({ - pdfInfo - }) => { - this._numPages = pdfInfo.numPages; + switch (ex.name) { + case "PasswordException": + reason = new _util.PasswordException(ex.message, ex.code); + break; - loadingTask._capability.resolve(new PDFDocumentProxy(pdfInfo, this)); - }); - messageHandler.on("DocException", function (ex) { - let reason; + case "InvalidPDFException": + reason = new _util.InvalidPDFException(ex.message); + break; - switch (ex.name) { - case "PasswordException": - reason = new _util.PasswordException(ex.message, ex.code); - break; + case "MissingPDFException": + reason = new _util.MissingPDFException(ex.message); + break; - case "InvalidPDFException": - reason = new _util.InvalidPDFException(ex.message); - break; + case "UnexpectedResponseException": + reason = new _util.UnexpectedResponseException(ex.message, ex.status); + break; - case "MissingPDFException": - reason = new _util.MissingPDFException(ex.message); - break; + case "UnknownErrorException": + reason = new _util.UnknownErrorException(ex.message, ex.details); + break; + } - case "UnexpectedResponseException": - reason = new _util.UnexpectedResponseException(ex.message, ex.status); - break; + loadingTask._capability.reject(reason); + }); + messageHandler.on("PasswordRequest", function (exception) { + _this14._passwordCapability = (0, _util.createPromiseCapability)(); - case "UnknownErrorException": - reason = new _util.UnknownErrorException(ex.message, ex.details); - break; - } + if (loadingTask.onPassword) { + var updatePassword = function updatePassword(password) { + _this14._passwordCapability.resolve({ + password: password + }); + }; - loadingTask._capability.reject(reason); - }); - messageHandler.on("PasswordRequest", exception => { - this._passwordCapability = (0, _util.createPromiseCapability)(); + try { + loadingTask.onPassword(updatePassword, exception.code); + } catch (ex) { + _this14._passwordCapability.reject(ex); + } + } else { + _this14._passwordCapability.reject(new _util.PasswordException(exception.message, exception.code)); + } - if (loadingTask.onPassword) { - const updatePassword = password => { - this._passwordCapability.resolve({ - password + return _this14._passwordCapability.promise; + }); + messageHandler.on("DataLoaded", function (data) { + if (loadingTask.onProgress) { + loadingTask.onProgress({ + loaded: data.length, + total: data.length }); - }; - - try { - loadingTask.onPassword(updatePassword, exception.code); - } catch (ex) { - this._passwordCapability.reject(ex); } - } else { - this._passwordCapability.reject(new _util.PasswordException(exception.message, exception.code)); - } - return this._passwordCapability.promise; - }); - messageHandler.on("DataLoaded", data => { - if (loadingTask.onProgress) { - loadingTask.onProgress({ - loaded: data.length, - total: data.length - }); - } + _this14.downloadInfoCapability.resolve(data); + }); + messageHandler.on("StartRenderPage", function (data) { + if (_this14.destroyed) { + return; + } - this.downloadInfoCapability.resolve(data); - }); - messageHandler.on("StartRenderPage", data => { - if (this.destroyed) { - return; - } + var page = _this14.pageCache[data.pageIndex]; - const page = this.pageCache[data.pageIndex]; + page._startRenderPage(data.transparency, data.intent); + }); + messageHandler.on("commonobj", function (data) { + if (_this14.destroyed) { + return; + } - page._startRenderPage(data.transparency, data.intent); - }); - messageHandler.on("commonobj", data => { - if (this.destroyed) { - return; - } + var _data = _slicedToArray(data, 3), + id = _data[0], + type = _data[1], + exportedData = _data[2]; - const [id, type, exportedData] = data; + if (_this14.commonObjs.has(id)) { + return; + } - if (this.commonObjs.has(id)) { - return; - } + switch (type) { + case "Font": + var params = _this14._params; - switch (type) { - case "Font": - const params = this._params; + if ("error" in exportedData) { + var exportedError = exportedData.error; + (0, _util.warn)("Error during font loading: ".concat(exportedError)); - if ("error" in exportedData) { - const exportedError = exportedData.error; - (0, _util.warn)(`Error during font loading: ${exportedError}`); - this.commonObjs.resolve(id, exportedError); - break; - } + _this14.commonObjs.resolve(id, exportedError); - let fontRegistry = null; + break; + } - if (params.pdfBug && globalThis.FontInspector && globalThis.FontInspector.enabled) { - fontRegistry = { - registerFont(font, url) { - globalThis.FontInspector.fontAdded(font, url); - } + var fontRegistry = null; - }; - } + if (params.pdfBug && globalThis.FontInspector && globalThis.FontInspector.enabled) { + fontRegistry = { + registerFont: function registerFont(font, url) { + globalThis.FontInspector.fontAdded(font, url); + } + }; + } - const font = new _font_loader.FontFaceObject(exportedData, { - isEvalSupported: params.isEvalSupported, - disableFontFace: params.disableFontFace, - ignoreErrors: params.ignoreErrors, - onUnsupportedFeature: this._onUnsupportedFeature.bind(this), - fontRegistry - }); - this.fontLoader.bind(font).catch(reason => { - return messageHandler.sendWithPromise("FontFallback", { - id + var font = new _font_loader.FontFaceObject(exportedData, { + isEvalSupported: params.isEvalSupported, + disableFontFace: params.disableFontFace, + ignoreErrors: params.ignoreErrors, + onUnsupportedFeature: _this14._onUnsupportedFeature.bind(_this14), + fontRegistry: fontRegistry }); - }).finally(() => { - if (!params.fontExtraProperties && font.data) { - font.data = null; - } - this.commonObjs.resolve(id, font); - }); - break; + _this14.fontLoader.bind(font)["catch"](function (reason) { + return messageHandler.sendWithPromise("FontFallback", { + id: id + }); + })["finally"](function () { + if (!params.fontExtraProperties && font.data) { + font.data = null; + } - case "FontPath": - case "FontType3Res": - case "Image": - this.commonObjs.resolve(id, exportedData); - break; + _this14.commonObjs.resolve(id, font); + }); - default: - throw new Error(`Got unknown common object type ${type}`); - } - }); - messageHandler.on("obj", data => { - if (this.destroyed) { - return undefined; - } + break; - const [id, pageIndex, type, imageData] = data; - const pageProxy = this.pageCache[pageIndex]; + case "FontPath": + case "FontType3Res": + case "Image": + _this14.commonObjs.resolve(id, exportedData); - if (pageProxy.objs.has(id)) { - return undefined; - } + break; - switch (type) { - case "Image": - pageProxy.objs.resolve(id, imageData); - const MAX_IMAGE_SIZE_TO_STORE = 8000000; + default: + throw new Error("Got unknown common object type ".concat(type)); + } + }); + messageHandler.on("obj", function (data) { + if (_this14.destroyed) { + return undefined; + } - if (imageData && "data" in imageData && imageData.data.length > MAX_IMAGE_SIZE_TO_STORE) { - pageProxy.cleanupAfterRender = true; - } + var _data2 = _slicedToArray(data, 4), + id = _data2[0], + pageIndex = _data2[1], + type = _data2[2], + imageData = _data2[3]; - break; + var pageProxy = _this14.pageCache[pageIndex]; - default: - throw new Error(`Got unknown object type ${type}`); - } + if (pageProxy.objs.has(id)) { + return undefined; + } - return undefined; - }); - messageHandler.on("DocProgress", data => { - if (this.destroyed) { - return; - } + switch (type) { + case "Image": + pageProxy.objs.resolve(id, imageData); + var MAX_IMAGE_SIZE_TO_STORE = 8000000; - if (loadingTask.onProgress) { - loadingTask.onProgress({ - loaded: data.loaded, - total: data.total - }); - } - }); - messageHandler.on("UnsupportedFeature", this._onUnsupportedFeature.bind(this)); - messageHandler.on("FetchBuiltInCMap", (data, sink) => { - if (this.destroyed) { - sink.error(new Error("Worker was destroyed")); - return; - } + if (imageData && "data" in imageData && imageData.data.length > MAX_IMAGE_SIZE_TO_STORE) { + pageProxy.cleanupAfterRender = true; + } - let fetched = false; + break; - sink.onPull = () => { - if (fetched) { - sink.close(); + default: + throw new Error("Got unknown object type ".concat(type)); + } + + return undefined; + }); + messageHandler.on("DocProgress", function (data) { + if (_this14.destroyed) { return; } - fetched = true; - this.CMapReaderFactory.fetch(data).then(function (builtInCMap) { - sink.enqueue(builtInCMap, 1, [builtInCMap.cMapData.buffer]); - }).catch(function (reason) { - sink.error(reason); - }); - }; - }); - } + if (loadingTask.onProgress) { + loadingTask.onProgress({ + loaded: data.loaded, + total: data.total + }); + } + }); + messageHandler.on("UnsupportedFeature", this._onUnsupportedFeature.bind(this)); + messageHandler.on("FetchBuiltInCMap", function (data, sink) { + if (_this14.destroyed) { + sink.error(new Error("Worker was destroyed")); + return; + } - _onUnsupportedFeature({ - featureId - }) { - if (this.destroyed) { - return; - } + var fetched = false; - if (this.loadingTask.onUnsupportedFeature) { - this.loadingTask.onUnsupportedFeature(featureId); - } - } + sink.onPull = function () { + if (fetched) { + sink.close(); + return; + } - getData() { - return this.messageHandler.sendWithPromise("GetData", null); - } + fetched = true; - getPage(pageNumber) { - if (!Number.isInteger(pageNumber) || pageNumber <= 0 || pageNumber > this._numPages) { - return Promise.reject(new Error("Invalid page request")); + _this14.CMapReaderFactory.fetch(data).then(function (builtInCMap) { + sink.enqueue(builtInCMap, 1, [builtInCMap.cMapData.buffer]); + })["catch"](function (reason) { + sink.error(reason); + }); + }; + }); } + }, { + key: "_onUnsupportedFeature", + value: function _onUnsupportedFeature(_ref15) { + var featureId = _ref15.featureId; - const pageIndex = pageNumber - 1; + if (this.destroyed) { + return; + } - if (pageIndex in this.pagePromises) { - return this.pagePromises[pageIndex]; + if (this.loadingTask.onUnsupportedFeature) { + this.loadingTask.onUnsupportedFeature(featureId); + } + } + }, { + key: "getData", + value: function getData() { + return this.messageHandler.sendWithPromise("GetData", null); } + }, { + key: "getPage", + value: function getPage(pageNumber) { + var _this15 = this; - const promise = this.messageHandler.sendWithPromise("GetPage", { - pageIndex - }).then(pageInfo => { - if (this.destroyed) { - throw new Error("Transport destroyed"); + if (!Number.isInteger(pageNumber) || pageNumber <= 0 || pageNumber > this._numPages) { + return Promise.reject(new Error("Invalid page request")); } - const page = new PDFPageProxy(pageIndex, pageInfo, this, this._params.pdfBug); - this.pageCache[pageIndex] = page; - return page; - }); - this.pagePromises[pageIndex] = promise; - return promise; - } - - getPageIndex(ref) { - return this.messageHandler.sendWithPromise("GetPageIndex", { - ref - }).catch(function (reason) { - return Promise.reject(new Error(reason)); - }); - } + var pageIndex = pageNumber - 1; - getAnnotations(pageIndex, intent) { - return this.messageHandler.sendWithPromise("GetAnnotations", { - pageIndex, - intent - }); - } + if (pageIndex in this.pagePromises) { + return this.pagePromises[pageIndex]; + } - getDestinations() { - return this.messageHandler.sendWithPromise("GetDestinations", null); - } + var promise = this.messageHandler.sendWithPromise("GetPage", { + pageIndex: pageIndex + }).then(function (pageInfo) { + if (_this15.destroyed) { + throw new Error("Transport destroyed"); + } - getDestination(id) { - if (typeof id !== "string") { - return Promise.reject(new Error("Invalid destination request.")); + var page = new PDFPageProxy(pageIndex, pageInfo, _this15, _this15._params.pdfBug); + _this15.pageCache[pageIndex] = page; + return page; + }); + this.pagePromises[pageIndex] = promise; + return promise; + } + }, { + key: "getPageIndex", + value: function getPageIndex(ref) { + return this.messageHandler.sendWithPromise("GetPageIndex", { + ref: ref + })["catch"](function (reason) { + return Promise.reject(new Error(reason)); + }); + } + }, { + key: "getAnnotations", + value: function getAnnotations(pageIndex, intent) { + return this.messageHandler.sendWithPromise("GetAnnotations", { + pageIndex: pageIndex, + intent: intent + }); + } + }, { + key: "getDestinations", + value: function getDestinations() { + return this.messageHandler.sendWithPromise("GetDestinations", null); } + }, { + key: "getDestination", + value: function getDestination(id) { + if (typeof id !== "string") { + return Promise.reject(new Error("Invalid destination request.")); + } - return this.messageHandler.sendWithPromise("GetDestination", { - id - }); - } + return this.messageHandler.sendWithPromise("GetDestination", { + id: id + }); + } + }, { + key: "getPageLabels", + value: function getPageLabels() { + return this.messageHandler.sendWithPromise("GetPageLabels", null); + } + }, { + key: "getPageLayout", + value: function getPageLayout() { + return this.messageHandler.sendWithPromise("GetPageLayout", null); + } + }, { + key: "getPageMode", + value: function getPageMode() { + return this.messageHandler.sendWithPromise("GetPageMode", null); + } + }, { + key: "getViewerPreferences", + value: function getViewerPreferences() { + return this.messageHandler.sendWithPromise("GetViewerPreferences", null); + } + }, { + key: "getOpenAction", + value: function getOpenAction() { + return this.messageHandler.sendWithPromise("GetOpenAction", null); + } + }, { + key: "getAttachments", + value: function getAttachments() { + return this.messageHandler.sendWithPromise("GetAttachments", null); + } + }, { + key: "getJavaScript", + value: function getJavaScript() { + return this.messageHandler.sendWithPromise("GetJavaScript", null); + } + }, { + key: "getOutline", + value: function getOutline() { + return this.messageHandler.sendWithPromise("GetOutline", null); + } + }, { + key: "getPermissions", + value: function getPermissions() { + return this.messageHandler.sendWithPromise("GetPermissions", null); + } + }, { + key: "getMetadata", + value: function getMetadata() { + var _this16 = this; + + return this.messageHandler.sendWithPromise("GetMetadata", null).then(function (results) { + return { + info: results[0], + metadata: results[1] ? new _metadata.Metadata(results[1]) : null, + contentDispositionFilename: _this16._fullReader ? _this16._fullReader.filename : null + }; + }); + } + }, { + key: "getStats", + value: function getStats() { + return this.messageHandler.sendWithPromise("GetStats", null); + } + }, { + key: "startCleanup", + value: function startCleanup() { + var _this17 = this; - getPageLabels() { - return this.messageHandler.sendWithPromise("GetPageLabels", null); - } + return this.messageHandler.sendWithPromise("Cleanup", null).then(function () { + for (var i = 0, ii = _this17.pageCache.length; i < ii; i++) { + var page = _this17.pageCache[i]; - getPageLayout() { - return this.messageHandler.sendWithPromise("GetPageLayout", null); - } + if (page) { + var cleanupSuccessful = page.cleanup(); - getPageMode() { - return this.messageHandler.sendWithPromise("GetPageMode", null); - } + if (!cleanupSuccessful) { + throw new Error("startCleanup: Page ".concat(i + 1, " is currently rendering.")); + } + } + } - getViewerPreferences() { - return this.messageHandler.sendWithPromise("GetViewerPreferences", null); - } + _this17.commonObjs.clear(); - getOpenAction() { - return this.messageHandler.sendWithPromise("GetOpenAction", null); - } + _this17.fontLoader.clear(); + }); + } + }, { + key: "loadingParams", + get: function get() { + var params = this._params; + return (0, _util.shadow)(this, "loadingParams", { + disableAutoFetch: params.disableAutoFetch, + disableFontFace: params.disableFontFace + }); + } + }]); - getAttachments() { - return this.messageHandler.sendWithPromise("GetAttachments", null); - } + return WorkerTransport; +}(); - getJavaScript() { - return this.messageHandler.sendWithPromise("GetJavaScript", null); - } +var PDFObjects = /*#__PURE__*/function () { + function PDFObjects() { + _classCallCheck(this, PDFObjects); - getOutline() { - return this.messageHandler.sendWithPromise("GetOutline", null); + this._objs = Object.create(null); } - getPermissions() { - return this.messageHandler.sendWithPromise("GetPermissions", null); - } + _createClass(PDFObjects, [{ + key: "_ensureObj", + value: function _ensureObj(objId) { + if (this._objs[objId]) { + return this._objs[objId]; + } - getMetadata() { - return this.messageHandler.sendWithPromise("GetMetadata", null).then(results => { - return { - info: results[0], - metadata: results[1] ? new _metadata.Metadata(results[1]) : null, - contentDispositionFilename: this._fullReader ? this._fullReader.filename : null + return this._objs[objId] = { + capability: (0, _util.createPromiseCapability)(), + data: null, + resolved: false }; - }); - } - - getStats() { - return this.messageHandler.sendWithPromise("GetStats", null); - } + } + }, { + key: "get", + value: function get(objId) { + var callback = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null; - startCleanup() { - return this.messageHandler.sendWithPromise("Cleanup", null).then(() => { - for (let i = 0, ii = this.pageCache.length; i < ii; i++) { - const page = this.pageCache[i]; + if (callback) { + this._ensureObj(objId).capability.promise.then(callback); - if (page) { - const cleanupSuccessful = page.cleanup(); - - if (!cleanupSuccessful) { - throw new Error(`startCleanup: Page ${i + 1} is currently rendering.`); - } - } + return null; } - this.commonObjs.clear(); - this.fontLoader.clear(); - }); - } - - get loadingParams() { - const params = this._params; - return (0, _util.shadow)(this, "loadingParams", { - disableAutoFetch: params.disableAutoFetch, - disableFontFace: params.disableFontFace - }); - } + var obj = this._objs[objId]; -} - -class PDFObjects { - constructor() { - this._objs = Object.create(null); - } + if (!obj || !obj.resolved) { + throw new Error("Requesting object that isn't resolved yet ".concat(objId, ".")); + } - _ensureObj(objId) { - if (this._objs[objId]) { - return this._objs[objId]; + return obj.data; } - - return this._objs[objId] = { - capability: (0, _util.createPromiseCapability)(), - data: null, - resolved: false - }; - } - - get(objId, callback = null) { - if (callback) { - this._ensureObj(objId).capability.promise.then(callback); - - return null; + }, { + key: "has", + value: function has(objId) { + var obj = this._objs[objId]; + return obj ? obj.resolved : false; } + }, { + key: "resolve", + value: function resolve(objId, data) { + var obj = this._ensureObj(objId); - const obj = this._objs[objId]; - - if (!obj || !obj.resolved) { - throw new Error(`Requesting object that isn't resolved yet ${objId}.`); + obj.resolved = true; + obj.data = data; + obj.capability.resolve(data); } + }, { + key: "clear", + value: function clear() { + this._objs = Object.create(null); + } + }]); - return obj.data; - } - - has(objId) { - const obj = this._objs[objId]; - return obj ? obj.resolved : false; - } - - resolve(objId, data) { - const obj = this._ensureObj(objId); - - obj.resolved = true; - obj.data = data; - obj.capability.resolve(data); - } - - clear() { - this._objs = Object.create(null); - } + return PDFObjects; +}(); -} +var RenderTask = /*#__PURE__*/function () { + function RenderTask(internalRenderTask) { + _classCallCheck(this, RenderTask); -class RenderTask { - constructor(internalRenderTask) { this._internalRenderTask = internalRenderTask; this.onContinue = null; } - get promise() { - return this._internalRenderTask.capability.promise; - } + _createClass(RenderTask, [{ + key: "cancel", + value: function cancel() { + this._internalRenderTask.cancel(); + } + }, { + key: "promise", + get: function get() { + return this._internalRenderTask.capability.promise; + } + }]); - cancel() { - this._internalRenderTask.cancel(); - } + return RenderTask; +}(); -} +var InternalRenderTask = function InternalRenderTaskClosure() { + var canvasInRendering = new WeakSet(); + + var InternalRenderTask = /*#__PURE__*/function () { + function InternalRenderTask(_ref16) { + var callback = _ref16.callback, + params = _ref16.params, + objs = _ref16.objs, + commonObjs = _ref16.commonObjs, + operatorList = _ref16.operatorList, + pageIndex = _ref16.pageIndex, + canvasFactory = _ref16.canvasFactory, + webGLContext = _ref16.webGLContext, + _ref16$useRequestAnim = _ref16.useRequestAnimationFrame, + useRequestAnimationFrame = _ref16$useRequestAnim === void 0 ? false : _ref16$useRequestAnim, + _ref16$pdfBug = _ref16.pdfBug, + pdfBug = _ref16$pdfBug === void 0 ? false : _ref16$pdfBug; + + _classCallCheck(this, InternalRenderTask); -const InternalRenderTask = function InternalRenderTaskClosure() { - const canvasInRendering = new WeakSet(); - - class InternalRenderTask { - constructor({ - callback, - params, - objs, - commonObjs, - operatorList, - pageIndex, - canvasFactory, - webGLContext, - useRequestAnimationFrame = false, - pdfBug = false - }) { this.callback = callback; this.params = params; this.objs = objs; @@ -3671,140 +14349,176 @@ const InternalRenderTask = function InternalRenderTaskClosure() { this._canvas = params.canvasContext.canvas; } - initializeGraphics(transparency = false) { - if (this.cancelled) { - return; - } + _createClass(InternalRenderTask, [{ + key: "initializeGraphics", + value: function initializeGraphics() { + var transparency = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; - if (this._canvas) { - if (canvasInRendering.has(this._canvas)) { - throw new Error("Cannot use the same canvas during multiple render() operations. " + "Use different canvas or ensure previous operations were " + "cancelled or completed."); + if (this.cancelled) { + return; } - canvasInRendering.add(this._canvas); - } - - if (this._pdfBug && globalThis.StepperManager && globalThis.StepperManager.enabled) { - this.stepper = globalThis.StepperManager.create(this._pageIndex); - this.stepper.init(this.operatorList); - this.stepper.nextBreakPoint = this.stepper.getNextBreakPoint(); - } - - const { - canvasContext, - viewport, - transform, - imageLayer, - background - } = this.params; - this.gfx = new _canvas.CanvasGraphics(canvasContext, this.commonObjs, this.objs, this.canvasFactory, this.webGLContext, imageLayer); - this.gfx.beginDrawing({ - transform, - viewport, - transparency, - background - }); - this.operatorListIdx = 0; - this.graphicsReady = true; + if (this._canvas) { + if (canvasInRendering.has(this._canvas)) { + throw new Error("Cannot use the same canvas during multiple render() operations. " + "Use different canvas or ensure previous operations were " + "cancelled or completed."); + } - if (this.graphicsReadyCallback) { - this.graphicsReadyCallback(); - } - } + canvasInRendering.add(this._canvas); + } - cancel(error = null) { - this.running = false; - this.cancelled = true; + if (this._pdfBug && globalThis.StepperManager && globalThis.StepperManager.enabled) { + this.stepper = globalThis.StepperManager.create(this._pageIndex); + this.stepper.init(this.operatorList); + this.stepper.nextBreakPoint = this.stepper.getNextBreakPoint(); + } - if (this.gfx) { - this.gfx.endDrawing(); - } + var _this$params = this.params, + canvasContext = _this$params.canvasContext, + viewport = _this$params.viewport, + transform = _this$params.transform, + imageLayer = _this$params.imageLayer, + background = _this$params.background; + this.gfx = new _canvas.CanvasGraphics(canvasContext, this.commonObjs, this.objs, this.canvasFactory, this.webGLContext, imageLayer); + this.gfx.beginDrawing({ + transform: transform, + viewport: viewport, + transparency: transparency, + background: background + }); + this.operatorListIdx = 0; + this.graphicsReady = true; - if (this._canvas) { - canvasInRendering.delete(this._canvas); + if (this.graphicsReadyCallback) { + this.graphicsReadyCallback(); + } } + }, { + key: "cancel", + value: function cancel() { + var error = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null; + this.running = false; + this.cancelled = true; - this.callback(error || new _display_utils.RenderingCancelledException(`Rendering cancelled, page ${this._pageIndex + 1}`, "canvas")); - } - - operatorListChanged() { - if (!this.graphicsReady) { - if (!this.graphicsReadyCallback) { - this.graphicsReadyCallback = this._continueBound; + if (this.gfx) { + this.gfx.endDrawing(); } - return; - } + if (this._canvas) { + canvasInRendering["delete"](this._canvas); + } - if (this.stepper) { - this.stepper.updateOperatorList(this.operatorList); + this.callback(error || new _display_utils.RenderingCancelledException("Rendering cancelled, page ".concat(this._pageIndex + 1), "canvas")); } + }, { + key: "operatorListChanged", + value: function operatorListChanged() { + if (!this.graphicsReady) { + if (!this.graphicsReadyCallback) { + this.graphicsReadyCallback = this._continueBound; + } - if (this.running) { - return; - } + return; + } - this._continue(); - } + if (this.stepper) { + this.stepper.updateOperatorList(this.operatorList); + } - _continue() { - this.running = true; + if (this.running) { + return; + } - if (this.cancelled) { - return; + this._continue(); } + }, { + key: "_continue", + value: function _continue() { + this.running = true; - if (this.task.onContinue) { - this.task.onContinue(this._scheduleNextBound); - } else { - this._scheduleNext(); - } - } + if (this.cancelled) { + return; + } - _scheduleNext() { - if (this._useRequestAnimationFrame) { - window.requestAnimationFrame(() => { - this._nextBound().catch(this.cancel.bind(this)); - }); - } else { - Promise.resolve().then(this._nextBound).catch(this.cancel.bind(this)); + if (this.task.onContinue) { + this.task.onContinue(this._scheduleNextBound); + } else { + this._scheduleNext(); + } } - } + }, { + key: "_scheduleNext", + value: function _scheduleNext() { + var _this18 = this; - async _next() { - if (this.cancelled) { - return; + if (this._useRequestAnimationFrame) { + window.requestAnimationFrame(function () { + _this18._nextBound()["catch"](_this18.cancel.bind(_this18)); + }); + } else { + Promise.resolve().then(this._nextBound)["catch"](this.cancel.bind(this)); + } } + }, { + key: "_next", + value: function () { + var _next2 = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee2() { + return _regenerator["default"].wrap(function _callee2$(_context2) { + while (1) { + switch (_context2.prev = _context2.next) { + case 0: + if (!this.cancelled) { + _context2.next = 2; + break; + } + + return _context2.abrupt("return"); + + case 2: + this.operatorListIdx = this.gfx.executeOperatorList(this.operatorList, this.operatorListIdx, this._continueBound, this.stepper); + + if (this.operatorListIdx === this.operatorList.argsArray.length) { + this.running = false; + + if (this.operatorList.lastChunk) { + this.gfx.endDrawing(); + + if (this._canvas) { + canvasInRendering["delete"](this._canvas); + } + + this.callback(); + } + } + + case 4: + case "end": + return _context2.stop(); + } + } + }, _callee2, this); + })); - this.operatorListIdx = this.gfx.executeOperatorList(this.operatorList, this.operatorListIdx, this._continueBound, this.stepper); - - if (this.operatorListIdx === this.operatorList.argsArray.length) { - this.running = false; - - if (this.operatorList.lastChunk) { - this.gfx.endDrawing(); - - if (this._canvas) { - canvasInRendering.delete(this._canvas); - } - - this.callback(); + function _next() { + return _next2.apply(this, arguments); } - } - } - } + return _next; + }() + }]); + + return InternalRenderTask; + }(); return InternalRenderTask; }(); -const version = '2.5.207'; +var version = '2.5.207'; exports.version = version; -const build = '0974d6052'; +var build = '0974d6052'; exports.build = build; /***/ }), -/* 6 */ +/* 199 */ /***/ (function(module, exports, __w_pdfjs_require__) { "use strict"; @@ -3815,13 +14529,45 @@ Object.defineProperty(exports, "__esModule", { }); exports.FontLoader = exports.FontFaceObject = void 0; -var _util = __w_pdfjs_require__(2); +var _regenerator = _interopRequireDefault(__w_pdfjs_require__(2)); + +var _util = __w_pdfjs_require__(5); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } + +function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } } + +function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +var BaseFontLoader = /*#__PURE__*/function () { + function BaseFontLoader(_ref) { + var docId = _ref.docId, + onUnsupportedFeature = _ref.onUnsupportedFeature; + + _classCallCheck(this, BaseFontLoader); -class BaseFontLoader { - constructor({ - docId, - onUnsupportedFeature - }) { if (this.constructor === BaseFontLoader) { (0, _util.unreachable)("Cannot initialize BaseFontLoader."); } @@ -3832,264 +14578,348 @@ class BaseFontLoader { this.styleElement = null; } - addNativeFontFace(nativeFontFace) { - this.nativeFontFaces.push(nativeFontFace); - document.fonts.add(nativeFontFace); - } + _createClass(BaseFontLoader, [{ + key: "addNativeFontFace", + value: function addNativeFontFace(nativeFontFace) { + this.nativeFontFaces.push(nativeFontFace); + document.fonts.add(nativeFontFace); + } + }, { + key: "insertRule", + value: function insertRule(rule) { + var styleElement = this.styleElement; - insertRule(rule) { - let styleElement = this.styleElement; + if (!styleElement) { + styleElement = this.styleElement = document.createElement("style"); + styleElement.id = "PDFJS_FONT_STYLE_TAG_".concat(this.docId); + document.documentElement.getElementsByTagName("head")[0].appendChild(styleElement); + } - if (!styleElement) { - styleElement = this.styleElement = document.createElement("style"); - styleElement.id = `PDFJS_FONT_STYLE_TAG_${this.docId}`; - document.documentElement.getElementsByTagName("head")[0].appendChild(styleElement); + var styleSheet = styleElement.sheet; + styleSheet.insertRule(rule, styleSheet.cssRules.length); } + }, { + key: "clear", + value: function clear() { + this.nativeFontFaces.forEach(function (nativeFontFace) { + document.fonts["delete"](nativeFontFace); + }); + this.nativeFontFaces.length = 0; + + if (this.styleElement) { + this.styleElement.remove(); + this.styleElement = null; + } + } + }, { + key: "bind", + value: function () { + var _bind = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee(font) { + var _this = this; + + var nativeFontFace, rule; + return _regenerator["default"].wrap(function _callee$(_context) { + while (1) { + switch (_context.prev = _context.next) { + case 0: + if (!(font.attached || font.missingFile)) { + _context.next = 2; + break; + } - const styleSheet = styleElement.sheet; - styleSheet.insertRule(rule, styleSheet.cssRules.length); - } + return _context.abrupt("return"); - clear() { - this.nativeFontFaces.forEach(function (nativeFontFace) { - document.fonts.delete(nativeFontFace); - }); - this.nativeFontFaces.length = 0; + case 2: + font.attached = true; - if (this.styleElement) { - this.styleElement.remove(); - this.styleElement = null; - } - } + if (!this.isFontLoadingAPISupported) { + _context.next = 19; + break; + } - async bind(font) { - if (font.attached || font.missingFile) { - return; - } + nativeFontFace = font.createNativeFontFace(); - font.attached = true; + if (!nativeFontFace) { + _context.next = 18; + break; + } - if (this.isFontLoadingAPISupported) { - const nativeFontFace = font.createNativeFontFace(); + this.addNativeFontFace(nativeFontFace); + _context.prev = 7; + _context.next = 10; + return nativeFontFace.loaded; - if (nativeFontFace) { - this.addNativeFontFace(nativeFontFace); + case 10: + _context.next = 18; + break; - try { - await nativeFontFace.loaded; - } catch (ex) { - this._onUnsupportedFeature({ - featureId: _util.UNSUPPORTED_FEATURES.errorFontLoadNative - }); + case 12: + _context.prev = 12; + _context.t0 = _context["catch"](7); - (0, _util.warn)(`Failed to load font '${nativeFontFace.family}': '${ex}'.`); - font.disableFontFace = true; - throw ex; - } - } + this._onUnsupportedFeature({ + featureId: _util.UNSUPPORTED_FEATURES.errorFontLoadNative + }); - return; - } + (0, _util.warn)("Failed to load font '".concat(nativeFontFace.family, "': '").concat(_context.t0, "'.")); + font.disableFontFace = true; + throw _context.t0; - const rule = font.createFontFaceRule(); + case 18: + return _context.abrupt("return"); - if (rule) { - this.insertRule(rule); + case 19: + rule = font.createFontFaceRule(); - if (this.isSyncFontLoadingSupported) { - return; - } + if (!rule) { + _context.next = 26; + break; + } - await new Promise(resolve => { - const request = this._queueLoadingCallback(resolve); + this.insertRule(rule); - this._prepareFontLoadEvent([rule], [font], request); - }); - } - } + if (!this.isSyncFontLoadingSupported) { + _context.next = 24; + break; + } - _queueLoadingCallback(callback) { - (0, _util.unreachable)("Abstract method `_queueLoadingCallback`."); - } + return _context.abrupt("return"); - get isFontLoadingAPISupported() { - const supported = typeof document !== "undefined" && !!document.fonts; - return (0, _util.shadow)(this, "isFontLoadingAPISupported", supported); - } + case 24: + _context.next = 26; + return new Promise(function (resolve) { + var request = _this._queueLoadingCallback(resolve); - get isSyncFontLoadingSupported() { - (0, _util.unreachable)("Abstract method `isSyncFontLoadingSupported`."); - } + _this._prepareFontLoadEvent([rule], [font], request); + }); - get _loadTestFont() { - (0, _util.unreachable)("Abstract method `_loadTestFont`."); - } + case 26: + case "end": + return _context.stop(); + } + } + }, _callee, this, [[7, 12]]); + })); - _prepareFontLoadEvent(rules, fontsToLoad, request) { - (0, _util.unreachable)("Abstract method `_prepareFontLoadEvent`."); - } + function bind(_x) { + return _bind.apply(this, arguments); + } -} + return bind; + }() + }, { + key: "_queueLoadingCallback", + value: function _queueLoadingCallback(callback) { + (0, _util.unreachable)("Abstract method `_queueLoadingCallback`."); + } + }, { + key: "_prepareFontLoadEvent", + value: function _prepareFontLoadEvent(rules, fontsToLoad, request) { + (0, _util.unreachable)("Abstract method `_prepareFontLoadEvent`."); + } + }, { + key: "isFontLoadingAPISupported", + get: function get() { + var supported = typeof document !== "undefined" && !!document.fonts; + return (0, _util.shadow)(this, "isFontLoadingAPISupported", supported); + } + }, { + key: "isSyncFontLoadingSupported", + get: function get() { + (0, _util.unreachable)("Abstract method `isSyncFontLoadingSupported`."); + } + }, { + key: "_loadTestFont", + get: function get() { + (0, _util.unreachable)("Abstract method `_loadTestFont`."); + } + }]); -let FontLoader; + return BaseFontLoader; +}(); + +var FontLoader; exports.FontLoader = FontLoader; { - exports.FontLoader = FontLoader = class GenericFontLoader extends BaseFontLoader { - constructor(docId) { - super(docId); - this.loadingContext = { + exports.FontLoader = FontLoader = /*#__PURE__*/function (_BaseFontLoader) { + _inherits(GenericFontLoader, _BaseFontLoader); + + var _super = _createSuper(GenericFontLoader); + + function GenericFontLoader(docId) { + var _this2; + + _classCallCheck(this, GenericFontLoader); + + _this2 = _super.call(this, docId); + _this2.loadingContext = { requests: [], nextRequestId: 0 }; - this.loadTestFontId = 0; + _this2.loadTestFontId = 0; + return _this2; } - get isSyncFontLoadingSupported() { - let supported = false; - - if (typeof navigator === "undefined") { - supported = true; - } else { - const m = /Mozilla\/5.0.*?rv:(\d+).*? Gecko/.exec(navigator.userAgent); + _createClass(GenericFontLoader, [{ + key: "_queueLoadingCallback", + value: function _queueLoadingCallback(callback) { + function completeRequest() { + (0, _util.assert)(!request.done, "completeRequest() cannot be called twice."); + request.done = true; - if (m && m[1] >= 14) { - supported = true; + while (context.requests.length > 0 && context.requests[0].done) { + var otherRequest = context.requests.shift(); + setTimeout(otherRequest.callback, 0); + } } - } - - return (0, _util.shadow)(this, "isSyncFontLoadingSupported", supported); - } - _queueLoadingCallback(callback) { - function completeRequest() { - (0, _util.assert)(!request.done, "completeRequest() cannot be called twice."); - request.done = true; + var context = this.loadingContext; + var request = { + id: "pdfjs-font-loading-".concat(context.nextRequestId++), + done: false, + complete: completeRequest, + callback: callback + }; + context.requests.push(request); + return request; + } + }, { + key: "_prepareFontLoadEvent", + value: function _prepareFontLoadEvent(rules, fonts, request) { + function int32(data, offset) { + return data.charCodeAt(offset) << 24 | data.charCodeAt(offset + 1) << 16 | data.charCodeAt(offset + 2) << 8 | data.charCodeAt(offset + 3) & 0xff; + } - while (context.requests.length > 0 && context.requests[0].done) { - const otherRequest = context.requests.shift(); - setTimeout(otherRequest.callback, 0); + function spliceString(s, offset, remove, insert) { + var chunk1 = s.substring(0, offset); + var chunk2 = s.substring(offset + remove); + return chunk1 + insert + chunk2; } - } - const context = this.loadingContext; - const request = { - id: `pdfjs-font-loading-${context.nextRequestId++}`, - done: false, - complete: completeRequest, - callback - }; - context.requests.push(request); - return request; - } + var i, ii; + var canvas = document.createElement("canvas"); + canvas.width = 1; + canvas.height = 1; + var ctx = canvas.getContext("2d"); + var called = 0; - get _loadTestFont() { - const getLoadTestFont = function () { - return atob("T1RUTwALAIAAAwAwQ0ZGIDHtZg4AAAOYAAAAgUZGVE1lkzZwAAAEHAAAABxHREVGABQA" + "FQAABDgAAAAeT1MvMlYNYwkAAAEgAAAAYGNtYXABDQLUAAACNAAAAUJoZWFk/xVFDQAA" + "ALwAAAA2aGhlYQdkA+oAAAD0AAAAJGhtdHgD6AAAAAAEWAAAAAZtYXhwAAJQAAAAARgA" + "AAAGbmFtZVjmdH4AAAGAAAAAsXBvc3T/hgAzAAADeAAAACAAAQAAAAEAALZRFsRfDzz1" + "AAsD6AAAAADOBOTLAAAAAM4KHDwAAAAAA+gDIQAAAAgAAgAAAAAAAAABAAADIQAAAFoD" + "6AAAAAAD6AABAAAAAAAAAAAAAAAAAAAAAQAAUAAAAgAAAAQD6AH0AAUAAAKKArwAAACM" + "AooCvAAAAeAAMQECAAACAAYJAAAAAAAAAAAAAQAAAAAAAAAAAAAAAFBmRWQAwAAuAC4D" + "IP84AFoDIQAAAAAAAQAAAAAAAAAAACAAIAABAAAADgCuAAEAAAAAAAAAAQAAAAEAAAAA" + "AAEAAQAAAAEAAAAAAAIAAQAAAAEAAAAAAAMAAQAAAAEAAAAAAAQAAQAAAAEAAAAAAAUA" + "AQAAAAEAAAAAAAYAAQAAAAMAAQQJAAAAAgABAAMAAQQJAAEAAgABAAMAAQQJAAIAAgAB" + "AAMAAQQJAAMAAgABAAMAAQQJAAQAAgABAAMAAQQJAAUAAgABAAMAAQQJAAYAAgABWABY" + "AAAAAAAAAwAAAAMAAAAcAAEAAAAAADwAAwABAAAAHAAEACAAAAAEAAQAAQAAAC7//wAA" + "AC7////TAAEAAAAAAAABBgAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" + "AAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" + "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" + "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" + "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" + "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAD/gwAyAAAAAQAAAAAAAAAAAAAAAAAA" + "AAABAAQEAAEBAQJYAAEBASH4DwD4GwHEAvgcA/gXBIwMAYuL+nz5tQXkD5j3CBLnEQAC" + "AQEBIVhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYAAABAQAADwACAQEEE/t3" + "Dov6fAH6fAT+fPp8+nwHDosMCvm1Cvm1DAz6fBQAAAAAAAABAAAAAMmJbzEAAAAAzgTj" + "FQAAAADOBOQpAAEAAAAAAAAADAAUAAQAAAABAAAAAgABAAAAAAAAAAAD6AAAAAAAAA=="); - }; + function isFontReady(name, callback) { + called++; - return (0, _util.shadow)(this, "_loadTestFont", getLoadTestFont()); - } + if (called > 30) { + (0, _util.warn)("Load test font never loaded."); + callback(); + return; + } - _prepareFontLoadEvent(rules, fonts, request) { - function int32(data, offset) { - return data.charCodeAt(offset) << 24 | data.charCodeAt(offset + 1) << 16 | data.charCodeAt(offset + 2) << 8 | data.charCodeAt(offset + 3) & 0xff; - } + ctx.font = "30px " + name; + ctx.fillText(".", 0, 20); + var imageData = ctx.getImageData(0, 0, 1, 1); - function spliceString(s, offset, remove, insert) { - const chunk1 = s.substring(0, offset); - const chunk2 = s.substring(offset + remove); - return chunk1 + insert + chunk2; - } + if (imageData.data[3] > 0) { + callback(); + return; + } - let i, ii; - const canvas = document.createElement("canvas"); - canvas.width = 1; - canvas.height = 1; - const ctx = canvas.getContext("2d"); - let called = 0; + setTimeout(isFontReady.bind(null, name, callback)); + } - function isFontReady(name, callback) { - called++; + var loadTestFontId = "lt".concat(Date.now()).concat(this.loadTestFontId++); + var data = this._loadTestFont; + var COMMENT_OFFSET = 976; + data = spliceString(data, COMMENT_OFFSET, loadTestFontId.length, loadTestFontId); + var CFF_CHECKSUM_OFFSET = 16; + var XXXX_VALUE = 0x58585858; + var checksum = int32(data, CFF_CHECKSUM_OFFSET); - if (called > 30) { - (0, _util.warn)("Load test font never loaded."); - callback(); - return; + for (i = 0, ii = loadTestFontId.length - 3; i < ii; i += 4) { + checksum = checksum - XXXX_VALUE + int32(loadTestFontId, i) | 0; } - ctx.font = "30px " + name; - ctx.fillText(".", 0, 20); - const imageData = ctx.getImageData(0, 0, 1, 1); - - if (imageData.data[3] > 0) { - callback(); - return; + if (i < loadTestFontId.length) { + checksum = checksum - XXXX_VALUE + int32(loadTestFontId + "XXX", i) | 0; } - setTimeout(isFontReady.bind(null, name, callback)); - } + data = spliceString(data, CFF_CHECKSUM_OFFSET, 4, (0, _util.string32)(checksum)); + var url = "url(data:font/opentype;base64,".concat(btoa(data), ");"); + var rule = "@font-face {font-family:\"".concat(loadTestFontId, "\";src:").concat(url, "}"); + this.insertRule(rule); + var names = []; - const loadTestFontId = `lt${Date.now()}${this.loadTestFontId++}`; - let data = this._loadTestFont; - const COMMENT_OFFSET = 976; - data = spliceString(data, COMMENT_OFFSET, loadTestFontId.length, loadTestFontId); - const CFF_CHECKSUM_OFFSET = 16; - const XXXX_VALUE = 0x58585858; - let checksum = int32(data, CFF_CHECKSUM_OFFSET); + for (i = 0, ii = fonts.length; i < ii; i++) { + names.push(fonts[i].loadedName); + } - for (i = 0, ii = loadTestFontId.length - 3; i < ii; i += 4) { - checksum = checksum - XXXX_VALUE + int32(loadTestFontId, i) | 0; - } + names.push(loadTestFontId); + var div = document.createElement("div"); + div.style.visibility = "hidden"; + div.style.width = div.style.height = "10px"; + div.style.position = "absolute"; + div.style.top = div.style.left = "0px"; + + for (i = 0, ii = names.length; i < ii; ++i) { + var span = document.createElement("span"); + span.textContent = "Hi"; + span.style.fontFamily = names[i]; + div.appendChild(span); + } - if (i < loadTestFontId.length) { - checksum = checksum - XXXX_VALUE + int32(loadTestFontId + "XXX", i) | 0; + document.body.appendChild(div); + isFontReady(loadTestFontId, function () { + document.body.removeChild(div); + request.complete(); + }); } + }, { + key: "isSyncFontLoadingSupported", + get: function get() { + var supported = false; - data = spliceString(data, CFF_CHECKSUM_OFFSET, 4, (0, _util.string32)(checksum)); - const url = `url(data:font/opentype;base64,${btoa(data)});`; - const rule = `@font-face {font-family:"${loadTestFontId}";src:${url}}`; - this.insertRule(rule); - const names = []; - - for (i = 0, ii = fonts.length; i < ii; i++) { - names.push(fonts[i].loadedName); - } + if (typeof navigator === "undefined") { + supported = true; + } else { + var m = /Mozilla\/5.0.*?rv:(\d+).*? Gecko/.exec(navigator.userAgent); - names.push(loadTestFontId); - const div = document.createElement("div"); - div.style.visibility = "hidden"; - div.style.width = div.style.height = "10px"; - div.style.position = "absolute"; - div.style.top = div.style.left = "0px"; + if (m && m[1] >= 14) { + supported = true; + } + } - for (i = 0, ii = names.length; i < ii; ++i) { - const span = document.createElement("span"); - span.textContent = "Hi"; - span.style.fontFamily = names[i]; - div.appendChild(span); + return (0, _util.shadow)(this, "isSyncFontLoadingSupported", supported); } + }, { + key: "_loadTestFont", + get: function get() { + var getLoadTestFont = function getLoadTestFont() { + return atob("T1RUTwALAIAAAwAwQ0ZGIDHtZg4AAAOYAAAAgUZGVE1lkzZwAAAEHAAAABxHREVGABQA" + "FQAABDgAAAAeT1MvMlYNYwkAAAEgAAAAYGNtYXABDQLUAAACNAAAAUJoZWFk/xVFDQAA" + "ALwAAAA2aGhlYQdkA+oAAAD0AAAAJGhtdHgD6AAAAAAEWAAAAAZtYXhwAAJQAAAAARgA" + "AAAGbmFtZVjmdH4AAAGAAAAAsXBvc3T/hgAzAAADeAAAACAAAQAAAAEAALZRFsRfDzz1" + "AAsD6AAAAADOBOTLAAAAAM4KHDwAAAAAA+gDIQAAAAgAAgAAAAAAAAABAAADIQAAAFoD" + "6AAAAAAD6AABAAAAAAAAAAAAAAAAAAAAAQAAUAAAAgAAAAQD6AH0AAUAAAKKArwAAACM" + "AooCvAAAAeAAMQECAAACAAYJAAAAAAAAAAAAAQAAAAAAAAAAAAAAAFBmRWQAwAAuAC4D" + "IP84AFoDIQAAAAAAAQAAAAAAAAAAACAAIAABAAAADgCuAAEAAAAAAAAAAQAAAAEAAAAA" + "AAEAAQAAAAEAAAAAAAIAAQAAAAEAAAAAAAMAAQAAAAEAAAAAAAQAAQAAAAEAAAAAAAUA" + "AQAAAAEAAAAAAAYAAQAAAAMAAQQJAAAAAgABAAMAAQQJAAEAAgABAAMAAQQJAAIAAgAB" + "AAMAAQQJAAMAAgABAAMAAQQJAAQAAgABAAMAAQQJAAUAAgABAAMAAQQJAAYAAgABWABY" + "AAAAAAAAAwAAAAMAAAAcAAEAAAAAADwAAwABAAAAHAAEACAAAAAEAAQAAQAAAC7//wAA" + "AC7////TAAEAAAAAAAABBgAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" + "AAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" + "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" + "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" + "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" + "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAD/gwAyAAAAAQAAAAAAAAAAAAAAAAAA" + "AAABAAQEAAEBAQJYAAEBASH4DwD4GwHEAvgcA/gXBIwMAYuL+nz5tQXkD5j3CBLnEQAC" + "AQEBIVhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYAAABAQAADwACAQEEE/t3" + "Dov6fAH6fAT+fPp8+nwHDosMCvm1Cvm1DAz6fBQAAAAAAAABAAAAAMmJbzEAAAAAzgTj" + "FQAAAADOBOQpAAEAAAAAAAAADAAUAAQAAAABAAAAAgABAAAAAAAAAAAD6AAAAAAAAA=="); + }; - document.body.appendChild(div); - isFontReady(loadTestFontId, function () { - document.body.removeChild(div); - request.complete(); - }); - } + return (0, _util.shadow)(this, "_loadTestFont", getLoadTestFont()); + } + }]); - }; + return GenericFontLoader; + }(BaseFontLoader); } -class FontFaceObject { - constructor(translatedData, { - isEvalSupported = true, - disableFontFace = false, - ignoreErrors = false, - onUnsupportedFeature = null, - fontRegistry = null - }) { +var FontFaceObject = /*#__PURE__*/function () { + function FontFaceObject(translatedData, _ref2) { + var _ref2$isEvalSupported = _ref2.isEvalSupported, + isEvalSupported = _ref2$isEvalSupported === void 0 ? true : _ref2$isEvalSupported, + _ref2$disableFontFace = _ref2.disableFontFace, + disableFontFace = _ref2$disableFontFace === void 0 ? false : _ref2$disableFontFace, + _ref2$ignoreErrors = _ref2.ignoreErrors, + ignoreErrors = _ref2$ignoreErrors === void 0 ? false : _ref2$ignoreErrors, + _ref2$onUnsupportedFe = _ref2.onUnsupportedFeature, + onUnsupportedFeature = _ref2$onUnsupportedFe === void 0 ? null : _ref2$onUnsupportedFe, + _ref2$fontRegistry = _ref2.fontRegistry, + fontRegistry = _ref2$fontRegistry === void 0 ? null : _ref2$fontRegistry; + + _classCallCheck(this, FontFaceObject); + this.compiledGlyphs = Object.create(null); - for (const i in translatedData) { + for (var i in translatedData) { this[i] = translatedData[i]; } @@ -4100,98 +14930,104 @@ class FontFaceObject { this.fontRegistry = fontRegistry; } - createNativeFontFace() { - if (!this.data || this.disableFontFace) { - return null; - } - - const nativeFontFace = new FontFace(this.loadedName, this.data, {}); + _createClass(FontFaceObject, [{ + key: "createNativeFontFace", + value: function createNativeFontFace() { + if (!this.data || this.disableFontFace) { + return null; + } - if (this.fontRegistry) { - this.fontRegistry.registerFont(this); - } + var nativeFontFace = new FontFace(this.loadedName, this.data, {}); - return nativeFontFace; - } + if (this.fontRegistry) { + this.fontRegistry.registerFont(this); + } - createFontFaceRule() { - if (!this.data || this.disableFontFace) { - return null; + return nativeFontFace; } + }, { + key: "createFontFaceRule", + value: function createFontFaceRule() { + if (!this.data || this.disableFontFace) { + return null; + } - const data = (0, _util.bytesToString)(new Uint8Array(this.data)); - const url = `url(data:${this.mimetype};base64,${btoa(data)});`; - const rule = `@font-face {font-family:"${this.loadedName}";src:${url}}`; - - if (this.fontRegistry) { - this.fontRegistry.registerFont(this, url); - } + var data = (0, _util.bytesToString)(new Uint8Array(this.data)); + var url = "url(data:".concat(this.mimetype, ";base64,").concat(btoa(data), ");"); + var rule = "@font-face {font-family:\"".concat(this.loadedName, "\";src:").concat(url, "}"); - return rule; - } + if (this.fontRegistry) { + this.fontRegistry.registerFont(this, url); + } - getPathGenerator(objs, character) { - if (this.compiledGlyphs[character] !== undefined) { - return this.compiledGlyphs[character]; + return rule; } + }, { + key: "getPathGenerator", + value: function getPathGenerator(objs, character) { + if (this.compiledGlyphs[character] !== undefined) { + return this.compiledGlyphs[character]; + } - let cmds, current; + var cmds, current; - try { - cmds = objs.get(this.loadedName + "_path_" + character); - } catch (ex) { - if (!this.ignoreErrors) { - throw ex; - } + try { + cmds = objs.get(this.loadedName + "_path_" + character); + } catch (ex) { + if (!this.ignoreErrors) { + throw ex; + } - if (this._onUnsupportedFeature) { - this._onUnsupportedFeature({ - featureId: _util.UNSUPPORTED_FEATURES.errorFontGetPath - }); + if (this._onUnsupportedFeature) { + this._onUnsupportedFeature({ + featureId: _util.UNSUPPORTED_FEATURES.errorFontGetPath + }); + } + + (0, _util.warn)("getPathGenerator - ignoring character: \"".concat(ex, "\".")); + return this.compiledGlyphs[character] = function (c, size) {}; } - (0, _util.warn)(`getPathGenerator - ignoring character: "${ex}".`); - return this.compiledGlyphs[character] = function (c, size) {}; - } + if (this.isEvalSupported && _util.IsEvalSupportedCached.value) { + var args, + js = ""; - if (this.isEvalSupported && _util.IsEvalSupportedCached.value) { - let args, - js = ""; + for (var i = 0, ii = cmds.length; i < ii; i++) { + current = cmds[i]; - for (let i = 0, ii = cmds.length; i < ii; i++) { - current = cmds[i]; + if (current.args !== undefined) { + args = current.args.join(","); + } else { + args = ""; + } - if (current.args !== undefined) { - args = current.args.join(","); - } else { - args = ""; + js += "c." + current.cmd + "(" + args + ");\n"; } - js += "c." + current.cmd + "(" + args + ");\n"; + return this.compiledGlyphs[character] = new Function("c", "size", js); } - return this.compiledGlyphs[character] = new Function("c", "size", js); - } + return this.compiledGlyphs[character] = function (c, size) { + for (var _i = 0, _ii = cmds.length; _i < _ii; _i++) { + current = cmds[_i]; - return this.compiledGlyphs[character] = function (c, size) { - for (let i = 0, ii = cmds.length; i < ii; i++) { - current = cmds[i]; + if (current.cmd === "scale") { + current.args = [size, -size]; + } - if (current.cmd === "scale") { - current.args = [size, -size]; + c[current.cmd].apply(c, current.args); } + }; + } + }]); - c[current.cmd].apply(c, current.args); - } - }; - } - -} + return FontFaceObject; +}(); exports.FontFaceObject = FontFaceObject; /***/ }), -/* 7 */ +/* 200 */ /***/ (function(module, exports, __w_pdfjs_require__) { "use strict"; @@ -4202,9 +15038,9 @@ Object.defineProperty(exports, "__esModule", { }); exports.apiCompatibilityParams = void 0; -var _is_node = __w_pdfjs_require__(4); +var _is_node = __w_pdfjs_require__(7); -const compatibilityParams = Object.create(null); +var compatibilityParams = Object.create(null); { (function checkFontFace() { if (_is_node.isNodeJS) { @@ -4212,11 +15048,11 @@ const compatibilityParams = Object.create(null); } })(); } -const apiCompatibilityParams = Object.freeze(compatibilityParams); +var apiCompatibilityParams = Object.freeze(compatibilityParams); exports.apiCompatibilityParams = apiCompatibilityParams; /***/ }), -/* 8 */ +/* 201 */ /***/ (function(module, exports, __w_pdfjs_require__) { "use strict"; @@ -4227,9 +15063,15 @@ Object.defineProperty(exports, "__esModule", { }); exports.CanvasGraphics = void 0; -var _util = __w_pdfjs_require__(2); +var _util = __w_pdfjs_require__(5); + +var _pattern_helper = __w_pdfjs_require__(202); + +function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; } -var _pattern_helper = __w_pdfjs_require__(9); +function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); } + +function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } var MIN_FONT_SIZE = 16; var MAX_FONT_SIZE = 100; @@ -4357,15 +15199,13 @@ var CachedCanvases = function CachedCanvasesClosure() { return canvasEntry; }, - - clear() { + clear: function clear() { for (var id in this.cache) { var canvasEntry = this.cache[id]; this.canvasFactory.destroy(canvasEntry); delete this.cache[id]; } } - }; return CachedCanvases; }(); @@ -4525,17 +15365,17 @@ function compileType3Glyph(imgData) { --i; } - var drawOutline = function (c) { + var drawOutline = function drawOutline(c) { c.save(); c.scale(1 / width, -1 / height); c.translate(0, -height); c.beginPath(); - for (let k = 0, kk = outlines.length; k < kk; k++) { + for (var k = 0, kk = outlines.length; k < kk; k++) { var o = outlines[k]; c.moveTo(o[0], o[1]); - for (let l = 2, ll = o.length; l < ll; l += 2) { + for (var l = 2, ll = o.length; l < ll; l += 2) { c.lineTo(o[l], o[l + 1]); } } @@ -4727,7 +15567,7 @@ var CanvasGraphics = function CanvasGraphicsClosure() { ctx.putImageData(chunkImgData, 0, i * FULL_CHUNK_HEIGHT); } } else { - throw new Error(`bad image kind: ${imgData.kind}`); + throw new Error("bad image kind: ".concat(imgData.kind)); } } @@ -4875,12 +15715,12 @@ var CanvasGraphics = function CanvasGraphicsClosure() { var backdrop = smask.backdrop || null; if (!smask.transferMap && webGLContext.isEnabled) { - const composed = webGLContext.composeSMask({ + var composed = webGLContext.composeSMask({ layer: layerCtx.canvas, - mask, + mask: mask, properties: { subtype: smask.subtype, - backdrop + backdrop: backdrop } }); ctx.setTransform(1, 0, 0, 1, 0, 0); @@ -4897,12 +15737,13 @@ var CanvasGraphics = function CanvasGraphicsClosure() { var NORMAL_CLIP = {}; var EO_CLIP = {}; CanvasGraphics.prototype = { - beginDrawing({ - transform, - viewport, - transparency = false, - background = null - }) { + beginDrawing: function beginDrawing(_ref) { + var transform = _ref.transform, + viewport = _ref.viewport, + _ref$transparency = _ref.transparency, + transparency = _ref$transparency === void 0 ? false : _ref$transparency, + _ref$background = _ref.background, + background = _ref$background === void 0 ? null : _ref$background; var width = this.ctx.canvas.width; var height = this.ctx.canvas.height; this.ctx.save(); @@ -4933,7 +15774,6 @@ var CanvasGraphics = function CanvasGraphicsClosure() { this.imageLayer.beginLayout(); } }, - executeOperatorList: function CanvasGraphics_executeOperatorList(operatorList, executionStartIdx, continueCallback, stepper) { var argsArray = operatorList.argsArray; var fnArray = operatorList.fnArray; @@ -4962,13 +15802,23 @@ var CanvasGraphics = function CanvasGraphicsClosure() { if (fnId !== _util.OPS.dependency) { this[fnId].apply(this, argsArray[i]); } else { - for (const depObjId of argsArray[i]) { - const objsPool = depObjId.startsWith("g_") ? commonObjs : objs; + var _iterator = _createForOfIteratorHelper(argsArray[i]), + _step; - if (!objsPool.has(depObjId)) { - objsPool.get(depObjId, continueCallback); - return i; + try { + for (_iterator.s(); !(_step = _iterator.n()).done;) { + var depObjId = _step.value; + var objsPool = depObjId.startsWith("g_") ? commonObjs : objs; + + if (!objsPool.has(depObjId)) { + objsPool.get(depObjId, continueCallback); + return i; + } } + } catch (err) { + _iterator.e(err); + } finally { + _iterator.f(); } } @@ -5032,11 +15882,8 @@ var CanvasGraphics = function CanvasGraphicsClosure() { ctx.lineDashOffset = dashPhase; } }, - - setRenderingIntent(intent) {}, - - setFlatness(flatness) {}, - + setRenderingIntent: function setRenderingIntent(intent) {}, + setFlatness: function setFlatness(flatness) {}, setGState: function CanvasGraphics_setGState(states) { for (var i = 0, ii = states.length; i < ii; i++) { var state = states[i]; @@ -5277,9 +16124,9 @@ var CanvasGraphics = function CanvasGraphicsClosure() { if (strokeColor && strokeColor.hasOwnProperty("type") && strokeColor.type === "Pattern") { ctx.save(); - const transform = ctx.mozCurrentTransform; + var transform = ctx.mozCurrentTransform; - const scale = _util.Util.singularValueDecompose2dScale(transform)[0]; + var scale = _util.Util.singularValueDecompose2dScale(transform)[0]; ctx.strokeStyle = strokeColor.getPattern(ctx, this); ctx.lineWidth = Math.max(this.getSinglePixelWidth() * MIN_WIDTH_FACTOR, this.current.lineWidth * scale); @@ -5411,7 +16258,7 @@ var CanvasGraphics = function CanvasGraphicsClosure() { var current = this.current; if (!fontObj) { - throw new Error(`Can't find font for ${fontRefName}`); + throw new Error("Can't find font for ".concat(fontRefName)); } current.fontMatrix = fontObj.fontMatrix ? fontObj.fontMatrix : _util.FONT_IDENTITY_MATRIX; @@ -5435,7 +16282,7 @@ var CanvasGraphics = function CanvasGraphicsClosure() { } var name = fontObj.loadedName || "sans-serif"; - let bold = "normal"; + var bold = "normal"; if (fontObj.black) { bold = "900"; @@ -5444,8 +16291,8 @@ var CanvasGraphics = function CanvasGraphicsClosure() { } var italic = fontObj.italic ? "italic" : "normal"; - var typeface = `"${name}", ${fontObj.fallbackName}`; - let browserFontSize = size; + var typeface = "\"".concat(name, "\", ").concat(fontObj.fallbackName); + var browserFontSize = size; if (size < MIN_FONT_SIZE) { browserFontSize = MIN_FONT_SIZE; @@ -5454,7 +16301,7 @@ var CanvasGraphics = function CanvasGraphicsClosure() { } this.current.fontSizeScale = size / browserFontSize; - this.ctx.font = `${italic} ${bold} ${browserFontSize}px ${typeface}`; + this.ctx.font = "".concat(italic, " ").concat(bold, " ").concat(browserFontSize, "px ").concat(typeface); }, setTextRenderingMode: function CanvasGraphics_setTextRenderingMode(mode) { this.current.textRenderingMode = mode; @@ -5479,8 +16326,7 @@ var CanvasGraphics = function CanvasGraphicsClosure() { nextLine: function CanvasGraphics_nextLine() { this.moveText(0, this.current.leading); }, - - paintChar(character, x, y, patternTransform) { + paintChar: function paintChar(character, x, y, patternTransform) { var ctx = this.ctx; var current = this.current; var font = current.font; @@ -5488,7 +16334,7 @@ var CanvasGraphics = function CanvasGraphicsClosure() { var fontSize = current.fontSize / current.fontSizeScale; var fillStrokeMode = textRenderingMode & _util.TextRenderingMode.FILL_STROKE_MASK; var isAddToPathSet = !!(textRenderingMode & _util.TextRenderingMode.ADD_TO_PATH_FLAG); - const patternFill = current.patternFill && !font.missingFile; + var patternFill = current.patternFill && !font.missingFile; var addToPath; if (font.disableFontFace || isAddToPathSet || patternFill) { @@ -5528,18 +16374,18 @@ var CanvasGraphics = function CanvasGraphicsClosure() { var paths = this.pendingTextPaths || (this.pendingTextPaths = []); paths.push({ transform: ctx.mozCurrentTransform, - x, - y, - fontSize, - addToPath + x: x, + y: y, + fontSize: fontSize, + addToPath: addToPath }); } }, get isFontSubpixelAAEnabled() { - const { - context: ctx - } = this.cachedCanvases.getCanvas("isFontSubpixelAAEnabled", 10, 10); + var _this$cachedCanvases$ = this.cachedCanvases.getCanvas("isFontSubpixelAAEnabled", 10, 10), + ctx = _this$cachedCanvases$.context; + ctx.scale(1.5, 1); ctx.fillText("I", 0, 10); var data = ctx.getImageData(0, 0, 10, 10).data; @@ -5582,11 +16428,11 @@ var CanvasGraphics = function CanvasGraphicsClosure() { var widthAdvanceScale = fontSize * current.fontMatrix[0]; var simpleFillText = current.textRenderingMode === _util.TextRenderingMode.FILL && !font.disableFontFace && !current.patternFill; ctx.save(); - let patternTransform; + var patternTransform; if (current.patternFill) { ctx.save(); - const pattern = current.fillColor.getPattern(ctx, this); + var pattern = current.fillColor.getPattern(ctx, this); patternTransform = ctx.mozCurrentTransform; ctx.restore(); ctx.fillStyle = pattern; @@ -5743,7 +16589,7 @@ var CanvasGraphics = function CanvasGraphicsClosure() { var operatorList = font.charProcOperatorList[glyph.operatorListId]; if (!operatorList) { - (0, _util.warn)(`Type3 character "${glyph.operatorListId}" is not available.`); + (0, _util.warn)("Type3 character \"".concat(glyph.operatorListId, "\" is not available.")); continue; } @@ -5771,14 +16617,16 @@ var CanvasGraphics = function CanvasGraphicsClosure() { this.endPath(); }, getColorN_Pattern: function CanvasGraphics_getColorN_Pattern(IR) { + var _this = this; + var pattern; if (IR[0] === "TilingPattern") { var color = IR[1]; var baseTransform = this.baseTransform || this.ctx.mozCurrentTransform.slice(); var canvasGraphicsFactory = { - createCanvasGraphics: ctx => { - return new CanvasGraphics(ctx, this.commonObjs, this.objs, this.canvasFactory, this.webGLContext); + createCanvasGraphics: function createCanvasGraphics(ctx) { + return new CanvasGraphics(ctx, _this.commonObjs, _this.objs, _this.canvasFactory, _this.webGLContext); } }; pattern = new _pattern_helper.TilingPattern(IR, color, this.ctx, canvasGraphicsFactory, baseTransform); @@ -5926,10 +16774,10 @@ var CanvasGraphics = function CanvasGraphicsClosure() { this.smaskStack.push({ canvas: scratchCanvas.canvas, context: groupCtx, - offsetX, - offsetY, - scaleX, - scaleY, + offsetX: offsetX, + offsetY: offsetY, + scaleX: scaleX, + scaleY: scaleY, subtype: group.smask.subtype, backdrop: group.smask.backdrop, transferMap: group.smask.transferMap || null, @@ -6008,8 +16856,8 @@ var CanvasGraphics = function CanvasGraphicsClosure() { if (width <= MAX_SIZE_TO_COMPILE && height <= MAX_SIZE_TO_COMPILE) { glyph.compiled = compileType3Glyph({ data: img.data, - width, - height + width: width, + height: height }); } else { glyph.compiled = null; @@ -6079,7 +16927,7 @@ var CanvasGraphics = function CanvasGraphicsClosure() { } }, paintImageXObject: function CanvasGraphics_paintImageXObject(objId) { - const imgData = objId.startsWith("g_") ? this.commonObjs.get(objId) : this.objs.get(objId); + var imgData = objId.startsWith("g_") ? this.commonObjs.get(objId) : this.objs.get(objId); if (!imgData) { (0, _util.warn)("Dependent image isn't ready yet"); @@ -6089,7 +16937,7 @@ var CanvasGraphics = function CanvasGraphicsClosure() { this.paintInlineImageXObject(imgData); }, paintImageXObjectRepeat: function CanvasGraphics_paintImageXObjectRepeat(objId, scaleX, scaleY, positions) { - const imgData = objId.startsWith("g_") ? this.commonObjs.get(objId) : this.objs.get(objId); + var imgData = objId.startsWith("g_") ? this.commonObjs.get(objId) : this.objs.get(objId); if (!imgData) { (0, _util.warn)("Dependent image isn't ready yet"); @@ -6169,7 +17017,7 @@ var CanvasGraphics = function CanvasGraphicsClosure() { if (this.imageLayer) { var position = this.getCanvasPosition(0, -height); this.imageLayer.appendImage({ - imgData, + imgData: imgData, left: position[0], top: position[1], width: width / currentTransform[0], @@ -6197,7 +17045,7 @@ var CanvasGraphics = function CanvasGraphicsClosure() { if (this.imageLayer) { var position = this.getCanvasPosition(entry.x, entry.y); this.imageLayer.appendImage({ - imgData, + imgData: imgData, left: position[0], top: position[1], width: w, @@ -6236,16 +17084,14 @@ var CanvasGraphics = function CanvasGraphicsClosure() { ctx.beginPath(); }, - - getSinglePixelWidth(scale) { + getSinglePixelWidth: function getSinglePixelWidth(scale) { if (this._cachedGetSinglePixelWidth === null) { - const inverse = this.ctx.mozCurrentTransformInverse; + var inverse = this.ctx.mozCurrentTransformInverse; this._cachedGetSinglePixelWidth = Math.sqrt(Math.max(inverse[0] * inverse[0] + inverse[1] * inverse[1], inverse[2] * inverse[2] + inverse[3] * inverse[3])); } return this._cachedGetSinglePixelWidth; }, - getCanvasPosition: function CanvasGraphics_getCanvasPosition(x, y) { var transform = this.ctx.mozCurrentTransform; return [transform[0] * x + transform[2] * y + transform[4], transform[1] * x + transform[3] * y + transform[5]]; @@ -6262,7 +17108,7 @@ var CanvasGraphics = function CanvasGraphicsClosure() { exports.CanvasGraphics = CanvasGraphics; /***/ }), -/* 9 */ +/* 202 */ /***/ (function(module, exports, __w_pdfjs_require__) { "use strict"; @@ -6274,7 +17120,7 @@ Object.defineProperty(exports, "__esModule", { exports.getShadingPatternFromIR = getShadingPatternFromIR; exports.TilingPattern = void 0; -var _util = __w_pdfjs_require__(2); +var _util = __w_pdfjs_require__(5); var ShadingIRs = {}; @@ -6283,9 +17129,9 @@ function applyBoundingBox(ctx, bbox) { return; } - const width = bbox[2] - bbox[0]; - const height = bbox[3] - bbox[1]; - const region = new Path2D(); + var width = bbox[2] - bbox[0]; + var height = bbox[3] - bbox[1]; + var region = new Path2D(); region.rect(bbox[0], bbox[1], width, height); ctx.clip(region); } @@ -6384,38 +17230,38 @@ var createMeshCanvas = function createMeshCanvasClosure() { for (var y = minY; y <= maxY; y++) { if (y < y2) { - let k; + var _k = void 0; if (y < y1) { - k = 0; + _k = 0; } else if (y1 === y2) { - k = 1; + _k = 1; } else { - k = (y1 - y) / (y1 - y2); + _k = (y1 - y) / (y1 - y2); } - xa = x1 - (x1 - x2) * k; - car = c1r - (c1r - c2r) * k; - cag = c1g - (c1g - c2g) * k; - cab = c1b - (c1b - c2b) * k; + xa = x1 - (x1 - x2) * _k; + car = c1r - (c1r - c2r) * _k; + cag = c1g - (c1g - c2g) * _k; + cab = c1b - (c1b - c2b) * _k; } else { - let k; + var _k2 = void 0; if (y > y3) { - k = 1; + _k2 = 1; } else if (y2 === y3) { - k = 0; + _k2 = 0; } else { - k = (y2 - y) / (y2 - y3); + _k2 = (y2 - y) / (y2 - y3); } - xa = x2 - (x2 - x3) * k; - car = c2r - (c2r - c3r) * k; - cag = c2g - (c2g - c3g) * k; - cab = c2b - (c2b - c3b) * k; + xa = x2 - (x2 - x3) * _k2; + car = c2r - (c2r - c3r) * _k2; + cag = c2g - (c2g - c3g) * _k2; + cab = c2b - (c2b - c3b) * _k2; } - let k; + var k = void 0; if (y < y1) { k = 0; @@ -6497,8 +17343,8 @@ var createMeshCanvas = function createMeshCanvasClosure() { var scaleX = boundsWidth / width; var scaleY = boundsHeight / height; var context = { - coords, - colors, + coords: coords, + colors: colors, offsetX: -offsetX, offsetY: -offsetY, scaleX: 1 / scaleX, @@ -6510,11 +17356,11 @@ var createMeshCanvas = function createMeshCanvasClosure() { if (webGLContext.isEnabled) { canvas = webGLContext.drawFigures({ - width, - height, - backgroundColor, - figures, - context + width: width, + height: height, + backgroundColor: backgroundColor, + figures: figures, + context: context }); tmpCanvas = cachedCanvases.getCanvas("mesh", paddedWidth, paddedHeight, false); tmpCanvas.context.drawImage(canvas, BORDER_SIZE, BORDER_SIZE); @@ -6544,11 +17390,11 @@ var createMeshCanvas = function createMeshCanvasClosure() { } return { - canvas, + canvas: canvas, offsetX: offsetX - BORDER_SIZE * scaleX, offsetY: offsetY - BORDER_SIZE * scaleY, - scaleX, - scaleY + scaleX: scaleX, + scaleY: scaleY }; } @@ -6614,7 +17460,7 @@ function getShadingPatternFromIR(raw) { var shadingIR = ShadingIRs[raw[0]]; if (!shadingIR) { - throw new Error(`Unknown IR type: ${raw[0]}`); + throw new Error("Unknown IR type: ".concat(raw[0])); } return shadingIR.fromIR(raw); @@ -6690,8 +17536,8 @@ var TilingPattern = function TilingPatternClosure() { } return { - scale, - size + scale: scale, + size: size }; }, clipBbox: function clipBbox(graphics, bbox, x0, y0, x1, y1) { @@ -6704,8 +17550,8 @@ var TilingPattern = function TilingPatternClosure() { } }, setFillAndStrokeStyleToContext: function setFillAndStrokeStyleToContext(graphics, paintType, color) { - const context = graphics.ctx, - current = graphics.current; + var context = graphics.ctx, + current = graphics.current; switch (paintType) { case PaintType.COLORED: @@ -6726,7 +17572,7 @@ var TilingPattern = function TilingPatternClosure() { break; default: - throw new _util.FormatError(`Unsupported paint type: ${paintType}`); + throw new _util.FormatError("Unsupported paint type: ".concat(paintType)); } }, getPattern: function TilingPattern_getPattern(ctx, owner) { @@ -6743,7 +17589,7 @@ var TilingPattern = function TilingPatternClosure() { exports.TilingPattern = TilingPattern; /***/ }), -/* 10 */ +/* 203 */ /***/ (function(module, exports, __w_pdfjs_require__) { "use strict"; @@ -6753,13 +17599,13 @@ Object.defineProperty(exports, "__esModule", { value: true }); exports.GlobalWorkerOptions = void 0; -const GlobalWorkerOptions = Object.create(null); +var GlobalWorkerOptions = Object.create(null); exports.GlobalWorkerOptions = GlobalWorkerOptions; GlobalWorkerOptions.workerPort = GlobalWorkerOptions.workerPort === undefined ? null : GlobalWorkerOptions.workerPort; GlobalWorkerOptions.workerSrc = GlobalWorkerOptions.workerSrc === undefined ? "" : GlobalWorkerOptions.workerSrc; /***/ }), -/* 11 */ +/* 204 */ /***/ (function(module, exports, __w_pdfjs_require__) { "use strict"; @@ -6770,14 +17616,30 @@ Object.defineProperty(exports, "__esModule", { }); exports.MessageHandler = void 0; -var _util = __w_pdfjs_require__(2); +var _regenerator = _interopRequireDefault(__w_pdfjs_require__(2)); -const CallbackKind = { +var _util = __w_pdfjs_require__(5); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } } + +function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +var CallbackKind = { UNKNOWN: 0, DATA: 1, ERROR: 2 }; -const StreamKind = { +var StreamKind = { UNKNOWN: 0, CANCEL: 1, CANCEL_COMPLETE: 2, @@ -6790,7 +17652,7 @@ const StreamKind = { }; function wrapReason(reason) { - if (typeof reason !== "object" || reason === null) { + if (_typeof(reason) !== "object" || reason === null) { return reason; } @@ -6812,8 +17674,12 @@ function wrapReason(reason) { } } -class MessageHandler { - constructor(sourceName, targetName, comObj) { +var MessageHandler = /*#__PURE__*/function () { + function MessageHandler(sourceName, targetName, comObj) { + var _this = this; + + _classCallCheck(this, MessageHandler); + this.sourceName = sourceName; this.targetName = targetName; this.comObj = comObj; @@ -6825,28 +17691,28 @@ class MessageHandler { this.callbackCapabilities = Object.create(null); this.actionHandler = Object.create(null); - this._onComObjOnMessage = event => { - const data = event.data; + this._onComObjOnMessage = function (event) { + var data = event.data; - if (data.targetName !== this.sourceName) { + if (data.targetName !== _this.sourceName) { return; } if (data.stream) { - this._processStreamMessage(data); + _this._processStreamMessage(data); return; } if (data.callback) { - const callbackId = data.callbackId; - const capability = this.callbackCapabilities[callbackId]; + var callbackId = data.callbackId; + var capability = _this.callbackCapabilities[callbackId]; if (!capability) { - throw new Error(`Cannot resolve callback ${callbackId}`); + throw new Error("Cannot resolve callback ".concat(callbackId)); } - delete this.callbackCapabilities[callbackId]; + delete _this.callbackCapabilities[callbackId]; if (data.callback === CallbackKind.DATA) { capability.resolve(data.data); @@ -6859,15 +17725,15 @@ class MessageHandler { return; } - const action = this.actionHandler[data.action]; + var action = _this.actionHandler[data.action]; if (!action) { - throw new Error(`Unknown action from worker: ${data.action}`); + throw new Error("Unknown action from worker: ".concat(data.action)); } if (data.callbackId) { - const cbSourceName = this.sourceName; - const cbTargetName = data.sourceName; + var cbSourceName = _this.sourceName; + var cbTargetName = data.sourceName; new Promise(function (resolve) { resolve(action(data.data)); }).then(function (result) { @@ -6891,7 +17757,7 @@ class MessageHandler { } if (data.streamId) { - this._createStreamSink(data); + _this._createStreamSink(data); return; } @@ -6902,365 +17768,397 @@ class MessageHandler { comObj.addEventListener("message", this._onComObjOnMessage); } - on(actionName, handler) { - const ah = this.actionHandler; + _createClass(MessageHandler, [{ + key: "on", + value: function on(actionName, handler) { + var ah = this.actionHandler; - if (ah[actionName]) { - throw new Error(`There is already an actionName called "${actionName}"`); - } - - ah[actionName] = handler; - } - - send(actionName, data, transfers) { - this._postMessage({ - sourceName: this.sourceName, - targetName: this.targetName, - action: actionName, - data - }, transfers); - } - - sendWithPromise(actionName, data, transfers) { - const callbackId = this.callbackId++; - const capability = (0, _util.createPromiseCapability)(); - this.callbackCapabilities[callbackId] = capability; + if (ah[actionName]) { + throw new Error("There is already an actionName called \"".concat(actionName, "\"")); + } - try { + ah[actionName] = handler; + } + }, { + key: "send", + value: function send(actionName, data, transfers) { this._postMessage({ sourceName: this.sourceName, targetName: this.targetName, action: actionName, - callbackId, - data + data: data }, transfers); - } catch (ex) { - capability.reject(ex); - } - - return capability.promise; - } - - sendWithStream(actionName, data, queueingStrategy, transfers) { - const streamId = this.streamId++; - const sourceName = this.sourceName; - const targetName = this.targetName; - const comObj = this.comObj; - return new ReadableStream({ - start: controller => { - const startCapability = (0, _util.createPromiseCapability)(); - this.streamControllers[streamId] = { - controller, - startCall: startCapability, - pullCall: null, - cancelCall: null, - isClosed: false - }; + } + }, { + key: "sendWithPromise", + value: function sendWithPromise(actionName, data, transfers) { + var callbackId = this.callbackId++; + var capability = (0, _util.createPromiseCapability)(); + this.callbackCapabilities[callbackId] = capability; + try { this._postMessage({ - sourceName, - targetName, + sourceName: this.sourceName, + targetName: this.targetName, action: actionName, - streamId, - data, - desiredSize: controller.desiredSize + callbackId: callbackId, + data: data }, transfers); + } catch (ex) { + capability.reject(ex); + } + + return capability.promise; + } + }, { + key: "sendWithStream", + value: function sendWithStream(actionName, data, queueingStrategy, transfers) { + var _this2 = this; + + var streamId = this.streamId++; + var sourceName = this.sourceName; + var targetName = this.targetName; + var comObj = this.comObj; + return new ReadableStream({ + start: function start(controller) { + var startCapability = (0, _util.createPromiseCapability)(); + _this2.streamControllers[streamId] = { + controller: controller, + startCall: startCapability, + pullCall: null, + cancelCall: null, + isClosed: false + }; - return startCapability.promise; - }, - pull: controller => { - const pullCapability = (0, _util.createPromiseCapability)(); - this.streamControllers[streamId].pullCall = pullCapability; - comObj.postMessage({ - sourceName, - targetName, - stream: StreamKind.PULL, - streamId, - desiredSize: controller.desiredSize - }); - return pullCapability.promise; - }, - cancel: reason => { - (0, _util.assert)(reason instanceof Error, "cancel must have a valid reason"); - const cancelCapability = (0, _util.createPromiseCapability)(); - this.streamControllers[streamId].cancelCall = cancelCapability; - this.streamControllers[streamId].isClosed = true; - comObj.postMessage({ - sourceName, - targetName, - stream: StreamKind.CANCEL, - streamId, - reason: wrapReason(reason) - }); - return cancelCapability.promise; - } - }, queueingStrategy); - } - - _createStreamSink(data) { - const self = this; - const action = this.actionHandler[data.action]; - const streamId = data.streamId; - const sourceName = this.sourceName; - const targetName = data.sourceName; - const comObj = this.comObj; - const streamSink = { - enqueue(chunk, size = 1, transfers) { - if (this.isCancelled) { - return; + _this2._postMessage({ + sourceName: sourceName, + targetName: targetName, + action: actionName, + streamId: streamId, + data: data, + desiredSize: controller.desiredSize + }, transfers); + + return startCapability.promise; + }, + pull: function pull(controller) { + var pullCapability = (0, _util.createPromiseCapability)(); + _this2.streamControllers[streamId].pullCall = pullCapability; + comObj.postMessage({ + sourceName: sourceName, + targetName: targetName, + stream: StreamKind.PULL, + streamId: streamId, + desiredSize: controller.desiredSize + }); + return pullCapability.promise; + }, + cancel: function cancel(reason) { + (0, _util.assert)(reason instanceof Error, "cancel must have a valid reason"); + var cancelCapability = (0, _util.createPromiseCapability)(); + _this2.streamControllers[streamId].cancelCall = cancelCapability; + _this2.streamControllers[streamId].isClosed = true; + comObj.postMessage({ + sourceName: sourceName, + targetName: targetName, + stream: StreamKind.CANCEL, + streamId: streamId, + reason: wrapReason(reason) + }); + return cancelCapability.promise; } + }, queueingStrategy); + } + }, { + key: "_createStreamSink", + value: function _createStreamSink(data) { + var self = this; + var action = this.actionHandler[data.action]; + var streamId = data.streamId; + var sourceName = this.sourceName; + var targetName = data.sourceName; + var comObj = this.comObj; + var streamSink = { + enqueue: function enqueue(chunk) { + var size = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1; + var transfers = arguments.length > 2 ? arguments[2] : undefined; + + if (this.isCancelled) { + return; + } - const lastDesiredSize = this.desiredSize; - this.desiredSize -= size; + var lastDesiredSize = this.desiredSize; + this.desiredSize -= size; - if (lastDesiredSize > 0 && this.desiredSize <= 0) { - this.sinkCapability = (0, _util.createPromiseCapability)(); - this.ready = this.sinkCapability.promise; - } + if (lastDesiredSize > 0 && this.desiredSize <= 0) { + this.sinkCapability = (0, _util.createPromiseCapability)(); + this.ready = this.sinkCapability.promise; + } - self._postMessage({ - sourceName, - targetName, - stream: StreamKind.ENQUEUE, - streamId, - chunk - }, transfers); - }, + self._postMessage({ + sourceName: sourceName, + targetName: targetName, + stream: StreamKind.ENQUEUE, + streamId: streamId, + chunk: chunk + }, transfers); + }, + close: function close() { + if (this.isCancelled) { + return; + } - close() { - if (this.isCancelled) { - return; - } + this.isCancelled = true; + comObj.postMessage({ + sourceName: sourceName, + targetName: targetName, + stream: StreamKind.CLOSE, + streamId: streamId + }); + delete self.streamSinks[streamId]; + }, + error: function error(reason) { + (0, _util.assert)(reason instanceof Error, "error must have a valid reason"); - this.isCancelled = true; + if (this.isCancelled) { + return; + } + + this.isCancelled = true; + comObj.postMessage({ + sourceName: sourceName, + targetName: targetName, + stream: StreamKind.ERROR, + streamId: streamId, + reason: wrapReason(reason) + }); + }, + sinkCapability: (0, _util.createPromiseCapability)(), + onPull: null, + onCancel: null, + isCancelled: false, + desiredSize: data.desiredSize, + ready: null + }; + streamSink.sinkCapability.resolve(); + streamSink.ready = streamSink.sinkCapability.promise; + this.streamSinks[streamId] = streamSink; + new Promise(function (resolve) { + resolve(action(data.data, streamSink)); + }).then(function () { comObj.postMessage({ - sourceName, - targetName, - stream: StreamKind.CLOSE, - streamId + sourceName: sourceName, + targetName: targetName, + stream: StreamKind.START_COMPLETE, + streamId: streamId, + success: true }); - delete self.streamSinks[streamId]; - }, - - error(reason) { - (0, _util.assert)(reason instanceof Error, "error must have a valid reason"); - - if (this.isCancelled) { - return; - } - - this.isCancelled = true; + }, function (reason) { comObj.postMessage({ - sourceName, - targetName, - stream: StreamKind.ERROR, - streamId, + sourceName: sourceName, + targetName: targetName, + stream: StreamKind.START_COMPLETE, + streamId: streamId, reason: wrapReason(reason) }); - }, - - sinkCapability: (0, _util.createPromiseCapability)(), - onPull: null, - onCancel: null, - isCancelled: false, - desiredSize: data.desiredSize, - ready: null - }; - streamSink.sinkCapability.resolve(); - streamSink.ready = streamSink.sinkCapability.promise; - this.streamSinks[streamId] = streamSink; - new Promise(function (resolve) { - resolve(action(data.data, streamSink)); - }).then(function () { - comObj.postMessage({ - sourceName, - targetName, - stream: StreamKind.START_COMPLETE, - streamId, - success: true }); - }, function (reason) { - comObj.postMessage({ - sourceName, - targetName, - stream: StreamKind.START_COMPLETE, - streamId, - reason: wrapReason(reason) - }); - }); - } + } + }, { + key: "_processStreamMessage", + value: function _processStreamMessage(data) { + var streamId = data.streamId; + var sourceName = this.sourceName; + var targetName = data.sourceName; + var comObj = this.comObj; + + switch (data.stream) { + case StreamKind.START_COMPLETE: + if (data.success) { + this.streamControllers[streamId].startCall.resolve(); + } else { + this.streamControllers[streamId].startCall.reject(wrapReason(data.reason)); + } - _processStreamMessage(data) { - const streamId = data.streamId; - const sourceName = this.sourceName; - const targetName = data.sourceName; - const comObj = this.comObj; + break; - switch (data.stream) { - case StreamKind.START_COMPLETE: - if (data.success) { - this.streamControllers[streamId].startCall.resolve(); - } else { - this.streamControllers[streamId].startCall.reject(wrapReason(data.reason)); - } + case StreamKind.PULL_COMPLETE: + if (data.success) { + this.streamControllers[streamId].pullCall.resolve(); + } else { + this.streamControllers[streamId].pullCall.reject(wrapReason(data.reason)); + } - break; + break; - case StreamKind.PULL_COMPLETE: - if (data.success) { - this.streamControllers[streamId].pullCall.resolve(); - } else { - this.streamControllers[streamId].pullCall.reject(wrapReason(data.reason)); - } + case StreamKind.PULL: + if (!this.streamSinks[streamId]) { + comObj.postMessage({ + sourceName: sourceName, + targetName: targetName, + stream: StreamKind.PULL_COMPLETE, + streamId: streamId, + success: true + }); + break; + } - break; + if (this.streamSinks[streamId].desiredSize <= 0 && data.desiredSize > 0) { + this.streamSinks[streamId].sinkCapability.resolve(); + } - case StreamKind.PULL: - if (!this.streamSinks[streamId]) { - comObj.postMessage({ - sourceName, - targetName, - stream: StreamKind.PULL_COMPLETE, - streamId, - success: true + this.streamSinks[streamId].desiredSize = data.desiredSize; + var onPull = this.streamSinks[data.streamId].onPull; + new Promise(function (resolve) { + resolve(onPull && onPull()); + }).then(function () { + comObj.postMessage({ + sourceName: sourceName, + targetName: targetName, + stream: StreamKind.PULL_COMPLETE, + streamId: streamId, + success: true + }); + }, function (reason) { + comObj.postMessage({ + sourceName: sourceName, + targetName: targetName, + stream: StreamKind.PULL_COMPLETE, + streamId: streamId, + reason: wrapReason(reason) + }); }); break; - } - if (this.streamSinks[streamId].desiredSize <= 0 && data.desiredSize > 0) { - this.streamSinks[streamId].sinkCapability.resolve(); - } + case StreamKind.ENQUEUE: + (0, _util.assert)(this.streamControllers[streamId], "enqueue should have stream controller"); - this.streamSinks[streamId].desiredSize = data.desiredSize; - const { - onPull - } = this.streamSinks[data.streamId]; - new Promise(function (resolve) { - resolve(onPull && onPull()); - }).then(function () { - comObj.postMessage({ - sourceName, - targetName, - stream: StreamKind.PULL_COMPLETE, - streamId, - success: true - }); - }, function (reason) { - comObj.postMessage({ - sourceName, - targetName, - stream: StreamKind.PULL_COMPLETE, - streamId, - reason: wrapReason(reason) - }); - }); - break; - - case StreamKind.ENQUEUE: - (0, _util.assert)(this.streamControllers[streamId], "enqueue should have stream controller"); + if (this.streamControllers[streamId].isClosed) { + break; + } - if (this.streamControllers[streamId].isClosed) { + this.streamControllers[streamId].controller.enqueue(data.chunk); break; - } - - this.streamControllers[streamId].controller.enqueue(data.chunk); - break; - case StreamKind.CLOSE: - (0, _util.assert)(this.streamControllers[streamId], "close should have stream controller"); + case StreamKind.CLOSE: + (0, _util.assert)(this.streamControllers[streamId], "close should have stream controller"); - if (this.streamControllers[streamId].isClosed) { - break; - } - - this.streamControllers[streamId].isClosed = true; - this.streamControllers[streamId].controller.close(); + if (this.streamControllers[streamId].isClosed) { + break; + } - this._deleteStreamController(streamId); + this.streamControllers[streamId].isClosed = true; + this.streamControllers[streamId].controller.close(); - break; + this._deleteStreamController(streamId); - case StreamKind.ERROR: - (0, _util.assert)(this.streamControllers[streamId], "error should have stream controller"); - this.streamControllers[streamId].controller.error(wrapReason(data.reason)); + break; - this._deleteStreamController(streamId); + case StreamKind.ERROR: + (0, _util.assert)(this.streamControllers[streamId], "error should have stream controller"); + this.streamControllers[streamId].controller.error(wrapReason(data.reason)); - break; + this._deleteStreamController(streamId); - case StreamKind.CANCEL_COMPLETE: - if (data.success) { - this.streamControllers[streamId].cancelCall.resolve(); - } else { - this.streamControllers[streamId].cancelCall.reject(wrapReason(data.reason)); - } + break; - this._deleteStreamController(streamId); + case StreamKind.CANCEL_COMPLETE: + if (data.success) { + this.streamControllers[streamId].cancelCall.resolve(); + } else { + this.streamControllers[streamId].cancelCall.reject(wrapReason(data.reason)); + } - break; + this._deleteStreamController(streamId); - case StreamKind.CANCEL: - if (!this.streamSinks[streamId]) { break; - } - const { - onCancel - } = this.streamSinks[data.streamId]; - new Promise(function (resolve) { - resolve(onCancel && onCancel(wrapReason(data.reason))); - }).then(function () { - comObj.postMessage({ - sourceName, - targetName, - stream: StreamKind.CANCEL_COMPLETE, - streamId, - success: true - }); - }, function (reason) { - comObj.postMessage({ - sourceName, - targetName, - stream: StreamKind.CANCEL_COMPLETE, - streamId, - reason: wrapReason(reason) + case StreamKind.CANCEL: + if (!this.streamSinks[streamId]) { + break; + } + + var onCancel = this.streamSinks[data.streamId].onCancel; + new Promise(function (resolve) { + resolve(onCancel && onCancel(wrapReason(data.reason))); + }).then(function () { + comObj.postMessage({ + sourceName: sourceName, + targetName: targetName, + stream: StreamKind.CANCEL_COMPLETE, + streamId: streamId, + success: true + }); + }, function (reason) { + comObj.postMessage({ + sourceName: sourceName, + targetName: targetName, + stream: StreamKind.CANCEL_COMPLETE, + streamId: streamId, + reason: wrapReason(reason) + }); }); - }); - this.streamSinks[streamId].sinkCapability.reject(wrapReason(data.reason)); - this.streamSinks[streamId].isCancelled = true; - delete this.streamSinks[streamId]; - break; + this.streamSinks[streamId].sinkCapability.reject(wrapReason(data.reason)); + this.streamSinks[streamId].isCancelled = true; + delete this.streamSinks[streamId]; + break; - default: - throw new Error("Unexpected stream case"); - } - } + default: + throw new Error("Unexpected stream case"); + } + } + }, { + key: "_deleteStreamController", + value: function () { + var _deleteStreamController2 = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee(streamId) { + return _regenerator["default"].wrap(function _callee$(_context) { + while (1) { + switch (_context.prev = _context.next) { + case 0: + _context.next = 2; + return Promise.allSettled([this.streamControllers[streamId].startCall, this.streamControllers[streamId].pullCall, this.streamControllers[streamId].cancelCall].map(function (capability) { + return capability && capability.promise; + })); + + case 2: + delete this.streamControllers[streamId]; + + case 3: + case "end": + return _context.stop(); + } + } + }, _callee, this); + })); - async _deleteStreamController(streamId) { - await Promise.allSettled([this.streamControllers[streamId].startCall, this.streamControllers[streamId].pullCall, this.streamControllers[streamId].cancelCall].map(function (capability) { - return capability && capability.promise; - })); - delete this.streamControllers[streamId]; - } + function _deleteStreamController(_x) { + return _deleteStreamController2.apply(this, arguments); + } - _postMessage(message, transfers) { - if (transfers && this.postMessageTransfers) { - this.comObj.postMessage(message, transfers); - } else { - this.comObj.postMessage(message); + return _deleteStreamController; + }() + }, { + key: "_postMessage", + value: function _postMessage(message, transfers) { + if (transfers && this.postMessageTransfers) { + this.comObj.postMessage(message, transfers); + } else { + this.comObj.postMessage(message); + } } - } - - destroy() { - this.comObj.removeEventListener("message", this._onComObjOnMessage); - } + }, { + key: "destroy", + value: function destroy() { + this.comObj.removeEventListener("message", this._onComObjOnMessage); + } + }]); -} + return MessageHandler; +}(); exports.MessageHandler = MessageHandler; /***/ }), -/* 12 */ +/* 205 */ /***/ (function(module, exports, __w_pdfjs_require__) { "use strict"; @@ -7271,16 +18169,38 @@ Object.defineProperty(exports, "__esModule", { }); exports.Metadata = void 0; -var _util = __w_pdfjs_require__(2); +var _util = __w_pdfjs_require__(5); + +var _xml_parser = __w_pdfjs_require__(206); + +function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); } + +function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; } + +function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e2) { throw _e2; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e3) { didErr = true; err = _e3; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; } + +function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); } + +function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } -var _xml_parser = __w_pdfjs_require__(13); +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +var Metadata = /*#__PURE__*/function () { + function Metadata(data) { + _classCallCheck(this, Metadata); -class Metadata { - constructor(data) { (0, _util.assert)(typeof data === "string", "Metadata: input is not a string"); data = this._repair(data); - const parser = new _xml_parser.SimpleXMLParser(); - const xmlDocument = parser.parseFromString(data); + var parser = new _xml_parser.SimpleXMLParser(); + var xmlDocument = parser.parseFromString(data); this._metadataMap = new Map(); if (xmlDocument) { @@ -7288,107 +18208,128 @@ class Metadata { } } - _repair(data) { - return data.replace(/^[^<]+/, "").replace(/>\\376\\377([^<]+)/g, function (all, codes) { - const bytes = codes.replace(/\\([0-3])([0-7])([0-7])/g, function (code, d1, d2, d3) { - return String.fromCharCode(d1 * 64 + d2 * 8 + d3 * 1); - }).replace(/&(amp|apos|gt|lt|quot);/g, function (str, name) { - switch (name) { - case "amp": - return "&"; + _createClass(Metadata, [{ + key: "_repair", + value: function _repair(data) { + return data.replace(/^[^<]+/, "").replace(/>\\376\\377([^<]+)/g, function (all, codes) { + var bytes = codes.replace(/\\([0-3])([0-7])([0-7])/g, function (code, d1, d2, d3) { + return String.fromCharCode(d1 * 64 + d2 * 8 + d3 * 1); + }).replace(/&(amp|apos|gt|lt|quot);/g, function (str, name) { + switch (name) { + case "amp": + return "&"; - case "apos": - return "'"; + case "apos": + return "'"; - case "gt": - return ">"; + case "gt": + return ">"; - case "lt": - return "<"; + case "lt": + return "<"; - case "quot": - return '"'; - } + case "quot": + return '"'; + } - throw new Error(`_repair: ${name} isn't defined.`); - }); - let chars = ""; + throw new Error("_repair: ".concat(name, " isn't defined.")); + }); + var chars = ""; - for (let i = 0, ii = bytes.length; i < ii; i += 2) { - const code = bytes.charCodeAt(i) * 256 + bytes.charCodeAt(i + 1); + for (var i = 0, ii = bytes.length; i < ii; i += 2) { + var code = bytes.charCodeAt(i) * 256 + bytes.charCodeAt(i + 1); - if (code >= 32 && code < 127 && code !== 60 && code !== 62 && code !== 38) { - chars += String.fromCharCode(code); - } else { - chars += "&#x" + (0x10000 + code).toString(16).substring(1) + ";"; + if (code >= 32 && code < 127 && code !== 60 && code !== 62 && code !== 38) { + chars += String.fromCharCode(code); + } else { + chars += "&#x" + (0x10000 + code).toString(16).substring(1) + ";"; + } } - } - return ">" + chars; - }); - } - - _parse(xmlDocument) { - let rdf = xmlDocument.documentElement; + return ">" + chars; + }); + } + }, { + key: "_parse", + value: function _parse(xmlDocument) { + var rdf = xmlDocument.documentElement; - if (rdf.nodeName.toLowerCase() !== "rdf:rdf") { - rdf = rdf.firstChild; + if (rdf.nodeName.toLowerCase() !== "rdf:rdf") { + rdf = rdf.firstChild; - while (rdf && rdf.nodeName.toLowerCase() !== "rdf:rdf") { - rdf = rdf.nextSibling; + while (rdf && rdf.nodeName.toLowerCase() !== "rdf:rdf") { + rdf = rdf.nextSibling; + } } - } - const nodeName = rdf ? rdf.nodeName.toLowerCase() : null; + var nodeName = rdf ? rdf.nodeName.toLowerCase() : null; - if (!rdf || nodeName !== "rdf:rdf" || !rdf.hasChildNodes()) { - return; - } + if (!rdf || nodeName !== "rdf:rdf" || !rdf.hasChildNodes()) { + return; + } - const children = rdf.childNodes; + var children = rdf.childNodes; - for (let i = 0, ii = children.length; i < ii; i++) { - const desc = children[i]; + for (var i = 0, ii = children.length; i < ii; i++) { + var desc = children[i]; - if (desc.nodeName.toLowerCase() !== "rdf:description") { - continue; - } + if (desc.nodeName.toLowerCase() !== "rdf:description") { + continue; + } - for (let j = 0, jj = desc.childNodes.length; j < jj; j++) { - if (desc.childNodes[j].nodeName.toLowerCase() !== "#text") { - const entry = desc.childNodes[j]; - const name = entry.nodeName.toLowerCase(); + for (var j = 0, jj = desc.childNodes.length; j < jj; j++) { + if (desc.childNodes[j].nodeName.toLowerCase() !== "#text") { + var entry = desc.childNodes[j]; + var name = entry.nodeName.toLowerCase(); - this._metadataMap.set(name, entry.textContent.trim()); + this._metadataMap.set(name, entry.textContent.trim()); + } } } } - } - - get(name) { - return this._metadataMap.has(name) ? this._metadataMap.get(name) : null; - } + }, { + key: "get", + value: function get(name) { + return this._metadataMap.has(name) ? this._metadataMap.get(name) : null; + } + }, { + key: "getAll", + value: function getAll() { + var obj = Object.create(null); - getAll() { - const obj = Object.create(null); + var _iterator = _createForOfIteratorHelper(this._metadataMap), + _step; - for (const [key, value] of this._metadataMap) { - obj[key] = value; - } + try { + for (_iterator.s(); !(_step = _iterator.n()).done;) { + var _step$value = _slicedToArray(_step.value, 2), + key = _step$value[0], + value = _step$value[1]; - return obj; - } + obj[key] = value; + } + } catch (err) { + _iterator.e(err); + } finally { + _iterator.f(); + } - has(name) { - return this._metadataMap.has(name); - } + return obj; + } + }, { + key: "has", + value: function has(name) { + return this._metadataMap.has(name); + } + }]); -} + return Metadata; +}(); exports.Metadata = Metadata; /***/ }), -/* 13 */ +/* 206 */ /***/ (function(module, exports, __w_pdfjs_require__) { "use strict"; @@ -7398,7 +18339,46 @@ Object.defineProperty(exports, "__esModule", { value: true }); exports.SimpleXMLParser = void 0; -const XMLParserErrorCode = { + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); } + +function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); } + +function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; } + +function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); } + +function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +var XMLParserErrorCode = { NoError: 0, EndOfDocument: -1, UnterminatedCdat: -2, @@ -7413,12 +18393,12 @@ const XMLParserErrorCode = { }; function isWhitespace(s, index) { - const ch = s[index]; + var ch = s[index]; return ch === " " || ch === "\n" || ch === "\r" || ch === "\t"; } function isWhitespaceString(s) { - for (let i = 0, ii = s.length; i < ii; i++) { + for (var i = 0, ii = s.length; i < ii; i++) { if (!isWhitespace(s, i)) { return false; } @@ -7427,275 +18407,299 @@ function isWhitespaceString(s) { return true; } -class XMLParserBase { - _resolveEntities(s) { - return s.replace(/&([^;]+);/g, (all, entity) => { - if (entity.substring(0, 2) === "#x") { - return String.fromCharCode(parseInt(entity.substring(2), 16)); - } else if (entity.substring(0, 1) === "#") { - return String.fromCharCode(parseInt(entity.substring(1), 10)); - } - - switch (entity) { - case "lt": - return "<"; +var XMLParserBase = /*#__PURE__*/function () { + function XMLParserBase() { + _classCallCheck(this, XMLParserBase); + } - case "gt": - return ">"; + _createClass(XMLParserBase, [{ + key: "_resolveEntities", + value: function _resolveEntities(s) { + var _this = this; - case "amp": - return "&"; + return s.replace(/&([^;]+);/g, function (all, entity) { + if (entity.substring(0, 2) === "#x") { + return String.fromCharCode(parseInt(entity.substring(2), 16)); + } else if (entity.substring(0, 1) === "#") { + return String.fromCharCode(parseInt(entity.substring(1), 10)); + } - case "quot": - return '"'; - } + switch (entity) { + case "lt": + return "<"; - return this.onResolveEntity(entity); - }); - } + case "gt": + return ">"; - _parseContent(s, start) { - const attributes = []; - let pos = start; + case "amp": + return "&"; - function skipWs() { - while (pos < s.length && isWhitespace(s, pos)) { - ++pos; - } - } + case "quot": + return '"'; + } - while (pos < s.length && !isWhitespace(s, pos) && s[pos] !== ">" && s[pos] !== "/") { - ++pos; + return _this.onResolveEntity(entity); + }); } + }, { + key: "_parseContent", + value: function _parseContent(s, start) { + var attributes = []; + var pos = start; - const name = s.substring(start, pos); - skipWs(); - - while (pos < s.length && s[pos] !== ">" && s[pos] !== "/" && s[pos] !== "?") { - skipWs(); - let attrName = "", - attrValue = ""; + function skipWs() { + while (pos < s.length && isWhitespace(s, pos)) { + ++pos; + } + } - while (pos < s.length && !isWhitespace(s, pos) && s[pos] !== "=") { - attrName += s[pos]; + while (pos < s.length && !isWhitespace(s, pos) && s[pos] !== ">" && s[pos] !== "/") { ++pos; } + var name = s.substring(start, pos); skipWs(); - if (s[pos] !== "=") { - return null; - } + while (pos < s.length && s[pos] !== ">" && s[pos] !== "/" && s[pos] !== "?") { + skipWs(); + var attrName = "", + attrValue = ""; - ++pos; - skipWs(); - const attrEndChar = s[pos]; + while (pos < s.length && !isWhitespace(s, pos) && s[pos] !== "=") { + attrName += s[pos]; + ++pos; + } - if (attrEndChar !== '"' && attrEndChar !== "'") { - return null; - } + skipWs(); - const attrEndIndex = s.indexOf(attrEndChar, ++pos); + if (s[pos] !== "=") { + return null; + } - if (attrEndIndex < 0) { - return null; - } + ++pos; + skipWs(); + var attrEndChar = s[pos]; - attrValue = s.substring(pos, attrEndIndex); - attributes.push({ - name: attrName, - value: this._resolveEntities(attrValue) - }); - pos = attrEndIndex + 1; - skipWs(); - } + if (attrEndChar !== '"' && attrEndChar !== "'") { + return null; + } - return { - name, - attributes, - parsed: pos - start - }; - } + var attrEndIndex = s.indexOf(attrEndChar, ++pos); - _parseProcessingInstruction(s, start) { - let pos = start; + if (attrEndIndex < 0) { + return null; + } - function skipWs() { - while (pos < s.length && isWhitespace(s, pos)) { - ++pos; + attrValue = s.substring(pos, attrEndIndex); + attributes.push({ + name: attrName, + value: this._resolveEntities(attrValue) + }); + pos = attrEndIndex + 1; + skipWs(); } - } - - while (pos < s.length && !isWhitespace(s, pos) && s[pos] !== ">" && s[pos] !== "/") { - ++pos; - } - - const name = s.substring(start, pos); - skipWs(); - const attrStart = pos; - while (pos < s.length && (s[pos] !== "?" || s[pos + 1] !== ">")) { - ++pos; + return { + name: name, + attributes: attributes, + parsed: pos - start + }; } + }, { + key: "_parseProcessingInstruction", + value: function _parseProcessingInstruction(s, start) { + var pos = start; - const value = s.substring(attrStart, pos); - return { - name, - value, - parsed: pos - start - }; - } - - parseXml(s) { - let i = 0; - - while (i < s.length) { - const ch = s[i]; - let j = i; - - if (ch === "<") { - ++j; - const ch2 = s[j]; - let q; - - switch (ch2) { - case "/": - ++j; - q = s.indexOf(">", j); + function skipWs() { + while (pos < s.length && isWhitespace(s, pos)) { + ++pos; + } + } - if (q < 0) { - this.onError(XMLParserErrorCode.UnterminatedElement); - return; - } + while (pos < s.length && !isWhitespace(s, pos) && s[pos] !== ">" && s[pos] !== "/") { + ++pos; + } - this.onEndElement(s.substring(j, q)); - j = q + 1; - break; + var name = s.substring(start, pos); + skipWs(); + var attrStart = pos; - case "?": - ++j; + while (pos < s.length && (s[pos] !== "?" || s[pos + 1] !== ">")) { + ++pos; + } - const pi = this._parseProcessingInstruction(s, j); + var value = s.substring(attrStart, pos); + return { + name: name, + value: value, + parsed: pos - start + }; + } + }, { + key: "parseXml", + value: function parseXml(s) { + var i = 0; - if (s.substring(j + pi.parsed, j + pi.parsed + 2) !== "?>") { - this.onError(XMLParserErrorCode.UnterminatedXmlDeclaration); - return; - } + while (i < s.length) { + var ch = s[i]; + var j = i; - this.onPi(pi.name, pi.value); - j += pi.parsed + 2; - break; + if (ch === "<") { + ++j; + var ch2 = s[j]; + var q = void 0; - case "!": - if (s.substring(j + 1, j + 3) === "--") { - q = s.indexOf("-->", j + 3); + switch (ch2) { + case "/": + ++j; + q = s.indexOf(">", j); if (q < 0) { - this.onError(XMLParserErrorCode.UnterminatedComment); + this.onError(XMLParserErrorCode.UnterminatedElement); return; } - this.onComment(s.substring(j + 3, q)); - j = q + 3; - } else if (s.substring(j + 1, j + 8) === "[CDATA[") { - q = s.indexOf("]]>", j + 8); + this.onEndElement(s.substring(j, q)); + j = q + 1; + break; - if (q < 0) { - this.onError(XMLParserErrorCode.UnterminatedCdat); - return; - } + case "?": + ++j; - this.onCdata(s.substring(j + 8, q)); - j = q + 3; - } else if (s.substring(j + 1, j + 8) === "DOCTYPE") { - const q2 = s.indexOf("[", j + 8); - let complexDoctype = false; - q = s.indexOf(">", j + 8); + var pi = this._parseProcessingInstruction(s, j); - if (q < 0) { - this.onError(XMLParserErrorCode.UnterminatedDoctypeDeclaration); + if (s.substring(j + pi.parsed, j + pi.parsed + 2) !== "?>") { + this.onError(XMLParserErrorCode.UnterminatedXmlDeclaration); return; } - if (q2 > 0 && q > q2) { - q = s.indexOf("]>", j + 8); + this.onPi(pi.name, pi.value); + j += pi.parsed + 2; + break; + + case "!": + if (s.substring(j + 1, j + 3) === "--") { + q = s.indexOf("-->", j + 3); if (q < 0) { - this.onError(XMLParserErrorCode.UnterminatedDoctypeDeclaration); + this.onError(XMLParserErrorCode.UnterminatedComment); return; } - complexDoctype = true; - } + this.onComment(s.substring(j + 3, q)); + j = q + 3; + } else if (s.substring(j + 1, j + 8) === "[CDATA[") { + q = s.indexOf("]]>", j + 8); - const doctypeContent = s.substring(j + 8, q + (complexDoctype ? 1 : 0)); - this.onDoctype(doctypeContent); - j = q + (complexDoctype ? 2 : 1); - } else { - this.onError(XMLParserErrorCode.MalformedElement); - return; - } - - break; - - default: - const content = this._parseContent(s, j); - - if (content === null) { - this.onError(XMLParserErrorCode.MalformedElement); - return; - } + if (q < 0) { + this.onError(XMLParserErrorCode.UnterminatedCdat); + return; + } - let isClosed = false; + this.onCdata(s.substring(j + 8, q)); + j = q + 3; + } else if (s.substring(j + 1, j + 8) === "DOCTYPE") { + var q2 = s.indexOf("[", j + 8); + var complexDoctype = false; + q = s.indexOf(">", j + 8); - if (s.substring(j + content.parsed, j + content.parsed + 2) === "/>") { - isClosed = true; - } else if (s.substring(j + content.parsed, j + content.parsed + 1) !== ">") { - this.onError(XMLParserErrorCode.UnterminatedElement); - return; - } + if (q < 0) { + this.onError(XMLParserErrorCode.UnterminatedDoctypeDeclaration); + return; + } - this.onBeginElement(content.name, content.attributes, isClosed); - j += content.parsed + (isClosed ? 2 : 1); - break; - } - } else { - while (j < s.length && s[j] !== "<") { - j++; - } + if (q2 > 0 && q > q2) { + q = s.indexOf("]>", j + 8); - const text = s.substring(i, j); - this.onText(this._resolveEntities(text)); - } + if (q < 0) { + this.onError(XMLParserErrorCode.UnterminatedDoctypeDeclaration); + return; + } - i = j; - } - } + complexDoctype = true; + } - onResolveEntity(name) { - return `&${name};`; - } + var doctypeContent = s.substring(j + 8, q + (complexDoctype ? 1 : 0)); + this.onDoctype(doctypeContent); + j = q + (complexDoctype ? 2 : 1); + } else { + this.onError(XMLParserErrorCode.MalformedElement); + return; + } - onPi(name, value) {} + break; - onComment(text) {} + default: + var content = this._parseContent(s, j); - onCdata(text) {} + if (content === null) { + this.onError(XMLParserErrorCode.MalformedElement); + return; + } - onDoctype(doctypeContent) {} + var isClosed = false; - onText(text) {} + if (s.substring(j + content.parsed, j + content.parsed + 2) === "/>") { + isClosed = true; + } else if (s.substring(j + content.parsed, j + content.parsed + 1) !== ">") { + this.onError(XMLParserErrorCode.UnterminatedElement); + return; + } - onBeginElement(name, attributes, isEmpty) {} + this.onBeginElement(content.name, content.attributes, isClosed); + j += content.parsed + (isClosed ? 2 : 1); + break; + } + } else { + while (j < s.length && s[j] !== "<") { + j++; + } - onEndElement(name) {} + var text = s.substring(i, j); + this.onText(this._resolveEntities(text)); + } - onError(code) {} + i = j; + } + } + }, { + key: "onResolveEntity", + value: function onResolveEntity(name) { + return "&".concat(name, ";"); + } + }, { + key: "onPi", + value: function onPi(name, value) {} + }, { + key: "onComment", + value: function onComment(text) {} + }, { + key: "onCdata", + value: function onCdata(text) {} + }, { + key: "onDoctype", + value: function onDoctype(doctypeContent) {} + }, { + key: "onText", + value: function onText(text) {} + }, { + key: "onBeginElement", + value: function onBeginElement(name, attributes, isEmpty) {} + }, { + key: "onEndElement", + value: function onEndElement(name) {} + }, { + key: "onError", + value: function onError(code) {} + }]); + + return XMLParserBase; +}(); -} +var SimpleDOMNode = /*#__PURE__*/function () { + function SimpleDOMNode(nodeName, nodeValue) { + _classCallCheck(this, SimpleDOMNode); -class SimpleDOMNode { - constructor(nodeName, nodeValue) { this.nodeName = nodeName; this.nodeValue = nodeValue; Object.defineProperty(this, "parentNode", { @@ -7704,134 +18708,161 @@ class SimpleDOMNode { }); } - get firstChild() { - return this.childNodes && this.childNodes[0]; - } + _createClass(SimpleDOMNode, [{ + key: "hasChildNodes", + value: function hasChildNodes() { + return this.childNodes && this.childNodes.length > 0; + } + }, { + key: "firstChild", + get: function get() { + return this.childNodes && this.childNodes[0]; + } + }, { + key: "nextSibling", + get: function get() { + var childNodes = this.parentNode.childNodes; - get nextSibling() { - const childNodes = this.parentNode.childNodes; + if (!childNodes) { + return undefined; + } - if (!childNodes) { - return undefined; - } + var index = childNodes.indexOf(this); - const index = childNodes.indexOf(this); + if (index === -1) { + return undefined; + } - if (index === -1) { - return undefined; + return childNodes[index + 1]; } + }, { + key: "textContent", + get: function get() { + if (!this.childNodes) { + return this.nodeValue || ""; + } - return childNodes[index + 1]; - } - - get textContent() { - if (!this.childNodes) { - return this.nodeValue || ""; + return this.childNodes.map(function (child) { + return child.textContent; + }).join(""); } + }]); - return this.childNodes.map(function (child) { - return child.textContent; - }).join(""); - } + return SimpleDOMNode; +}(); - hasChildNodes() { - return this.childNodes && this.childNodes.length > 0; - } +var SimpleXMLParser = /*#__PURE__*/function (_XMLParserBase) { + _inherits(SimpleXMLParser, _XMLParserBase); -} + var _super = _createSuper(SimpleXMLParser); -class SimpleXMLParser extends XMLParserBase { - constructor() { - super(); - this._currentFragment = null; - this._stack = null; - this._errorCode = XMLParserErrorCode.NoError; - } + function SimpleXMLParser() { + var _this2; - parseFromString(data) { - this._currentFragment = []; - this._stack = []; - this._errorCode = XMLParserErrorCode.NoError; - this.parseXml(data); + _classCallCheck(this, SimpleXMLParser); - if (this._errorCode !== XMLParserErrorCode.NoError) { - return undefined; - } + _this2 = _super.call(this); + _this2._currentFragment = null; + _this2._stack = null; + _this2._errorCode = XMLParserErrorCode.NoError; + return _this2; + } - const [documentElement] = this._currentFragment; + _createClass(SimpleXMLParser, [{ + key: "parseFromString", + value: function parseFromString(data) { + this._currentFragment = []; + this._stack = []; + this._errorCode = XMLParserErrorCode.NoError; + this.parseXml(data); - if (!documentElement) { - return undefined; - } + if (this._errorCode !== XMLParserErrorCode.NoError) { + return undefined; + } - return { - documentElement - }; - } + var _this$_currentFragmen = _slicedToArray(this._currentFragment, 1), + documentElement = _this$_currentFragmen[0]; - onResolveEntity(name) { - switch (name) { - case "apos": - return "'"; - } + if (!documentElement) { + return undefined; + } - return super.onResolveEntity(name); - } + return { + documentElement: documentElement + }; + } + }, { + key: "onResolveEntity", + value: function onResolveEntity(name) { + switch (name) { + case "apos": + return "'"; + } - onText(text) { - if (isWhitespaceString(text)) { - return; + return _get(_getPrototypeOf(SimpleXMLParser.prototype), "onResolveEntity", this).call(this, name); } + }, { + key: "onText", + value: function onText(text) { + if (isWhitespaceString(text)) { + return; + } - const node = new SimpleDOMNode("#text", text); + var node = new SimpleDOMNode("#text", text); - this._currentFragment.push(node); - } + this._currentFragment.push(node); + } + }, { + key: "onCdata", + value: function onCdata(text) { + var node = new SimpleDOMNode("#text", text); - onCdata(text) { - const node = new SimpleDOMNode("#text", text); + this._currentFragment.push(node); + } + }, { + key: "onBeginElement", + value: function onBeginElement(name, attributes, isEmpty) { + var node = new SimpleDOMNode(name); + node.childNodes = []; - this._currentFragment.push(node); - } + this._currentFragment.push(node); - onBeginElement(name, attributes, isEmpty) { - const node = new SimpleDOMNode(name); - node.childNodes = []; + if (isEmpty) { + return; + } - this._currentFragment.push(node); + this._stack.push(this._currentFragment); - if (isEmpty) { - return; + this._currentFragment = node.childNodes; } + }, { + key: "onEndElement", + value: function onEndElement(name) { + this._currentFragment = this._stack.pop() || []; + var lastElement = this._currentFragment[this._currentFragment.length - 1]; - this._stack.push(this._currentFragment); - - this._currentFragment = node.childNodes; - } - - onEndElement(name) { - this._currentFragment = this._stack.pop() || []; - const lastElement = this._currentFragment[this._currentFragment.length - 1]; + if (!lastElement) { + return; + } - if (!lastElement) { - return; + for (var i = 0, ii = lastElement.childNodes.length; i < ii; i++) { + lastElement.childNodes[i].parentNode = lastElement; + } } - - for (let i = 0, ii = lastElement.childNodes.length; i < ii; i++) { - lastElement.childNodes[i].parentNode = lastElement; + }, { + key: "onError", + value: function onError(code) { + this._errorCode = code; } - } + }]); - onError(code) { - this._errorCode = code; - } - -} + return SimpleXMLParser; +}(XMLParserBase); exports.SimpleXMLParser = SimpleXMLParser; /***/ }), -/* 14 */ +/* 207 */ /***/ (function(module, exports, __w_pdfjs_require__) { "use strict"; @@ -7842,17 +18873,41 @@ Object.defineProperty(exports, "__esModule", { }); exports.PDFDataTransportStream = void 0; -var _util = __w_pdfjs_require__(2); +var _regenerator = _interopRequireDefault(__w_pdfjs_require__(2)); + +var _util = __w_pdfjs_require__(5); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } } + +function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; } + +function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; } + +function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); } + +function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +var PDFDataTransportStream = /*#__PURE__*/function () { + function PDFDataTransportStream(params, pdfDataRangeTransport) { + var _this = this; + + _classCallCheck(this, PDFDataTransportStream); -class PDFDataTransportStream { - constructor(params, pdfDataRangeTransport) { (0, _util.assert)(pdfDataRangeTransport, 'PDFDataTransportStream - missing required "pdfDataRangeTransport" argument.'); this._queuedChunks = []; this._progressiveDone = params.progressiveDone || false; - const initialData = params.initialData; + var initialData = params.initialData; if (initialData && initialData.length > 0) { - const buffer = new Uint8Array(initialData).buffer; + var buffer = new Uint8Array(initialData).buffer; this._queuedChunks.push(buffer); } @@ -7864,147 +18919,172 @@ class PDFDataTransportStream { this._fullRequestReader = null; this._rangeReaders = []; - this._pdfDataRangeTransport.addRangeListener((begin, chunk) => { - this._onReceiveData({ - begin, - chunk + this._pdfDataRangeTransport.addRangeListener(function (begin, chunk) { + _this._onReceiveData({ + begin: begin, + chunk: chunk }); }); - this._pdfDataRangeTransport.addProgressListener((loaded, total) => { - this._onProgress({ - loaded, - total + this._pdfDataRangeTransport.addProgressListener(function (loaded, total) { + _this._onProgress({ + loaded: loaded, + total: total }); }); - this._pdfDataRangeTransport.addProgressiveReadListener(chunk => { - this._onReceiveData({ - chunk + this._pdfDataRangeTransport.addProgressiveReadListener(function (chunk) { + _this._onReceiveData({ + chunk: chunk }); }); - this._pdfDataRangeTransport.addProgressiveDoneListener(() => { - this._onProgressiveDone(); + this._pdfDataRangeTransport.addProgressiveDoneListener(function () { + _this._onProgressiveDone(); }); this._pdfDataRangeTransport.transportReady(); } - _onReceiveData(args) { - const buffer = new Uint8Array(args.chunk).buffer; + _createClass(PDFDataTransportStream, [{ + key: "_onReceiveData", + value: function _onReceiveData(args) { + var buffer = new Uint8Array(args.chunk).buffer; - if (args.begin === undefined) { - if (this._fullRequestReader) { - this._fullRequestReader._enqueue(buffer); - } else { - this._queuedChunks.push(buffer); - } - } else { - const found = this._rangeReaders.some(function (rangeReader) { - if (rangeReader._begin !== args.begin) { - return false; + if (args.begin === undefined) { + if (this._fullRequestReader) { + this._fullRequestReader._enqueue(buffer); + } else { + this._queuedChunks.push(buffer); } + } else { + var found = this._rangeReaders.some(function (rangeReader) { + if (rangeReader._begin !== args.begin) { + return false; + } - rangeReader._enqueue(buffer); + rangeReader._enqueue(buffer); - return true; - }); + return true; + }); - (0, _util.assert)(found, "_onReceiveData - no `PDFDataTransportStreamRangeReader` instance found."); + (0, _util.assert)(found, "_onReceiveData - no `PDFDataTransportStreamRangeReader` instance found."); + } } - } - - get _progressiveDataLength() { - return this._fullRequestReader ? this._fullRequestReader._loaded : 0; - } - - _onProgress(evt) { - if (evt.total === undefined) { - const firstReader = this._rangeReaders[0]; + }, { + key: "_onProgress", + value: function _onProgress(evt) { + if (evt.total === undefined) { + var firstReader = this._rangeReaders[0]; - if (firstReader && firstReader.onProgress) { - firstReader.onProgress({ - loaded: evt.loaded - }); - } - } else { - const fullReader = this._fullRequestReader; + if (firstReader && firstReader.onProgress) { + firstReader.onProgress({ + loaded: evt.loaded + }); + } + } else { + var fullReader = this._fullRequestReader; - if (fullReader && fullReader.onProgress) { - fullReader.onProgress({ - loaded: evt.loaded, - total: evt.total - }); + if (fullReader && fullReader.onProgress) { + fullReader.onProgress({ + loaded: evt.loaded, + total: evt.total + }); + } } } - } + }, { + key: "_onProgressiveDone", + value: function _onProgressiveDone() { + if (this._fullRequestReader) { + this._fullRequestReader.progressiveDone(); + } - _onProgressiveDone() { - if (this._fullRequestReader) { - this._fullRequestReader.progressiveDone(); + this._progressiveDone = true; } + }, { + key: "_removeRangeReader", + value: function _removeRangeReader(reader) { + var i = this._rangeReaders.indexOf(reader); - this._progressiveDone = true; - } - - _removeRangeReader(reader) { - const i = this._rangeReaders.indexOf(reader); - - if (i >= 0) { - this._rangeReaders.splice(i, 1); + if (i >= 0) { + this._rangeReaders.splice(i, 1); + } } - } - - getFullReader() { - (0, _util.assert)(!this._fullRequestReader, "PDFDataTransportStream.getFullReader can only be called once."); - const queuedChunks = this._queuedChunks; - this._queuedChunks = null; - return new PDFDataTransportStreamReader(this, queuedChunks, this._progressiveDone); - } - - getRangeReader(begin, end) { - if (end <= this._progressiveDataLength) { - return null; + }, { + key: "getFullReader", + value: function getFullReader() { + (0, _util.assert)(!this._fullRequestReader, "PDFDataTransportStream.getFullReader can only be called once."); + var queuedChunks = this._queuedChunks; + this._queuedChunks = null; + return new PDFDataTransportStreamReader(this, queuedChunks, this._progressiveDone); } + }, { + key: "getRangeReader", + value: function getRangeReader(begin, end) { + if (end <= this._progressiveDataLength) { + return null; + } - const reader = new PDFDataTransportStreamRangeReader(this, begin, end); - - this._pdfDataRangeTransport.requestDataRange(begin, end); + var reader = new PDFDataTransportStreamRangeReader(this, begin, end); - this._rangeReaders.push(reader); + this._pdfDataRangeTransport.requestDataRange(begin, end); - return reader; - } + this._rangeReaders.push(reader); - cancelAllRequests(reason) { - if (this._fullRequestReader) { - this._fullRequestReader.cancel(reason); + return reader; } + }, { + key: "cancelAllRequests", + value: function cancelAllRequests(reason) { + if (this._fullRequestReader) { + this._fullRequestReader.cancel(reason); + } - const readers = this._rangeReaders.slice(0); + var readers = this._rangeReaders.slice(0); - readers.forEach(function (rangeReader) { - rangeReader.cancel(reason); - }); + readers.forEach(function (rangeReader) { + rangeReader.cancel(reason); + }); - this._pdfDataRangeTransport.abort(); - } + this._pdfDataRangeTransport.abort(); + } + }, { + key: "_progressiveDataLength", + get: function get() { + return this._fullRequestReader ? this._fullRequestReader._loaded : 0; + } + }]); -} + return PDFDataTransportStream; +}(); exports.PDFDataTransportStream = PDFDataTransportStream; -class PDFDataTransportStreamReader { - constructor(stream, queuedChunks, progressiveDone = false) { +var PDFDataTransportStreamReader = /*#__PURE__*/function () { + function PDFDataTransportStreamReader(stream, queuedChunks) { + var progressiveDone = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + + _classCallCheck(this, PDFDataTransportStreamReader); + this._stream = stream; this._done = progressiveDone || false; this._filename = null; this._queuedChunks = queuedChunks || []; this._loaded = 0; - for (const chunk of this._queuedChunks) { - this._loaded += chunk.byteLength; + var _iterator = _createForOfIteratorHelper(this._queuedChunks), + _step; + + try { + for (_iterator.s(); !(_step = _iterator.n()).done;) { + var chunk = _step.value; + this._loaded += chunk.byteLength; + } + } catch (err) { + _iterator.e(err); + } finally { + _iterator.f(); } this._requests = []; @@ -8013,94 +19093,135 @@ class PDFDataTransportStreamReader { this.onProgress = null; } - _enqueue(chunk) { - if (this._done) { - return; - } - - if (this._requests.length > 0) { - const requestCapability = this._requests.shift(); - - requestCapability.resolve({ - value: chunk, - done: false - }); - } else { - this._queuedChunks.push(chunk); - } - - this._loaded += chunk.byteLength; - } + _createClass(PDFDataTransportStreamReader, [{ + key: "_enqueue", + value: function _enqueue(chunk) { + if (this._done) { + return; + } - get headersReady() { - return this._headersReady; - } + if (this._requests.length > 0) { + var requestCapability = this._requests.shift(); - get filename() { - return this._filename; - } + requestCapability.resolve({ + value: chunk, + done: false + }); + } else { + this._queuedChunks.push(chunk); + } - get isRangeSupported() { - return this._stream._isRangeSupported; - } + this._loaded += chunk.byteLength; + } + }, { + key: "read", + value: function () { + var _read = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee() { + var chunk, requestCapability; + return _regenerator["default"].wrap(function _callee$(_context) { + while (1) { + switch (_context.prev = _context.next) { + case 0: + if (!(this._queuedChunks.length > 0)) { + _context.next = 3; + break; + } - get isStreamingSupported() { - return this._stream._isStreamingSupported; - } + chunk = this._queuedChunks.shift(); + return _context.abrupt("return", { + value: chunk, + done: false + }); - get contentLength() { - return this._stream._contentLength; - } + case 3: + if (!this._done) { + _context.next = 5; + break; + } - async read() { - if (this._queuedChunks.length > 0) { - const chunk = this._queuedChunks.shift(); + return _context.abrupt("return", { + value: undefined, + done: true + }); - return { - value: chunk, - done: false - }; - } + case 5: + requestCapability = (0, _util.createPromiseCapability)(); - if (this._done) { - return { - value: undefined, - done: true - }; - } + this._requests.push(requestCapability); - const requestCapability = (0, _util.createPromiseCapability)(); + return _context.abrupt("return", requestCapability.promise); - this._requests.push(requestCapability); + case 8: + case "end": + return _context.stop(); + } + } + }, _callee, this); + })); - return requestCapability.promise; - } + function read() { + return _read.apply(this, arguments); + } - cancel(reason) { - this._done = true; + return read; + }() + }, { + key: "cancel", + value: function cancel(reason) { + this._done = true; - this._requests.forEach(function (requestCapability) { - requestCapability.resolve({ - value: undefined, - done: true + this._requests.forEach(function (requestCapability) { + requestCapability.resolve({ + value: undefined, + done: true + }); }); - }); - this._requests = []; - } + this._requests = []; + } + }, { + key: "progressiveDone", + value: function progressiveDone() { + if (this._done) { + return; + } - progressiveDone() { - if (this._done) { - return; + this._done = true; } + }, { + key: "headersReady", + get: function get() { + return this._headersReady; + } + }, { + key: "filename", + get: function get() { + return this._filename; + } + }, { + key: "isRangeSupported", + get: function get() { + return this._stream._isRangeSupported; + } + }, { + key: "isStreamingSupported", + get: function get() { + return this._stream._isStreamingSupported; + } + }, { + key: "contentLength", + get: function get() { + return this._stream._contentLength; + } + }]); - this._done = true; - } + return PDFDataTransportStreamReader; +}(); -} +var PDFDataTransportStreamRangeReader = /*#__PURE__*/function () { + function PDFDataTransportStreamRangeReader(stream, begin, end) { + _classCallCheck(this, PDFDataTransportStreamRangeReader); -class PDFDataTransportStreamRangeReader { - constructor(stream, begin, end) { this._stream = stream; this._begin = begin; this._end = end; @@ -8110,83 +19231,118 @@ class PDFDataTransportStreamRangeReader { this.onProgress = null; } - _enqueue(chunk) { - if (this._done) { - return; - } + _createClass(PDFDataTransportStreamRangeReader, [{ + key: "_enqueue", + value: function _enqueue(chunk) { + if (this._done) { + return; + } - if (this._requests.length === 0) { - this._queuedChunk = chunk; - } else { - const requestsCapability = this._requests.shift(); + if (this._requests.length === 0) { + this._queuedChunk = chunk; + } else { + var requestsCapability = this._requests.shift(); - requestsCapability.resolve({ - value: chunk, - done: false - }); + requestsCapability.resolve({ + value: chunk, + done: false + }); - this._requests.forEach(function (requestCapability) { - requestCapability.resolve({ - value: undefined, - done: true + this._requests.forEach(function (requestCapability) { + requestCapability.resolve({ + value: undefined, + done: true + }); }); - }); - this._requests = []; - } + this._requests = []; + } - this._done = true; + this._done = true; - this._stream._removeRangeReader(this); - } + this._stream._removeRangeReader(this); + } + }, { + key: "read", + value: function () { + var _read2 = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee2() { + var chunk, requestCapability; + return _regenerator["default"].wrap(function _callee2$(_context2) { + while (1) { + switch (_context2.prev = _context2.next) { + case 0: + if (!this._queuedChunk) { + _context2.next = 4; + break; + } - get isStreamingSupported() { - return false; - } + chunk = this._queuedChunk; + this._queuedChunk = null; + return _context2.abrupt("return", { + value: chunk, + done: false + }); + + case 4: + if (!this._done) { + _context2.next = 6; + break; + } - async read() { - if (this._queuedChunk) { - const chunk = this._queuedChunk; - this._queuedChunk = null; - return { - value: chunk, - done: false - }; - } + return _context2.abrupt("return", { + value: undefined, + done: true + }); - if (this._done) { - return { - value: undefined, - done: true - }; - } + case 6: + requestCapability = (0, _util.createPromiseCapability)(); - const requestCapability = (0, _util.createPromiseCapability)(); + this._requests.push(requestCapability); - this._requests.push(requestCapability); + return _context2.abrupt("return", requestCapability.promise); - return requestCapability.promise; - } + case 9: + case "end": + return _context2.stop(); + } + } + }, _callee2, this); + })); - cancel(reason) { - this._done = true; + function read() { + return _read2.apply(this, arguments); + } - this._requests.forEach(function (requestCapability) { - requestCapability.resolve({ - value: undefined, - done: true + return read; + }() + }, { + key: "cancel", + value: function cancel(reason) { + this._done = true; + + this._requests.forEach(function (requestCapability) { + requestCapability.resolve({ + value: undefined, + done: true + }); }); - }); - this._requests = []; + this._requests = []; - this._stream._removeRangeReader(this); - } + this._stream._removeRangeReader(this); + } + }, { + key: "isStreamingSupported", + get: function get() { + return false; + } + }]); -} + return PDFDataTransportStreamRangeReader; +}(); /***/ }), -/* 15 */ +/* 208 */ /***/ (function(module, exports, __w_pdfjs_require__) { "use strict"; @@ -8197,48 +19353,62 @@ Object.defineProperty(exports, "__esModule", { }); exports.WebGLContext = void 0; -var _util = __w_pdfjs_require__(2); +var _util = __w_pdfjs_require__(5); -class WebGLContext { - constructor({ - enable = false - }) { - this._enabled = enable === true; - } +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - get isEnabled() { - let enabled = this._enabled; +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } - if (enabled) { - enabled = WebGLUtils.tryInitGL(); - } +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } - return (0, _util.shadow)(this, "isEnabled", enabled); - } +var WebGLContext = /*#__PURE__*/function () { + function WebGLContext(_ref) { + var _ref$enable = _ref.enable, + enable = _ref$enable === void 0 ? false : _ref$enable; - composeSMask({ - layer, - mask, - properties - }) { - return WebGLUtils.composeSMask(layer, mask, properties); - } + _classCallCheck(this, WebGLContext); - drawFigures({ - width, - height, - backgroundColor, - figures, - context - }) { - return WebGLUtils.drawFigures(width, height, backgroundColor, figures, context); + this._enabled = enable === true; } - clear() { - WebGLUtils.cleanup(); - } + _createClass(WebGLContext, [{ + key: "composeSMask", + value: function composeSMask(_ref2) { + var layer = _ref2.layer, + mask = _ref2.mask, + properties = _ref2.properties; + return WebGLUtils.composeSMask(layer, mask, properties); + } + }, { + key: "drawFigures", + value: function drawFigures(_ref3) { + var width = _ref3.width, + height = _ref3.height, + backgroundColor = _ref3.backgroundColor, + figures = _ref3.figures, + context = _ref3.context; + return WebGLUtils.drawFigures(width, height, backgroundColor, figures, context); + } + }, { + key: "clear", + value: function clear() { + WebGLUtils.cleanup(); + } + }, { + key: "isEnabled", + get: function get() { + var enabled = this._enabled; -} + if (enabled) { + enabled = WebGLUtils.tryInitGL(); + } + + return (0, _util.shadow)(this, "isEnabled", enabled); + } + }]); + + return WebGLContext; +}(); exports.WebGLContext = WebGLContext; @@ -8602,7 +19772,7 @@ var WebGLUtils = function WebGLUtilsClosure() { } return { - tryInitGL() { + tryInitGL: function tryInitGL() { try { generateGL(); return !!currentGL; @@ -8610,11 +19780,9 @@ var WebGLUtils = function WebGLUtilsClosure() { return false; }, - - composeSMask, - drawFigures, - - cleanup() { + composeSMask: composeSMask, + drawFigures: drawFigures, + cleanup: function cleanup() { if (smaskCache && smaskCache.canvas) { smaskCache.canvas.width = 0; smaskCache.canvas.height = 0; @@ -8628,12 +19796,11 @@ var WebGLUtils = function WebGLUtilsClosure() { smaskCache = null; figuresCache = null; } - }; }(); /***/ }), -/* 16 */ +/* 209 */ /***/ (function(module, exports, __w_pdfjs_require__) { "use strict"; @@ -8646,95 +19813,140 @@ exports.AnnotationLayer = void 0; var _display_utils = __w_pdfjs_require__(1); -var _util = __w_pdfjs_require__(2); +var _util = __w_pdfjs_require__(5); -class AnnotationElementFactory { - static create(parameters) { - const subtype = parameters.data.annotationType; +function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; } - switch (subtype) { - case _util.AnnotationType.LINK: - return new LinkAnnotationElement(parameters); +function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); } - case _util.AnnotationType.TEXT: - return new TextAnnotationElement(parameters); +function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } - case _util.AnnotationType.WIDGET: - const fieldType = parameters.data.fieldType; +function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); } - switch (fieldType) { - case "Tx": - return new TextWidgetAnnotationElement(parameters); +function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; } - case "Btn": - if (parameters.data.radioButton) { - return new RadioButtonWidgetAnnotationElement(parameters); - } else if (parameters.data.checkBox) { - return new CheckboxWidgetAnnotationElement(parameters); - } +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } - return new PushButtonWidgetAnnotationElement(parameters); +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } - case "Ch": - return new ChoiceWidgetAnnotationElement(parameters); - } +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } - return new WidgetAnnotationElement(parameters); +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } - case _util.AnnotationType.POPUP: - return new PopupAnnotationElement(parameters); +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } - case _util.AnnotationType.FREETEXT: - return new FreeTextAnnotationElement(parameters); +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } - case _util.AnnotationType.LINE: - return new LineAnnotationElement(parameters); +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } - case _util.AnnotationType.SQUARE: - return new SquareAnnotationElement(parameters); +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } - case _util.AnnotationType.CIRCLE: - return new CircleAnnotationElement(parameters); +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - case _util.AnnotationType.POLYLINE: - return new PolylineAnnotationElement(parameters); +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } - case _util.AnnotationType.CARET: - return new CaretAnnotationElement(parameters); +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } - case _util.AnnotationType.INK: - return new InkAnnotationElement(parameters); +var AnnotationElementFactory = /*#__PURE__*/function () { + function AnnotationElementFactory() { + _classCallCheck(this, AnnotationElementFactory); + } - case _util.AnnotationType.POLYGON: - return new PolygonAnnotationElement(parameters); + _createClass(AnnotationElementFactory, null, [{ + key: "create", + value: function create(parameters) { + var subtype = parameters.data.annotationType; - case _util.AnnotationType.HIGHLIGHT: - return new HighlightAnnotationElement(parameters); + switch (subtype) { + case _util.AnnotationType.LINK: + return new LinkAnnotationElement(parameters); - case _util.AnnotationType.UNDERLINE: - return new UnderlineAnnotationElement(parameters); + case _util.AnnotationType.TEXT: + return new TextAnnotationElement(parameters); - case _util.AnnotationType.SQUIGGLY: - return new SquigglyAnnotationElement(parameters); + case _util.AnnotationType.WIDGET: + var fieldType = parameters.data.fieldType; - case _util.AnnotationType.STRIKEOUT: - return new StrikeOutAnnotationElement(parameters); + switch (fieldType) { + case "Tx": + return new TextWidgetAnnotationElement(parameters); - case _util.AnnotationType.STAMP: - return new StampAnnotationElement(parameters); + case "Btn": + if (parameters.data.radioButton) { + return new RadioButtonWidgetAnnotationElement(parameters); + } else if (parameters.data.checkBox) { + return new CheckboxWidgetAnnotationElement(parameters); + } - case _util.AnnotationType.FILEATTACHMENT: - return new FileAttachmentAnnotationElement(parameters); + return new PushButtonWidgetAnnotationElement(parameters); - default: - return new AnnotationElement(parameters); + case "Ch": + return new ChoiceWidgetAnnotationElement(parameters); + } + + return new WidgetAnnotationElement(parameters); + + case _util.AnnotationType.POPUP: + return new PopupAnnotationElement(parameters); + + case _util.AnnotationType.FREETEXT: + return new FreeTextAnnotationElement(parameters); + + case _util.AnnotationType.LINE: + return new LineAnnotationElement(parameters); + + case _util.AnnotationType.SQUARE: + return new SquareAnnotationElement(parameters); + + case _util.AnnotationType.CIRCLE: + return new CircleAnnotationElement(parameters); + + case _util.AnnotationType.POLYLINE: + return new PolylineAnnotationElement(parameters); + + case _util.AnnotationType.CARET: + return new CaretAnnotationElement(parameters); + + case _util.AnnotationType.INK: + return new InkAnnotationElement(parameters); + + case _util.AnnotationType.POLYGON: + return new PolygonAnnotationElement(parameters); + + case _util.AnnotationType.HIGHLIGHT: + return new HighlightAnnotationElement(parameters); + + case _util.AnnotationType.UNDERLINE: + return new UnderlineAnnotationElement(parameters); + + case _util.AnnotationType.SQUIGGLY: + return new SquigglyAnnotationElement(parameters); + + case _util.AnnotationType.STRIKEOUT: + return new StrikeOutAnnotationElement(parameters); + + case _util.AnnotationType.STAMP: + return new StampAnnotationElement(parameters); + + case _util.AnnotationType.FILEATTACHMENT: + return new FileAttachmentAnnotationElement(parameters); + + default: + return new AnnotationElement(parameters); + } } - } + }]); -} + return AnnotationElementFactory; +}(); + +var AnnotationElement = /*#__PURE__*/function () { + function AnnotationElement(parameters) { + var isRenderable = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; + var ignoreBorder = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + + _classCallCheck(this, AnnotationElement); -class AnnotationElement { - constructor(parameters, isRenderable = false, ignoreBorder = false) { this.isRenderable = isRenderable; this.data = parameters.data; this.layer = parameters.layer; @@ -8751,411 +19963,535 @@ class AnnotationElement { } } - _createContainer(ignoreBorder = false) { - const data = this.data, + _createClass(AnnotationElement, [{ + key: "_createContainer", + value: function _createContainer() { + var ignoreBorder = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + var data = this.data, page = this.page, viewport = this.viewport; - const container = document.createElement("section"); - let width = data.rect[2] - data.rect[0]; - let height = data.rect[3] - data.rect[1]; - container.setAttribute("data-annotation-id", data.id); + var container = document.createElement("section"); + var width = data.rect[2] - data.rect[0]; + var height = data.rect[3] - data.rect[1]; + container.setAttribute("data-annotation-id", data.id); - const rect = _util.Util.normalizeRect([data.rect[0], page.view[3] - data.rect[1] + page.view[1], data.rect[2], page.view[3] - data.rect[3] + page.view[1]]); + var rect = _util.Util.normalizeRect([data.rect[0], page.view[3] - data.rect[1] + page.view[1], data.rect[2], page.view[3] - data.rect[3] + page.view[1]]); - container.style.transform = `matrix(${viewport.transform.join(",")})`; - container.style.transformOrigin = `-${rect[0]}px -${rect[1]}px`; + container.style.transform = "matrix(".concat(viewport.transform.join(","), ")"); + container.style.transformOrigin = "-".concat(rect[0], "px -").concat(rect[1], "px"); - if (!ignoreBorder && data.borderStyle.width > 0) { - container.style.borderWidth = `${data.borderStyle.width}px`; + if (!ignoreBorder && data.borderStyle.width > 0) { + container.style.borderWidth = "".concat(data.borderStyle.width, "px"); - if (data.borderStyle.style !== _util.AnnotationBorderStyleType.UNDERLINE) { - width = width - 2 * data.borderStyle.width; - height = height - 2 * data.borderStyle.width; - } + if (data.borderStyle.style !== _util.AnnotationBorderStyleType.UNDERLINE) { + width = width - 2 * data.borderStyle.width; + height = height - 2 * data.borderStyle.width; + } - const horizontalRadius = data.borderStyle.horizontalCornerRadius; - const verticalRadius = data.borderStyle.verticalCornerRadius; + var horizontalRadius = data.borderStyle.horizontalCornerRadius; + var verticalRadius = data.borderStyle.verticalCornerRadius; - if (horizontalRadius > 0 || verticalRadius > 0) { - const radius = `${horizontalRadius}px / ${verticalRadius}px`; - container.style.borderRadius = radius; - } + if (horizontalRadius > 0 || verticalRadius > 0) { + var radius = "".concat(horizontalRadius, "px / ").concat(verticalRadius, "px"); + container.style.borderRadius = radius; + } - switch (data.borderStyle.style) { - case _util.AnnotationBorderStyleType.SOLID: - container.style.borderStyle = "solid"; - break; + switch (data.borderStyle.style) { + case _util.AnnotationBorderStyleType.SOLID: + container.style.borderStyle = "solid"; + break; - case _util.AnnotationBorderStyleType.DASHED: - container.style.borderStyle = "dashed"; - break; + case _util.AnnotationBorderStyleType.DASHED: + container.style.borderStyle = "dashed"; + break; - case _util.AnnotationBorderStyleType.BEVELED: - (0, _util.warn)("Unimplemented border style: beveled"); - break; + case _util.AnnotationBorderStyleType.BEVELED: + (0, _util.warn)("Unimplemented border style: beveled"); + break; - case _util.AnnotationBorderStyleType.INSET: - (0, _util.warn)("Unimplemented border style: inset"); - break; + case _util.AnnotationBorderStyleType.INSET: + (0, _util.warn)("Unimplemented border style: inset"); + break; - case _util.AnnotationBorderStyleType.UNDERLINE: - container.style.borderBottomStyle = "solid"; - break; + case _util.AnnotationBorderStyleType.UNDERLINE: + container.style.borderBottomStyle = "solid"; + break; - default: - break; - } + default: + break; + } - if (data.color) { - container.style.borderColor = _util.Util.makeCssRgb(data.color[0] | 0, data.color[1] | 0, data.color[2] | 0); - } else { - container.style.borderWidth = 0; + if (data.color) { + container.style.borderColor = _util.Util.makeCssRgb(data.color[0] | 0, data.color[1] | 0, data.color[2] | 0); + } else { + container.style.borderWidth = 0; + } } + + container.style.left = "".concat(rect[0], "px"); + container.style.top = "".concat(rect[1], "px"); + container.style.width = "".concat(width, "px"); + container.style.height = "".concat(height, "px"); + return container; + } + }, { + key: "_createPopup", + value: function _createPopup(container, trigger, data) { + if (!trigger) { + trigger = document.createElement("div"); + trigger.style.height = container.style.height; + trigger.style.width = container.style.width; + container.appendChild(trigger); + } + + var popupElement = new PopupElement({ + container: container, + trigger: trigger, + color: data.color, + title: data.title, + modificationDate: data.modificationDate, + contents: data.contents, + hideWrapper: true + }); + var popup = popupElement.render(); + popup.style.left = container.style.width; + container.appendChild(popup); + } + }, { + key: "render", + value: function render() { + (0, _util.unreachable)("Abstract method `AnnotationElement.render` called"); } + }]); - container.style.left = `${rect[0]}px`; - container.style.top = `${rect[1]}px`; - container.style.width = `${width}px`; - container.style.height = `${height}px`; - return container; - } + return AnnotationElement; +}(); - _createPopup(container, trigger, data) { - if (!trigger) { - trigger = document.createElement("div"); - trigger.style.height = container.style.height; - trigger.style.width = container.style.width; - container.appendChild(trigger); - } +var LinkAnnotationElement = /*#__PURE__*/function (_AnnotationElement) { + _inherits(LinkAnnotationElement, _AnnotationElement); - const popupElement = new PopupElement({ - container, - trigger, - color: data.color, - title: data.title, - modificationDate: data.modificationDate, - contents: data.contents, - hideWrapper: true - }); - const popup = popupElement.render(); - popup.style.left = container.style.width; - container.appendChild(popup); - } + var _super = _createSuper(LinkAnnotationElement); + + function LinkAnnotationElement(parameters) { + _classCallCheck(this, LinkAnnotationElement); - render() { - (0, _util.unreachable)("Abstract method `AnnotationElement.render` called"); + var isRenderable = !!(parameters.data.url || parameters.data.dest || parameters.data.action); + return _super.call(this, parameters, isRenderable); } -} + _createClass(LinkAnnotationElement, [{ + key: "render", + value: function render() { + this.container.className = "linkAnnotation"; + var data = this.data, + linkService = this.linkService; + var link = document.createElement("a"); -class LinkAnnotationElement extends AnnotationElement { - constructor(parameters) { - const isRenderable = !!(parameters.data.url || parameters.data.dest || parameters.data.action); - super(parameters, isRenderable); - } - - render() { - this.container.className = "linkAnnotation"; - const { - data, - linkService - } = this; - const link = document.createElement("a"); - - if (data.url) { - (0, _display_utils.addLinkAttributes)(link, { - url: data.url, - target: data.newWindow ? _display_utils.LinkTarget.BLANK : linkService.externalLinkTarget, - rel: linkService.externalLinkRel, - enabled: linkService.externalLinkEnabled - }); - } else if (data.action) { - this._bindNamedAction(link, data.action); - } else { - this._bindLink(link, data.dest); + if (data.url) { + (0, _display_utils.addLinkAttributes)(link, { + url: data.url, + target: data.newWindow ? _display_utils.LinkTarget.BLANK : linkService.externalLinkTarget, + rel: linkService.externalLinkRel, + enabled: linkService.externalLinkEnabled + }); + } else if (data.action) { + this._bindNamedAction(link, data.action); + } else { + this._bindLink(link, data.dest); + } + + this.container.appendChild(link); + return this.container; } + }, { + key: "_bindLink", + value: function _bindLink(link, destination) { + var _this = this; - this.container.appendChild(link); - return this.container; - } + link.href = this.linkService.getDestinationHash(destination); + + link.onclick = function () { + if (destination) { + _this.linkService.navigateTo(destination); + } - _bindLink(link, destination) { - link.href = this.linkService.getDestinationHash(destination); + return false; + }; - link.onclick = () => { if (destination) { - this.linkService.navigateTo(destination); + link.className = "internalLink"; } + } + }, { + key: "_bindNamedAction", + value: function _bindNamedAction(link, action) { + var _this2 = this; - return false; - }; + link.href = this.linkService.getAnchorUrl(""); + + link.onclick = function () { + _this2.linkService.executeNamedAction(action); + + return false; + }; - if (destination) { link.className = "internalLink"; } - } + }]); - _bindNamedAction(link, action) { - link.href = this.linkService.getAnchorUrl(""); + return LinkAnnotationElement; +}(AnnotationElement); - link.onclick = () => { - this.linkService.executeNamedAction(action); - return false; - }; +var TextAnnotationElement = /*#__PURE__*/function (_AnnotationElement2) { + _inherits(TextAnnotationElement, _AnnotationElement2); - link.className = "internalLink"; + var _super2 = _createSuper(TextAnnotationElement); + + function TextAnnotationElement(parameters) { + _classCallCheck(this, TextAnnotationElement); + + var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents); + return _super2.call(this, parameters, isRenderable); } -} + _createClass(TextAnnotationElement, [{ + key: "render", + value: function render() { + this.container.className = "textAnnotation"; + var image = document.createElement("img"); + image.style.height = this.container.style.height; + image.style.width = this.container.style.width; + image.src = this.imageResourcesPath + "annotation-" + this.data.name.toLowerCase() + ".svg"; + image.alt = "[{{type}} Annotation]"; + image.dataset.l10nId = "text_annotation_type"; + image.dataset.l10nArgs = JSON.stringify({ + type: this.data.name + }); -class TextAnnotationElement extends AnnotationElement { - constructor(parameters) { - const isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents); - super(parameters, isRenderable); - } - - render() { - this.container.className = "textAnnotation"; - const image = document.createElement("img"); - image.style.height = this.container.style.height; - image.style.width = this.container.style.width; - image.src = this.imageResourcesPath + "annotation-" + this.data.name.toLowerCase() + ".svg"; - image.alt = "[{{type}} Annotation]"; - image.dataset.l10nId = "text_annotation_type"; - image.dataset.l10nArgs = JSON.stringify({ - type: this.data.name - }); + if (!this.data.hasPopup) { + this._createPopup(this.container, image, this.data); + } - if (!this.data.hasPopup) { - this._createPopup(this.container, image, this.data); + this.container.appendChild(image); + return this.container; } + }]); - this.container.appendChild(image); - return this.container; - } + return TextAnnotationElement; +}(AnnotationElement); -} +var WidgetAnnotationElement = /*#__PURE__*/function (_AnnotationElement3) { + _inherits(WidgetAnnotationElement, _AnnotationElement3); + + var _super3 = _createSuper(WidgetAnnotationElement); -class WidgetAnnotationElement extends AnnotationElement { - render() { - return this.container; + function WidgetAnnotationElement() { + _classCallCheck(this, WidgetAnnotationElement); + + return _super3.apply(this, arguments); } -} + _createClass(WidgetAnnotationElement, [{ + key: "render", + value: function render() { + return this.container; + } + }]); + + return WidgetAnnotationElement; +}(AnnotationElement); -class TextWidgetAnnotationElement extends WidgetAnnotationElement { - constructor(parameters) { - const isRenderable = parameters.renderInteractiveForms || !parameters.data.hasAppearance && !!parameters.data.fieldValue; - super(parameters, isRenderable); +var TextWidgetAnnotationElement = /*#__PURE__*/function (_WidgetAnnotationElem) { + _inherits(TextWidgetAnnotationElement, _WidgetAnnotationElem); + + var _super4 = _createSuper(TextWidgetAnnotationElement); + + function TextWidgetAnnotationElement(parameters) { + _classCallCheck(this, TextWidgetAnnotationElement); + + var isRenderable = parameters.renderInteractiveForms || !parameters.data.hasAppearance && !!parameters.data.fieldValue; + return _super4.call(this, parameters, isRenderable); } - render() { - const TEXT_ALIGNMENT = ["left", "center", "right"]; - this.container.className = "textWidgetAnnotation"; - let element = null; + _createClass(TextWidgetAnnotationElement, [{ + key: "render", + value: function render() { + var TEXT_ALIGNMENT = ["left", "center", "right"]; + this.container.className = "textWidgetAnnotation"; + var element = null; - if (this.renderInteractiveForms) { - if (this.data.multiLine) { - element = document.createElement("textarea"); - element.textContent = this.data.fieldValue; + if (this.renderInteractiveForms) { + if (this.data.multiLine) { + element = document.createElement("textarea"); + element.textContent = this.data.fieldValue; + } else { + element = document.createElement("input"); + element.type = "text"; + element.setAttribute("value", this.data.fieldValue); + } + + element.disabled = this.data.readOnly; + element.name = this.data.fieldName; + + if (this.data.maxLen !== null) { + element.maxLength = this.data.maxLen; + } + + if (this.data.comb) { + var fieldWidth = this.data.rect[2] - this.data.rect[0]; + var combWidth = fieldWidth / this.data.maxLen; + element.classList.add("comb"); + element.style.letterSpacing = "calc(".concat(combWidth, "px - 1ch)"); + } } else { - element = document.createElement("input"); - element.type = "text"; - element.setAttribute("value", this.data.fieldValue); - } + element = document.createElement("div"); + element.textContent = this.data.fieldValue; + element.style.verticalAlign = "middle"; + element.style.display = "table-cell"; + var font = null; - element.disabled = this.data.readOnly; - element.name = this.data.fieldName; + if (this.data.fontRefName && this.page.commonObjs.has(this.data.fontRefName)) { + font = this.page.commonObjs.get(this.data.fontRefName); + } - if (this.data.maxLen !== null) { - element.maxLength = this.data.maxLen; + this._setTextStyle(element, font); } - if (this.data.comb) { - const fieldWidth = this.data.rect[2] - this.data.rect[0]; - const combWidth = fieldWidth / this.data.maxLen; - element.classList.add("comb"); - element.style.letterSpacing = `calc(${combWidth}px - 1ch)`; + if (this.data.textAlignment !== null) { + element.style.textAlign = TEXT_ALIGNMENT[this.data.textAlignment]; } - } else { - element = document.createElement("div"); - element.textContent = this.data.fieldValue; - element.style.verticalAlign = "middle"; - element.style.display = "table-cell"; - let font = null; - if (this.data.fontRefName && this.page.commonObjs.has(this.data.fontRefName)) { - font = this.page.commonObjs.get(this.data.fontRefName); + this.container.appendChild(element); + return this.container; + } + }, { + key: "_setTextStyle", + value: function _setTextStyle(element, font) { + var style = element.style; + style.fontSize = "".concat(this.data.fontSize, "px"); + style.direction = this.data.fontDirection < 0 ? "rtl" : "ltr"; + + if (!font) { + return; + } + + var bold = "normal"; + + if (font.black) { + bold = "900"; + } else if (font.bold) { + bold = "bold"; } - this._setTextStyle(element, font); + style.fontWeight = bold; + style.fontStyle = font.italic ? "italic" : "normal"; + var fontFamily = font.loadedName ? "\"".concat(font.loadedName, "\", ") : ""; + var fallbackName = font.fallbackName || "Helvetica, sans-serif"; + style.fontFamily = fontFamily + fallbackName; } + }]); - if (this.data.textAlignment !== null) { - element.style.textAlign = TEXT_ALIGNMENT[this.data.textAlignment]; - } + return TextWidgetAnnotationElement; +}(WidgetAnnotationElement); - this.container.appendChild(element); - return this.container; +var CheckboxWidgetAnnotationElement = /*#__PURE__*/function (_WidgetAnnotationElem2) { + _inherits(CheckboxWidgetAnnotationElement, _WidgetAnnotationElem2); + + var _super5 = _createSuper(CheckboxWidgetAnnotationElement); + + function CheckboxWidgetAnnotationElement(parameters) { + _classCallCheck(this, CheckboxWidgetAnnotationElement); + + return _super5.call(this, parameters, parameters.renderInteractiveForms); } - _setTextStyle(element, font) { - const style = element.style; - style.fontSize = `${this.data.fontSize}px`; - style.direction = this.data.fontDirection < 0 ? "rtl" : "ltr"; + _createClass(CheckboxWidgetAnnotationElement, [{ + key: "render", + value: function render() { + this.container.className = "buttonWidgetAnnotation checkBox"; + var element = document.createElement("input"); + element.disabled = this.data.readOnly; + element.type = "checkbox"; + element.name = this.data.fieldName; - if (!font) { - return; + if (this.data.fieldValue && this.data.fieldValue !== "Off") { + element.setAttribute("checked", true); + } + + this.container.appendChild(element); + return this.container; } + }]); - let bold = "normal"; + return CheckboxWidgetAnnotationElement; +}(WidgetAnnotationElement); - if (font.black) { - bold = "900"; - } else if (font.bold) { - bold = "bold"; - } +var RadioButtonWidgetAnnotationElement = /*#__PURE__*/function (_WidgetAnnotationElem3) { + _inherits(RadioButtonWidgetAnnotationElement, _WidgetAnnotationElem3); - style.fontWeight = bold; - style.fontStyle = font.italic ? "italic" : "normal"; - const fontFamily = font.loadedName ? `"${font.loadedName}", ` : ""; - const fallbackName = font.fallbackName || "Helvetica, sans-serif"; - style.fontFamily = fontFamily + fallbackName; - } + var _super6 = _createSuper(RadioButtonWidgetAnnotationElement); -} + function RadioButtonWidgetAnnotationElement(parameters) { + _classCallCheck(this, RadioButtonWidgetAnnotationElement); -class CheckboxWidgetAnnotationElement extends WidgetAnnotationElement { - constructor(parameters) { - super(parameters, parameters.renderInteractiveForms); + return _super6.call(this, parameters, parameters.renderInteractiveForms); } - render() { - this.container.className = "buttonWidgetAnnotation checkBox"; - const element = document.createElement("input"); - element.disabled = this.data.readOnly; - element.type = "checkbox"; - element.name = this.data.fieldName; + _createClass(RadioButtonWidgetAnnotationElement, [{ + key: "render", + value: function render() { + this.container.className = "buttonWidgetAnnotation radioButton"; + var element = document.createElement("input"); + element.disabled = this.data.readOnly; + element.type = "radio"; + element.name = this.data.fieldName; - if (this.data.fieldValue && this.data.fieldValue !== "Off") { - element.setAttribute("checked", true); + if (this.data.fieldValue === this.data.buttonValue) { + element.setAttribute("checked", true); + } + + this.container.appendChild(element); + return this.container; } + }]); - this.container.appendChild(element); - return this.container; - } + return RadioButtonWidgetAnnotationElement; +}(WidgetAnnotationElement); -} +var PushButtonWidgetAnnotationElement = /*#__PURE__*/function (_LinkAnnotationElemen) { + _inherits(PushButtonWidgetAnnotationElement, _LinkAnnotationElemen); + + var _super7 = _createSuper(PushButtonWidgetAnnotationElement); + + function PushButtonWidgetAnnotationElement() { + _classCallCheck(this, PushButtonWidgetAnnotationElement); -class RadioButtonWidgetAnnotationElement extends WidgetAnnotationElement { - constructor(parameters) { - super(parameters, parameters.renderInteractiveForms); + return _super7.apply(this, arguments); } - render() { - this.container.className = "buttonWidgetAnnotation radioButton"; - const element = document.createElement("input"); - element.disabled = this.data.readOnly; - element.type = "radio"; - element.name = this.data.fieldName; + _createClass(PushButtonWidgetAnnotationElement, [{ + key: "render", + value: function render() { + var container = _get(_getPrototypeOf(PushButtonWidgetAnnotationElement.prototype), "render", this).call(this); - if (this.data.fieldValue === this.data.buttonValue) { - element.setAttribute("checked", true); + container.className = "buttonWidgetAnnotation pushButton"; + return container; } + }]); - this.container.appendChild(element); - return this.container; - } + return PushButtonWidgetAnnotationElement; +}(LinkAnnotationElement); -} +var ChoiceWidgetAnnotationElement = /*#__PURE__*/function (_WidgetAnnotationElem4) { + _inherits(ChoiceWidgetAnnotationElement, _WidgetAnnotationElem4); -class PushButtonWidgetAnnotationElement extends LinkAnnotationElement { - render() { - const container = super.render(); - container.className = "buttonWidgetAnnotation pushButton"; - return container; - } + var _super8 = _createSuper(ChoiceWidgetAnnotationElement); -} + function ChoiceWidgetAnnotationElement(parameters) { + _classCallCheck(this, ChoiceWidgetAnnotationElement); -class ChoiceWidgetAnnotationElement extends WidgetAnnotationElement { - constructor(parameters) { - super(parameters, parameters.renderInteractiveForms); + return _super8.call(this, parameters, parameters.renderInteractiveForms); } - render() { - this.container.className = "choiceWidgetAnnotation"; - const selectElement = document.createElement("select"); - selectElement.disabled = this.data.readOnly; - selectElement.name = this.data.fieldName; + _createClass(ChoiceWidgetAnnotationElement, [{ + key: "render", + value: function render() { + this.container.className = "choiceWidgetAnnotation"; + var selectElement = document.createElement("select"); + selectElement.disabled = this.data.readOnly; + selectElement.name = this.data.fieldName; - if (!this.data.combo) { - selectElement.size = this.data.options.length; + if (!this.data.combo) { + selectElement.size = this.data.options.length; - if (this.data.multiSelect) { - selectElement.multiple = true; + if (this.data.multiSelect) { + selectElement.multiple = true; + } } - } - for (const option of this.data.options) { - const optionElement = document.createElement("option"); - optionElement.textContent = option.displayValue; - optionElement.value = option.exportValue; + var _iterator = _createForOfIteratorHelper(this.data.options), + _step; - if (this.data.fieldValue.includes(option.displayValue)) { - optionElement.setAttribute("selected", true); + try { + for (_iterator.s(); !(_step = _iterator.n()).done;) { + var option = _step.value; + var optionElement = document.createElement("option"); + optionElement.textContent = option.displayValue; + optionElement.value = option.exportValue; + + if (this.data.fieldValue.includes(option.displayValue)) { + optionElement.setAttribute("selected", true); + } + + selectElement.appendChild(optionElement); + } + } catch (err) { + _iterator.e(err); + } finally { + _iterator.f(); } - selectElement.appendChild(optionElement); + this.container.appendChild(selectElement); + return this.container; } + }]); - this.container.appendChild(selectElement); - return this.container; - } + return ChoiceWidgetAnnotationElement; +}(WidgetAnnotationElement); -} +var PopupAnnotationElement = /*#__PURE__*/function (_AnnotationElement4) { + _inherits(PopupAnnotationElement, _AnnotationElement4); + + var _super9 = _createSuper(PopupAnnotationElement); + + function PopupAnnotationElement(parameters) { + _classCallCheck(this, PopupAnnotationElement); -class PopupAnnotationElement extends AnnotationElement { - constructor(parameters) { - const isRenderable = !!(parameters.data.title || parameters.data.contents); - super(parameters, isRenderable); + var isRenderable = !!(parameters.data.title || parameters.data.contents); + return _super9.call(this, parameters, isRenderable); } - render() { - const IGNORE_TYPES = ["Line", "Square", "Circle", "PolyLine", "Polygon", "Ink"]; - this.container.className = "popupAnnotation"; + _createClass(PopupAnnotationElement, [{ + key: "render", + value: function render() { + var IGNORE_TYPES = ["Line", "Square", "Circle", "PolyLine", "Polygon", "Ink"]; + this.container.className = "popupAnnotation"; - if (IGNORE_TYPES.includes(this.data.parentType)) { - return this.container; - } + if (IGNORE_TYPES.includes(this.data.parentType)) { + return this.container; + } - const selector = `[data-annotation-id="${this.data.parentId}"]`; - const parentElement = this.layer.querySelector(selector); + var selector = "[data-annotation-id=\"".concat(this.data.parentId, "\"]"); + var parentElement = this.layer.querySelector(selector); - if (!parentElement) { + if (!parentElement) { + return this.container; + } + + var popup = new PopupElement({ + container: this.container, + trigger: parentElement, + color: this.data.color, + title: this.data.title, + modificationDate: this.data.modificationDate, + contents: this.data.contents + }); + var parentLeft = parseFloat(parentElement.style.left); + var parentWidth = parseFloat(parentElement.style.width); + this.container.style.transformOrigin = "-".concat(parentLeft + parentWidth, "px -").concat(parentElement.style.top); + this.container.style.left = "".concat(parentLeft + parentWidth, "px"); + this.container.appendChild(popup.render()); return this.container; } + }]); - const popup = new PopupElement({ - container: this.container, - trigger: parentElement, - color: this.data.color, - title: this.data.title, - modificationDate: this.data.modificationDate, - contents: this.data.contents - }); - const parentLeft = parseFloat(parentElement.style.left); - const parentWidth = parseFloat(parentElement.style.width); - this.container.style.transformOrigin = `-${parentLeft + parentWidth}px -${parentElement.style.top}`; - this.container.style.left = `${parentLeft + parentWidth}px`; - this.container.appendChild(popup.render()); - return this.container; - } + return PopupAnnotationElement; +}(AnnotationElement); -} +var PopupElement = /*#__PURE__*/function () { + function PopupElement(parameters) { + _classCallCheck(this, PopupElement); -class PopupElement { - constructor(parameters) { this.container = parameters.container; this.trigger = parameters.trigger; this.color = parameters.color; @@ -9166,510 +20502,733 @@ class PopupElement { this.pinned = false; } - render() { - const BACKGROUND_ENLIGHT = 0.7; - const wrapper = document.createElement("div"); - wrapper.className = "popupWrapper"; - this.hideElement = this.hideWrapper ? wrapper : this.container; - this.hideElement.setAttribute("hidden", true); - const popup = document.createElement("div"); - popup.className = "popup"; - const color = this.color; - - if (color) { - const r = BACKGROUND_ENLIGHT * (255 - color[0]) + color[0]; - const g = BACKGROUND_ENLIGHT * (255 - color[1]) + color[1]; - const b = BACKGROUND_ENLIGHT * (255 - color[2]) + color[2]; - popup.style.backgroundColor = _util.Util.makeCssRgb(r | 0, g | 0, b | 0); - } - - const title = document.createElement("h1"); - title.textContent = this.title; - popup.appendChild(title); - - const dateObject = _display_utils.PDFDateString.toDateObject(this.modificationDate); - - if (dateObject) { - const modificationDate = document.createElement("span"); - modificationDate.textContent = "{{date}}, {{time}}"; - modificationDate.dataset.l10nId = "annotation_date_string"; - modificationDate.dataset.l10nArgs = JSON.stringify({ - date: dateObject.toLocaleDateString(), - time: dateObject.toLocaleTimeString() - }); - popup.appendChild(modificationDate); - } - - const contents = this._formatContents(this.contents); + _createClass(PopupElement, [{ + key: "render", + value: function render() { + var BACKGROUND_ENLIGHT = 0.7; + var wrapper = document.createElement("div"); + wrapper.className = "popupWrapper"; + this.hideElement = this.hideWrapper ? wrapper : this.container; + this.hideElement.setAttribute("hidden", true); + var popup = document.createElement("div"); + popup.className = "popup"; + var color = this.color; - popup.appendChild(contents); - this.trigger.addEventListener("click", this._toggle.bind(this)); - this.trigger.addEventListener("mouseover", this._show.bind(this, false)); - this.trigger.addEventListener("mouseout", this._hide.bind(this, false)); - popup.addEventListener("click", this._hide.bind(this, true)); - wrapper.appendChild(popup); - return wrapper; - } + if (color) { + var r = BACKGROUND_ENLIGHT * (255 - color[0]) + color[0]; + var g = BACKGROUND_ENLIGHT * (255 - color[1]) + color[1]; + var b = BACKGROUND_ENLIGHT * (255 - color[2]) + color[2]; + popup.style.backgroundColor = _util.Util.makeCssRgb(r | 0, g | 0, b | 0); + } - _formatContents(contents) { - const p = document.createElement("p"); - const lines = contents.split(/(?:\r\n?|\n)/); + var title = document.createElement("h1"); + title.textContent = this.title; + popup.appendChild(title); - for (let i = 0, ii = lines.length; i < ii; ++i) { - const line = lines[i]; - p.appendChild(document.createTextNode(line)); + var dateObject = _display_utils.PDFDateString.toDateObject(this.modificationDate); - if (i < ii - 1) { - p.appendChild(document.createElement("br")); + if (dateObject) { + var modificationDate = document.createElement("span"); + modificationDate.textContent = "{{date}}, {{time}}"; + modificationDate.dataset.l10nId = "annotation_date_string"; + modificationDate.dataset.l10nArgs = JSON.stringify({ + date: dateObject.toLocaleDateString(), + time: dateObject.toLocaleTimeString() + }); + popup.appendChild(modificationDate); } - } - return p; - } + var contents = this._formatContents(this.contents); - _toggle() { - if (this.pinned) { - this._hide(true); - } else { - this._show(true); + popup.appendChild(contents); + this.trigger.addEventListener("click", this._toggle.bind(this)); + this.trigger.addEventListener("mouseover", this._show.bind(this, false)); + this.trigger.addEventListener("mouseout", this._hide.bind(this, false)); + popup.addEventListener("click", this._hide.bind(this, true)); + wrapper.appendChild(popup); + return wrapper; } - } + }, { + key: "_formatContents", + value: function _formatContents(contents) { + var p = document.createElement("p"); + var lines = contents.split(/(?:\r\n?|\n)/); - _show(pin = false) { - if (pin) { - this.pinned = true; - } + for (var i = 0, ii = lines.length; i < ii; ++i) { + var line = lines[i]; + p.appendChild(document.createTextNode(line)); - if (this.hideElement.hasAttribute("hidden")) { - this.hideElement.removeAttribute("hidden"); - this.container.style.zIndex += 1; - } - } + if (i < ii - 1) { + p.appendChild(document.createElement("br")); + } + } - _hide(unpin = true) { - if (unpin) { - this.pinned = false; + return p; } - - if (!this.hideElement.hasAttribute("hidden") && !this.pinned) { - this.hideElement.setAttribute("hidden", true); - this.container.style.zIndex -= 1; + }, { + key: "_toggle", + value: function _toggle() { + if (this.pinned) { + this._hide(true); + } else { + this._show(true); + } } - } + }, { + key: "_show", + value: function _show() { + var pin = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; -} + if (pin) { + this.pinned = true; + } -class FreeTextAnnotationElement extends AnnotationElement { - constructor(parameters) { - const isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents); - super(parameters, isRenderable, true); - } + if (this.hideElement.hasAttribute("hidden")) { + this.hideElement.removeAttribute("hidden"); + this.container.style.zIndex += 1; + } + } + }, { + key: "_hide", + value: function _hide() { + var unpin = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true; - render() { - this.container.className = "freeTextAnnotation"; + if (unpin) { + this.pinned = false; + } - if (!this.data.hasPopup) { - this._createPopup(this.container, null, this.data); + if (!this.hideElement.hasAttribute("hidden") && !this.pinned) { + this.hideElement.setAttribute("hidden", true); + this.container.style.zIndex -= 1; + } } + }]); - return this.container; - } + return PopupElement; +}(); -} +var FreeTextAnnotationElement = /*#__PURE__*/function (_AnnotationElement5) { + _inherits(FreeTextAnnotationElement, _AnnotationElement5); + + var _super10 = _createSuper(FreeTextAnnotationElement); -class LineAnnotationElement extends AnnotationElement { - constructor(parameters) { - const isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents); - super(parameters, isRenderable, true); + function FreeTextAnnotationElement(parameters) { + _classCallCheck(this, FreeTextAnnotationElement); + + var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents); + return _super10.call(this, parameters, isRenderable, true); } - render() { - this.container.className = "lineAnnotation"; - const data = this.data; - const width = data.rect[2] - data.rect[0]; - const height = data.rect[3] - data.rect[1]; - const svg = this.svgFactory.create(width, height); - const line = this.svgFactory.createElement("svg:line"); - line.setAttribute("x1", data.rect[2] - data.lineCoordinates[0]); - line.setAttribute("y1", data.rect[3] - data.lineCoordinates[1]); - line.setAttribute("x2", data.rect[2] - data.lineCoordinates[2]); - line.setAttribute("y2", data.rect[3] - data.lineCoordinates[3]); - line.setAttribute("stroke-width", data.borderStyle.width || 1); - line.setAttribute("stroke", "transparent"); - svg.appendChild(line); - this.container.append(svg); + _createClass(FreeTextAnnotationElement, [{ + key: "render", + value: function render() { + this.container.className = "freeTextAnnotation"; - this._createPopup(this.container, line, data); + if (!this.data.hasPopup) { + this._createPopup(this.container, null, this.data); + } - return this.container; - } + return this.container; + } + }]); -} + return FreeTextAnnotationElement; +}(AnnotationElement); -class SquareAnnotationElement extends AnnotationElement { - constructor(parameters) { - const isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents); - super(parameters, isRenderable, true); - } +var LineAnnotationElement = /*#__PURE__*/function (_AnnotationElement6) { + _inherits(LineAnnotationElement, _AnnotationElement6); - render() { - this.container.className = "squareAnnotation"; - const data = this.data; - const width = data.rect[2] - data.rect[0]; - const height = data.rect[3] - data.rect[1]; - const svg = this.svgFactory.create(width, height); - const borderWidth = data.borderStyle.width; - const square = this.svgFactory.createElement("svg:rect"); - square.setAttribute("x", borderWidth / 2); - square.setAttribute("y", borderWidth / 2); - square.setAttribute("width", width - borderWidth); - square.setAttribute("height", height - borderWidth); - square.setAttribute("stroke-width", borderWidth || 1); - square.setAttribute("stroke", "transparent"); - square.setAttribute("fill", "none"); - svg.appendChild(square); - this.container.append(svg); + var _super11 = _createSuper(LineAnnotationElement); - this._createPopup(this.container, square, data); + function LineAnnotationElement(parameters) { + _classCallCheck(this, LineAnnotationElement); - return this.container; + var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents); + return _super11.call(this, parameters, isRenderable, true); } -} + _createClass(LineAnnotationElement, [{ + key: "render", + value: function render() { + this.container.className = "lineAnnotation"; + var data = this.data; + var width = data.rect[2] - data.rect[0]; + var height = data.rect[3] - data.rect[1]; + var svg = this.svgFactory.create(width, height); + var line = this.svgFactory.createElement("svg:line"); + line.setAttribute("x1", data.rect[2] - data.lineCoordinates[0]); + line.setAttribute("y1", data.rect[3] - data.lineCoordinates[1]); + line.setAttribute("x2", data.rect[2] - data.lineCoordinates[2]); + line.setAttribute("y2", data.rect[3] - data.lineCoordinates[3]); + line.setAttribute("stroke-width", data.borderStyle.width || 1); + line.setAttribute("stroke", "transparent"); + svg.appendChild(line); + this.container.append(svg); -class CircleAnnotationElement extends AnnotationElement { - constructor(parameters) { - const isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents); - super(parameters, isRenderable, true); - } + this._createPopup(this.container, line, data); + + return this.container; + } + }]); - render() { - this.container.className = "circleAnnotation"; - const data = this.data; - const width = data.rect[2] - data.rect[0]; - const height = data.rect[3] - data.rect[1]; - const svg = this.svgFactory.create(width, height); - const borderWidth = data.borderStyle.width; - const circle = this.svgFactory.createElement("svg:ellipse"); - circle.setAttribute("cx", width / 2); - circle.setAttribute("cy", height / 2); - circle.setAttribute("rx", width / 2 - borderWidth / 2); - circle.setAttribute("ry", height / 2 - borderWidth / 2); - circle.setAttribute("stroke-width", borderWidth || 1); - circle.setAttribute("stroke", "transparent"); - circle.setAttribute("fill", "none"); - svg.appendChild(circle); - this.container.append(svg); + return LineAnnotationElement; +}(AnnotationElement); - this._createPopup(this.container, circle, data); +var SquareAnnotationElement = /*#__PURE__*/function (_AnnotationElement7) { + _inherits(SquareAnnotationElement, _AnnotationElement7); - return this.container; - } + var _super12 = _createSuper(SquareAnnotationElement); -} + function SquareAnnotationElement(parameters) { + _classCallCheck(this, SquareAnnotationElement); -class PolylineAnnotationElement extends AnnotationElement { - constructor(parameters) { - const isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents); - super(parameters, isRenderable, true); - this.containerClassName = "polylineAnnotation"; - this.svgElementName = "svg:polyline"; + var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents); + return _super12.call(this, parameters, isRenderable, true); } - render() { - this.container.className = this.containerClassName; - const data = this.data; - const width = data.rect[2] - data.rect[0]; - const height = data.rect[3] - data.rect[1]; - const svg = this.svgFactory.create(width, height); - let points = []; + _createClass(SquareAnnotationElement, [{ + key: "render", + value: function render() { + this.container.className = "squareAnnotation"; + var data = this.data; + var width = data.rect[2] - data.rect[0]; + var height = data.rect[3] - data.rect[1]; + var svg = this.svgFactory.create(width, height); + var borderWidth = data.borderStyle.width; + var square = this.svgFactory.createElement("svg:rect"); + square.setAttribute("x", borderWidth / 2); + square.setAttribute("y", borderWidth / 2); + square.setAttribute("width", width - borderWidth); + square.setAttribute("height", height - borderWidth); + square.setAttribute("stroke-width", borderWidth || 1); + square.setAttribute("stroke", "transparent"); + square.setAttribute("fill", "none"); + svg.appendChild(square); + this.container.append(svg); + + this._createPopup(this.container, square, data); - for (const coordinate of data.vertices) { - const x = coordinate.x - data.rect[0]; - const y = data.rect[3] - coordinate.y; - points.push(x + "," + y); + return this.container; } + }]); - points = points.join(" "); - const polyline = this.svgFactory.createElement(this.svgElementName); - polyline.setAttribute("points", points); - polyline.setAttribute("stroke-width", data.borderStyle.width || 1); - polyline.setAttribute("stroke", "transparent"); - polyline.setAttribute("fill", "none"); - svg.appendChild(polyline); - this.container.append(svg); + return SquareAnnotationElement; +}(AnnotationElement); - this._createPopup(this.container, polyline, data); +var CircleAnnotationElement = /*#__PURE__*/function (_AnnotationElement8) { + _inherits(CircleAnnotationElement, _AnnotationElement8); - return this.container; - } + var _super13 = _createSuper(CircleAnnotationElement); -} + function CircleAnnotationElement(parameters) { + _classCallCheck(this, CircleAnnotationElement); -class PolygonAnnotationElement extends PolylineAnnotationElement { - constructor(parameters) { - super(parameters); - this.containerClassName = "polygonAnnotation"; - this.svgElementName = "svg:polygon"; + var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents); + return _super13.call(this, parameters, isRenderable, true); } -} - -class CaretAnnotationElement extends AnnotationElement { - constructor(parameters) { - const isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents); - super(parameters, isRenderable, true); - } + _createClass(CircleAnnotationElement, [{ + key: "render", + value: function render() { + this.container.className = "circleAnnotation"; + var data = this.data; + var width = data.rect[2] - data.rect[0]; + var height = data.rect[3] - data.rect[1]; + var svg = this.svgFactory.create(width, height); + var borderWidth = data.borderStyle.width; + var circle = this.svgFactory.createElement("svg:ellipse"); + circle.setAttribute("cx", width / 2); + circle.setAttribute("cy", height / 2); + circle.setAttribute("rx", width / 2 - borderWidth / 2); + circle.setAttribute("ry", height / 2 - borderWidth / 2); + circle.setAttribute("stroke-width", borderWidth || 1); + circle.setAttribute("stroke", "transparent"); + circle.setAttribute("fill", "none"); + svg.appendChild(circle); + this.container.append(svg); - render() { - this.container.className = "caretAnnotation"; + this._createPopup(this.container, circle, data); - if (!this.data.hasPopup) { - this._createPopup(this.container, null, this.data); + return this.container; } + }]); - return this.container; - } + return CircleAnnotationElement; +}(AnnotationElement); -} +var PolylineAnnotationElement = /*#__PURE__*/function (_AnnotationElement9) { + _inherits(PolylineAnnotationElement, _AnnotationElement9); + + var _super14 = _createSuper(PolylineAnnotationElement); + + function PolylineAnnotationElement(parameters) { + var _this3; -class InkAnnotationElement extends AnnotationElement { - constructor(parameters) { - const isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents); - super(parameters, isRenderable, true); - this.containerClassName = "inkAnnotation"; - this.svgElementName = "svg:polyline"; + _classCallCheck(this, PolylineAnnotationElement); + + var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents); + _this3 = _super14.call(this, parameters, isRenderable, true); + _this3.containerClassName = "polylineAnnotation"; + _this3.svgElementName = "svg:polyline"; + return _this3; } - render() { - this.container.className = this.containerClassName; - const data = this.data; - const width = data.rect[2] - data.rect[0]; - const height = data.rect[3] - data.rect[1]; - const svg = this.svgFactory.create(width, height); + _createClass(PolylineAnnotationElement, [{ + key: "render", + value: function render() { + this.container.className = this.containerClassName; + var data = this.data; + var width = data.rect[2] - data.rect[0]; + var height = data.rect[3] - data.rect[1]; + var svg = this.svgFactory.create(width, height); + var points = []; - for (const inkList of data.inkLists) { - let points = []; + var _iterator2 = _createForOfIteratorHelper(data.vertices), + _step2; - for (const coordinate of inkList) { - const x = coordinate.x - data.rect[0]; - const y = data.rect[3] - coordinate.y; - points.push(`${x},${y}`); + try { + for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) { + var coordinate = _step2.value; + var x = coordinate.x - data.rect[0]; + var y = data.rect[3] - coordinate.y; + points.push(x + "," + y); + } + } catch (err) { + _iterator2.e(err); + } finally { + _iterator2.f(); } points = points.join(" "); - const polyline = this.svgFactory.createElement(this.svgElementName); + var polyline = this.svgFactory.createElement(this.svgElementName); polyline.setAttribute("points", points); polyline.setAttribute("stroke-width", data.borderStyle.width || 1); polyline.setAttribute("stroke", "transparent"); polyline.setAttribute("fill", "none"); + svg.appendChild(polyline); + this.container.append(svg); this._createPopup(this.container, polyline, data); - svg.appendChild(polyline); + return this.container; } + }]); + + return PolylineAnnotationElement; +}(AnnotationElement); + +var PolygonAnnotationElement = /*#__PURE__*/function (_PolylineAnnotationEl) { + _inherits(PolygonAnnotationElement, _PolylineAnnotationEl); + + var _super15 = _createSuper(PolygonAnnotationElement); + + function PolygonAnnotationElement(parameters) { + var _this4; - this.container.append(svg); - return this.container; + _classCallCheck(this, PolygonAnnotationElement); + + _this4 = _super15.call(this, parameters); + _this4.containerClassName = "polygonAnnotation"; + _this4.svgElementName = "svg:polygon"; + return _this4; } -} + return PolygonAnnotationElement; +}(PolylineAnnotationElement); + +var CaretAnnotationElement = /*#__PURE__*/function (_AnnotationElement10) { + _inherits(CaretAnnotationElement, _AnnotationElement10); + + var _super16 = _createSuper(CaretAnnotationElement); + + function CaretAnnotationElement(parameters) { + _classCallCheck(this, CaretAnnotationElement); -class HighlightAnnotationElement extends AnnotationElement { - constructor(parameters) { - const isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents); - super(parameters, isRenderable, true); + var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents); + return _super16.call(this, parameters, isRenderable, true); } - render() { - this.container.className = "highlightAnnotation"; + _createClass(CaretAnnotationElement, [{ + key: "render", + value: function render() { + this.container.className = "caretAnnotation"; - if (!this.data.hasPopup) { - this._createPopup(this.container, null, this.data); + if (!this.data.hasPopup) { + this._createPopup(this.container, null, this.data); + } + + return this.container; } + }]); - return this.container; - } + return CaretAnnotationElement; +}(AnnotationElement); -} +var InkAnnotationElement = /*#__PURE__*/function (_AnnotationElement11) { + _inherits(InkAnnotationElement, _AnnotationElement11); + + var _super17 = _createSuper(InkAnnotationElement); -class UnderlineAnnotationElement extends AnnotationElement { - constructor(parameters) { - const isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents); - super(parameters, isRenderable, true); + function InkAnnotationElement(parameters) { + var _this5; + + _classCallCheck(this, InkAnnotationElement); + + var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents); + _this5 = _super17.call(this, parameters, isRenderable, true); + _this5.containerClassName = "inkAnnotation"; + _this5.svgElementName = "svg:polyline"; + return _this5; } - render() { - this.container.className = "underlineAnnotation"; + _createClass(InkAnnotationElement, [{ + key: "render", + value: function render() { + this.container.className = this.containerClassName; + var data = this.data; + var width = data.rect[2] - data.rect[0]; + var height = data.rect[3] - data.rect[1]; + var svg = this.svgFactory.create(width, height); + + var _iterator3 = _createForOfIteratorHelper(data.inkLists), + _step3; + + try { + for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) { + var inkList = _step3.value; + var points = []; + + var _iterator4 = _createForOfIteratorHelper(inkList), + _step4; + + try { + for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) { + var coordinate = _step4.value; + var x = coordinate.x - data.rect[0]; + var y = data.rect[3] - coordinate.y; + points.push("".concat(x, ",").concat(y)); + } + } catch (err) { + _iterator4.e(err); + } finally { + _iterator4.f(); + } + + points = points.join(" "); + var polyline = this.svgFactory.createElement(this.svgElementName); + polyline.setAttribute("points", points); + polyline.setAttribute("stroke-width", data.borderStyle.width || 1); + polyline.setAttribute("stroke", "transparent"); + polyline.setAttribute("fill", "none"); + + this._createPopup(this.container, polyline, data); + + svg.appendChild(polyline); + } + } catch (err) { + _iterator3.e(err); + } finally { + _iterator3.f(); + } - if (!this.data.hasPopup) { - this._createPopup(this.container, null, this.data); + this.container.append(svg); + return this.container; } + }]); - return this.container; - } + return InkAnnotationElement; +}(AnnotationElement); -} +var HighlightAnnotationElement = /*#__PURE__*/function (_AnnotationElement12) { + _inherits(HighlightAnnotationElement, _AnnotationElement12); -class SquigglyAnnotationElement extends AnnotationElement { - constructor(parameters) { - const isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents); - super(parameters, isRenderable, true); + var _super18 = _createSuper(HighlightAnnotationElement); + + function HighlightAnnotationElement(parameters) { + _classCallCheck(this, HighlightAnnotationElement); + + var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents); + return _super18.call(this, parameters, isRenderable, true); } - render() { - this.container.className = "squigglyAnnotation"; + _createClass(HighlightAnnotationElement, [{ + key: "render", + value: function render() { + this.container.className = "highlightAnnotation"; - if (!this.data.hasPopup) { - this._createPopup(this.container, null, this.data); + if (!this.data.hasPopup) { + this._createPopup(this.container, null, this.data); + } + + return this.container; } + }]); - return this.container; - } + return HighlightAnnotationElement; +}(AnnotationElement); -} +var UnderlineAnnotationElement = /*#__PURE__*/function (_AnnotationElement13) { + _inherits(UnderlineAnnotationElement, _AnnotationElement13); + + var _super19 = _createSuper(UnderlineAnnotationElement); -class StrikeOutAnnotationElement extends AnnotationElement { - constructor(parameters) { - const isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents); - super(parameters, isRenderable, true); + function UnderlineAnnotationElement(parameters) { + _classCallCheck(this, UnderlineAnnotationElement); + + var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents); + return _super19.call(this, parameters, isRenderable, true); } - render() { - this.container.className = "strikeoutAnnotation"; + _createClass(UnderlineAnnotationElement, [{ + key: "render", + value: function render() { + this.container.className = "underlineAnnotation"; + + if (!this.data.hasPopup) { + this._createPopup(this.container, null, this.data); + } - if (!this.data.hasPopup) { - this._createPopup(this.container, null, this.data); + return this.container; } + }]); - return this.container; - } + return UnderlineAnnotationElement; +}(AnnotationElement); -} +var SquigglyAnnotationElement = /*#__PURE__*/function (_AnnotationElement14) { + _inherits(SquigglyAnnotationElement, _AnnotationElement14); + + var _super20 = _createSuper(SquigglyAnnotationElement); + + function SquigglyAnnotationElement(parameters) { + _classCallCheck(this, SquigglyAnnotationElement); -class StampAnnotationElement extends AnnotationElement { - constructor(parameters) { - const isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents); - super(parameters, isRenderable, true); + var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents); + return _super20.call(this, parameters, isRenderable, true); } - render() { - this.container.className = "stampAnnotation"; + _createClass(SquigglyAnnotationElement, [{ + key: "render", + value: function render() { + this.container.className = "squigglyAnnotation"; + + if (!this.data.hasPopup) { + this._createPopup(this.container, null, this.data); + } - if (!this.data.hasPopup) { - this._createPopup(this.container, null, this.data); + return this.container; } + }]); + + return SquigglyAnnotationElement; +}(AnnotationElement); + +var StrikeOutAnnotationElement = /*#__PURE__*/function (_AnnotationElement15) { + _inherits(StrikeOutAnnotationElement, _AnnotationElement15); - return this.container; + var _super21 = _createSuper(StrikeOutAnnotationElement); + + function StrikeOutAnnotationElement(parameters) { + _classCallCheck(this, StrikeOutAnnotationElement); + + var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents); + return _super21.call(this, parameters, isRenderable, true); } -} + _createClass(StrikeOutAnnotationElement, [{ + key: "render", + value: function render() { + this.container.className = "strikeoutAnnotation"; -class FileAttachmentAnnotationElement extends AnnotationElement { - constructor(parameters) { - super(parameters, true); - const { - filename, - content - } = this.data.file; - this.filename = (0, _display_utils.getFilenameFromUrl)(filename); - this.content = content; - - if (this.linkService.eventBus) { - this.linkService.eventBus.dispatch("fileattachmentannotation", { - source: this, - id: (0, _util.stringToPDFString)(filename), - filename, - content - }); + if (!this.data.hasPopup) { + this._createPopup(this.container, null, this.data); + } + + return this.container; } + }]); + + return StrikeOutAnnotationElement; +}(AnnotationElement); + +var StampAnnotationElement = /*#__PURE__*/function (_AnnotationElement16) { + _inherits(StampAnnotationElement, _AnnotationElement16); + + var _super22 = _createSuper(StampAnnotationElement); + + function StampAnnotationElement(parameters) { + _classCallCheck(this, StampAnnotationElement); + + var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents); + return _super22.call(this, parameters, isRenderable, true); } - render() { - this.container.className = "fileAttachmentAnnotation"; - const trigger = document.createElement("div"); - trigger.style.height = this.container.style.height; - trigger.style.width = this.container.style.width; - trigger.addEventListener("dblclick", this._download.bind(this)); + _createClass(StampAnnotationElement, [{ + key: "render", + value: function render() { + this.container.className = "stampAnnotation"; - if (!this.data.hasPopup && (this.data.title || this.data.contents)) { - this._createPopup(this.container, trigger, this.data); + if (!this.data.hasPopup) { + this._createPopup(this.container, null, this.data); + } + + return this.container; } + }]); - this.container.appendChild(trigger); - return this.container; - } + return StampAnnotationElement; +}(AnnotationElement); - _download() { - if (!this.downloadManager) { - (0, _util.warn)("Download cannot be started due to unavailable download manager"); - return; +var FileAttachmentAnnotationElement = /*#__PURE__*/function (_AnnotationElement17) { + _inherits(FileAttachmentAnnotationElement, _AnnotationElement17); + + var _super23 = _createSuper(FileAttachmentAnnotationElement); + + function FileAttachmentAnnotationElement(parameters) { + var _this6; + + _classCallCheck(this, FileAttachmentAnnotationElement); + + _this6 = _super23.call(this, parameters, true); + var _this6$data$file = _this6.data.file, + filename = _this6$data$file.filename, + content = _this6$data$file.content; + _this6.filename = (0, _display_utils.getFilenameFromUrl)(filename); + _this6.content = content; + + if (_this6.linkService.eventBus) { + _this6.linkService.eventBus.dispatch("fileattachmentannotation", { + source: _assertThisInitialized(_this6), + id: (0, _util.stringToPDFString)(filename), + filename: filename, + content: content + }); } - this.downloadManager.downloadData(this.content, this.filename, ""); + return _this6; } -} + _createClass(FileAttachmentAnnotationElement, [{ + key: "render", + value: function render() { + this.container.className = "fileAttachmentAnnotation"; + var trigger = document.createElement("div"); + trigger.style.height = this.container.style.height; + trigger.style.width = this.container.style.width; + trigger.addEventListener("dblclick", this._download.bind(this)); -class AnnotationLayer { - static render(parameters) { - const sortedAnnotations = [], - popupAnnotations = []; - - for (const data of parameters.annotations) { - if (!data) { - continue; + if (!this.data.hasPopup && (this.data.title || this.data.contents)) { + this._createPopup(this.container, trigger, this.data); } - if (data.annotationType === _util.AnnotationType.POPUP) { - popupAnnotations.push(data); - continue; + this.container.appendChild(trigger); + return this.container; + } + }, { + key: "_download", + value: function _download() { + if (!this.downloadManager) { + (0, _util.warn)("Download cannot be started due to unavailable download manager"); + return; } - sortedAnnotations.push(data); + this.downloadManager.downloadData(this.content, this.filename, ""); } + }]); - if (popupAnnotations.length) { - sortedAnnotations.push(...popupAnnotations); - } + return FileAttachmentAnnotationElement; +}(AnnotationElement); - for (const data of sortedAnnotations) { - const element = AnnotationElementFactory.create({ - data, - layer: parameters.div, - page: parameters.page, - viewport: parameters.viewport, - linkService: parameters.linkService, - downloadManager: parameters.downloadManager, - imageResourcesPath: parameters.imageResourcesPath || "", - renderInteractiveForms: parameters.renderInteractiveForms || false, - svgFactory: new _display_utils.DOMSVGFactory() - }); +var AnnotationLayer = /*#__PURE__*/function () { + function AnnotationLayer() { + _classCallCheck(this, AnnotationLayer); + } + + _createClass(AnnotationLayer, null, [{ + key: "render", + value: function render(parameters) { + var sortedAnnotations = [], + popupAnnotations = []; + + var _iterator5 = _createForOfIteratorHelper(parameters.annotations), + _step5; - if (element.isRenderable) { - parameters.div.appendChild(element.render()); + try { + for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) { + var _data = _step5.value; + + if (!_data) { + continue; + } + + if (_data.annotationType === _util.AnnotationType.POPUP) { + popupAnnotations.push(_data); + continue; + } + + sortedAnnotations.push(_data); + } + } catch (err) { + _iterator5.e(err); + } finally { + _iterator5.f(); + } + + if (popupAnnotations.length) { + sortedAnnotations.push.apply(sortedAnnotations, popupAnnotations); + } + + for (var _i = 0, _sortedAnnotations = sortedAnnotations; _i < _sortedAnnotations.length; _i++) { + var data = _sortedAnnotations[_i]; + var element = AnnotationElementFactory.create({ + data: data, + layer: parameters.div, + page: parameters.page, + viewport: parameters.viewport, + linkService: parameters.linkService, + downloadManager: parameters.downloadManager, + imageResourcesPath: parameters.imageResourcesPath || "", + renderInteractiveForms: parameters.renderInteractiveForms || false, + svgFactory: new _display_utils.DOMSVGFactory() + }); + + if (element.isRenderable) { + parameters.div.appendChild(element.render()); + } } } - } + }, { + key: "update", + value: function update(parameters) { + var _iterator6 = _createForOfIteratorHelper(parameters.annotations), + _step6; - static update(parameters) { - for (const data of parameters.annotations) { - const element = parameters.div.querySelector(`[data-annotation-id="${data.id}"]`); + try { + for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) { + var data = _step6.value; + var element = parameters.div.querySelector("[data-annotation-id=\"".concat(data.id, "\"]")); - if (element) { - element.style.transform = `matrix(${parameters.viewport.transform.join(",")})`; + if (element) { + element.style.transform = "matrix(".concat(parameters.viewport.transform.join(","), ")"); + } + } + } catch (err) { + _iterator6.e(err); + } finally { + _iterator6.f(); } - } - parameters.div.removeAttribute("hidden"); - } + parameters.div.removeAttribute("hidden"); + } + }]); -} + return AnnotationLayer; +}(); exports.AnnotationLayer = AnnotationLayer; /***/ }), -/* 17 */ +/* 210 */ /***/ (function(module, exports, __w_pdfjs_require__) { "use strict"; @@ -9680,7 +21239,7 @@ Object.defineProperty(exports, "__esModule", { }); exports.renderTextLayer = void 0; -var _util = __w_pdfjs_require__(2); +var _util = __w_pdfjs_require__(5); var renderTextLayer = function renderTextLayerClosure() { var MAX_TEXT_DIVS_TO_RENDER = 100000; @@ -9732,7 +21291,7 @@ var renderTextLayer = function renderTextLayerClosure() { fontAscent = (1 + style.descent) * fontAscent; } - let left, top; + var left, top; if (angle === 0) { left = tx[4]; @@ -9742,9 +21301,9 @@ var renderTextLayer = function renderTextLayerClosure() { top = tx[5] - fontAscent * Math.cos(angle); } - textDiv.style.left = `${left}px`; - textDiv.style.top = `${top}px`; - textDiv.style.fontSize = `${fontHeight}px`; + textDiv.style.left = "".concat(left, "px"); + textDiv.style.top = "".concat(top, "px"); + textDiv.style.fontSize = "".concat(fontHeight, "px"); textDiv.style.fontFamily = style.fontFamily; textDiv.textContent = geom.str; @@ -9756,13 +21315,13 @@ var renderTextLayer = function renderTextLayerClosure() { textDivProperties.angle = angle * (180 / Math.PI); } - let shouldScaleText = false; + var shouldScaleText = false; if (geom.str.length > 1) { shouldScaleText = true; } else if (geom.transform[0] !== geom.transform[3]) { - const absScaleX = Math.abs(geom.transform[0]), - absScaleY = Math.abs(geom.transform[3]); + var absScaleX = Math.abs(geom.transform[0]), + absScaleY = Math.abs(geom.transform[3]); if (absScaleX !== absScaleY && Math.max(absScaleX, absScaleY) / Math.min(absScaleX, absScaleY) > 1.5) { shouldScaleText = true; @@ -9810,7 +21369,7 @@ var renderTextLayer = function renderTextLayerClosure() { bottom: b[3], div: textDiv, size: [divWidth, divHeight], - m + m: m }); } } @@ -9841,10 +21400,10 @@ var renderTextLayer = function renderTextLayerClosure() { } function findPositiveMin(ts, offset, count) { - let result = 0; + var result = 0; - for (let i = 0; i < count; i++) { - const t = ts[offset++]; + for (var i = 0; i < count; i++) { + var t = ts[offset++]; if (t > 0) { result = result ? Math.min(t, result) : t; @@ -10104,15 +21663,16 @@ var renderTextLayer = function renderTextLayerClosure() { }); } - function TextLayerRenderTask({ - textContent, - textContentStream, - container, - viewport, - textDivs, - textContentItemsStr, - enhanceTextSelection - }) { + function TextLayerRenderTask(_ref) { + var _this = this; + + var textContent = _ref.textContent, + textContentStream = _ref.textContentStream, + container = _ref.container, + viewport = _ref.viewport, + textDivs = _ref.textDivs, + textContentItemsStr = _ref.textContentItemsStr, + enhanceTextSelection = _ref.enhanceTextSelection; this._textContent = textContent; this._textContentStream = textContentStream; this._container = container; @@ -10132,13 +21692,13 @@ var renderTextLayer = function renderTextLayerClosure() { this._renderTimer = null; this._bounds = []; - this._capability.promise.finally(() => { - if (this._layoutTextCtx) { - this._layoutTextCtx.canvas.width = 0; - this._layoutTextCtx.canvas.height = 0; - this._layoutTextCtx = null; + this._capability.promise["finally"](function () { + if (_this._layoutTextCtx) { + _this._layoutTextCtx.canvas.width = 0; + _this._layoutTextCtx.canvas.height = 0; + _this._layoutTextCtx = null; } - }).catch(() => {}); + })["catch"](function () {}); } TextLayerRenderTask.prototype = { @@ -10162,48 +21722,44 @@ var renderTextLayer = function renderTextLayerClosure() { this._capability.reject(new Error("TextLayer task cancelled.")); }, - - _processItems(items, styleCache) { - for (let i = 0, len = items.length; i < len; i++) { + _processItems: function _processItems(items, styleCache) { + for (var i = 0, len = items.length; i < len; i++) { this._textContentItemsStr.push(items[i].str); appendText(this, items[i], styleCache); } }, - - _layoutText(textDiv) { - const textDivProperties = this._textDivProperties.get(textDiv); + _layoutText: function _layoutText(textDiv) { + var textDivProperties = this._textDivProperties.get(textDiv); if (textDivProperties.isWhitespace) { return; } - let transform = ""; + var transform = ""; if (textDivProperties.canvasWidth !== 0) { - const { - fontSize, - fontFamily - } = textDiv.style; + var _textDiv$style = textDiv.style, + fontSize = _textDiv$style.fontSize, + fontFamily = _textDiv$style.fontFamily; if (fontSize !== this._layoutTextLastFontSize || fontFamily !== this._layoutTextLastFontFamily) { - this._layoutTextCtx.font = `${fontSize} ${fontFamily}`; + this._layoutTextCtx.font = "".concat(fontSize, " ").concat(fontFamily); this._layoutTextLastFontSize = fontSize; this._layoutTextLastFontFamily = fontFamily; } - const { - width - } = this._layoutTextCtx.measureText(textDiv.textContent); + var _this$_layoutTextCtx$ = this._layoutTextCtx.measureText(textDiv.textContent), + width = _this$_layoutTextCtx$.width; if (width > 0) { textDivProperties.scale = textDivProperties.canvasWidth / width; - transform = `scaleX(${textDivProperties.scale})`; + transform = "scaleX(".concat(textDivProperties.scale, ")"); } } if (textDivProperties.angle !== 0) { - transform = `rotate(${textDivProperties.angle}deg) ${transform}`; + transform = "rotate(".concat(textDivProperties.angle, "deg) ").concat(transform); } if (transform.length > 0) { @@ -10218,29 +21774,30 @@ var renderTextLayer = function renderTextLayerClosure() { this._container.appendChild(textDiv); }, - _render: function TextLayer_render(timeout) { - const capability = (0, _util.createPromiseCapability)(); - let styleCache = Object.create(null); - const canvas = document.createElement("canvas"); + var _this2 = this; + + var capability = (0, _util.createPromiseCapability)(); + var styleCache = Object.create(null); + var canvas = document.createElement("canvas"); canvas.mozOpaque = true; this._layoutTextCtx = canvas.getContext("2d", { alpha: false }); if (this._textContent) { - const textItems = this._textContent.items; - const textStyles = this._textContent.styles; + var textItems = this._textContent.items; + var textStyles = this._textContent.styles; this._processItems(textItems, textStyles); capability.resolve(); } else if (this._textContentStream) { - const pump = () => { - this._reader.read().then(({ - value, - done - }) => { + var pump = function pump() { + _this2._reader.read().then(function (_ref2) { + var value = _ref2.value, + done = _ref2.done; + if (done) { capability.resolve(); return; @@ -10248,7 +21805,7 @@ var renderTextLayer = function renderTextLayerClosure() { Object.assign(styleCache, value.styles); - this._processItems(value.items, styleCache); + _this2._processItems(value.items, styleCache); pump(); }, capability.reject); @@ -10260,15 +21817,15 @@ var renderTextLayer = function renderTextLayerClosure() { throw new Error('Neither "textContent" nor "textContentStream"' + " parameters specified."); } - capability.promise.then(() => { + capability.promise.then(function () { styleCache = null; if (!timeout) { - render(this); + render(_this2); } else { - this._renderTimer = setTimeout(() => { - render(this); - this._renderTimer = null; + _this2._renderTimer = setTimeout(function () { + render(_this2); + _this2._renderTimer = null; }, timeout); } }, this._capability.reject); @@ -10283,13 +21840,13 @@ var renderTextLayer = function renderTextLayerClosure() { this._bounds = null; } - const transformBuf = [], - paddingBuf = []; + var transformBuf = [], + paddingBuf = []; for (var i = 0, ii = this._textDivs.length; i < ii; i++) { - const div = this._textDivs[i]; + var div = this._textDivs[i]; - const divProps = this._textDivProperties.get(div); + var divProps = this._textDivProperties.get(div); if (divProps.isWhitespace) { continue; @@ -10304,27 +21861,27 @@ var renderTextLayer = function renderTextLayerClosure() { } if (divProps.paddingTop > 0) { - paddingBuf.push(`${divProps.paddingTop}px`); - transformBuf.push(`translateY(${-divProps.paddingTop}px)`); + paddingBuf.push("".concat(divProps.paddingTop, "px")); + transformBuf.push("translateY(".concat(-divProps.paddingTop, "px)")); } else { paddingBuf.push(0); } if (divProps.paddingRight > 0) { - paddingBuf.push(`${divProps.paddingRight / divProps.scale}px`); + paddingBuf.push("".concat(divProps.paddingRight / divProps.scale, "px")); } else { paddingBuf.push(0); } if (divProps.paddingBottom > 0) { - paddingBuf.push(`${divProps.paddingBottom}px`); + paddingBuf.push("".concat(divProps.paddingBottom, "px")); } else { paddingBuf.push(0); } if (divProps.paddingLeft > 0) { - paddingBuf.push(`${divProps.paddingLeft / divProps.scale}px`); - transformBuf.push(`translateX(${-divProps.paddingLeft / divProps.scale}px)`); + paddingBuf.push("".concat(divProps.paddingLeft / divProps.scale, "px")); + transformBuf.push("translateX(".concat(-divProps.paddingLeft / divProps.scale, "px)")); } else { paddingBuf.push(0); } @@ -10364,7 +21921,7 @@ var renderTextLayer = function renderTextLayerClosure() { exports.renderTextLayer = renderTextLayer; /***/ }), -/* 18 */ +/* 211 */ /***/ (function(module, exports, __w_pdfjs_require__) { "use strict"; @@ -10375,37 +21932,144 @@ Object.defineProperty(exports, "__esModule", { }); exports.SVGGraphics = void 0; -var _util = __w_pdfjs_require__(2); +var _util = __w_pdfjs_require__(5); var _display_utils = __w_pdfjs_require__(1); -var _is_node = __w_pdfjs_require__(4); +var _is_node = __w_pdfjs_require__(7); + +function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); } + +function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); } + +function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); } + +function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); } -let SVGGraphics = function () { +function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; } + +function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e2) { throw _e2; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e3) { didErr = true; err = _e3; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; } + +function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); } + +function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +var SVGGraphics = function SVGGraphics() { throw new Error("Not implemented: SVGGraphics"); }; exports.SVGGraphics = SVGGraphics; { - const SVG_DEFAULTS = { + var opListToTree = function opListToTree(opList) { + var opTree = []; + var tmp = []; + + var _iterator = _createForOfIteratorHelper(opList), + _step; + + try { + for (_iterator.s(); !(_step = _iterator.n()).done;) { + var opListElement = _step.value; + + if (opListElement.fn === "save") { + opTree.push({ + fnId: 92, + fn: "group", + items: [] + }); + tmp.push(opTree); + opTree = opTree[opTree.length - 1].items; + continue; + } + + if (opListElement.fn === "restore") { + opTree = tmp.pop(); + } else { + opTree.push(opListElement); + } + } + } catch (err) { + _iterator.e(err); + } finally { + _iterator.f(); + } + + return opTree; + }; + + var pf = function pf(value) { + if (Number.isInteger(value)) { + return value.toString(); + } + + var s = value.toFixed(10); + var i = s.length - 1; + + if (s[i] !== "0") { + return s; + } + + do { + i--; + } while (s[i] === "0"); + + return s.substring(0, s[i] === "." ? i : i + 1); + }; + + var pm = function pm(m) { + if (m[4] === 0 && m[5] === 0) { + if (m[1] === 0 && m[2] === 0) { + if (m[0] === 1 && m[3] === 1) { + return ""; + } + + return "scale(".concat(pf(m[0]), " ").concat(pf(m[3]), ")"); + } + + if (m[0] === m[3] && m[1] === -m[2]) { + var a = Math.acos(m[0]) * 180 / Math.PI; + return "rotate(".concat(pf(a), ")"); + } + } else { + if (m[0] === 1 && m[1] === 0 && m[2] === 0 && m[3] === 1) { + return "translate(".concat(pf(m[4]), " ").concat(pf(m[5]), ")"); + } + } + + return "matrix(".concat(pf(m[0]), " ").concat(pf(m[1]), " ").concat(pf(m[2]), " ").concat(pf(m[3]), " ").concat(pf(m[4]), " ") + "".concat(pf(m[5]), ")"); + }; + + var SVG_DEFAULTS = { fontStyle: "normal", fontWeight: "normal", fillColor: "#000000" }; - const XML_NS = "http://www.w3.org/XML/1998/namespace"; - const XLINK_NS = "http://www.w3.org/1999/xlink"; - const LINE_CAP_STYLES = ["butt", "round", "square"]; - const LINE_JOIN_STYLES = ["miter", "round", "bevel"]; + var XML_NS = "http://www.w3.org/XML/1998/namespace"; + var XLINK_NS = "http://www.w3.org/1999/xlink"; + var LINE_CAP_STYLES = ["butt", "round", "square"]; + var LINE_JOIN_STYLES = ["miter", "round", "bevel"]; - const convertImgDataToPng = function () { - const PNG_HEADER = new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]); - const CHUNK_WRAPPER_SIZE = 12; - const crcTable = new Int32Array(256); + var convertImgDataToPng = function () { + var PNG_HEADER = new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]); + var CHUNK_WRAPPER_SIZE = 12; + var crcTable = new Int32Array(256); - for (let i = 0; i < 256; i++) { - let c = i; + for (var i = 0; i < 256; i++) { + var c = i; - for (let h = 0; h < 8; h++) { + for (var h = 0; h < 8; h++) { if (c & 1) { c = 0xedb88320 ^ c >> 1 & 0x7fffffff; } else { @@ -10417,11 +22081,11 @@ exports.SVGGraphics = SVGGraphics; } function crc32(data, start, end) { - let crc = -1; + var crc = -1; - for (let i = start; i < end; i++) { - const a = (crc ^ data[i]) & 0xff; - const b = crcTable[a]; + for (var _i = start; _i < end; _i++) { + var a = (crc ^ data[_i]) & 0xff; + var b = crcTable[a]; crc = crc >>> 8 ^ b; } @@ -10429,8 +22093,8 @@ exports.SVGGraphics = SVGGraphics; } function writePngChunk(type, body, data, offset) { - let p = offset; - const len = body.length; + var p = offset; + var len = body.length; data[p] = len >> 24 & 0xff; data[p + 1] = len >> 16 & 0xff; data[p + 2] = len >> 8 & 0xff; @@ -10443,7 +22107,7 @@ exports.SVGGraphics = SVGGraphics; p += 4; data.set(body, p); p += body.length; - const crc = crc32(data, offset + 4, p); + var crc = crc32(data, offset + 4, p); data[p] = crc >> 24 & 0xff; data[p + 1] = crc >> 16 & 0xff; data[p + 2] = crc >> 8 & 0xff; @@ -10451,11 +22115,11 @@ exports.SVGGraphics = SVGGraphics; } function adler32(data, start, end) { - let a = 1; - let b = 0; + var a = 1; + var b = 0; - for (let i = start; i < end; ++i) { - a = (a + (data[i] & 0xff)) % 65521; + for (var _i2 = start; _i2 < end; ++_i2) { + a = (a + (data[_i2] & 0xff)) % 65521; b = (b + a) % 65521; } @@ -10468,7 +22132,7 @@ exports.SVGGraphics = SVGGraphics; } try { - let input; + var input; if (parseInt(process.versions.node) >= 8) { input = literals; @@ -10476,7 +22140,7 @@ exports.SVGGraphics = SVGGraphics; input = Buffer.from(literals); } - const output = require("zlib").deflateSync(input, { + var output = require("zlib").deflateSync(input, { level: 9 }); @@ -10489,14 +22153,14 @@ exports.SVGGraphics = SVGGraphics; } function deflateSyncUncompressed(literals) { - let len = literals.length; - const maxBlockLength = 0xffff; - const deflateBlocks = Math.ceil(len / maxBlockLength); - const idat = new Uint8Array(2 + len + deflateBlocks * 5 + 4); - let pi = 0; + var len = literals.length; + var maxBlockLength = 0xffff; + var deflateBlocks = Math.ceil(len / maxBlockLength); + var idat = new Uint8Array(2 + len + deflateBlocks * 5 + 4); + var pi = 0; idat[pi++] = 0x78; idat[pi++] = 0x9c; - let pos = 0; + var pos = 0; while (len > maxBlockLength) { idat[pi++] = 0x00; @@ -10517,7 +22181,7 @@ exports.SVGGraphics = SVGGraphics; idat[pi++] = (~len & 0xffff) >> 8 & 0xff; idat.set(literals.subarray(pos), pi); pi += literals.length - pos; - const adler = adler32(literals, 0, literals.length); + var adler = adler32(literals, 0, literals.length); idat[pi++] = adler >> 24 & 0xff; idat[pi++] = adler >> 16 & 0xff; idat[pi++] = adler >> 8 & 0xff; @@ -10526,10 +22190,10 @@ exports.SVGGraphics = SVGGraphics; } function encode(imgData, kind, forceDataSchema, isMask) { - const width = imgData.width; - const height = imgData.height; - let bitDepth, colorType, lineSize; - const bytes = imgData.data; + var width = imgData.width; + var height = imgData.height; + var bitDepth, colorType, lineSize; + var bytes = imgData.data; switch (kind) { case _util.ImageKind.GRAYSCALE_1BPP: @@ -10554,11 +22218,11 @@ exports.SVGGraphics = SVGGraphics; throw new Error("invalid format"); } - const literals = new Uint8Array((1 + lineSize) * height); - let offsetLiterals = 0, + var literals = new Uint8Array((1 + lineSize) * height); + var offsetLiterals = 0, offsetBytes = 0; - for (let y = 0; y < height; ++y) { + for (var y = 0; y < height; ++y) { literals[offsetLiterals++] = 0; literals.set(bytes.subarray(offsetBytes, offsetBytes + lineSize), offsetLiterals); offsetBytes += lineSize; @@ -10568,20 +22232,20 @@ exports.SVGGraphics = SVGGraphics; if (kind === _util.ImageKind.GRAYSCALE_1BPP && isMask) { offsetLiterals = 0; - for (let y = 0; y < height; y++) { + for (var _y = 0; _y < height; _y++) { offsetLiterals++; - for (let i = 0; i < lineSize; i++) { + for (var _i3 = 0; _i3 < lineSize; _i3++) { literals[offsetLiterals++] ^= 0xff; } } } - const ihdr = new Uint8Array([width >> 24 & 0xff, width >> 16 & 0xff, width >> 8 & 0xff, width & 0xff, height >> 24 & 0xff, height >> 16 & 0xff, height >> 8 & 0xff, height & 0xff, bitDepth, colorType, 0x00, 0x00, 0x00]); - const idat = deflateSync(literals); - const pngLength = PNG_HEADER.length + CHUNK_WRAPPER_SIZE * 3 + ihdr.length + idat.length; - const data = new Uint8Array(pngLength); - let offset = 0; + var ihdr = new Uint8Array([width >> 24 & 0xff, width >> 16 & 0xff, width >> 8 & 0xff, width & 0xff, height >> 24 & 0xff, height >> 16 & 0xff, height >> 8 & 0xff, height & 0xff, bitDepth, colorType, 0x00, 0x00, 0x00]); + var idat = deflateSync(literals); + var pngLength = PNG_HEADER.length + CHUNK_WRAPPER_SIZE * 3 + ihdr.length + idat.length; + var data = new Uint8Array(pngLength); + var offset = 0; data.set(PNG_HEADER, offset); offset += PNG_HEADER.length; writePngChunk("IHDR", ihdr, data, offset); @@ -10593,13 +22257,15 @@ exports.SVGGraphics = SVGGraphics; } return function convertImgDataToPng(imgData, forceDataSchema, isMask) { - const kind = imgData.kind === undefined ? _util.ImageKind.GRAYSCALE_1BPP : imgData.kind; + var kind = imgData.kind === undefined ? _util.ImageKind.GRAYSCALE_1BPP : imgData.kind; return encode(imgData, kind, forceDataSchema, isMask); }; }(); - class SVGExtraState { - constructor() { + var SVGExtraState = /*#__PURE__*/function () { + function SVGExtraState() { + _classCallCheck(this, SVGExtraState); + this.fontSizeScale = 1; this.fontWeight = SVG_DEFAULTS.fontWeight; this.fontSize = 0; @@ -10632,90 +22298,32 @@ exports.SVGGraphics = SVGGraphics; this.maskId = ""; } - clone() { - return Object.create(this); - } - - setCurrentPoint(x, y) { - this.x = x; - this.y = y; - } - - } - - function opListToTree(opList) { - let opTree = []; - const tmp = []; - - for (const opListElement of opList) { - if (opListElement.fn === "save") { - opTree.push({ - fnId: 92, - fn: "group", - items: [] - }); - tmp.push(opTree); - opTree = opTree[opTree.length - 1].items; - continue; + _createClass(SVGExtraState, [{ + key: "clone", + value: function clone() { + return Object.create(this); } - - if (opListElement.fn === "restore") { - opTree = tmp.pop(); - } else { - opTree.push(opListElement); + }, { + key: "setCurrentPoint", + value: function setCurrentPoint(x, y) { + this.x = x; + this.y = y; } - } - - return opTree; - } - - function pf(value) { - if (Number.isInteger(value)) { - return value.toString(); - } - - const s = value.toFixed(10); - let i = s.length - 1; - - if (s[i] !== "0") { - return s; - } - - do { - i--; - } while (s[i] === "0"); + }]); - return s.substring(0, s[i] === "." ? i : i + 1); - } + return SVGExtraState; + }(); - function pm(m) { - if (m[4] === 0 && m[5] === 0) { - if (m[1] === 0 && m[2] === 0) { - if (m[0] === 1 && m[3] === 1) { - return ""; - } + var clipCount = 0; + var maskCount = 0; + var shadingCount = 0; - return `scale(${pf(m[0])} ${pf(m[3])})`; - } + exports.SVGGraphics = SVGGraphics = /*#__PURE__*/function () { + function SVGGraphics(commonObjs, objs) { + var forceDataSchema = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; - if (m[0] === m[3] && m[1] === -m[2]) { - const a = Math.acos(m[0]) * 180 / Math.PI; - return `rotate(${pf(a)})`; - } - } else { - if (m[0] === 1 && m[1] === 0 && m[2] === 0 && m[3] === 1) { - return `translate(${pf(m[4])} ${pf(m[5])})`; - } - } + _classCallCheck(this, SVGGraphics); - return `matrix(${pf(m[0])} ${pf(m[1])} ${pf(m[2])} ${pf(m[3])} ${pf(m[4])} ` + `${pf(m[5])})`; - } - - let clipCount = 0; - let maskCount = 0; - let shadingCount = 0; - exports.SVGGraphics = SVGGraphics = class SVGGraphics { - constructor(commonObjs, objs, forceDataSchema = false) { this.svgFactory = new _display_utils.DOMSVGFactory(); this.current = new SVGExtraState(); this.transformMatrix = _util.IDENTITY_MATRIX; @@ -10731,1166 +22339,1325 @@ exports.SVGGraphics = SVGGraphics; this.forceDataSchema = !!forceDataSchema; this._operatorIdMapping = []; - for (const op in _util.OPS) { + for (var op in _util.OPS) { this._operatorIdMapping[_util.OPS[op]] = op; } } - save() { - this.transformStack.push(this.transformMatrix); - const old = this.current; - this.extraStack.push(old); - this.current = old.clone(); - } + _createClass(SVGGraphics, [{ + key: "save", + value: function save() { + this.transformStack.push(this.transformMatrix); + var old = this.current; + this.extraStack.push(old); + this.current = old.clone(); + } + }, { + key: "restore", + value: function restore() { + this.transformMatrix = this.transformStack.pop(); + this.current = this.extraStack.pop(); + this.pendingClip = null; + this.tgrp = null; + } + }, { + key: "group", + value: function group(items) { + this.save(); + this.executeOpTree(items); + this.restore(); + } + }, { + key: "loadDependencies", + value: function loadDependencies(operatorList) { + var _this = this; - restore() { - this.transformMatrix = this.transformStack.pop(); - this.current = this.extraStack.pop(); - this.pendingClip = null; - this.tgrp = null; - } + var fnArray = operatorList.fnArray; + var argsArray = operatorList.argsArray; - group(items) { - this.save(); - this.executeOpTree(items); - this.restore(); - } + for (var i = 0, ii = fnArray.length; i < ii; i++) { + if (fnArray[i] !== _util.OPS.dependency) { + continue; + } - loadDependencies(operatorList) { - const fnArray = operatorList.fnArray; - const argsArray = operatorList.argsArray; + var _iterator2 = _createForOfIteratorHelper(argsArray[i]), + _step2; - for (let i = 0, ii = fnArray.length; i < ii; i++) { - if (fnArray[i] !== _util.OPS.dependency) { - continue; - } + try { + var _loop = function _loop() { + var obj = _step2.value; + var objsPool = obj.startsWith("g_") ? _this.commonObjs : _this.objs; + var promise = new Promise(function (resolve) { + objsPool.get(obj, resolve); + }); - for (const obj of argsArray[i]) { - const objsPool = obj.startsWith("g_") ? this.commonObjs : this.objs; - const promise = new Promise(resolve => { - objsPool.get(obj, resolve); - }); - this.current.dependencies.push(promise); - } - } + _this.current.dependencies.push(promise); + }; - return Promise.all(this.current.dependencies); - } + for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) { + _loop(); + } + } catch (err) { + _iterator2.e(err); + } finally { + _iterator2.f(); + } + } - transform(a, b, c, d, e, f) { - const transformMatrix = [a, b, c, d, e, f]; - this.transformMatrix = _util.Util.transform(this.transformMatrix, transformMatrix); - this.tgrp = null; - } + return Promise.all(this.current.dependencies); + } + }, { + key: "transform", + value: function transform(a, b, c, d, e, f) { + var transformMatrix = [a, b, c, d, e, f]; + this.transformMatrix = _util.Util.transform(this.transformMatrix, transformMatrix); + this.tgrp = null; + } + }, { + key: "getSVG", + value: function getSVG(operatorList, viewport) { + var _this2 = this; - getSVG(operatorList, viewport) { - this.viewport = viewport; + this.viewport = viewport; - const svgElement = this._initialize(viewport); + var svgElement = this._initialize(viewport); - return this.loadDependencies(operatorList).then(() => { - this.transformMatrix = _util.IDENTITY_MATRIX; - this.executeOpTree(this.convertOpList(operatorList)); - return svgElement; - }); - } + return this.loadDependencies(operatorList).then(function () { + _this2.transformMatrix = _util.IDENTITY_MATRIX; - convertOpList(operatorList) { - const operatorIdMapping = this._operatorIdMapping; - const argsArray = operatorList.argsArray; - const fnArray = operatorList.fnArray; - const opList = []; + _this2.executeOpTree(_this2.convertOpList(operatorList)); - for (let i = 0, ii = fnArray.length; i < ii; i++) { - const fnId = fnArray[i]; - opList.push({ - fnId, - fn: operatorIdMapping[fnId], - args: argsArray[i] + return svgElement; }); } + }, { + key: "convertOpList", + value: function convertOpList(operatorList) { + var operatorIdMapping = this._operatorIdMapping; + var argsArray = operatorList.argsArray; + var fnArray = operatorList.fnArray; + var opList = []; + + for (var i = 0, ii = fnArray.length; i < ii; i++) { + var fnId = fnArray[i]; + opList.push({ + fnId: fnId, + fn: operatorIdMapping[fnId], + args: argsArray[i] + }); + } - return opListToTree(opList); - } + return opListToTree(opList); + } + }, { + key: "executeOpTree", + value: function executeOpTree(opTree) { + var _iterator3 = _createForOfIteratorHelper(opTree), + _step3; - executeOpTree(opTree) { - for (const opTreeElement of opTree) { - const fn = opTreeElement.fn; - const fnId = opTreeElement.fnId; - const args = opTreeElement.args; + try { + for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) { + var opTreeElement = _step3.value; + var fn = opTreeElement.fn; + var fnId = opTreeElement.fnId; + var args = opTreeElement.args; - switch (fnId | 0) { - case _util.OPS.beginText: - this.beginText(); - break; + switch (fnId | 0) { + case _util.OPS.beginText: + this.beginText(); + break; - case _util.OPS.dependency: - break; + case _util.OPS.dependency: + break; - case _util.OPS.setLeading: - this.setLeading(args); - break; + case _util.OPS.setLeading: + this.setLeading(args); + break; - case _util.OPS.setLeadingMoveText: - this.setLeadingMoveText(args[0], args[1]); - break; + case _util.OPS.setLeadingMoveText: + this.setLeadingMoveText(args[0], args[1]); + break; - case _util.OPS.setFont: - this.setFont(args); - break; + case _util.OPS.setFont: + this.setFont(args); + break; - case _util.OPS.showText: - this.showText(args[0]); - break; + case _util.OPS.showText: + this.showText(args[0]); + break; - case _util.OPS.showSpacedText: - this.showText(args[0]); - break; + case _util.OPS.showSpacedText: + this.showText(args[0]); + break; - case _util.OPS.endText: - this.endText(); - break; + case _util.OPS.endText: + this.endText(); + break; - case _util.OPS.moveText: - this.moveText(args[0], args[1]); - break; + case _util.OPS.moveText: + this.moveText(args[0], args[1]); + break; - case _util.OPS.setCharSpacing: - this.setCharSpacing(args[0]); - break; + case _util.OPS.setCharSpacing: + this.setCharSpacing(args[0]); + break; - case _util.OPS.setWordSpacing: - this.setWordSpacing(args[0]); - break; + case _util.OPS.setWordSpacing: + this.setWordSpacing(args[0]); + break; - case _util.OPS.setHScale: - this.setHScale(args[0]); - break; + case _util.OPS.setHScale: + this.setHScale(args[0]); + break; - case _util.OPS.setTextMatrix: - this.setTextMatrix(args[0], args[1], args[2], args[3], args[4], args[5]); - break; + case _util.OPS.setTextMatrix: + this.setTextMatrix(args[0], args[1], args[2], args[3], args[4], args[5]); + break; - case _util.OPS.setTextRise: - this.setTextRise(args[0]); - break; + case _util.OPS.setTextRise: + this.setTextRise(args[0]); + break; - case _util.OPS.setTextRenderingMode: - this.setTextRenderingMode(args[0]); - break; + case _util.OPS.setTextRenderingMode: + this.setTextRenderingMode(args[0]); + break; - case _util.OPS.setLineWidth: - this.setLineWidth(args[0]); - break; + case _util.OPS.setLineWidth: + this.setLineWidth(args[0]); + break; - case _util.OPS.setLineJoin: - this.setLineJoin(args[0]); - break; + case _util.OPS.setLineJoin: + this.setLineJoin(args[0]); + break; - case _util.OPS.setLineCap: - this.setLineCap(args[0]); - break; + case _util.OPS.setLineCap: + this.setLineCap(args[0]); + break; - case _util.OPS.setMiterLimit: - this.setMiterLimit(args[0]); - break; + case _util.OPS.setMiterLimit: + this.setMiterLimit(args[0]); + break; - case _util.OPS.setFillRGBColor: - this.setFillRGBColor(args[0], args[1], args[2]); - break; + case _util.OPS.setFillRGBColor: + this.setFillRGBColor(args[0], args[1], args[2]); + break; - case _util.OPS.setStrokeRGBColor: - this.setStrokeRGBColor(args[0], args[1], args[2]); - break; + case _util.OPS.setStrokeRGBColor: + this.setStrokeRGBColor(args[0], args[1], args[2]); + break; - case _util.OPS.setStrokeColorN: - this.setStrokeColorN(args); - break; + case _util.OPS.setStrokeColorN: + this.setStrokeColorN(args); + break; - case _util.OPS.setFillColorN: - this.setFillColorN(args); - break; + case _util.OPS.setFillColorN: + this.setFillColorN(args); + break; - case _util.OPS.shadingFill: - this.shadingFill(args[0]); - break; + case _util.OPS.shadingFill: + this.shadingFill(args[0]); + break; - case _util.OPS.setDash: - this.setDash(args[0], args[1]); - break; + case _util.OPS.setDash: + this.setDash(args[0], args[1]); + break; - case _util.OPS.setRenderingIntent: - this.setRenderingIntent(args[0]); - break; + case _util.OPS.setRenderingIntent: + this.setRenderingIntent(args[0]); + break; - case _util.OPS.setFlatness: - this.setFlatness(args[0]); - break; + case _util.OPS.setFlatness: + this.setFlatness(args[0]); + break; - case _util.OPS.setGState: - this.setGState(args[0]); - break; + case _util.OPS.setGState: + this.setGState(args[0]); + break; - case _util.OPS.fill: - this.fill(); - break; + case _util.OPS.fill: + this.fill(); + break; - case _util.OPS.eoFill: - this.eoFill(); - break; + case _util.OPS.eoFill: + this.eoFill(); + break; - case _util.OPS.stroke: - this.stroke(); - break; + case _util.OPS.stroke: + this.stroke(); + break; - case _util.OPS.fillStroke: - this.fillStroke(); - break; + case _util.OPS.fillStroke: + this.fillStroke(); + break; - case _util.OPS.eoFillStroke: - this.eoFillStroke(); - break; + case _util.OPS.eoFillStroke: + this.eoFillStroke(); + break; - case _util.OPS.clip: - this.clip("nonzero"); - break; + case _util.OPS.clip: + this.clip("nonzero"); + break; - case _util.OPS.eoClip: - this.clip("evenodd"); - break; + case _util.OPS.eoClip: + this.clip("evenodd"); + break; - case _util.OPS.paintSolidColorImageMask: - this.paintSolidColorImageMask(); - break; + case _util.OPS.paintSolidColorImageMask: + this.paintSolidColorImageMask(); + break; - case _util.OPS.paintImageXObject: - this.paintImageXObject(args[0]); - break; + case _util.OPS.paintImageXObject: + this.paintImageXObject(args[0]); + break; - case _util.OPS.paintInlineImageXObject: - this.paintInlineImageXObject(args[0]); - break; + case _util.OPS.paintInlineImageXObject: + this.paintInlineImageXObject(args[0]); + break; - case _util.OPS.paintImageMaskXObject: - this.paintImageMaskXObject(args[0]); - break; + case _util.OPS.paintImageMaskXObject: + this.paintImageMaskXObject(args[0]); + break; - case _util.OPS.paintFormXObjectBegin: - this.paintFormXObjectBegin(args[0], args[1]); - break; + case _util.OPS.paintFormXObjectBegin: + this.paintFormXObjectBegin(args[0], args[1]); + break; - case _util.OPS.paintFormXObjectEnd: - this.paintFormXObjectEnd(); - break; + case _util.OPS.paintFormXObjectEnd: + this.paintFormXObjectEnd(); + break; - case _util.OPS.closePath: - this.closePath(); - break; + case _util.OPS.closePath: + this.closePath(); + break; - case _util.OPS.closeStroke: - this.closeStroke(); - break; + case _util.OPS.closeStroke: + this.closeStroke(); + break; - case _util.OPS.closeFillStroke: - this.closeFillStroke(); - break; + case _util.OPS.closeFillStroke: + this.closeFillStroke(); + break; - case _util.OPS.closeEOFillStroke: - this.closeEOFillStroke(); - break; + case _util.OPS.closeEOFillStroke: + this.closeEOFillStroke(); + break; - case _util.OPS.nextLine: - this.nextLine(); - break; + case _util.OPS.nextLine: + this.nextLine(); + break; - case _util.OPS.transform: - this.transform(args[0], args[1], args[2], args[3], args[4], args[5]); - break; + case _util.OPS.transform: + this.transform(args[0], args[1], args[2], args[3], args[4], args[5]); + break; - case _util.OPS.constructPath: - this.constructPath(args[0], args[1]); - break; + case _util.OPS.constructPath: + this.constructPath(args[0], args[1]); + break; - case _util.OPS.endPath: - this.endPath(); - break; + case _util.OPS.endPath: + this.endPath(); + break; - case 92: - this.group(opTreeElement.items); - break; + case 92: + this.group(opTreeElement.items); + break; - default: - (0, _util.warn)(`Unimplemented operator ${fn}`); - break; + default: + (0, _util.warn)("Unimplemented operator ".concat(fn)); + break; + } + } + } catch (err) { + _iterator3.e(err); + } finally { + _iterator3.f(); } } - } + }, { + key: "setWordSpacing", + value: function setWordSpacing(wordSpacing) { + this.current.wordSpacing = wordSpacing; + } + }, { + key: "setCharSpacing", + value: function setCharSpacing(charSpacing) { + this.current.charSpacing = charSpacing; + } + }, { + key: "nextLine", + value: function nextLine() { + this.moveText(0, this.current.leading); + } + }, { + key: "setTextMatrix", + value: function setTextMatrix(a, b, c, d, e, f) { + var current = this.current; + current.textMatrix = current.lineMatrix = [a, b, c, d, e, f]; + current.textMatrixScale = Math.sqrt(a * a + b * b); + current.x = current.lineX = 0; + current.y = current.lineY = 0; + current.xcoords = []; + current.ycoords = []; + current.tspan = this.svgFactory.createElement("svg:tspan"); + current.tspan.setAttributeNS(null, "font-family", current.fontFamily); + current.tspan.setAttributeNS(null, "font-size", "".concat(pf(current.fontSize), "px")); + current.tspan.setAttributeNS(null, "y", pf(-current.y)); + current.txtElement = this.svgFactory.createElement("svg:text"); + current.txtElement.appendChild(current.tspan); + } + }, { + key: "beginText", + value: function beginText() { + var current = this.current; + current.x = current.lineX = 0; + current.y = current.lineY = 0; + current.textMatrix = _util.IDENTITY_MATRIX; + current.lineMatrix = _util.IDENTITY_MATRIX; + current.textMatrixScale = 1; + current.tspan = this.svgFactory.createElement("svg:tspan"); + current.txtElement = this.svgFactory.createElement("svg:text"); + current.txtgrp = this.svgFactory.createElement("svg:g"); + current.xcoords = []; + current.ycoords = []; + } + }, { + key: "moveText", + value: function moveText(x, y) { + var current = this.current; + current.x = current.lineX += x; + current.y = current.lineY += y; + current.xcoords = []; + current.ycoords = []; + current.tspan = this.svgFactory.createElement("svg:tspan"); + current.tspan.setAttributeNS(null, "font-family", current.fontFamily); + current.tspan.setAttributeNS(null, "font-size", "".concat(pf(current.fontSize), "px")); + current.tspan.setAttributeNS(null, "y", pf(-current.y)); + } + }, { + key: "showText", + value: function showText(glyphs) { + var current = this.current; + var font = current.font; + var fontSize = current.fontSize; - setWordSpacing(wordSpacing) { - this.current.wordSpacing = wordSpacing; - } + if (fontSize === 0) { + return; + } - setCharSpacing(charSpacing) { - this.current.charSpacing = charSpacing; - } + var fontSizeScale = current.fontSizeScale; + var charSpacing = current.charSpacing; + var wordSpacing = current.wordSpacing; + var fontDirection = current.fontDirection; + var textHScale = current.textHScale * fontDirection; + var vertical = font.vertical; + var spacingDir = vertical ? 1 : -1; + var defaultVMetrics = font.defaultVMetrics; + var widthAdvanceScale = fontSize * current.fontMatrix[0]; + var x = 0; - nextLine() { - this.moveText(0, this.current.leading); - } + var _iterator4 = _createForOfIteratorHelper(glyphs), + _step4; - setTextMatrix(a, b, c, d, e, f) { - const current = this.current; - current.textMatrix = current.lineMatrix = [a, b, c, d, e, f]; - current.textMatrixScale = Math.sqrt(a * a + b * b); - current.x = current.lineX = 0; - current.y = current.lineY = 0; - current.xcoords = []; - current.ycoords = []; - current.tspan = this.svgFactory.createElement("svg:tspan"); - current.tspan.setAttributeNS(null, "font-family", current.fontFamily); - current.tspan.setAttributeNS(null, "font-size", `${pf(current.fontSize)}px`); - current.tspan.setAttributeNS(null, "y", pf(-current.y)); - current.txtElement = this.svgFactory.createElement("svg:text"); - current.txtElement.appendChild(current.tspan); - } - - beginText() { - const current = this.current; - current.x = current.lineX = 0; - current.y = current.lineY = 0; - current.textMatrix = _util.IDENTITY_MATRIX; - current.lineMatrix = _util.IDENTITY_MATRIX; - current.textMatrixScale = 1; - current.tspan = this.svgFactory.createElement("svg:tspan"); - current.txtElement = this.svgFactory.createElement("svg:text"); - current.txtgrp = this.svgFactory.createElement("svg:g"); - current.xcoords = []; - current.ycoords = []; - } - - moveText(x, y) { - const current = this.current; - current.x = current.lineX += x; - current.y = current.lineY += y; - current.xcoords = []; - current.ycoords = []; - current.tspan = this.svgFactory.createElement("svg:tspan"); - current.tspan.setAttributeNS(null, "font-family", current.fontFamily); - current.tspan.setAttributeNS(null, "font-size", `${pf(current.fontSize)}px`); - current.tspan.setAttributeNS(null, "y", pf(-current.y)); - } - - showText(glyphs) { - const current = this.current; - const font = current.font; - const fontSize = current.fontSize; + try { + for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) { + var glyph = _step4.value; + + if (glyph === null) { + x += fontDirection * wordSpacing; + continue; + } else if ((0, _util.isNum)(glyph)) { + x += spacingDir * glyph * fontSize / 1000; + continue; + } - if (fontSize === 0) { - return; - } + var spacing = (glyph.isSpace ? wordSpacing : 0) + charSpacing; + var character = glyph.fontChar; + var scaledX = void 0, + scaledY = void 0; + var width = glyph.width; + + if (vertical) { + var vx = void 0; + var vmetric = glyph.vmetric || defaultVMetrics; + vx = glyph.vmetric ? vmetric[1] : width * 0.5; + vx = -vx * widthAdvanceScale; + var vy = vmetric[2] * widthAdvanceScale; + width = vmetric ? -vmetric[0] : width; + scaledX = vx / fontSizeScale; + scaledY = (x + vy) / fontSizeScale; + } else { + scaledX = x / fontSizeScale; + scaledY = 0; + } - const fontSizeScale = current.fontSizeScale; - const charSpacing = current.charSpacing; - const wordSpacing = current.wordSpacing; - const fontDirection = current.fontDirection; - const textHScale = current.textHScale * fontDirection; - const vertical = font.vertical; - const spacingDir = vertical ? 1 : -1; - const defaultVMetrics = font.defaultVMetrics; - const widthAdvanceScale = fontSize * current.fontMatrix[0]; - let x = 0; - - for (const glyph of glyphs) { - if (glyph === null) { - x += fontDirection * wordSpacing; - continue; - } else if ((0, _util.isNum)(glyph)) { - x += spacingDir * glyph * fontSize / 1000; - continue; - } + if (glyph.isInFont || font.missingFile) { + current.xcoords.push(current.x + scaledX); - const spacing = (glyph.isSpace ? wordSpacing : 0) + charSpacing; - const character = glyph.fontChar; - let scaledX, scaledY; - let width = glyph.width; + if (vertical) { + current.ycoords.push(-current.y + scaledY); + } - if (vertical) { - let vx; - const vmetric = glyph.vmetric || defaultVMetrics; - vx = glyph.vmetric ? vmetric[1] : width * 0.5; - vx = -vx * widthAdvanceScale; - const vy = vmetric[2] * widthAdvanceScale; - width = vmetric ? -vmetric[0] : width; - scaledX = vx / fontSizeScale; - scaledY = (x + vy) / fontSizeScale; - } else { - scaledX = x / fontSizeScale; - scaledY = 0; - } + current.tspan.textContent += character; + } else {} - if (glyph.isInFont || font.missingFile) { - current.xcoords.push(current.x + scaledX); + var charWidth = void 0; - if (vertical) { - current.ycoords.push(-current.y + scaledY); - } + if (vertical) { + charWidth = width * widthAdvanceScale - spacing * fontDirection; + } else { + charWidth = width * widthAdvanceScale + spacing * fontDirection; + } - current.tspan.textContent += character; - } else {} + x += charWidth; + } + } catch (err) { + _iterator4.e(err); + } finally { + _iterator4.f(); + } - let charWidth; + current.tspan.setAttributeNS(null, "x", current.xcoords.map(pf).join(" ")); if (vertical) { - charWidth = width * widthAdvanceScale - spacing * fontDirection; + current.tspan.setAttributeNS(null, "y", current.ycoords.map(pf).join(" ")); } else { - charWidth = width * widthAdvanceScale + spacing * fontDirection; + current.tspan.setAttributeNS(null, "y", pf(-current.y)); } - x += charWidth; - } + if (vertical) { + current.y -= x; + } else { + current.x += x * textHScale; + } - current.tspan.setAttributeNS(null, "x", current.xcoords.map(pf).join(" ")); + current.tspan.setAttributeNS(null, "font-family", current.fontFamily); + current.tspan.setAttributeNS(null, "font-size", "".concat(pf(current.fontSize), "px")); - if (vertical) { - current.tspan.setAttributeNS(null, "y", current.ycoords.map(pf).join(" ")); - } else { - current.tspan.setAttributeNS(null, "y", pf(-current.y)); - } + if (current.fontStyle !== SVG_DEFAULTS.fontStyle) { + current.tspan.setAttributeNS(null, "font-style", current.fontStyle); + } - if (vertical) { - current.y -= x; - } else { - current.x += x * textHScale; - } + if (current.fontWeight !== SVG_DEFAULTS.fontWeight) { + current.tspan.setAttributeNS(null, "font-weight", current.fontWeight); + } - current.tspan.setAttributeNS(null, "font-family", current.fontFamily); - current.tspan.setAttributeNS(null, "font-size", `${pf(current.fontSize)}px`); + var fillStrokeMode = current.textRenderingMode & _util.TextRenderingMode.FILL_STROKE_MASK; - if (current.fontStyle !== SVG_DEFAULTS.fontStyle) { - current.tspan.setAttributeNS(null, "font-style", current.fontStyle); - } + if (fillStrokeMode === _util.TextRenderingMode.FILL || fillStrokeMode === _util.TextRenderingMode.FILL_STROKE) { + if (current.fillColor !== SVG_DEFAULTS.fillColor) { + current.tspan.setAttributeNS(null, "fill", current.fillColor); + } - if (current.fontWeight !== SVG_DEFAULTS.fontWeight) { - current.tspan.setAttributeNS(null, "font-weight", current.fontWeight); - } + if (current.fillAlpha < 1) { + current.tspan.setAttributeNS(null, "fill-opacity", current.fillAlpha); + } + } else if (current.textRenderingMode === _util.TextRenderingMode.ADD_TO_PATH) { + current.tspan.setAttributeNS(null, "fill", "transparent"); + } else { + current.tspan.setAttributeNS(null, "fill", "none"); + } - const fillStrokeMode = current.textRenderingMode & _util.TextRenderingMode.FILL_STROKE_MASK; + if (fillStrokeMode === _util.TextRenderingMode.STROKE || fillStrokeMode === _util.TextRenderingMode.FILL_STROKE) { + var lineWidthScale = 1 / (current.textMatrixScale || 1); - if (fillStrokeMode === _util.TextRenderingMode.FILL || fillStrokeMode === _util.TextRenderingMode.FILL_STROKE) { - if (current.fillColor !== SVG_DEFAULTS.fillColor) { - current.tspan.setAttributeNS(null, "fill", current.fillColor); + this._setStrokeAttributes(current.tspan, lineWidthScale); } - if (current.fillAlpha < 1) { - current.tspan.setAttributeNS(null, "fill-opacity", current.fillAlpha); + var textMatrix = current.textMatrix; + + if (current.textRise !== 0) { + textMatrix = textMatrix.slice(); + textMatrix[5] += current.textRise; } - } else if (current.textRenderingMode === _util.TextRenderingMode.ADD_TO_PATH) { - current.tspan.setAttributeNS(null, "fill", "transparent"); - } else { - current.tspan.setAttributeNS(null, "fill", "none"); - } - if (fillStrokeMode === _util.TextRenderingMode.STROKE || fillStrokeMode === _util.TextRenderingMode.FILL_STROKE) { - const lineWidthScale = 1 / (current.textMatrixScale || 1); + current.txtElement.setAttributeNS(null, "transform", "".concat(pm(textMatrix), " scale(").concat(pf(textHScale), ", -1)")); + current.txtElement.setAttributeNS(XML_NS, "xml:space", "preserve"); + current.txtElement.appendChild(current.tspan); + current.txtgrp.appendChild(current.txtElement); - this._setStrokeAttributes(current.tspan, lineWidthScale); + this._ensureTransformGroup().appendChild(current.txtElement); + } + }, { + key: "setLeadingMoveText", + value: function setLeadingMoveText(x, y) { + this.setLeading(-y); + this.moveText(x, y); } + }, { + key: "addFontStyle", + value: function addFontStyle(fontObj) { + if (!fontObj.data) { + throw new Error("addFontStyle: No font data available, " + 'ensure that the "fontExtraProperties" API parameter is set.'); + } - let textMatrix = current.textMatrix; + if (!this.cssStyle) { + this.cssStyle = this.svgFactory.createElement("svg:style"); + this.cssStyle.setAttributeNS(null, "type", "text/css"); + this.defs.appendChild(this.cssStyle); + } - if (current.textRise !== 0) { - textMatrix = textMatrix.slice(); - textMatrix[5] += current.textRise; + var url = (0, _util.createObjectURL)(fontObj.data, fontObj.mimetype, this.forceDataSchema); + this.cssStyle.textContent += "@font-face { font-family: \"".concat(fontObj.loadedName, "\";") + " src: url(".concat(url, "); }\n"); } + }, { + key: "setFont", + value: function setFont(details) { + var current = this.current; + var fontObj = this.commonObjs.get(details[0]); + var size = details[1]; + current.font = fontObj; + + if (this.embedFonts && !fontObj.missingFile && !this.embeddedFonts[fontObj.loadedName]) { + this.addFontStyle(fontObj); + this.embeddedFonts[fontObj.loadedName] = fontObj; + } - current.txtElement.setAttributeNS(null, "transform", `${pm(textMatrix)} scale(${pf(textHScale)}, -1)`); - current.txtElement.setAttributeNS(XML_NS, "xml:space", "preserve"); - current.txtElement.appendChild(current.tspan); - current.txtgrp.appendChild(current.txtElement); + current.fontMatrix = fontObj.fontMatrix ? fontObj.fontMatrix : _util.FONT_IDENTITY_MATRIX; + var bold = "normal"; - this._ensureTransformGroup().appendChild(current.txtElement); - } + if (fontObj.black) { + bold = "900"; + } else if (fontObj.bold) { + bold = "bold"; + } - setLeadingMoveText(x, y) { - this.setLeading(-y); - this.moveText(x, y); - } + var italic = fontObj.italic ? "italic" : "normal"; - addFontStyle(fontObj) { - if (!fontObj.data) { - throw new Error("addFontStyle: No font data available, " + 'ensure that the "fontExtraProperties" API parameter is set.'); - } + if (size < 0) { + size = -size; + current.fontDirection = -1; + } else { + current.fontDirection = 1; + } - if (!this.cssStyle) { - this.cssStyle = this.svgFactory.createElement("svg:style"); - this.cssStyle.setAttributeNS(null, "type", "text/css"); - this.defs.appendChild(this.cssStyle); + current.fontSize = size; + current.fontFamily = fontObj.loadedName; + current.fontWeight = bold; + current.fontStyle = italic; + current.tspan = this.svgFactory.createElement("svg:tspan"); + current.tspan.setAttributeNS(null, "y", pf(-current.y)); + current.xcoords = []; + current.ycoords = []; } - - const url = (0, _util.createObjectURL)(fontObj.data, fontObj.mimetype, this.forceDataSchema); - this.cssStyle.textContent += `@font-face { font-family: "${fontObj.loadedName}";` + ` src: url(${url}); }\n`; - } - - setFont(details) { - const current = this.current; - const fontObj = this.commonObjs.get(details[0]); - let size = details[1]; - current.font = fontObj; - - if (this.embedFonts && !fontObj.missingFile && !this.embeddedFonts[fontObj.loadedName]) { - this.addFontStyle(fontObj); - this.embeddedFonts[fontObj.loadedName] = fontObj; + }, { + key: "endText", + value: function endText() { + var current = this.current; + + if (current.textRenderingMode & _util.TextRenderingMode.ADD_TO_PATH_FLAG && current.txtElement && current.txtElement.hasChildNodes()) { + current.element = current.txtElement; + this.clip("nonzero"); + this.endPath(); + } } - - current.fontMatrix = fontObj.fontMatrix ? fontObj.fontMatrix : _util.FONT_IDENTITY_MATRIX; - let bold = "normal"; - - if (fontObj.black) { - bold = "900"; - } else if (fontObj.bold) { - bold = "bold"; + }, { + key: "setLineWidth", + value: function setLineWidth(width) { + if (width > 0) { + this.current.lineWidth = width; + } } - - const italic = fontObj.italic ? "italic" : "normal"; - - if (size < 0) { - size = -size; - current.fontDirection = -1; - } else { - current.fontDirection = 1; + }, { + key: "setLineCap", + value: function setLineCap(style) { + this.current.lineCap = LINE_CAP_STYLES[style]; } - - current.fontSize = size; - current.fontFamily = fontObj.loadedName; - current.fontWeight = bold; - current.fontStyle = italic; - current.tspan = this.svgFactory.createElement("svg:tspan"); - current.tspan.setAttributeNS(null, "y", pf(-current.y)); - current.xcoords = []; - current.ycoords = []; - } - - endText() { - const current = this.current; - - if (current.textRenderingMode & _util.TextRenderingMode.ADD_TO_PATH_FLAG && current.txtElement && current.txtElement.hasChildNodes()) { - current.element = current.txtElement; - this.clip("nonzero"); - this.endPath(); + }, { + key: "setLineJoin", + value: function setLineJoin(style) { + this.current.lineJoin = LINE_JOIN_STYLES[style]; } - } - - setLineWidth(width) { - if (width > 0) { - this.current.lineWidth = width; + }, { + key: "setMiterLimit", + value: function setMiterLimit(limit) { + this.current.miterLimit = limit; } - } - - setLineCap(style) { - this.current.lineCap = LINE_CAP_STYLES[style]; - } - - setLineJoin(style) { - this.current.lineJoin = LINE_JOIN_STYLES[style]; - } - - setMiterLimit(limit) { - this.current.miterLimit = limit; - } - - setStrokeAlpha(strokeAlpha) { - this.current.strokeAlpha = strokeAlpha; - } - - setStrokeRGBColor(r, g, b) { - this.current.strokeColor = _util.Util.makeCssRgb(r, g, b); - } - - setFillAlpha(fillAlpha) { - this.current.fillAlpha = fillAlpha; - } - - setFillRGBColor(r, g, b) { - this.current.fillColor = _util.Util.makeCssRgb(r, g, b); - this.current.tspan = this.svgFactory.createElement("svg:tspan"); - this.current.xcoords = []; - this.current.ycoords = []; - } - - setStrokeColorN(args) { - this.current.strokeColor = this._makeColorN_Pattern(args); - } - - setFillColorN(args) { - this.current.fillColor = this._makeColorN_Pattern(args); - } - - shadingFill(args) { - const width = this.viewport.width; - const height = this.viewport.height; + }, { + key: "setStrokeAlpha", + value: function setStrokeAlpha(strokeAlpha) { + this.current.strokeAlpha = strokeAlpha; + } + }, { + key: "setStrokeRGBColor", + value: function setStrokeRGBColor(r, g, b) { + this.current.strokeColor = _util.Util.makeCssRgb(r, g, b); + } + }, { + key: "setFillAlpha", + value: function setFillAlpha(fillAlpha) { + this.current.fillAlpha = fillAlpha; + } + }, { + key: "setFillRGBColor", + value: function setFillRGBColor(r, g, b) { + this.current.fillColor = _util.Util.makeCssRgb(r, g, b); + this.current.tspan = this.svgFactory.createElement("svg:tspan"); + this.current.xcoords = []; + this.current.ycoords = []; + } + }, { + key: "setStrokeColorN", + value: function setStrokeColorN(args) { + this.current.strokeColor = this._makeColorN_Pattern(args); + } + }, { + key: "setFillColorN", + value: function setFillColorN(args) { + this.current.fillColor = this._makeColorN_Pattern(args); + } + }, { + key: "shadingFill", + value: function shadingFill(args) { + var width = this.viewport.width; + var height = this.viewport.height; - const inv = _util.Util.inverseTransform(this.transformMatrix); + var inv = _util.Util.inverseTransform(this.transformMatrix); - const bl = _util.Util.applyTransform([0, 0], inv); + var bl = _util.Util.applyTransform([0, 0], inv); - const br = _util.Util.applyTransform([0, height], inv); + var br = _util.Util.applyTransform([0, height], inv); - const ul = _util.Util.applyTransform([width, 0], inv); + var ul = _util.Util.applyTransform([width, 0], inv); - const ur = _util.Util.applyTransform([width, height], inv); + var ur = _util.Util.applyTransform([width, height], inv); - const x0 = Math.min(bl[0], br[0], ul[0], ur[0]); - const y0 = Math.min(bl[1], br[1], ul[1], ur[1]); - const x1 = Math.max(bl[0], br[0], ul[0], ur[0]); - const y1 = Math.max(bl[1], br[1], ul[1], ur[1]); - const rect = this.svgFactory.createElement("svg:rect"); - rect.setAttributeNS(null, "x", x0); - rect.setAttributeNS(null, "y", y0); - rect.setAttributeNS(null, "width", x1 - x0); - rect.setAttributeNS(null, "height", y1 - y0); - rect.setAttributeNS(null, "fill", this._makeShadingPattern(args)); + var x0 = Math.min(bl[0], br[0], ul[0], ur[0]); + var y0 = Math.min(bl[1], br[1], ul[1], ur[1]); + var x1 = Math.max(bl[0], br[0], ul[0], ur[0]); + var y1 = Math.max(bl[1], br[1], ul[1], ur[1]); + var rect = this.svgFactory.createElement("svg:rect"); + rect.setAttributeNS(null, "x", x0); + rect.setAttributeNS(null, "y", y0); + rect.setAttributeNS(null, "width", x1 - x0); + rect.setAttributeNS(null, "height", y1 - y0); + rect.setAttributeNS(null, "fill", this._makeShadingPattern(args)); + + if (this.current.fillAlpha < 1) { + rect.setAttributeNS(null, "fill-opacity", this.current.fillAlpha); + } - if (this.current.fillAlpha < 1) { - rect.setAttributeNS(null, "fill-opacity", this.current.fillAlpha); + this._ensureTransformGroup().appendChild(rect); } + }, { + key: "_makeColorN_Pattern", + value: function _makeColorN_Pattern(args) { + if (args[0] === "TilingPattern") { + return this._makeTilingPattern(args); + } - this._ensureTransformGroup().appendChild(rect); - } - - _makeColorN_Pattern(args) { - if (args[0] === "TilingPattern") { - return this._makeTilingPattern(args); + return this._makeShadingPattern(args); } + }, { + key: "_makeTilingPattern", + value: function _makeTilingPattern(args) { + var color = args[1]; + var operatorList = args[2]; + var matrix = args[3] || _util.IDENTITY_MATRIX; + + var _args$ = _slicedToArray(args[4], 4), + x0 = _args$[0], + y0 = _args$[1], + x1 = _args$[2], + y1 = _args$[3]; + + var xstep = args[5]; + var ystep = args[6]; + var paintType = args[7]; + var tilingId = "shading".concat(shadingCount++); + + var _Util$applyTransform = _util.Util.applyTransform([x0, y0], matrix), + _Util$applyTransform2 = _slicedToArray(_Util$applyTransform, 2), + tx0 = _Util$applyTransform2[0], + ty0 = _Util$applyTransform2[1]; + + var _Util$applyTransform3 = _util.Util.applyTransform([x1, y1], matrix), + _Util$applyTransform4 = _slicedToArray(_Util$applyTransform3, 2), + tx1 = _Util$applyTransform4[0], + ty1 = _Util$applyTransform4[1]; + + var _Util$singularValueDe = _util.Util.singularValueDecompose2dScale(matrix), + _Util$singularValueDe2 = _slicedToArray(_Util$singularValueDe, 2), + xscale = _Util$singularValueDe2[0], + yscale = _Util$singularValueDe2[1]; + + var txstep = xstep * xscale; + var tystep = ystep * yscale; + var tiling = this.svgFactory.createElement("svg:pattern"); + tiling.setAttributeNS(null, "id", tilingId); + tiling.setAttributeNS(null, "patternUnits", "userSpaceOnUse"); + tiling.setAttributeNS(null, "width", txstep); + tiling.setAttributeNS(null, "height", tystep); + tiling.setAttributeNS(null, "x", "".concat(tx0)); + tiling.setAttributeNS(null, "y", "".concat(ty0)); + var svg = this.svg; + var transformMatrix = this.transformMatrix; + var fillColor = this.current.fillColor; + var strokeColor = this.current.strokeColor; + var bbox = this.svgFactory.create(tx1 - tx0, ty1 - ty0); + this.svg = bbox; + this.transformMatrix = matrix; + + if (paintType === 2) { + var cssColor = _util.Util.makeCssRgb.apply(_util.Util, _toConsumableArray(color)); + + this.current.fillColor = cssColor; + this.current.strokeColor = cssColor; + } - return this._makeShadingPattern(args); - } - - _makeTilingPattern(args) { - const color = args[1]; - const operatorList = args[2]; - const matrix = args[3] || _util.IDENTITY_MATRIX; - const [x0, y0, x1, y1] = args[4]; - const xstep = args[5]; - const ystep = args[6]; - const paintType = args[7]; - const tilingId = `shading${shadingCount++}`; + this.executeOpTree(this.convertOpList(operatorList)); + this.svg = svg; + this.transformMatrix = transformMatrix; + this.current.fillColor = fillColor; + this.current.strokeColor = strokeColor; + tiling.appendChild(bbox.childNodes[0]); + this.defs.appendChild(tiling); + return "url(#".concat(tilingId, ")"); + } + }, { + key: "_makeShadingPattern", + value: function _makeShadingPattern(args) { + switch (args[0]) { + case "RadialAxial": + var shadingId = "shading".concat(shadingCount++); + var colorStops = args[3]; + var gradient; + + switch (args[1]) { + case "axial": + var point0 = args[4]; + var point1 = args[5]; + gradient = this.svgFactory.createElement("svg:linearGradient"); + gradient.setAttributeNS(null, "id", shadingId); + gradient.setAttributeNS(null, "gradientUnits", "userSpaceOnUse"); + gradient.setAttributeNS(null, "x1", point0[0]); + gradient.setAttributeNS(null, "y1", point0[1]); + gradient.setAttributeNS(null, "x2", point1[0]); + gradient.setAttributeNS(null, "y2", point1[1]); + break; + + case "radial": + var focalPoint = args[4]; + var circlePoint = args[5]; + var focalRadius = args[6]; + var circleRadius = args[7]; + gradient = this.svgFactory.createElement("svg:radialGradient"); + gradient.setAttributeNS(null, "id", shadingId); + gradient.setAttributeNS(null, "gradientUnits", "userSpaceOnUse"); + gradient.setAttributeNS(null, "cx", circlePoint[0]); + gradient.setAttributeNS(null, "cy", circlePoint[1]); + gradient.setAttributeNS(null, "r", circleRadius); + gradient.setAttributeNS(null, "fx", focalPoint[0]); + gradient.setAttributeNS(null, "fy", focalPoint[1]); + gradient.setAttributeNS(null, "fr", focalRadius); + break; + + default: + throw new Error("Unknown RadialAxial type: ".concat(args[1])); + } - const [tx0, ty0] = _util.Util.applyTransform([x0, y0], matrix); + var _iterator5 = _createForOfIteratorHelper(colorStops), + _step5; - const [tx1, ty1] = _util.Util.applyTransform([x1, y1], matrix); + try { + for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) { + var colorStop = _step5.value; + var stop = this.svgFactory.createElement("svg:stop"); + stop.setAttributeNS(null, "offset", colorStop[0]); + stop.setAttributeNS(null, "stop-color", colorStop[1]); + gradient.appendChild(stop); + } + } catch (err) { + _iterator5.e(err); + } finally { + _iterator5.f(); + } - const [xscale, yscale] = _util.Util.singularValueDecompose2dScale(matrix); + this.defs.appendChild(gradient); + return "url(#".concat(shadingId, ")"); - const txstep = xstep * xscale; - const tystep = ystep * yscale; - const tiling = this.svgFactory.createElement("svg:pattern"); - tiling.setAttributeNS(null, "id", tilingId); - tiling.setAttributeNS(null, "patternUnits", "userSpaceOnUse"); - tiling.setAttributeNS(null, "width", txstep); - tiling.setAttributeNS(null, "height", tystep); - tiling.setAttributeNS(null, "x", `${tx0}`); - tiling.setAttributeNS(null, "y", `${ty0}`); - const svg = this.svg; - const transformMatrix = this.transformMatrix; - const fillColor = this.current.fillColor; - const strokeColor = this.current.strokeColor; - const bbox = this.svgFactory.create(tx1 - tx0, ty1 - ty0); - this.svg = bbox; - this.transformMatrix = matrix; + case "Mesh": + (0, _util.warn)("Unimplemented pattern Mesh"); + return null; - if (paintType === 2) { - const cssColor = _util.Util.makeCssRgb(...color); + case "Dummy": + return "hotpink"; - this.current.fillColor = cssColor; - this.current.strokeColor = cssColor; + default: + throw new Error("Unknown IR type: ".concat(args[0])); + } } + }, { + key: "setDash", + value: function setDash(dashArray, dashPhase) { + this.current.dashArray = dashArray; + this.current.dashPhase = dashPhase; + } + }, { + key: "constructPath", + value: function constructPath(ops, args) { + var current = this.current; + var x = current.x, + y = current.y; + var d = []; + var j = 0; - this.executeOpTree(this.convertOpList(operatorList)); - this.svg = svg; - this.transformMatrix = transformMatrix; - this.current.fillColor = fillColor; - this.current.strokeColor = strokeColor; - tiling.appendChild(bbox.childNodes[0]); - this.defs.appendChild(tiling); - return `url(#${tilingId})`; - } - - _makeShadingPattern(args) { - switch (args[0]) { - case "RadialAxial": - const shadingId = `shading${shadingCount++}`; - const colorStops = args[3]; - let gradient; - - switch (args[1]) { - case "axial": - const point0 = args[4]; - const point1 = args[5]; - gradient = this.svgFactory.createElement("svg:linearGradient"); - gradient.setAttributeNS(null, "id", shadingId); - gradient.setAttributeNS(null, "gradientUnits", "userSpaceOnUse"); - gradient.setAttributeNS(null, "x1", point0[0]); - gradient.setAttributeNS(null, "y1", point0[1]); - gradient.setAttributeNS(null, "x2", point1[0]); - gradient.setAttributeNS(null, "y2", point1[1]); - break; - - case "radial": - const focalPoint = args[4]; - const circlePoint = args[5]; - const focalRadius = args[6]; - const circleRadius = args[7]; - gradient = this.svgFactory.createElement("svg:radialGradient"); - gradient.setAttributeNS(null, "id", shadingId); - gradient.setAttributeNS(null, "gradientUnits", "userSpaceOnUse"); - gradient.setAttributeNS(null, "cx", circlePoint[0]); - gradient.setAttributeNS(null, "cy", circlePoint[1]); - gradient.setAttributeNS(null, "r", circleRadius); - gradient.setAttributeNS(null, "fx", focalPoint[0]); - gradient.setAttributeNS(null, "fy", focalPoint[1]); - gradient.setAttributeNS(null, "fr", focalRadius); - break; - - default: - throw new Error(`Unknown RadialAxial type: ${args[1]}`); - } + var _iterator6 = _createForOfIteratorHelper(ops), + _step6; - for (const colorStop of colorStops) { - const stop = this.svgFactory.createElement("svg:stop"); - stop.setAttributeNS(null, "offset", colorStop[0]); - stop.setAttributeNS(null, "stop-color", colorStop[1]); - gradient.appendChild(stop); + try { + for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) { + var op = _step6.value; + + switch (op | 0) { + case _util.OPS.rectangle: + x = args[j++]; + y = args[j++]; + var width = args[j++]; + var height = args[j++]; + var xw = x + width; + var yh = y + height; + d.push("M", pf(x), pf(y), "L", pf(xw), pf(y), "L", pf(xw), pf(yh), "L", pf(x), pf(yh), "Z"); + break; + + case _util.OPS.moveTo: + x = args[j++]; + y = args[j++]; + d.push("M", pf(x), pf(y)); + break; + + case _util.OPS.lineTo: + x = args[j++]; + y = args[j++]; + d.push("L", pf(x), pf(y)); + break; + + case _util.OPS.curveTo: + x = args[j + 4]; + y = args[j + 5]; + d.push("C", pf(args[j]), pf(args[j + 1]), pf(args[j + 2]), pf(args[j + 3]), pf(x), pf(y)); + j += 6; + break; + + case _util.OPS.curveTo2: + d.push("C", pf(x), pf(y), pf(args[j]), pf(args[j + 1]), pf(args[j + 2]), pf(args[j + 3])); + x = args[j + 2]; + y = args[j + 3]; + j += 4; + break; + + case _util.OPS.curveTo3: + x = args[j + 2]; + y = args[j + 3]; + d.push("C", pf(args[j]), pf(args[j + 1]), pf(x), pf(y), pf(x), pf(y)); + j += 4; + break; + + case _util.OPS.closePath: + d.push("Z"); + break; + } } + } catch (err) { + _iterator6.e(err); + } finally { + _iterator6.f(); + } - this.defs.appendChild(gradient); - return `url(#${shadingId})`; + d = d.join(" "); - case "Mesh": - (0, _util.warn)("Unimplemented pattern Mesh"); - return null; + if (current.path && ops.length > 0 && ops[0] !== _util.OPS.rectangle && ops[0] !== _util.OPS.moveTo) { + d = current.path.getAttributeNS(null, "d") + d; + } else { + current.path = this.svgFactory.createElement("svg:path"); - case "Dummy": - return "hotpink"; + this._ensureTransformGroup().appendChild(current.path); + } - default: - throw new Error(`Unknown IR type: ${args[0]}`); + current.path.setAttributeNS(null, "d", d); + current.path.setAttributeNS(null, "fill", "none"); + current.element = current.path; + current.setCurrentPoint(x, y); } - } - - setDash(dashArray, dashPhase) { - this.current.dashArray = dashArray; - this.current.dashPhase = dashPhase; - } + }, { + key: "endPath", + value: function endPath() { + var current = this.current; + current.path = null; - constructPath(ops, args) { - const current = this.current; - let x = current.x, - y = current.y; - let d = []; - let j = 0; + if (!this.pendingClip) { + return; + } - for (const op of ops) { - switch (op | 0) { - case _util.OPS.rectangle: - x = args[j++]; - y = args[j++]; - const width = args[j++]; - const height = args[j++]; - const xw = x + width; - const yh = y + height; - d.push("M", pf(x), pf(y), "L", pf(xw), pf(y), "L", pf(xw), pf(yh), "L", pf(x), pf(yh), "Z"); - break; + if (!current.element) { + this.pendingClip = null; + return; + } - case _util.OPS.moveTo: - x = args[j++]; - y = args[j++]; - d.push("M", pf(x), pf(y)); - break; + var clipId = "clippath".concat(clipCount++); + var clipPath = this.svgFactory.createElement("svg:clipPath"); + clipPath.setAttributeNS(null, "id", clipId); + clipPath.setAttributeNS(null, "transform", pm(this.transformMatrix)); + var clipElement = current.element.cloneNode(true); - case _util.OPS.lineTo: - x = args[j++]; - y = args[j++]; - d.push("L", pf(x), pf(y)); - break; + if (this.pendingClip === "evenodd") { + clipElement.setAttributeNS(null, "clip-rule", "evenodd"); + } else { + clipElement.setAttributeNS(null, "clip-rule", "nonzero"); + } - case _util.OPS.curveTo: - x = args[j + 4]; - y = args[j + 5]; - d.push("C", pf(args[j]), pf(args[j + 1]), pf(args[j + 2]), pf(args[j + 3]), pf(x), pf(y)); - j += 6; - break; + this.pendingClip = null; + clipPath.appendChild(clipElement); + this.defs.appendChild(clipPath); - case _util.OPS.curveTo2: - d.push("C", pf(x), pf(y), pf(args[j]), pf(args[j + 1]), pf(args[j + 2]), pf(args[j + 3])); - x = args[j + 2]; - y = args[j + 3]; - j += 4; - break; + if (current.activeClipUrl) { + current.clipGroup = null; + this.extraStack.forEach(function (prev) { + prev.clipGroup = null; + }); + clipPath.setAttributeNS(null, "clip-path", current.activeClipUrl); + } - case _util.OPS.curveTo3: - x = args[j + 2]; - y = args[j + 3]; - d.push("C", pf(args[j]), pf(args[j + 1]), pf(x), pf(y), pf(x), pf(y)); - j += 4; - break; + current.activeClipUrl = "url(#".concat(clipId, ")"); + this.tgrp = null; + } + }, { + key: "clip", + value: function clip(type) { + this.pendingClip = type; + } + }, { + key: "closePath", + value: function closePath() { + var current = this.current; - case _util.OPS.closePath: - d.push("Z"); - break; + if (current.path) { + var d = "".concat(current.path.getAttributeNS(null, "d"), "Z"); + current.path.setAttributeNS(null, "d", d); } } - - d = d.join(" "); - - if (current.path && ops.length > 0 && ops[0] !== _util.OPS.rectangle && ops[0] !== _util.OPS.moveTo) { - d = current.path.getAttributeNS(null, "d") + d; - } else { - current.path = this.svgFactory.createElement("svg:path"); - - this._ensureTransformGroup().appendChild(current.path); + }, { + key: "setLeading", + value: function setLeading(leading) { + this.current.leading = -leading; } - - current.path.setAttributeNS(null, "d", d); - current.path.setAttributeNS(null, "fill", "none"); - current.element = current.path; - current.setCurrentPoint(x, y); - } - - endPath() { - const current = this.current; - current.path = null; - - if (!this.pendingClip) { - return; + }, { + key: "setTextRise", + value: function setTextRise(textRise) { + this.current.textRise = textRise; } - - if (!current.element) { - this.pendingClip = null; - return; + }, { + key: "setTextRenderingMode", + value: function setTextRenderingMode(textRenderingMode) { + this.current.textRenderingMode = textRenderingMode; } - - const clipId = `clippath${clipCount++}`; - const clipPath = this.svgFactory.createElement("svg:clipPath"); - clipPath.setAttributeNS(null, "id", clipId); - clipPath.setAttributeNS(null, "transform", pm(this.transformMatrix)); - const clipElement = current.element.cloneNode(true); - - if (this.pendingClip === "evenodd") { - clipElement.setAttributeNS(null, "clip-rule", "evenodd"); - } else { - clipElement.setAttributeNS(null, "clip-rule", "nonzero"); + }, { + key: "setHScale", + value: function setHScale(scale) { + this.current.textHScale = scale / 100; } + }, { + key: "setRenderingIntent", + value: function setRenderingIntent(intent) {} + }, { + key: "setFlatness", + value: function setFlatness(flatness) {} + }, { + key: "setGState", + value: function setGState(states) { + var _iterator7 = _createForOfIteratorHelper(states), + _step7; - this.pendingClip = null; - clipPath.appendChild(clipElement); - this.defs.appendChild(clipPath); - - if (current.activeClipUrl) { - current.clipGroup = null; - this.extraStack.forEach(function (prev) { - prev.clipGroup = null; - }); - clipPath.setAttributeNS(null, "clip-path", current.activeClipUrl); + try { + for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) { + var _step7$value = _slicedToArray(_step7.value, 2), + key = _step7$value[0], + value = _step7$value[1]; + + switch (key) { + case "LW": + this.setLineWidth(value); + break; + + case "LC": + this.setLineCap(value); + break; + + case "LJ": + this.setLineJoin(value); + break; + + case "ML": + this.setMiterLimit(value); + break; + + case "D": + this.setDash(value[0], value[1]); + break; + + case "RI": + this.setRenderingIntent(value); + break; + + case "FL": + this.setFlatness(value); + break; + + case "Font": + this.setFont(value); + break; + + case "CA": + this.setStrokeAlpha(value); + break; + + case "ca": + this.setFillAlpha(value); + break; + + default: + (0, _util.warn)("Unimplemented graphic state operator ".concat(key)); + break; + } + } + } catch (err) { + _iterator7.e(err); + } finally { + _iterator7.f(); + } } - - current.activeClipUrl = `url(#${clipId})`; - this.tgrp = null; - } - - clip(type) { - this.pendingClip = type; - } - - closePath() { - const current = this.current; - - if (current.path) { - const d = `${current.path.getAttributeNS(null, "d")}Z`; - current.path.setAttributeNS(null, "d", d); + }, { + key: "fill", + value: function fill() { + var current = this.current; + + if (current.element) { + current.element.setAttributeNS(null, "fill", current.fillColor); + current.element.setAttributeNS(null, "fill-opacity", current.fillAlpha); + this.endPath(); + } } - } - - setLeading(leading) { - this.current.leading = -leading; - } - - setTextRise(textRise) { - this.current.textRise = textRise; - } - - setTextRenderingMode(textRenderingMode) { - this.current.textRenderingMode = textRenderingMode; - } - - setHScale(scale) { - this.current.textHScale = scale / 100; - } - - setRenderingIntent(intent) {} - - setFlatness(flatness) {} - - setGState(states) { - for (const [key, value] of states) { - switch (key) { - case "LW": - this.setLineWidth(value); - break; - - case "LC": - this.setLineCap(value); - break; - - case "LJ": - this.setLineJoin(value); - break; - - case "ML": - this.setMiterLimit(value); - break; - - case "D": - this.setDash(value[0], value[1]); - break; - - case "RI": - this.setRenderingIntent(value); - break; - - case "FL": - this.setFlatness(value); - break; - - case "Font": - this.setFont(value); - break; - - case "CA": - this.setStrokeAlpha(value); - break; + }, { + key: "stroke", + value: function stroke() { + var current = this.current; - case "ca": - this.setFillAlpha(value); - break; + if (current.element) { + this._setStrokeAttributes(current.element); - default: - (0, _util.warn)(`Unimplemented graphic state operator ${key}`); - break; + current.element.setAttributeNS(null, "fill", "none"); + this.endPath(); } } - } - - fill() { - const current = this.current; + }, { + key: "_setStrokeAttributes", + value: function _setStrokeAttributes(element) { + var lineWidthScale = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1; + var current = this.current; + var dashArray = current.dashArray; + + if (lineWidthScale !== 1 && dashArray.length > 0) { + dashArray = dashArray.map(function (value) { + return lineWidthScale * value; + }); + } - if (current.element) { - current.element.setAttributeNS(null, "fill", current.fillColor); - current.element.setAttributeNS(null, "fill-opacity", current.fillAlpha); - this.endPath(); + element.setAttributeNS(null, "stroke", current.strokeColor); + element.setAttributeNS(null, "stroke-opacity", current.strokeAlpha); + element.setAttributeNS(null, "stroke-miterlimit", pf(current.miterLimit)); + element.setAttributeNS(null, "stroke-linecap", current.lineCap); + element.setAttributeNS(null, "stroke-linejoin", current.lineJoin); + element.setAttributeNS(null, "stroke-width", pf(lineWidthScale * current.lineWidth) + "px"); + element.setAttributeNS(null, "stroke-dasharray", dashArray.map(pf).join(" ")); + element.setAttributeNS(null, "stroke-dashoffset", pf(lineWidthScale * current.dashPhase) + "px"); } - } - - stroke() { - const current = this.current; - - if (current.element) { - this._setStrokeAttributes(current.element); + }, { + key: "eoFill", + value: function eoFill() { + if (this.current.element) { + this.current.element.setAttributeNS(null, "fill-rule", "evenodd"); + } - current.element.setAttributeNS(null, "fill", "none"); - this.endPath(); + this.fill(); } - } - - _setStrokeAttributes(element, lineWidthScale = 1) { - const current = this.current; - let dashArray = current.dashArray; - - if (lineWidthScale !== 1 && dashArray.length > 0) { - dashArray = dashArray.map(function (value) { - return lineWidthScale * value; - }); + }, { + key: "fillStroke", + value: function fillStroke() { + this.stroke(); + this.fill(); } + }, { + key: "eoFillStroke", + value: function eoFillStroke() { + if (this.current.element) { + this.current.element.setAttributeNS(null, "fill-rule", "evenodd"); + } - element.setAttributeNS(null, "stroke", current.strokeColor); - element.setAttributeNS(null, "stroke-opacity", current.strokeAlpha); - element.setAttributeNS(null, "stroke-miterlimit", pf(current.miterLimit)); - element.setAttributeNS(null, "stroke-linecap", current.lineCap); - element.setAttributeNS(null, "stroke-linejoin", current.lineJoin); - element.setAttributeNS(null, "stroke-width", pf(lineWidthScale * current.lineWidth) + "px"); - element.setAttributeNS(null, "stroke-dasharray", dashArray.map(pf).join(" ")); - element.setAttributeNS(null, "stroke-dashoffset", pf(lineWidthScale * current.dashPhase) + "px"); - } - - eoFill() { - if (this.current.element) { - this.current.element.setAttributeNS(null, "fill-rule", "evenodd"); + this.fillStroke(); } - - this.fill(); - } - - fillStroke() { - this.stroke(); - this.fill(); - } - - eoFillStroke() { - if (this.current.element) { - this.current.element.setAttributeNS(null, "fill-rule", "evenodd"); + }, { + key: "closeStroke", + value: function closeStroke() { + this.closePath(); + this.stroke(); } - - this.fillStroke(); - } - - closeStroke() { - this.closePath(); - this.stroke(); - } - - closeFillStroke() { - this.closePath(); - this.fillStroke(); - } - - closeEOFillStroke() { - this.closePath(); - this.eoFillStroke(); - } - - paintSolidColorImageMask() { - const rect = this.svgFactory.createElement("svg:rect"); - rect.setAttributeNS(null, "x", "0"); - rect.setAttributeNS(null, "y", "0"); - rect.setAttributeNS(null, "width", "1px"); - rect.setAttributeNS(null, "height", "1px"); - rect.setAttributeNS(null, "fill", this.current.fillColor); - - this._ensureTransformGroup().appendChild(rect); - } - - paintImageXObject(objId) { - const imgData = this.objs.get(objId); - - if (!imgData) { - (0, _util.warn)(`Dependent image with object ID ${objId} is not ready yet`); - return; + }, { + key: "closeFillStroke", + value: function closeFillStroke() { + this.closePath(); + this.fillStroke(); } - - this.paintInlineImageXObject(imgData); - } - - paintInlineImageXObject(imgData, mask) { - const width = imgData.width; - const height = imgData.height; - const imgSrc = convertImgDataToPng(imgData, this.forceDataSchema, !!mask); - const cliprect = this.svgFactory.createElement("svg:rect"); - cliprect.setAttributeNS(null, "x", "0"); - cliprect.setAttributeNS(null, "y", "0"); - cliprect.setAttributeNS(null, "width", pf(width)); - cliprect.setAttributeNS(null, "height", pf(height)); - this.current.element = cliprect; - this.clip("nonzero"); - const imgEl = this.svgFactory.createElement("svg:image"); - imgEl.setAttributeNS(XLINK_NS, "xlink:href", imgSrc); - imgEl.setAttributeNS(null, "x", "0"); - imgEl.setAttributeNS(null, "y", pf(-height)); - imgEl.setAttributeNS(null, "width", pf(width) + "px"); - imgEl.setAttributeNS(null, "height", pf(height) + "px"); - imgEl.setAttributeNS(null, "transform", `scale(${pf(1 / width)} ${pf(-1 / height)})`); - - if (mask) { - mask.appendChild(imgEl); - } else { - this._ensureTransformGroup().appendChild(imgEl); + }, { + key: "closeEOFillStroke", + value: function closeEOFillStroke() { + this.closePath(); + this.eoFillStroke(); } - } - - paintImageMaskXObject(imgData) { - const current = this.current; - const width = imgData.width; - const height = imgData.height; - const fillColor = current.fillColor; - current.maskId = `mask${maskCount++}`; - const mask = this.svgFactory.createElement("svg:mask"); - mask.setAttributeNS(null, "id", current.maskId); - const rect = this.svgFactory.createElement("svg:rect"); - rect.setAttributeNS(null, "x", "0"); - rect.setAttributeNS(null, "y", "0"); - rect.setAttributeNS(null, "width", pf(width)); - rect.setAttributeNS(null, "height", pf(height)); - rect.setAttributeNS(null, "fill", fillColor); - rect.setAttributeNS(null, "mask", `url(#${current.maskId})`); - this.defs.appendChild(mask); + }, { + key: "paintSolidColorImageMask", + value: function paintSolidColorImageMask() { + var rect = this.svgFactory.createElement("svg:rect"); + rect.setAttributeNS(null, "x", "0"); + rect.setAttributeNS(null, "y", "0"); + rect.setAttributeNS(null, "width", "1px"); + rect.setAttributeNS(null, "height", "1px"); + rect.setAttributeNS(null, "fill", this.current.fillColor); - this._ensureTransformGroup().appendChild(rect); + this._ensureTransformGroup().appendChild(rect); + } + }, { + key: "paintImageXObject", + value: function paintImageXObject(objId) { + var imgData = this.objs.get(objId); - this.paintInlineImageXObject(imgData, mask); - } + if (!imgData) { + (0, _util.warn)("Dependent image with object ID ".concat(objId, " is not ready yet")); + return; + } - paintFormXObjectBegin(matrix, bbox) { - if (Array.isArray(matrix) && matrix.length === 6) { - this.transform(matrix[0], matrix[1], matrix[2], matrix[3], matrix[4], matrix[5]); + this.paintInlineImageXObject(imgData); } - - if (bbox) { - const width = bbox[2] - bbox[0]; - const height = bbox[3] - bbox[1]; - const cliprect = this.svgFactory.createElement("svg:rect"); - cliprect.setAttributeNS(null, "x", bbox[0]); - cliprect.setAttributeNS(null, "y", bbox[1]); + }, { + key: "paintInlineImageXObject", + value: function paintInlineImageXObject(imgData, mask) { + var width = imgData.width; + var height = imgData.height; + var imgSrc = convertImgDataToPng(imgData, this.forceDataSchema, !!mask); + var cliprect = this.svgFactory.createElement("svg:rect"); + cliprect.setAttributeNS(null, "x", "0"); + cliprect.setAttributeNS(null, "y", "0"); cliprect.setAttributeNS(null, "width", pf(width)); cliprect.setAttributeNS(null, "height", pf(height)); this.current.element = cliprect; this.clip("nonzero"); - this.endPath(); + var imgEl = this.svgFactory.createElement("svg:image"); + imgEl.setAttributeNS(XLINK_NS, "xlink:href", imgSrc); + imgEl.setAttributeNS(null, "x", "0"); + imgEl.setAttributeNS(null, "y", pf(-height)); + imgEl.setAttributeNS(null, "width", pf(width) + "px"); + imgEl.setAttributeNS(null, "height", pf(height) + "px"); + imgEl.setAttributeNS(null, "transform", "scale(".concat(pf(1 / width), " ").concat(pf(-1 / height), ")")); + + if (mask) { + mask.appendChild(imgEl); + } else { + this._ensureTransformGroup().appendChild(imgEl); + } } - } - - paintFormXObjectEnd() {} - - _initialize(viewport) { - const svg = this.svgFactory.create(viewport.width, viewport.height); - const definitions = this.svgFactory.createElement("svg:defs"); - svg.appendChild(definitions); - this.defs = definitions; - const rootGroup = this.svgFactory.createElement("svg:g"); - rootGroup.setAttributeNS(null, "transform", pm(viewport.transform)); - svg.appendChild(rootGroup); - this.svg = rootGroup; - return svg; - } - - _ensureClipGroup() { - if (!this.current.clipGroup) { - const clipGroup = this.svgFactory.createElement("svg:g"); - clipGroup.setAttributeNS(null, "clip-path", this.current.activeClipUrl); - this.svg.appendChild(clipGroup); - this.current.clipGroup = clipGroup; + }, { + key: "paintImageMaskXObject", + value: function paintImageMaskXObject(imgData) { + var current = this.current; + var width = imgData.width; + var height = imgData.height; + var fillColor = current.fillColor; + current.maskId = "mask".concat(maskCount++); + var mask = this.svgFactory.createElement("svg:mask"); + mask.setAttributeNS(null, "id", current.maskId); + var rect = this.svgFactory.createElement("svg:rect"); + rect.setAttributeNS(null, "x", "0"); + rect.setAttributeNS(null, "y", "0"); + rect.setAttributeNS(null, "width", pf(width)); + rect.setAttributeNS(null, "height", pf(height)); + rect.setAttributeNS(null, "fill", fillColor); + rect.setAttributeNS(null, "mask", "url(#".concat(current.maskId, ")")); + this.defs.appendChild(mask); + + this._ensureTransformGroup().appendChild(rect); + + this.paintInlineImageXObject(imgData, mask); } + }, { + key: "paintFormXObjectBegin", + value: function paintFormXObjectBegin(matrix, bbox) { + if (Array.isArray(matrix) && matrix.length === 6) { + this.transform(matrix[0], matrix[1], matrix[2], matrix[3], matrix[4], matrix[5]); + } - return this.current.clipGroup; - } - - _ensureTransformGroup() { - if (!this.tgrp) { - this.tgrp = this.svgFactory.createElement("svg:g"); - this.tgrp.setAttributeNS(null, "transform", pm(this.transformMatrix)); - - if (this.current.activeClipUrl) { - this._ensureClipGroup().appendChild(this.tgrp); - } else { - this.svg.appendChild(this.tgrp); + if (bbox) { + var width = bbox[2] - bbox[0]; + var height = bbox[3] - bbox[1]; + var cliprect = this.svgFactory.createElement("svg:rect"); + cliprect.setAttributeNS(null, "x", bbox[0]); + cliprect.setAttributeNS(null, "y", bbox[1]); + cliprect.setAttributeNS(null, "width", pf(width)); + cliprect.setAttributeNS(null, "height", pf(height)); + this.current.element = cliprect; + this.clip("nonzero"); + this.endPath(); } } + }, { + key: "paintFormXObjectEnd", + value: function paintFormXObjectEnd() {} + }, { + key: "_initialize", + value: function _initialize(viewport) { + var svg = this.svgFactory.create(viewport.width, viewport.height); + var definitions = this.svgFactory.createElement("svg:defs"); + svg.appendChild(definitions); + this.defs = definitions; + var rootGroup = this.svgFactory.createElement("svg:g"); + rootGroup.setAttributeNS(null, "transform", pm(viewport.transform)); + svg.appendChild(rootGroup); + this.svg = rootGroup; + return svg; + } + }, { + key: "_ensureClipGroup", + value: function _ensureClipGroup() { + if (!this.current.clipGroup) { + var clipGroup = this.svgFactory.createElement("svg:g"); + clipGroup.setAttributeNS(null, "clip-path", this.current.activeClipUrl); + this.svg.appendChild(clipGroup); + this.current.clipGroup = clipGroup; + } - return this.tgrp; - } + return this.current.clipGroup; + } + }, { + key: "_ensureTransformGroup", + value: function _ensureTransformGroup() { + if (!this.tgrp) { + this.tgrp = this.svgFactory.createElement("svg:g"); + this.tgrp.setAttributeNS(null, "transform", pm(this.transformMatrix)); + + if (this.current.activeClipUrl) { + this._ensureClipGroup().appendChild(this.tgrp); + } else { + this.svg.appendChild(this.tgrp); + } + } - }; + return this.tgrp; + } + }]); + + return SVGGraphics; + }(); } /***/ }), -/* 19 */ +/* 212 */ /***/ (function(module, exports, __w_pdfjs_require__) { "use strict"; @@ -11901,31 +23668,61 @@ Object.defineProperty(exports, "__esModule", { }); exports.PDFNodeStream = void 0; -var _util = __w_pdfjs_require__(2); +var _regenerator = _interopRequireDefault(__w_pdfjs_require__(2)); + +var _util = __w_pdfjs_require__(5); + +var _network_utils = __w_pdfjs_require__(213); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } -var _network_utils = __w_pdfjs_require__(20); +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } + +function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } } + +function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } ; -const fs = require("fs"); +var fs = require("fs"); -const http = require("http"); +var http = require("http"); -const https = require("https"); +var https = require("https"); -const url = require("url"); +var url = require("url"); -const fileUriRegex = /^file:\/\/\/[a-zA-Z]:\//; +var fileUriRegex = /^file:\/\/\/[a-zA-Z]:\//; function parseUrl(sourceUrl) { - const parsedUrl = url.parse(sourceUrl); + var parsedUrl = url.parse(sourceUrl); if (parsedUrl.protocol === "file:" || parsedUrl.host) { return parsedUrl; } if (/^[a-z]:[/\\]/i.test(sourceUrl)) { - return url.parse(`file:///${sourceUrl}`); + return url.parse("file:///".concat(sourceUrl)); } if (!parsedUrl.host) { @@ -11935,8 +23732,10 @@ function parseUrl(sourceUrl) { return parsedUrl; } -class PDFNodeStream { - constructor(source) { +var PDFNodeStream = /*#__PURE__*/function () { + function PDFNodeStream(source) { + _classCallCheck(this, PDFNodeStream); + this.source = source; this.url = parseUrl(source.url); this.isHttp = this.url.protocol === "http:" || this.url.protocol === "https:"; @@ -11946,51 +23745,60 @@ class PDFNodeStream { this._rangeRequestReaders = []; } - get _progressiveDataLength() { - return this._fullRequestReader ? this._fullRequestReader._loaded : 0; - } - - getFullReader() { - (0, _util.assert)(!this._fullRequestReader, "PDFNodeStream.getFullReader can only be called once."); - this._fullRequestReader = this.isFsUrl ? new PDFNodeStreamFsFullReader(this) : new PDFNodeStreamFullReader(this); - return this._fullRequestReader; - } - - getRangeReader(start, end) { - if (end <= this._progressiveDataLength) { - return null; + _createClass(PDFNodeStream, [{ + key: "getFullReader", + value: function getFullReader() { + (0, _util.assert)(!this._fullRequestReader, "PDFNodeStream.getFullReader can only be called once."); + this._fullRequestReader = this.isFsUrl ? new PDFNodeStreamFsFullReader(this) : new PDFNodeStreamFullReader(this); + return this._fullRequestReader; } + }, { + key: "getRangeReader", + value: function getRangeReader(start, end) { + if (end <= this._progressiveDataLength) { + return null; + } - const rangeReader = this.isFsUrl ? new PDFNodeStreamFsRangeReader(this, start, end) : new PDFNodeStreamRangeReader(this, start, end); - - this._rangeRequestReaders.push(rangeReader); + var rangeReader = this.isFsUrl ? new PDFNodeStreamFsRangeReader(this, start, end) : new PDFNodeStreamRangeReader(this, start, end); - return rangeReader; - } + this._rangeRequestReaders.push(rangeReader); - cancelAllRequests(reason) { - if (this._fullRequestReader) { - this._fullRequestReader.cancel(reason); + return rangeReader; } + }, { + key: "cancelAllRequests", + value: function cancelAllRequests(reason) { + if (this._fullRequestReader) { + this._fullRequestReader.cancel(reason); + } - const readers = this._rangeRequestReaders.slice(0); + var readers = this._rangeRequestReaders.slice(0); - readers.forEach(function (reader) { - reader.cancel(reason); - }); - } + readers.forEach(function (reader) { + reader.cancel(reason); + }); + } + }, { + key: "_progressiveDataLength", + get: function get() { + return this._fullRequestReader ? this._fullRequestReader._loaded : 0; + } + }]); -} + return PDFNodeStream; +}(); exports.PDFNodeStream = PDFNodeStream; -class BaseFullReader { - constructor(stream) { +var BaseFullReader = /*#__PURE__*/function () { + function BaseFullReader(stream) { + _classCallCheck(this, BaseFullReader); + this._url = stream.url; this._done = false; this._storedError = null; this.onProgress = null; - const source = stream.source; + var source = stream.source; this._contentLength = source.length; this._loaded = 0; this._filename = null; @@ -12008,107 +23816,157 @@ class BaseFullReader { this._headersCapability = (0, _util.createPromiseCapability)(); } - get headersReady() { - return this._headersCapability.promise; - } + _createClass(BaseFullReader, [{ + key: "read", + value: function () { + var _read = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee() { + var chunk, buffer; + return _regenerator["default"].wrap(function _callee$(_context) { + while (1) { + switch (_context.prev = _context.next) { + case 0: + _context.next = 2; + return this._readCapability.promise; + + case 2: + if (!this._done) { + _context.next = 4; + break; + } - get filename() { - return this._filename; - } + return _context.abrupt("return", { + value: undefined, + done: true + }); - get contentLength() { - return this._contentLength; - } + case 4: + if (!this._storedError) { + _context.next = 6; + break; + } - get isRangeSupported() { - return this._isRangeSupported; - } + throw this._storedError; - get isStreamingSupported() { - return this._isStreamingSupported; - } + case 6: + chunk = this._readableStream.read(); - async read() { - await this._readCapability.promise; + if (!(chunk === null)) { + _context.next = 10; + break; + } - if (this._done) { - return { - value: undefined, - done: true - }; - } + this._readCapability = (0, _util.createPromiseCapability)(); + return _context.abrupt("return", this.read()); - if (this._storedError) { - throw this._storedError; - } + case 10: + this._loaded += chunk.length; - const chunk = this._readableStream.read(); + if (this.onProgress) { + this.onProgress({ + loaded: this._loaded, + total: this._contentLength + }); + } - if (chunk === null) { - this._readCapability = (0, _util.createPromiseCapability)(); - return this.read(); - } + buffer = new Uint8Array(chunk).buffer; + return _context.abrupt("return", { + value: buffer, + done: false + }); - this._loaded += chunk.length; + case 14: + case "end": + return _context.stop(); + } + } + }, _callee, this); + })); - if (this.onProgress) { - this.onProgress({ - loaded: this._loaded, - total: this._contentLength - }); - } + function read() { + return _read.apply(this, arguments); + } - const buffer = new Uint8Array(chunk).buffer; - return { - value: buffer, - done: false - }; - } + return read; + }() + }, { + key: "cancel", + value: function cancel(reason) { + if (!this._readableStream) { + this._error(reason); - cancel(reason) { - if (!this._readableStream) { - this._error(reason); + return; + } - return; + this._readableStream.destroy(reason); } + }, { + key: "_error", + value: function _error(reason) { + this._storedError = reason; - this._readableStream.destroy(reason); - } - - _error(reason) { - this._storedError = reason; + this._readCapability.resolve(); + } + }, { + key: "_setReadableStream", + value: function _setReadableStream(readableStream) { + var _this = this; - this._readCapability.resolve(); - } + this._readableStream = readableStream; + readableStream.on("readable", function () { + _this._readCapability.resolve(); + }); + readableStream.on("end", function () { + readableStream.destroy(); + _this._done = true; - _setReadableStream(readableStream) { - this._readableStream = readableStream; - readableStream.on("readable", () => { - this._readCapability.resolve(); - }); - readableStream.on("end", () => { - readableStream.destroy(); - this._done = true; + _this._readCapability.resolve(); + }); + readableStream.on("error", function (reason) { + _this._error(reason); + }); - this._readCapability.resolve(); - }); - readableStream.on("error", reason => { - this._error(reason); - }); + if (!this._isStreamingSupported && this._isRangeSupported) { + this._error(new _util.AbortException("streaming is disabled")); + } - if (!this._isStreamingSupported && this._isRangeSupported) { - this._error(new _util.AbortException("streaming is disabled")); + if (this._storedError) { + this._readableStream.destroy(this._storedError); + } } - - if (this._storedError) { - this._readableStream.destroy(this._storedError); + }, { + key: "headersReady", + get: function get() { + return this._headersCapability.promise; } - } + }, { + key: "filename", + get: function get() { + return this._filename; + } + }, { + key: "contentLength", + get: function get() { + return this._contentLength; + } + }, { + key: "isRangeSupported", + get: function get() { + return this._isRangeSupported; + } + }, { + key: "isStreamingSupported", + get: function get() { + return this._isStreamingSupported; + } + }]); -} + return BaseFullReader; +}(); + +var BaseRangeReader = /*#__PURE__*/function () { + function BaseRangeReader(stream) { + _classCallCheck(this, BaseRangeReader); -class BaseRangeReader { - constructor(stream) { this._url = stream.url; this._done = false; this._storedError = null; @@ -12116,87 +23974,131 @@ class BaseRangeReader { this._loaded = 0; this._readableStream = null; this._readCapability = (0, _util.createPromiseCapability)(); - const source = stream.source; + var source = stream.source; this._isStreamingSupported = !source.disableStream; } - get isStreamingSupported() { - return this._isStreamingSupported; - } + _createClass(BaseRangeReader, [{ + key: "read", + value: function () { + var _read2 = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee2() { + var chunk, buffer; + return _regenerator["default"].wrap(function _callee2$(_context2) { + while (1) { + switch (_context2.prev = _context2.next) { + case 0: + _context2.next = 2; + return this._readCapability.promise; + + case 2: + if (!this._done) { + _context2.next = 4; + break; + } - async read() { - await this._readCapability.promise; + return _context2.abrupt("return", { + value: undefined, + done: true + }); - if (this._done) { - return { - value: undefined, - done: true - }; - } + case 4: + if (!this._storedError) { + _context2.next = 6; + break; + } - if (this._storedError) { - throw this._storedError; - } + throw this._storedError; - const chunk = this._readableStream.read(); + case 6: + chunk = this._readableStream.read(); - if (chunk === null) { - this._readCapability = (0, _util.createPromiseCapability)(); - return this.read(); - } + if (!(chunk === null)) { + _context2.next = 10; + break; + } - this._loaded += chunk.length; + this._readCapability = (0, _util.createPromiseCapability)(); + return _context2.abrupt("return", this.read()); - if (this.onProgress) { - this.onProgress({ - loaded: this._loaded - }); - } + case 10: + this._loaded += chunk.length; - const buffer = new Uint8Array(chunk).buffer; - return { - value: buffer, - done: false - }; - } + if (this.onProgress) { + this.onProgress({ + loaded: this._loaded + }); + } - cancel(reason) { - if (!this._readableStream) { - this._error(reason); + buffer = new Uint8Array(chunk).buffer; + return _context2.abrupt("return", { + value: buffer, + done: false + }); - return; - } + case 14: + case "end": + return _context2.stop(); + } + } + }, _callee2, this); + })); - this._readableStream.destroy(reason); - } + function read() { + return _read2.apply(this, arguments); + } - _error(reason) { - this._storedError = reason; + return read; + }() + }, { + key: "cancel", + value: function cancel(reason) { + if (!this._readableStream) { + this._error(reason); - this._readCapability.resolve(); - } + return; + } - _setReadableStream(readableStream) { - this._readableStream = readableStream; - readableStream.on("readable", () => { - this._readCapability.resolve(); - }); - readableStream.on("end", () => { - readableStream.destroy(); - this._done = true; + this._readableStream.destroy(reason); + } + }, { + key: "_error", + value: function _error(reason) { + this._storedError = reason; this._readCapability.resolve(); - }); - readableStream.on("error", reason => { - this._error(reason); - }); + } + }, { + key: "_setReadableStream", + value: function _setReadableStream(readableStream) { + var _this2 = this; - if (this._storedError) { - this._readableStream.destroy(this._storedError); + this._readableStream = readableStream; + readableStream.on("readable", function () { + _this2._readCapability.resolve(); + }); + readableStream.on("end", function () { + readableStream.destroy(); + _this2._done = true; + + _this2._readCapability.resolve(); + }); + readableStream.on("error", function (reason) { + _this2._error(reason); + }); + + if (this._storedError) { + this._readableStream.destroy(this._storedError); + } } - } + }, { + key: "isStreamingSupported", + get: function get() { + return this._isStreamingSupported; + } + }]); -} + return BaseRangeReader; +}(); function createRequestOptions(parsedUrl, headers) { return { @@ -12206,160 +24108,203 @@ function createRequestOptions(parsedUrl, headers) { port: parsedUrl.port, path: parsedUrl.path, method: "GET", - headers + headers: headers }; } -class PDFNodeStreamFullReader extends BaseFullReader { - constructor(stream) { - super(stream); +var PDFNodeStreamFullReader = /*#__PURE__*/function (_BaseFullReader) { + _inherits(PDFNodeStreamFullReader, _BaseFullReader); + + var _super = _createSuper(PDFNodeStreamFullReader); + + function PDFNodeStreamFullReader(stream) { + var _this3; + + _classCallCheck(this, PDFNodeStreamFullReader); + + _this3 = _super.call(this, stream); - const handleResponse = response => { + var handleResponse = function handleResponse(response) { if (response.statusCode === 404) { - const error = new _util.MissingPDFException(`Missing PDF "${this._url}".`); - this._storedError = error; + var error = new _util.MissingPDFException("Missing PDF \"".concat(_this3._url, "\".")); + _this3._storedError = error; - this._headersCapability.reject(error); + _this3._headersCapability.reject(error); return; } - this._headersCapability.resolve(); + _this3._headersCapability.resolve(); - this._setReadableStream(response); + _this3._setReadableStream(response); - const getResponseHeader = name => { - return this._readableStream.headers[name.toLowerCase()]; + var getResponseHeader = function getResponseHeader(name) { + return _this3._readableStream.headers[name.toLowerCase()]; }; - const { - allowRangeRequests, - suggestedLength - } = (0, _network_utils.validateRangeRequestCapabilities)({ - getResponseHeader, + var _validateRangeRequest = (0, _network_utils.validateRangeRequestCapabilities)({ + getResponseHeader: getResponseHeader, isHttp: stream.isHttp, - rangeChunkSize: this._rangeChunkSize, - disableRange: this._disableRange - }); - this._isRangeSupported = allowRangeRequests; - this._contentLength = suggestedLength || this._contentLength; - this._filename = (0, _network_utils.extractFilenameFromHeader)(getResponseHeader); + rangeChunkSize: _this3._rangeChunkSize, + disableRange: _this3._disableRange + }), + allowRangeRequests = _validateRangeRequest.allowRangeRequests, + suggestedLength = _validateRangeRequest.suggestedLength; + + _this3._isRangeSupported = allowRangeRequests; + _this3._contentLength = suggestedLength || _this3._contentLength; + _this3._filename = (0, _network_utils.extractFilenameFromHeader)(getResponseHeader); }; - this._request = null; + _this3._request = null; - if (this._url.protocol === "http:") { - this._request = http.request(createRequestOptions(this._url, stream.httpHeaders), handleResponse); + if (_this3._url.protocol === "http:") { + _this3._request = http.request(createRequestOptions(_this3._url, stream.httpHeaders), handleResponse); } else { - this._request = https.request(createRequestOptions(this._url, stream.httpHeaders), handleResponse); + _this3._request = https.request(createRequestOptions(_this3._url, stream.httpHeaders), handleResponse); } - this._request.on("error", reason => { - this._storedError = reason; + _this3._request.on("error", function (reason) { + _this3._storedError = reason; - this._headersCapability.reject(reason); + _this3._headersCapability.reject(reason); }); - this._request.end(); + _this3._request.end(); + + return _this3; } -} + return PDFNodeStreamFullReader; +}(BaseFullReader); + +var PDFNodeStreamRangeReader = /*#__PURE__*/function (_BaseRangeReader) { + _inherits(PDFNodeStreamRangeReader, _BaseRangeReader); + + var _super2 = _createSuper(PDFNodeStreamRangeReader); -class PDFNodeStreamRangeReader extends BaseRangeReader { - constructor(stream, start, end) { - super(stream); - this._httpHeaders = {}; + function PDFNodeStreamRangeReader(stream, start, end) { + var _this4; - for (const property in stream.httpHeaders) { - const value = stream.httpHeaders[property]; + _classCallCheck(this, PDFNodeStreamRangeReader); + + _this4 = _super2.call(this, stream); + _this4._httpHeaders = {}; + + for (var property in stream.httpHeaders) { + var value = stream.httpHeaders[property]; if (typeof value === "undefined") { continue; } - this._httpHeaders[property] = value; + _this4._httpHeaders[property] = value; } - this._httpHeaders.Range = `bytes=${start}-${end - 1}`; + _this4._httpHeaders.Range = "bytes=".concat(start, "-").concat(end - 1); - const handleResponse = response => { + var handleResponse = function handleResponse(response) { if (response.statusCode === 404) { - const error = new _util.MissingPDFException(`Missing PDF "${this._url}".`); - this._storedError = error; + var error = new _util.MissingPDFException("Missing PDF \"".concat(_this4._url, "\".")); + _this4._storedError = error; return; } - this._setReadableStream(response); + _this4._setReadableStream(response); }; - this._request = null; + _this4._request = null; - if (this._url.protocol === "http:") { - this._request = http.request(createRequestOptions(this._url, this._httpHeaders), handleResponse); + if (_this4._url.protocol === "http:") { + _this4._request = http.request(createRequestOptions(_this4._url, _this4._httpHeaders), handleResponse); } else { - this._request = https.request(createRequestOptions(this._url, this._httpHeaders), handleResponse); + _this4._request = https.request(createRequestOptions(_this4._url, _this4._httpHeaders), handleResponse); } - this._request.on("error", reason => { - this._storedError = reason; + _this4._request.on("error", function (reason) { + _this4._storedError = reason; }); - this._request.end(); + _this4._request.end(); + + return _this4; } -} + return PDFNodeStreamRangeReader; +}(BaseRangeReader); + +var PDFNodeStreamFsFullReader = /*#__PURE__*/function (_BaseFullReader2) { + _inherits(PDFNodeStreamFsFullReader, _BaseFullReader2); -class PDFNodeStreamFsFullReader extends BaseFullReader { - constructor(stream) { - super(stream); - let path = decodeURIComponent(this._url.path); + var _super3 = _createSuper(PDFNodeStreamFsFullReader); - if (fileUriRegex.test(this._url.href)) { + function PDFNodeStreamFsFullReader(stream) { + var _this5; + + _classCallCheck(this, PDFNodeStreamFsFullReader); + + _this5 = _super3.call(this, stream); + var path = decodeURIComponent(_this5._url.path); + + if (fileUriRegex.test(_this5._url.href)) { path = path.replace(/^\//, ""); } - fs.lstat(path, (error, stat) => { + fs.lstat(path, function (error, stat) { if (error) { if (error.code === "ENOENT") { - error = new _util.MissingPDFException(`Missing PDF "${path}".`); + error = new _util.MissingPDFException("Missing PDF \"".concat(path, "\".")); } - this._storedError = error; + _this5._storedError = error; - this._headersCapability.reject(error); + _this5._headersCapability.reject(error); return; } - this._contentLength = stat.size; + _this5._contentLength = stat.size; - this._setReadableStream(fs.createReadStream(path)); + _this5._setReadableStream(fs.createReadStream(path)); - this._headersCapability.resolve(); + _this5._headersCapability.resolve(); }); + return _this5; } -} + return PDFNodeStreamFsFullReader; +}(BaseFullReader); + +var PDFNodeStreamFsRangeReader = /*#__PURE__*/function (_BaseRangeReader2) { + _inherits(PDFNodeStreamFsRangeReader, _BaseRangeReader2); -class PDFNodeStreamFsRangeReader extends BaseRangeReader { - constructor(stream, start, end) { - super(stream); - let path = decodeURIComponent(this._url.path); + var _super4 = _createSuper(PDFNodeStreamFsRangeReader); - if (fileUriRegex.test(this._url.href)) { + function PDFNodeStreamFsRangeReader(stream, start, end) { + var _this6; + + _classCallCheck(this, PDFNodeStreamFsRangeReader); + + _this6 = _super4.call(this, stream); + var path = decodeURIComponent(_this6._url.path); + + if (fileUriRegex.test(_this6._url.href)) { path = path.replace(/^\//, ""); } - this._setReadableStream(fs.createReadStream(path, { - start, + _this6._setReadableStream(fs.createReadStream(path, { + start: start, end: end - 1 })); + + return _this6; } -} + return PDFNodeStreamFsRangeReader; +}(BaseRangeReader); /***/ }), -/* 20 */ +/* 213 */ /***/ (function(module, exports, __w_pdfjs_require__) { "use strict"; @@ -12373,22 +24318,21 @@ exports.extractFilenameFromHeader = extractFilenameFromHeader; exports.validateRangeRequestCapabilities = validateRangeRequestCapabilities; exports.validateResponseStatus = validateResponseStatus; -var _util = __w_pdfjs_require__(2); +var _util = __w_pdfjs_require__(5); -var _content_disposition = __w_pdfjs_require__(21); +var _content_disposition = __w_pdfjs_require__(214); -function validateRangeRequestCapabilities({ - getResponseHeader, - isHttp, - rangeChunkSize, - disableRange -}) { +function validateRangeRequestCapabilities(_ref) { + var getResponseHeader = _ref.getResponseHeader, + isHttp = _ref.isHttp, + rangeChunkSize = _ref.rangeChunkSize, + disableRange = _ref.disableRange; (0, _util.assert)(rangeChunkSize > 0, "Range chunk size must be larger than zero"); - const returnValues = { + var returnValues = { allowRangeRequests: false, suggestedLength: undefined }; - const length = parseInt(getResponseHeader("Content-Length"), 10); + var length = parseInt(getResponseHeader("Content-Length"), 10); if (!Number.isInteger(length)) { return returnValues; @@ -12408,7 +24352,7 @@ function validateRangeRequestCapabilities({ return returnValues; } - const contentEncoding = getResponseHeader("Content-Encoding") || "identity"; + var contentEncoding = getResponseHeader("Content-Encoding") || "identity"; if (contentEncoding !== "identity") { return returnValues; @@ -12419,10 +24363,10 @@ function validateRangeRequestCapabilities({ } function extractFilenameFromHeader(getResponseHeader) { - const contentDisposition = getResponseHeader("Content-Disposition"); + var contentDisposition = getResponseHeader("Content-Disposition"); if (contentDisposition) { - let filename = (0, _content_disposition.getFilenameFromContentDispositionHeader)(contentDisposition); + var filename = (0, _content_disposition.getFilenameFromContentDispositionHeader)(contentDisposition); if (filename.includes("%")) { try { @@ -12451,7 +24395,7 @@ function validateResponseStatus(status) { } /***/ }), -/* 21 */ +/* 214 */ /***/ (function(module, exports, __w_pdfjs_require__) { "use strict"; @@ -12462,13 +24406,25 @@ Object.defineProperty(exports, "__esModule", { }); exports.getFilenameFromContentDispositionHeader = getFilenameFromContentDispositionHeader; +function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); } + +function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); } + +function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; } + function getFilenameFromContentDispositionHeader(contentDisposition) { - let needsEncodingFixup = true; - let tmp = toParamRegExp("filename\\*", "i").exec(contentDisposition); + var needsEncodingFixup = true; + var tmp = toParamRegExp("filename\\*", "i").exec(contentDisposition); if (tmp) { tmp = tmp[1]; - let filename = rfc2616unquote(tmp); + var filename = rfc2616unquote(tmp); filename = unescape(filename); filename = rfc5987decode(filename); filename = rfc2047decode(filename); @@ -12478,17 +24434,20 @@ function getFilenameFromContentDispositionHeader(contentDisposition) { tmp = rfc2231getparam(contentDisposition); if (tmp) { - const filename = rfc2047decode(tmp); - return fixupEncoding(filename); + var _filename = rfc2047decode(tmp); + + return fixupEncoding(_filename); } tmp = toParamRegExp("filename", "i").exec(contentDisposition); if (tmp) { tmp = tmp[1]; - let filename = rfc2616unquote(tmp); - filename = rfc2047decode(filename); - return fixupEncoding(filename); + + var _filename2 = rfc2616unquote(tmp); + + _filename2 = rfc2047decode(_filename2); + return fixupEncoding(_filename2); } function toParamRegExp(attributePattern, flags) { @@ -12502,10 +24461,10 @@ function getFilenameFromContentDispositionHeader(contentDisposition) { } try { - const decoder = new TextDecoder(encoding, { + var decoder = new TextDecoder(encoding, { fatal: true }); - const bytes = Array.from(value, function (ch) { + var bytes = Array.from(value, function (ch) { return ch.charCodeAt(0) & 0xff; }); value = decoder.decode(new Uint8Array(bytes)); @@ -12536,12 +24495,17 @@ function getFilenameFromContentDispositionHeader(contentDisposition) { } function rfc2231getparam(contentDispositionStr) { - const matches = []; - let match; - const iter = toParamRegExp("filename\\*((?!0\\d)\\d+)(\\*?)", "ig"); + var matches = []; + var match; + var iter = toParamRegExp("filename\\*((?!0\\d)\\d+)(\\*?)", "ig"); while ((match = iter.exec(contentDispositionStr)) !== null) { - let [, n, quot, part] = match; + var _match = match, + _match2 = _slicedToArray(_match, 4), + n = _match2[1], + quot = _match2[2], + part = _match2[3]; + n = parseInt(n, 10); if (n in matches) { @@ -12555,25 +24519,28 @@ function getFilenameFromContentDispositionHeader(contentDisposition) { matches[n] = [quot, part]; } - const parts = []; + var parts = []; - for (let n = 0; n < matches.length; ++n) { - if (!(n in matches)) { + for (var _n2 = 0; _n2 < matches.length; ++_n2) { + if (!(_n2 in matches)) { break; } - let [quot, part] = matches[n]; - part = rfc2616unquote(part); + var _matches$_n = _slicedToArray(matches[_n2], 2), + _quot = _matches$_n[0], + _part = _matches$_n[1]; - if (quot) { - part = unescape(part); + _part = rfc2616unquote(_part); - if (n === 0) { - part = rfc5987decode(part); + if (_quot) { + _part = unescape(_part); + + if (_n2 === 0) { + _part = rfc5987decode(_part); } } - parts.push(part); + parts.push(_part); } return parts.join(""); @@ -12581,10 +24548,10 @@ function getFilenameFromContentDispositionHeader(contentDisposition) { function rfc2616unquote(value) { if (value.startsWith('"')) { - const parts = value.slice(1).split('\\"'); + var parts = value.slice(1).split('\\"'); - for (let i = 0; i < parts.length; ++i) { - const quotindex = parts[i].indexOf('"'); + for (var i = 0; i < parts.length; ++i) { + var quotindex = parts[i].indexOf('"'); if (quotindex !== -1) { parts[i] = parts[i].slice(0, quotindex); @@ -12601,15 +24568,15 @@ function getFilenameFromContentDispositionHeader(contentDisposition) { } function rfc5987decode(extvalue) { - const encodingend = extvalue.indexOf("'"); + var encodingend = extvalue.indexOf("'"); if (encodingend === -1) { return extvalue; } - const encoding = extvalue.slice(0, encodingend); - const langvalue = extvalue.slice(encodingend + 1); - const value = langvalue.replace(/^[^']*'/, ""); + var encoding = extvalue.slice(0, encodingend); + var langvalue = extvalue.slice(encodingend + 1); + var value = langvalue.replace(/^[^']*'/, ""); return textdecode(encoding, value); } @@ -12639,7 +24606,7 @@ function getFilenameFromContentDispositionHeader(contentDisposition) { } /***/ }), -/* 22 */ +/* 215 */ /***/ (function(module, exports, __w_pdfjs_require__) { "use strict"; @@ -12650,27 +24617,43 @@ Object.defineProperty(exports, "__esModule", { }); exports.PDFNetworkStream = void 0; -var _util = __w_pdfjs_require__(2); +var _regenerator = _interopRequireDefault(__w_pdfjs_require__(2)); + +var _util = __w_pdfjs_require__(5); + +var _network_utils = __w_pdfjs_require__(213); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } -var _network_utils = __w_pdfjs_require__(20); +function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } } + +function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } ; -const OK_RESPONSE = 200; -const PARTIAL_CONTENT_RESPONSE = 206; +var OK_RESPONSE = 200; +var PARTIAL_CONTENT_RESPONSE = 206; function getArrayBuffer(xhr) { - const data = xhr.response; + var data = xhr.response; if (typeof data !== "string") { return data; } - const array = (0, _util.stringToBytes)(data); + var array = (0, _util.stringToBytes)(data); return array.buffer; } -class NetworkManager { - constructor(url, args) { +var NetworkManager = /*#__PURE__*/function () { + function NetworkManager(url, args) { + _classCallCheck(this, NetworkManager); + this.url = url; args = args || {}; this.isHttp = /^https?:/i.test(url); @@ -12685,173 +24668,188 @@ class NetworkManager { this.pendingRequests = Object.create(null); } - requestRange(begin, end, listeners) { - const args = { - begin, - end - }; + _createClass(NetworkManager, [{ + key: "requestRange", + value: function requestRange(begin, end, listeners) { + var args = { + begin: begin, + end: end + }; - for (const prop in listeners) { - args[prop] = listeners[prop]; - } + for (var prop in listeners) { + args[prop] = listeners[prop]; + } - return this.request(args); - } + return this.request(args); + } + }, { + key: "requestFull", + value: function requestFull(listeners) { + return this.request(listeners); + } + }, { + key: "request", + value: function request(args) { + var xhr = this.getXhr(); + var xhrId = this.currXhrId++; + var pendingRequest = this.pendingRequests[xhrId] = { + xhr: xhr + }; + xhr.open("GET", this.url); + xhr.withCredentials = this.withCredentials; - requestFull(listeners) { - return this.request(listeners); - } + for (var property in this.httpHeaders) { + var value = this.httpHeaders[property]; - request(args) { - const xhr = this.getXhr(); - const xhrId = this.currXhrId++; - const pendingRequest = this.pendingRequests[xhrId] = { - xhr - }; - xhr.open("GET", this.url); - xhr.withCredentials = this.withCredentials; + if (typeof value === "undefined") { + continue; + } - for (const property in this.httpHeaders) { - const value = this.httpHeaders[property]; + xhr.setRequestHeader(property, value); + } - if (typeof value === "undefined") { - continue; + if (this.isHttp && "begin" in args && "end" in args) { + xhr.setRequestHeader("Range", "bytes=".concat(args.begin, "-").concat(args.end - 1)); + pendingRequest.expectedStatus = PARTIAL_CONTENT_RESPONSE; + } else { + pendingRequest.expectedStatus = OK_RESPONSE; } - xhr.setRequestHeader(property, value); - } + xhr.responseType = "arraybuffer"; - if (this.isHttp && "begin" in args && "end" in args) { - xhr.setRequestHeader("Range", `bytes=${args.begin}-${args.end - 1}`); - pendingRequest.expectedStatus = PARTIAL_CONTENT_RESPONSE; - } else { - pendingRequest.expectedStatus = OK_RESPONSE; + if (args.onError) { + xhr.onerror = function (evt) { + args.onError(xhr.status); + }; + } + + xhr.onreadystatechange = this.onStateChange.bind(this, xhrId); + xhr.onprogress = this.onProgress.bind(this, xhrId); + pendingRequest.onHeadersReceived = args.onHeadersReceived; + pendingRequest.onDone = args.onDone; + pendingRequest.onError = args.onError; + pendingRequest.onProgress = args.onProgress; + xhr.send(null); + return xhrId; } + }, { + key: "onProgress", + value: function onProgress(xhrId, evt) { + var pendingRequest = this.pendingRequests[xhrId]; - xhr.responseType = "arraybuffer"; + if (!pendingRequest) { + return; + } - if (args.onError) { - xhr.onerror = function (evt) { - args.onError(xhr.status); - }; + if (pendingRequest.onProgress) { + pendingRequest.onProgress(evt); + } } + }, { + key: "onStateChange", + value: function onStateChange(xhrId, evt) { + var pendingRequest = this.pendingRequests[xhrId]; - xhr.onreadystatechange = this.onStateChange.bind(this, xhrId); - xhr.onprogress = this.onProgress.bind(this, xhrId); - pendingRequest.onHeadersReceived = args.onHeadersReceived; - pendingRequest.onDone = args.onDone; - pendingRequest.onError = args.onError; - pendingRequest.onProgress = args.onProgress; - xhr.send(null); - return xhrId; - } - - onProgress(xhrId, evt) { - const pendingRequest = this.pendingRequests[xhrId]; + if (!pendingRequest) { + return; + } - if (!pendingRequest) { - return; - } + var xhr = pendingRequest.xhr; - if (pendingRequest.onProgress) { - pendingRequest.onProgress(evt); - } - } + if (xhr.readyState >= 2 && pendingRequest.onHeadersReceived) { + pendingRequest.onHeadersReceived(); + delete pendingRequest.onHeadersReceived; + } - onStateChange(xhrId, evt) { - const pendingRequest = this.pendingRequests[xhrId]; + if (xhr.readyState !== 4) { + return; + } - if (!pendingRequest) { - return; - } + if (!(xhrId in this.pendingRequests)) { + return; + } - const xhr = pendingRequest.xhr; + delete this.pendingRequests[xhrId]; - if (xhr.readyState >= 2 && pendingRequest.onHeadersReceived) { - pendingRequest.onHeadersReceived(); - delete pendingRequest.onHeadersReceived; - } + if (xhr.status === 0 && this.isHttp) { + if (pendingRequest.onError) { + pendingRequest.onError(xhr.status); + } - if (xhr.readyState !== 4) { - return; - } + return; + } - if (!(xhrId in this.pendingRequests)) { - return; - } + var xhrStatus = xhr.status || OK_RESPONSE; + var ok_response_on_range_request = xhrStatus === OK_RESPONSE && pendingRequest.expectedStatus === PARTIAL_CONTENT_RESPONSE; - delete this.pendingRequests[xhrId]; + if (!ok_response_on_range_request && xhrStatus !== pendingRequest.expectedStatus) { + if (pendingRequest.onError) { + pendingRequest.onError(xhr.status); + } - if (xhr.status === 0 && this.isHttp) { - if (pendingRequest.onError) { - pendingRequest.onError(xhr.status); + return; } - return; - } - - const xhrStatus = xhr.status || OK_RESPONSE; - const ok_response_on_range_request = xhrStatus === OK_RESPONSE && pendingRequest.expectedStatus === PARTIAL_CONTENT_RESPONSE; + var chunk = getArrayBuffer(xhr); - if (!ok_response_on_range_request && xhrStatus !== pendingRequest.expectedStatus) { - if (pendingRequest.onError) { + if (xhrStatus === PARTIAL_CONTENT_RESPONSE) { + var rangeHeader = xhr.getResponseHeader("Content-Range"); + var matches = /bytes (\d+)-(\d+)\/(\d+)/.exec(rangeHeader); + pendingRequest.onDone({ + begin: parseInt(matches[1], 10), + chunk: chunk + }); + } else if (chunk) { + pendingRequest.onDone({ + begin: 0, + chunk: chunk + }); + } else if (pendingRequest.onError) { pendingRequest.onError(xhr.status); } - - return; } + }, { + key: "hasPendingRequests", + value: function hasPendingRequests() { + for (var xhrId in this.pendingRequests) { + return true; + } - const chunk = getArrayBuffer(xhr); - - if (xhrStatus === PARTIAL_CONTENT_RESPONSE) { - const rangeHeader = xhr.getResponseHeader("Content-Range"); - const matches = /bytes (\d+)-(\d+)\/(\d+)/.exec(rangeHeader); - pendingRequest.onDone({ - begin: parseInt(matches[1], 10), - chunk - }); - } else if (chunk) { - pendingRequest.onDone({ - begin: 0, - chunk - }); - } else if (pendingRequest.onError) { - pendingRequest.onError(xhr.status); + return false; } - } - - hasPendingRequests() { - for (const xhrId in this.pendingRequests) { - return true; + }, { + key: "getRequestXhr", + value: function getRequestXhr(xhrId) { + return this.pendingRequests[xhrId].xhr; } - - return false; - } - - getRequestXhr(xhrId) { - return this.pendingRequests[xhrId].xhr; - } - - isPendingRequest(xhrId) { - return xhrId in this.pendingRequests; - } - - abortAllRequests() { - for (const xhrId in this.pendingRequests) { - this.abortRequest(xhrId | 0); + }, { + key: "isPendingRequest", + value: function isPendingRequest(xhrId) { + return xhrId in this.pendingRequests; } - } + }, { + key: "abortAllRequests", + value: function abortAllRequests() { + for (var xhrId in this.pendingRequests) { + this.abortRequest(xhrId | 0); + } + } + }, { + key: "abortRequest", + value: function abortRequest(xhrId) { + var xhr = this.pendingRequests[xhrId].xhr; + delete this.pendingRequests[xhrId]; + xhr.abort(); + } + }]); - abortRequest(xhrId) { - const xhr = this.pendingRequests[xhrId].xhr; - delete this.pendingRequests[xhrId]; - xhr.abort(); - } + return NetworkManager; +}(); -} +var PDFNetworkStream = /*#__PURE__*/function () { + function PDFNetworkStream(source) { + _classCallCheck(this, PDFNetworkStream); -class PDFNetworkStream { - constructor(source) { this._source = source; this._manager = new NetworkManager(source.url, { httpHeaders: source.httpHeaders, @@ -12862,49 +24860,58 @@ class PDFNetworkStream { this._rangeRequestReaders = []; } - _onRangeRequestReaderClosed(reader) { - const i = this._rangeRequestReaders.indexOf(reader); + _createClass(PDFNetworkStream, [{ + key: "_onRangeRequestReaderClosed", + value: function _onRangeRequestReaderClosed(reader) { + var i = this._rangeRequestReaders.indexOf(reader); - if (i >= 0) { - this._rangeRequestReaders.splice(i, 1); + if (i >= 0) { + this._rangeRequestReaders.splice(i, 1); + } } - } - - getFullReader() { - (0, _util.assert)(!this._fullRequestReader, "PDFNetworkStream.getFullReader can only be called once."); - this._fullRequestReader = new PDFNetworkStreamFullRequestReader(this._manager, this._source); - return this._fullRequestReader; - } - - getRangeReader(begin, end) { - const reader = new PDFNetworkStreamRangeRequestReader(this._manager, begin, end); - reader.onClosed = this._onRangeRequestReaderClosed.bind(this); - - this._rangeRequestReaders.push(reader); + }, { + key: "getFullReader", + value: function getFullReader() { + (0, _util.assert)(!this._fullRequestReader, "PDFNetworkStream.getFullReader can only be called once."); + this._fullRequestReader = new PDFNetworkStreamFullRequestReader(this._manager, this._source); + return this._fullRequestReader; + } + }, { + key: "getRangeReader", + value: function getRangeReader(begin, end) { + var reader = new PDFNetworkStreamRangeRequestReader(this._manager, begin, end); + reader.onClosed = this._onRangeRequestReaderClosed.bind(this); - return reader; - } + this._rangeRequestReaders.push(reader); - cancelAllRequests(reason) { - if (this._fullRequestReader) { - this._fullRequestReader.cancel(reason); + return reader; } + }, { + key: "cancelAllRequests", + value: function cancelAllRequests(reason) { + if (this._fullRequestReader) { + this._fullRequestReader.cancel(reason); + } - const readers = this._rangeRequestReaders.slice(0); + var readers = this._rangeRequestReaders.slice(0); - readers.forEach(function (reader) { - reader.cancel(reason); - }); - } + readers.forEach(function (reader) { + reader.cancel(reason); + }); + } + }]); -} + return PDFNetworkStream; +}(); exports.PDFNetworkStream = PDFNetworkStream; -class PDFNetworkStreamFullRequestReader { - constructor(manager, source) { +var PDFNetworkStreamFullRequestReader = /*#__PURE__*/function () { + function PDFNetworkStreamFullRequestReader(manager, source) { + _classCallCheck(this, PDFNetworkStreamFullRequestReader); + this._manager = manager; - const args = { + var args = { onHeadersReceived: this._onHeadersReceived.bind(this), onDone: this._onDone.bind(this), onError: this._onError.bind(this), @@ -12931,168 +24938,214 @@ class PDFNetworkStreamFullRequestReader { this.onProgress = null; } - _onHeadersReceived() { - const fullRequestXhrId = this._fullRequestId; - - const fullRequestXhr = this._manager.getRequestXhr(fullRequestXhrId); + _createClass(PDFNetworkStreamFullRequestReader, [{ + key: "_onHeadersReceived", + value: function _onHeadersReceived() { + var fullRequestXhrId = this._fullRequestId; - const getResponseHeader = name => { - return fullRequestXhr.getResponseHeader(name); - }; - - const { - allowRangeRequests, - suggestedLength - } = (0, _network_utils.validateRangeRequestCapabilities)({ - getResponseHeader, - isHttp: this._manager.isHttp, - rangeChunkSize: this._rangeChunkSize, - disableRange: this._disableRange - }); + var fullRequestXhr = this._manager.getRequestXhr(fullRequestXhrId); - if (allowRangeRequests) { - this._isRangeSupported = true; - } - - this._contentLength = suggestedLength || this._contentLength; - this._filename = (0, _network_utils.extractFilenameFromHeader)(getResponseHeader); + var getResponseHeader = function getResponseHeader(name) { + return fullRequestXhr.getResponseHeader(name); + }; - if (this._isRangeSupported) { - this._manager.abortRequest(fullRequestXhrId); - } + var _validateRangeRequest = (0, _network_utils.validateRangeRequestCapabilities)({ + getResponseHeader: getResponseHeader, + isHttp: this._manager.isHttp, + rangeChunkSize: this._rangeChunkSize, + disableRange: this._disableRange + }), + allowRangeRequests = _validateRangeRequest.allowRangeRequests, + suggestedLength = _validateRangeRequest.suggestedLength; - this._headersReceivedCapability.resolve(); - } + if (allowRangeRequests) { + this._isRangeSupported = true; + } - _onDone(args) { - if (args) { - if (this._requests.length > 0) { - const requestCapability = this._requests.shift(); + this._contentLength = suggestedLength || this._contentLength; + this._filename = (0, _network_utils.extractFilenameFromHeader)(getResponseHeader); - requestCapability.resolve({ - value: args.chunk, - done: false - }); - } else { - this._cachedChunks.push(args.chunk); + if (this._isRangeSupported) { + this._manager.abortRequest(fullRequestXhrId); } - } - this._done = true; - - if (this._cachedChunks.length > 0) { - return; + this._headersReceivedCapability.resolve(); } + }, { + key: "_onDone", + value: function _onDone(args) { + if (args) { + if (this._requests.length > 0) { + var requestCapability = this._requests.shift(); - this._requests.forEach(function (requestCapability) { - requestCapability.resolve({ - value: undefined, - done: true - }); - }); + requestCapability.resolve({ + value: args.chunk, + done: false + }); + } else { + this._cachedChunks.push(args.chunk); + } + } - this._requests = []; - } + this._done = true; - _onError(status) { - const url = this._url; - const exception = (0, _network_utils.createResponseStatusError)(status, url); - this._storedError = exception; + if (this._cachedChunks.length > 0) { + return; + } - this._headersReceivedCapability.reject(exception); + this._requests.forEach(function (requestCapability) { + requestCapability.resolve({ + value: undefined, + done: true + }); + }); - this._requests.forEach(function (requestCapability) { - requestCapability.reject(exception); - }); + this._requests = []; + } + }, { + key: "_onError", + value: function _onError(status) { + var url = this._url; + var exception = (0, _network_utils.createResponseStatusError)(status, url); + this._storedError = exception; - this._requests = []; - this._cachedChunks = []; - } + this._headersReceivedCapability.reject(exception); - _onProgress(data) { - if (this.onProgress) { - this.onProgress({ - loaded: data.loaded, - total: data.lengthComputable ? data.total : this._contentLength + this._requests.forEach(function (requestCapability) { + requestCapability.reject(exception); }); + + this._requests = []; + this._cachedChunks = []; } - } + }, { + key: "_onProgress", + value: function _onProgress(data) { + if (this.onProgress) { + this.onProgress({ + loaded: data.loaded, + total: data.lengthComputable ? data.total : this._contentLength + }); + } + } + }, { + key: "read", + value: function () { + var _read = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee() { + var chunk, requestCapability; + return _regenerator["default"].wrap(function _callee$(_context) { + while (1) { + switch (_context.prev = _context.next) { + case 0: + if (!this._storedError) { + _context.next = 2; + break; + } - get filename() { - return this._filename; - } + throw this._storedError; - get isRangeSupported() { - return this._isRangeSupported; - } + case 2: + if (!(this._cachedChunks.length > 0)) { + _context.next = 5; + break; + } - get isStreamingSupported() { - return this._isStreamingSupported; - } + chunk = this._cachedChunks.shift(); + return _context.abrupt("return", { + value: chunk, + done: false + }); - get contentLength() { - return this._contentLength; - } + case 5: + if (!this._done) { + _context.next = 7; + break; + } - get headersReady() { - return this._headersReceivedCapability.promise; - } + return _context.abrupt("return", { + value: undefined, + done: true + }); - async read() { - if (this._storedError) { - throw this._storedError; - } + case 7: + requestCapability = (0, _util.createPromiseCapability)(); - if (this._cachedChunks.length > 0) { - const chunk = this._cachedChunks.shift(); + this._requests.push(requestCapability); - return { - value: chunk, - done: false - }; - } + return _context.abrupt("return", requestCapability.promise); - if (this._done) { - return { - value: undefined, - done: true - }; - } - - const requestCapability = (0, _util.createPromiseCapability)(); - - this._requests.push(requestCapability); + case 10: + case "end": + return _context.stop(); + } + } + }, _callee, this); + })); - return requestCapability.promise; - } + function read() { + return _read.apply(this, arguments); + } - cancel(reason) { - this._done = true; + return read; + }() + }, { + key: "cancel", + value: function cancel(reason) { + this._done = true; - this._headersReceivedCapability.reject(reason); + this._headersReceivedCapability.reject(reason); - this._requests.forEach(function (requestCapability) { - requestCapability.resolve({ - value: undefined, - done: true + this._requests.forEach(function (requestCapability) { + requestCapability.resolve({ + value: undefined, + done: true + }); }); - }); - this._requests = []; + this._requests = []; + + if (this._manager.isPendingRequest(this._fullRequestId)) { + this._manager.abortRequest(this._fullRequestId); + } - if (this._manager.isPendingRequest(this._fullRequestId)) { - this._manager.abortRequest(this._fullRequestId); + this._fullRequestReader = null; + } + }, { + key: "filename", + get: function get() { + return this._filename; + } + }, { + key: "isRangeSupported", + get: function get() { + return this._isRangeSupported; } + }, { + key: "isStreamingSupported", + get: function get() { + return this._isStreamingSupported; + } + }, { + key: "contentLength", + get: function get() { + return this._contentLength; + } + }, { + key: "headersReady", + get: function get() { + return this._headersReceivedCapability.promise; + } + }]); - this._fullRequestReader = null; - } + return PDFNetworkStreamFullRequestReader; +}(); -} +var PDFNetworkStreamRangeRequestReader = /*#__PURE__*/function () { + function PDFNetworkStreamRangeRequestReader(manager, begin, end) { + _classCallCheck(this, PDFNetworkStreamRangeRequestReader); -class PDFNetworkStreamRangeRequestReader { - constructor(manager, begin, end) { this._manager = manager; - const args = { + var args = { onDone: this._onDone.bind(this), onProgress: this._onProgress.bind(this) }; @@ -13104,99 +25157,136 @@ class PDFNetworkStreamRangeRequestReader { this.onClosed = null; } - _close() { - if (this.onClosed) { - this.onClosed(this); + _createClass(PDFNetworkStreamRangeRequestReader, [{ + key: "_close", + value: function _close() { + if (this.onClosed) { + this.onClosed(this); + } } - } + }, { + key: "_onDone", + value: function _onDone(data) { + var chunk = data.chunk; - _onDone(data) { - const chunk = data.chunk; - - if (this._requests.length > 0) { - const requestCapability = this._requests.shift(); + if (this._requests.length > 0) { + var requestCapability = this._requests.shift(); - requestCapability.resolve({ - value: chunk, - done: false - }); - } else { - this._queuedChunk = chunk; - } + requestCapability.resolve({ + value: chunk, + done: false + }); + } else { + this._queuedChunk = chunk; + } - this._done = true; + this._done = true; - this._requests.forEach(function (requestCapability) { - requestCapability.resolve({ - value: undefined, - done: true + this._requests.forEach(function (requestCapability) { + requestCapability.resolve({ + value: undefined, + done: true + }); }); - }); - this._requests = []; - - this._close(); - } + this._requests = []; - _onProgress(evt) { - if (!this.isStreamingSupported && this.onProgress) { - this.onProgress({ - loaded: evt.loaded - }); + this._close(); } - } + }, { + key: "_onProgress", + value: function _onProgress(evt) { + if (!this.isStreamingSupported && this.onProgress) { + this.onProgress({ + loaded: evt.loaded + }); + } + } + }, { + key: "read", + value: function () { + var _read2 = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee2() { + var chunk, requestCapability; + return _regenerator["default"].wrap(function _callee2$(_context2) { + while (1) { + switch (_context2.prev = _context2.next) { + case 0: + if (!(this._queuedChunk !== null)) { + _context2.next = 4; + break; + } - get isStreamingSupported() { - return false; - } + chunk = this._queuedChunk; + this._queuedChunk = null; + return _context2.abrupt("return", { + value: chunk, + done: false + }); + + case 4: + if (!this._done) { + _context2.next = 6; + break; + } - async read() { - if (this._queuedChunk !== null) { - const chunk = this._queuedChunk; - this._queuedChunk = null; - return { - value: chunk, - done: false - }; - } + return _context2.abrupt("return", { + value: undefined, + done: true + }); - if (this._done) { - return { - value: undefined, - done: true - }; - } + case 6: + requestCapability = (0, _util.createPromiseCapability)(); - const requestCapability = (0, _util.createPromiseCapability)(); + this._requests.push(requestCapability); - this._requests.push(requestCapability); + return _context2.abrupt("return", requestCapability.promise); - return requestCapability.promise; - } + case 9: + case "end": + return _context2.stop(); + } + } + }, _callee2, this); + })); - cancel(reason) { - this._done = true; + function read() { + return _read2.apply(this, arguments); + } - this._requests.forEach(function (requestCapability) { - requestCapability.resolve({ - value: undefined, - done: true + return read; + }() + }, { + key: "cancel", + value: function cancel(reason) { + this._done = true; + + this._requests.forEach(function (requestCapability) { + requestCapability.resolve({ + value: undefined, + done: true + }); }); - }); - this._requests = []; + this._requests = []; - if (this._manager.isPendingRequest(this._requestId)) { - this._manager.abortRequest(this._requestId); - } + if (this._manager.isPendingRequest(this._requestId)) { + this._manager.abortRequest(this._requestId); + } - this._close(); - } + this._close(); + } + }, { + key: "isStreamingSupported", + get: function get() { + return false; + } + }]); -} + return PDFNetworkStreamRangeRequestReader; +}(); /***/ }), -/* 23 */ +/* 216 */ /***/ (function(module, exports, __w_pdfjs_require__) { "use strict"; @@ -13207,16 +25297,30 @@ Object.defineProperty(exports, "__esModule", { }); exports.PDFFetchStream = void 0; -var _util = __w_pdfjs_require__(2); +var _regenerator = _interopRequireDefault(__w_pdfjs_require__(2)); + +var _util = __w_pdfjs_require__(5); + +var _network_utils = __w_pdfjs_require__(213); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } } + +function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; } -var _network_utils = __w_pdfjs_require__(20); +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } ; function createFetchOptions(headers, withCredentials, abortController) { return { method: "GET", - headers, + headers: headers, signal: abortController && abortController.signal, mode: "cors", credentials: withCredentials ? "include" : "same-origin", @@ -13225,10 +25329,10 @@ function createFetchOptions(headers, withCredentials, abortController) { } function createHeaders(httpHeaders) { - const headers = new Headers(); + var headers = new Headers(); - for (const property in httpHeaders) { - const value = httpHeaders[property]; + for (var property in httpHeaders) { + var value = httpHeaders[property]; if (typeof value === "undefined") { continue; @@ -13240,8 +25344,10 @@ function createHeaders(httpHeaders) { return headers; } -class PDFFetchStream { - constructor(source) { +var PDFFetchStream = /*#__PURE__*/function () { + function PDFFetchStream(source) { + _classCallCheck(this, PDFFetchStream); + this.source = source; this.isHttp = /^https?:/i.test(source.url); this.httpHeaders = this.isHttp && source.httpHeaders || {}; @@ -13249,51 +25355,62 @@ class PDFFetchStream { this._rangeRequestReaders = []; } - get _progressiveDataLength() { - return this._fullRequestReader ? this._fullRequestReader._loaded : 0; - } - - getFullReader() { - (0, _util.assert)(!this._fullRequestReader, "PDFFetchStream.getFullReader can only be called once."); - this._fullRequestReader = new PDFFetchStreamReader(this); - return this._fullRequestReader; - } - - getRangeReader(begin, end) { - if (end <= this._progressiveDataLength) { - return null; + _createClass(PDFFetchStream, [{ + key: "getFullReader", + value: function getFullReader() { + (0, _util.assert)(!this._fullRequestReader, "PDFFetchStream.getFullReader can only be called once."); + this._fullRequestReader = new PDFFetchStreamReader(this); + return this._fullRequestReader; } + }, { + key: "getRangeReader", + value: function getRangeReader(begin, end) { + if (end <= this._progressiveDataLength) { + return null; + } - const reader = new PDFFetchStreamRangeReader(this, begin, end); - - this._rangeRequestReaders.push(reader); + var reader = new PDFFetchStreamRangeReader(this, begin, end); - return reader; - } + this._rangeRequestReaders.push(reader); - cancelAllRequests(reason) { - if (this._fullRequestReader) { - this._fullRequestReader.cancel(reason); + return reader; } + }, { + key: "cancelAllRequests", + value: function cancelAllRequests(reason) { + if (this._fullRequestReader) { + this._fullRequestReader.cancel(reason); + } - const readers = this._rangeRequestReaders.slice(0); + var readers = this._rangeRequestReaders.slice(0); - readers.forEach(function (reader) { - reader.cancel(reason); - }); - } + readers.forEach(function (reader) { + reader.cancel(reason); + }); + } + }, { + key: "_progressiveDataLength", + get: function get() { + return this._fullRequestReader ? this._fullRequestReader._loaded : 0; + } + }]); -} + return PDFFetchStream; +}(); exports.PDFFetchStream = PDFFetchStream; -class PDFFetchStreamReader { - constructor(stream) { +var PDFFetchStreamReader = /*#__PURE__*/function () { + function PDFFetchStreamReader(stream) { + var _this = this; + + _classCallCheck(this, PDFFetchStreamReader); + this._stream = stream; this._reader = null; this._loaded = 0; this._filename = null; - const source = stream.source; + var source = stream.source; this._withCredentials = source.withCredentials || false; this._contentLength = source.length; this._headersCapability = (0, _util.createPromiseCapability)(); @@ -13311,108 +25428,153 @@ class PDFFetchStreamReader { this._isStreamingSupported = !source.disableStream; this._isRangeSupported = !source.disableRange; this._headers = createHeaders(this._stream.httpHeaders); - const url = source.url; - fetch(url, createFetchOptions(this._headers, this._withCredentials, this._abortController)).then(response => { + var url = source.url; + fetch(url, createFetchOptions(this._headers, this._withCredentials, this._abortController)).then(function (response) { if (!(0, _network_utils.validateResponseStatus)(response.status)) { throw (0, _network_utils.createResponseStatusError)(response.status, url); } - this._reader = response.body.getReader(); + _this._reader = response.body.getReader(); - this._headersCapability.resolve(); + _this._headersCapability.resolve(); - const getResponseHeader = name => { + var getResponseHeader = function getResponseHeader(name) { return response.headers.get(name); }; - const { - allowRangeRequests, - suggestedLength - } = (0, _network_utils.validateRangeRequestCapabilities)({ - getResponseHeader, - isHttp: this._stream.isHttp, - rangeChunkSize: this._rangeChunkSize, - disableRange: this._disableRange - }); - this._isRangeSupported = allowRangeRequests; - this._contentLength = suggestedLength || this._contentLength; - this._filename = (0, _network_utils.extractFilenameFromHeader)(getResponseHeader); + var _validateRangeRequest = (0, _network_utils.validateRangeRequestCapabilities)({ + getResponseHeader: getResponseHeader, + isHttp: _this._stream.isHttp, + rangeChunkSize: _this._rangeChunkSize, + disableRange: _this._disableRange + }), + allowRangeRequests = _validateRangeRequest.allowRangeRequests, + suggestedLength = _validateRangeRequest.suggestedLength; - if (!this._isStreamingSupported && this._isRangeSupported) { - this.cancel(new _util.AbortException("Streaming is disabled.")); + _this._isRangeSupported = allowRangeRequests; + _this._contentLength = suggestedLength || _this._contentLength; + _this._filename = (0, _network_utils.extractFilenameFromHeader)(getResponseHeader); + + if (!_this._isStreamingSupported && _this._isRangeSupported) { + _this.cancel(new _util.AbortException("Streaming is disabled.")); } - }).catch(this._headersCapability.reject); + })["catch"](this._headersCapability.reject); this.onProgress = null; } - get headersReady() { - return this._headersCapability.promise; - } + _createClass(PDFFetchStreamReader, [{ + key: "read", + value: function () { + var _read = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee() { + var _yield$this$_reader$r, value, done, buffer; - get filename() { - return this._filename; - } + return _regenerator["default"].wrap(function _callee$(_context) { + while (1) { + switch (_context.prev = _context.next) { + case 0: + _context.next = 2; + return this._headersCapability.promise; - get contentLength() { - return this._contentLength; - } + case 2: + _context.next = 4; + return this._reader.read(); - get isRangeSupported() { - return this._isRangeSupported; - } + case 4: + _yield$this$_reader$r = _context.sent; + value = _yield$this$_reader$r.value; + done = _yield$this$_reader$r.done; - get isStreamingSupported() { - return this._isStreamingSupported; - } + if (!done) { + _context.next = 9; + break; + } - async read() { - await this._headersCapability.promise; - const { - value, - done - } = await this._reader.read(); + return _context.abrupt("return", { + value: value, + done: done + }); - if (done) { - return { - value, - done - }; - } + case 9: + this._loaded += value.byteLength; - this._loaded += value.byteLength; + if (this.onProgress) { + this.onProgress({ + loaded: this._loaded, + total: this._contentLength + }); + } - if (this.onProgress) { - this.onProgress({ - loaded: this._loaded, - total: this._contentLength - }); - } + buffer = new Uint8Array(value).buffer; + return _context.abrupt("return", { + value: buffer, + done: false + }); - const buffer = new Uint8Array(value).buffer; - return { - value: buffer, - done: false - }; - } + case 13: + case "end": + return _context.stop(); + } + } + }, _callee, this); + })); - cancel(reason) { - if (this._reader) { - this._reader.cancel(reason); - } + function read() { + return _read.apply(this, arguments); + } - if (this._abortController) { - this._abortController.abort(); + return read; + }() + }, { + key: "cancel", + value: function cancel(reason) { + if (this._reader) { + this._reader.cancel(reason); + } + + if (this._abortController) { + this._abortController.abort(); + } } - } + }, { + key: "headersReady", + get: function get() { + return this._headersCapability.promise; + } + }, { + key: "filename", + get: function get() { + return this._filename; + } + }, { + key: "contentLength", + get: function get() { + return this._contentLength; + } + }, { + key: "isRangeSupported", + get: function get() { + return this._isRangeSupported; + } + }, { + key: "isStreamingSupported", + get: function get() { + return this._isStreamingSupported; + } + }]); -} + return PDFFetchStreamReader; +}(); + +var PDFFetchStreamRangeReader = /*#__PURE__*/function () { + function PDFFetchStreamRangeReader(stream, begin, end) { + var _this2 = this; + + _classCallCheck(this, PDFFetchStreamRangeReader); -class PDFFetchStreamRangeReader { - constructor(stream, begin, end) { this._stream = stream; this._reader = null; this._loaded = 0; - const source = stream.source; + var source = stream.source; this._withCredentials = source.withCredentials || false; this._readCapability = (0, _util.createPromiseCapability)(); this._isStreamingSupported = !source.disableStream; @@ -13423,65 +25585,102 @@ class PDFFetchStreamRangeReader { this._headers = createHeaders(this._stream.httpHeaders); - this._headers.append("Range", `bytes=${begin}-${end - 1}`); + this._headers.append("Range", "bytes=".concat(begin, "-").concat(end - 1)); - const url = source.url; - fetch(url, createFetchOptions(this._headers, this._withCredentials, this._abortController)).then(response => { + var url = source.url; + fetch(url, createFetchOptions(this._headers, this._withCredentials, this._abortController)).then(function (response) { if (!(0, _network_utils.validateResponseStatus)(response.status)) { throw (0, _network_utils.createResponseStatusError)(response.status, url); } - this._readCapability.resolve(); + _this2._readCapability.resolve(); - this._reader = response.body.getReader(); + _this2._reader = response.body.getReader(); }); this.onProgress = null; } - get isStreamingSupported() { - return this._isStreamingSupported; - } + _createClass(PDFFetchStreamRangeReader, [{ + key: "read", + value: function () { + var _read2 = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee2() { + var _yield$this$_reader$r2, value, done, buffer; - async read() { - await this._readCapability.promise; - const { - value, - done - } = await this._reader.read(); + return _regenerator["default"].wrap(function _callee2$(_context2) { + while (1) { + switch (_context2.prev = _context2.next) { + case 0: + _context2.next = 2; + return this._readCapability.promise; - if (done) { - return { - value, - done - }; - } + case 2: + _context2.next = 4; + return this._reader.read(); - this._loaded += value.byteLength; + case 4: + _yield$this$_reader$r2 = _context2.sent; + value = _yield$this$_reader$r2.value; + done = _yield$this$_reader$r2.done; - if (this.onProgress) { - this.onProgress({ - loaded: this._loaded - }); - } + if (!done) { + _context2.next = 9; + break; + } - const buffer = new Uint8Array(value).buffer; - return { - value: buffer, - done: false - }; - } + return _context2.abrupt("return", { + value: value, + done: done + }); - cancel(reason) { - if (this._reader) { - this._reader.cancel(reason); - } + case 9: + this._loaded += value.byteLength; + + if (this.onProgress) { + this.onProgress({ + loaded: this._loaded + }); + } + + buffer = new Uint8Array(value).buffer; + return _context2.abrupt("return", { + value: buffer, + done: false + }); + + case 13: + case "end": + return _context2.stop(); + } + } + }, _callee2, this); + })); - if (this._abortController) { - this._abortController.abort(); + function read() { + return _read2.apply(this, arguments); + } + + return read; + }() + }, { + key: "cancel", + value: function cancel(reason) { + if (this._reader) { + this._reader.cancel(reason); + } + + if (this._abortController) { + this._abortController.abort(); + } } - } + }, { + key: "isStreamingSupported", + get: function get() { + return this._isStreamingSupported; + } + }]); -} + return PDFFetchStreamRangeReader; +}(); /***/ }) /******/ ]); |