Merge inbound to mozilla-central a=merge
authorCoroiu Cristina <ccoroiu@mozilla.com>
Tue, 27 Nov 2018 00:34:45 +0200
changeset 507241 a60b595747ade6cdad6b51906bc9a880f6276f19
parent 507220 f38d34679027acdcb303231cadbc7aef1849af53 (current diff)
parent 507240 e13ba7026e77deebda6fbfa1518709e24f6846e5 (diff)
child 507283 cf079e81ea44a2fb38a32843e537a2819ab3b5a2
child 507355 9dcdb35839c5b2ea345118d2c109682ee1fb0831
push id1905
push userffxbld-merge
push dateMon, 21 Jan 2019 12:33:13 +0000
treeherdermozilla-release@c2fca1944d8c [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersmerge
milestone65.0a1
first release with
nightly linux32
a60b595747ad / 65.0a1 / 20181126234942 / files
nightly linux64
a60b595747ad / 65.0a1 / 20181126234942 / files
nightly mac
a60b595747ad / 65.0a1 / 20181126234942 / files
nightly win32
a60b595747ad / 65.0a1 / 20181126234942 / files
nightly win64
a60b595747ad / 65.0a1 / 20181126234942 / files
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
releases
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Merge inbound to mozilla-central a=merge
browser/themes/shared/controlcenter/panel.inc.css
layout/generic/nsTextFrame.cpp
--- a/browser/extensions/pdfjs/README.mozilla
+++ b/browser/extensions/pdfjs/README.mozilla
@@ -1,5 +1,5 @@
 This is the PDF.js project output, https://github.com/mozilla/pdf.js
 
-Current extension version is: 2.1.70
+Current extension version is: 2.1.86
 
-Taken from upstream commit: 6ebdbb24
+Taken from upstream commit: 1cb7cc9b
--- a/browser/extensions/pdfjs/content/build/pdf.js
+++ b/browser/extensions/pdfjs/content/build/pdf.js
@@ -118,26 +118,35 @@ return /******/ (function(modules) { // 
 /************************************************************************/
 /******/ ([
 /* 0 */
 /***/ (function(module, exports, __w_pdfjs_require__) {
 
 "use strict";
 
 
-var pdfjsVersion = '2.1.70';
-var pdfjsBuild = '6ebdbb24';
+var pdfjsVersion = '2.1.86';
+var pdfjsBuild = '1cb7cc9b';
+
 var pdfjsSharedUtil = __w_pdfjs_require__(1);
+
 var pdfjsDisplayAPI = __w_pdfjs_require__(7);
+
 var pdfjsDisplayTextLayer = __w_pdfjs_require__(19);
+
 var pdfjsDisplayAnnotationLayer = __w_pdfjs_require__(20);
+
 var pdfjsDisplayDOMUtils = __w_pdfjs_require__(8);
+
 var pdfjsDisplaySVG = __w_pdfjs_require__(21);
+
 let pdfjsDisplayWorkerOptions = __w_pdfjs_require__(13);
+
 let pdfjsDisplayAPICompatibility = __w_pdfjs_require__(10);
+
 ;
 exports.build = pdfjsDisplayAPI.build;
 exports.version = pdfjsDisplayAPI.version;
 exports.getDocument = pdfjsDisplayAPI.getDocument;
 exports.LoopbackPort = pdfjsDisplayAPI.LoopbackPort;
 exports.PDFDataRangeTransport = pdfjsDisplayAPI.PDFDataRangeTransport;
 exports.PDFWorker = pdfjsDisplayAPI.PDFWorker;
 exports.renderTextLayer = pdfjsDisplayTextLayer.renderTextLayer;
@@ -174,58 +183,111 @@ exports.apiCompatibilityParams = pdfjsDi
 /***/ (function(module, exports, __w_pdfjs_require__) {
 
 "use strict";
 
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.unreachable = exports.warn = exports.utf8StringToString = exports.stringToUTF8String = exports.stringToPDFString = exports.stringToBytes = exports.string32 = exports.shadow = exports.setVerbosityLevel = exports.URL = exports.ReadableStream = exports.removeNullCharacters = exports.readUint32 = exports.readUint16 = exports.readInt8 = exports.log2 = exports.isEvalSupported = exports.isLittleEndian = exports.createValidAbsoluteUrl = exports.isSameOrigin = exports.isSpace = exports.isString = exports.isNum = exports.isEmptyObj = exports.isBool = exports.isArrayBuffer = exports.info = exports.getVerbosityLevel = exports.getLookupTableFactory = exports.getInheritableProperty = exports.deprecated = exports.createObjectURL = exports.createPromiseCapability = exports.bytesToString = exports.assert = exports.arraysToBytes = exports.arrayByteLength = exports.FormatError = exports.XRefParseException = exports.toRomanNumerals = exports.Util = exports.UnknownErrorException = exports.UnexpectedResponseException = exports.TextRenderingMode = exports.StreamType = exports.PermissionFlag = exports.PasswordResponses = exports.PasswordException = exports.NativeImageDecoding = exports.MissingPDFException = exports.MissingDataException = exports.InvalidPDFException = exports.AbortException = exports.CMapCompressionType = exports.ImageKind = exports.FontType = exports.AnnotationType = exports.AnnotationFlag = exports.AnnotationFieldFlag = exports.AnnotationBorderStyleType = exports.UNSUPPORTED_FEATURES = exports.VerbosityLevel = exports.OPS = exports.IDENTITY_MATRIX = exports.FONT_IDENTITY_MATRIX = undefined;
+exports.toRomanNumerals = toRomanNumerals;
+exports.arrayByteLength = arrayByteLength;
+exports.arraysToBytes = arraysToBytes;
+exports.assert = assert;
+exports.bytesToString = bytesToString;
+exports.createPromiseCapability = createPromiseCapability;
+exports.deprecated = deprecated;
+exports.getInheritableProperty = getInheritableProperty;
+exports.getLookupTableFactory = getLookupTableFactory;
+exports.getVerbosityLevel = getVerbosityLevel;
+exports.info = info;
+exports.isArrayBuffer = isArrayBuffer;
+exports.isBool = isBool;
+exports.isEmptyObj = isEmptyObj;
+exports.isNum = isNum;
+exports.isString = isString;
+exports.isSpace = isSpace;
+exports.isSameOrigin = isSameOrigin;
+exports.createValidAbsoluteUrl = createValidAbsoluteUrl;
+exports.isLittleEndian = isLittleEndian;
+exports.isEvalSupported = isEvalSupported;
+exports.log2 = log2;
+exports.readInt8 = readInt8;
+exports.readUint16 = readUint16;
+exports.readUint32 = readUint32;
+exports.removeNullCharacters = removeNullCharacters;
+exports.setVerbosityLevel = setVerbosityLevel;
+exports.shadow = shadow;
+exports.string32 = string32;
+exports.stringToBytes = stringToBytes;
+exports.stringToPDFString = stringToPDFString;
+exports.stringToUTF8String = stringToUTF8String;
+exports.utf8StringToString = utf8StringToString;
+exports.warn = warn;
+exports.unreachable = unreachable;
+Object.defineProperty(exports, "ReadableStream", {
+  enumerable: true,
+  get: function () {
+    return _streams_polyfill.ReadableStream;
+  }
+});
+Object.defineProperty(exports, "URL", {
+  enumerable: true,
+  get: function () {
+    return _url_polyfill.URL;
+  }
+});
+exports.createObjectURL = exports.FormatError = exports.XRefParseException = exports.Util = exports.UnknownErrorException = exports.UnexpectedResponseException = exports.TextRenderingMode = exports.StreamType = exports.PermissionFlag = exports.PasswordResponses = exports.PasswordException = exports.NativeImageDecoding = exports.MissingPDFException = exports.MissingDataException = exports.InvalidPDFException = exports.AbortException = exports.CMapCompressionType = exports.ImageKind = exports.FontType = exports.AnnotationType = exports.AnnotationFlag = exports.AnnotationFieldFlag = exports.AnnotationBorderStyleType = exports.UNSUPPORTED_FEATURES = exports.VerbosityLevel = exports.OPS = exports.IDENTITY_MATRIX = exports.FONT_IDENTITY_MATRIX = void 0;
 
 __w_pdfjs_require__(2);
 
 var _streams_polyfill = __w_pdfjs_require__(4);
 
 var _url_polyfill = __w_pdfjs_require__(6);
 
 const 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];
+exports.FONT_IDENTITY_MATRIX = FONT_IDENTITY_MATRIX;
 const NativeImageDecoding = {
   NONE: 'none',
   DECODE: 'decode',
   DISPLAY: 'display'
 };
+exports.NativeImageDecoding = NativeImageDecoding;
 const PermissionFlag = {
   PRINT: 0x04,
   MODIFY_CONTENTS: 0x08,
   COPY: 0x10,
   MODIFY_ANNOTATIONS: 0x20,
   FILL_INTERACTIVE_FORMS: 0x100,
   COPY_FOR_ACCESSIBILITY: 0x200,
   ASSEMBLE: 0x400,
   PRINT_HIGH_QUALITY: 0x800
 };
+exports.PermissionFlag = PermissionFlag;
 const TextRenderingMode = {
   FILL: 0,
   STROKE: 1,
   FILL_STROKE: 2,
   INVISIBLE: 3,
   FILL_ADD_TO_PATH: 4,
   STROKE_ADD_TO_PATH: 5,
   FILL_STROKE_ADD_TO_PATH: 6,
   ADD_TO_PATH: 7,
   FILL_STROKE_MASK: 3,
   ADD_TO_PATH_FLAG: 4
 };
+exports.TextRenderingMode = TextRenderingMode;
 const ImageKind = {
   GRAYSCALE_1BPP: 1,
   RGB_24BPP: 2,
   RGBA_32BPP: 3
 };
+exports.ImageKind = ImageKind;
 const AnnotationType = {
   TEXT: 1,
   LINK: 2,
   FREETEXT: 3,
   LINE: 4,
   SQUARE: 5,
   CIRCLE: 6,
   POLYGON: 7,
@@ -244,28 +306,30 @@ const AnnotationType = {
   WIDGET: 20,
   SCREEN: 21,
   PRINTERMARK: 22,
   TRAPNET: 23,
   WATERMARK: 24,
   THREED: 25,
   REDACT: 26
 };
+exports.AnnotationType = AnnotationType;
 const AnnotationFlag = {
   INVISIBLE: 0x01,
   HIDDEN: 0x02,
   PRINT: 0x04,
   NOZOOM: 0x08,
   NOROTATE: 0x10,
   NOVIEW: 0x20,
   READONLY: 0x40,
   LOCKED: 0x80,
   TOGGLENOVIEW: 0x100,
   LOCKEDCONTENTS: 0x200
 };
+exports.AnnotationFlag = AnnotationFlag;
 const AnnotationFieldFlag = {
   READONLY: 0x0000001,
   REQUIRED: 0x0000002,
   NOEXPORT: 0x0000004,
   MULTILINE: 0x0001000,
   PASSWORD: 0x0002000,
   NOTOGGLETOOFF: 0x0004000,
   RADIO: 0x0008000,
@@ -277,58 +341,64 @@ const AnnotationFieldFlag = {
   MULTISELECT: 0x0200000,
   DONOTSPELLCHECK: 0x0400000,
   DONOTSCROLL: 0x0800000,
   COMB: 0x1000000,
   RICHTEXT: 0x2000000,
   RADIOSINUNISON: 0x2000000,
   COMMITONSELCHANGE: 0x4000000
 };
+exports.AnnotationFieldFlag = AnnotationFieldFlag;
 const AnnotationBorderStyleType = {
   SOLID: 1,
   DASHED: 2,
   BEVELED: 3,
   INSET: 4,
   UNDERLINE: 5
 };
+exports.AnnotationBorderStyleType = AnnotationBorderStyleType;
 const StreamType = {
   UNKNOWN: 0,
   FLATE: 1,
   LZW: 2,
   DCT: 3,
   JPX: 4,
   JBIG: 5,
   A85: 6,
   AHX: 7,
   CCF: 8,
   RL: 9
 };
+exports.StreamType = StreamType;
 const FontType = {
   UNKNOWN: 0,
   TYPE1: 1,
   TYPE1C: 2,
   CIDFONTTYPE0: 3,
   CIDFONTTYPE0C: 4,
   TRUETYPE: 5,
   CIDFONTTYPE2: 6,
   TYPE3: 7,
   OPENTYPE: 8,
   TYPE0: 9,
   MMTYPE1: 10
 };
+exports.FontType = FontType;
 const VerbosityLevel = {
   ERRORS: 0,
   WARNINGS: 1,
   INFOS: 5
 };
+exports.VerbosityLevel = VerbosityLevel;
 const CMapCompressionType = {
   NONE: 0,
   BINARY: 1,
   STREAM: 2
 };
+exports.CMapCompressionType = CMapCompressionType;
 const OPS = {
   dependency: 1,
   setLineWidth: 2,
   setLineCap: 3,
   setLineJoin: 4,
   setMiterLimit: 5,
   setDash: 6,
   setRenderingIntent: 7,
@@ -412,579 +482,662 @@ const OPS = {
   paintImageXObject: 85,
   paintInlineImageXObject: 86,
   paintInlineImageXObjectGroup: 87,
   paintImageXObjectRepeat: 88,
   paintImageMaskXObjectRepeat: 89,
   paintSolidColorImageMask: 90,
   constructPath: 91
 };
+exports.OPS = OPS;
 const UNSUPPORTED_FEATURES = {
   unknown: 'unknown',
   forms: 'forms',
   javaScript: 'javaScript',
   smask: 'smask',
   shadingPattern: 'shadingPattern',
   font: 'font'
 };
+exports.UNSUPPORTED_FEATURES = UNSUPPORTED_FEATURES;
 const PasswordResponses = {
   NEED_PASSWORD: 1,
   INCORRECT_PASSWORD: 2
 };
+exports.PasswordResponses = PasswordResponses;
 let verbosity = VerbosityLevel.WARNINGS;
+
 function setVerbosityLevel(level) {
   if (Number.isInteger(level)) {
     verbosity = level;
   }
 }
+
 function getVerbosityLevel() {
   return verbosity;
 }
+
 function info(msg) {
   if (verbosity >= VerbosityLevel.INFOS) {
     console.log('Info: ' + msg);
   }
 }
+
 function warn(msg) {
   if (verbosity >= VerbosityLevel.WARNINGS) {
     console.log('Warning: ' + msg);
   }
 }
+
 function deprecated(details) {
   console.log('Deprecated API usage: ' + details);
 }
+
 function unreachable(msg) {
   throw new Error(msg);
 }
+
 function assert(cond, msg) {
   if (!cond) {
     unreachable(msg);
   }
 }
+
 function isSameOrigin(baseUrl, otherUrl) {
   try {
     var base = new _url_polyfill.URL(baseUrl);
+
     if (!base.origin || base.origin === 'null') {
       return false;
     }
   } catch (e) {
     return false;
   }
+
   var other = new _url_polyfill.URL(otherUrl, base);
   return base.origin === other.origin;
 }
+
 function _isValidProtocol(url) {
   if (!url) {
     return false;
   }
+
   switch (url.protocol) {
     case 'http:':
     case 'https:':
     case 'ftp:':
     case 'mailto:':
     case 'tel:':
       return true;
+
     default:
       return false;
   }
 }
+
 function createValidAbsoluteUrl(url, baseUrl) {
   if (!url) {
     return null;
   }
+
   try {
     var absoluteUrl = baseUrl ? new _url_polyfill.URL(url, baseUrl) : new _url_polyfill.URL(url);
+
     if (_isValidProtocol(absoluteUrl)) {
       return absoluteUrl;
     }
   } catch (ex) {}
+
   return null;
 }
+
 function shadow(obj, prop, value) {
   Object.defineProperty(obj, prop, {
     value,
     enumerable: true,
     configurable: true,
     writable: false
   });
   return value;
 }
+
 function getLookupTableFactory(initializer) {
   var lookup;
   return function () {
     if (initializer) {
       lookup = Object.create(null);
       initializer(lookup);
       initializer = null;
     }
+
     return lookup;
   };
 }
+
 var PasswordException = function PasswordExceptionClosure() {
   function PasswordException(msg, code) {
     this.name = 'PasswordException';
     this.message = msg;
     this.code = code;
   }
+
   PasswordException.prototype = new Error();
   PasswordException.constructor = PasswordException;
   return PasswordException;
 }();
+
+exports.PasswordException = PasswordException;
+
 var UnknownErrorException = function UnknownErrorExceptionClosure() {
   function UnknownErrorException(msg, details) {
     this.name = 'UnknownErrorException';
     this.message = msg;
     this.details = details;
   }
+
   UnknownErrorException.prototype = new Error();
   UnknownErrorException.constructor = UnknownErrorException;
   return UnknownErrorException;
 }();
+
+exports.UnknownErrorException = UnknownErrorException;
+
 var InvalidPDFException = function InvalidPDFExceptionClosure() {
   function InvalidPDFException(msg) {
     this.name = 'InvalidPDFException';
     this.message = msg;
   }
+
   InvalidPDFException.prototype = new Error();
   InvalidPDFException.constructor = InvalidPDFException;
   return InvalidPDFException;
 }();
+
+exports.InvalidPDFException = InvalidPDFException;
+
 var MissingPDFException = function MissingPDFExceptionClosure() {
   function MissingPDFException(msg) {
     this.name = 'MissingPDFException';
     this.message = msg;
   }
+
   MissingPDFException.prototype = new Error();
   MissingPDFException.constructor = MissingPDFException;
   return MissingPDFException;
 }();
+
+exports.MissingPDFException = MissingPDFException;
+
 var UnexpectedResponseException = function UnexpectedResponseExceptionClosure() {
   function UnexpectedResponseException(msg, status) {
     this.name = 'UnexpectedResponseException';
     this.message = msg;
     this.status = status;
   }
+
   UnexpectedResponseException.prototype = new Error();
   UnexpectedResponseException.constructor = UnexpectedResponseException;
   return UnexpectedResponseException;
 }();
+
+exports.UnexpectedResponseException = UnexpectedResponseException;
+
 var MissingDataException = function MissingDataExceptionClosure() {
   function MissingDataException(begin, end) {
     this.begin = begin;
     this.end = end;
     this.message = 'Missing data [' + begin + ', ' + end + ')';
   }
+
   MissingDataException.prototype = new Error();
   MissingDataException.prototype.name = 'MissingDataException';
   MissingDataException.constructor = MissingDataException;
   return MissingDataException;
 }();
+
+exports.MissingDataException = MissingDataException;
+
 var XRefParseException = function XRefParseExceptionClosure() {
   function XRefParseException(msg) {
     this.message = msg;
   }
+
   XRefParseException.prototype = new Error();
   XRefParseException.prototype.name = 'XRefParseException';
   XRefParseException.constructor = XRefParseException;
   return XRefParseException;
 }();
+
+exports.XRefParseException = XRefParseException;
+
 let FormatError = function FormatErrorClosure() {
   function FormatError(msg) {
     this.message = msg;
   }
+
   FormatError.prototype = new Error();
   FormatError.prototype.name = 'FormatError';
   FormatError.constructor = FormatError;
   return FormatError;
 }();
+
+exports.FormatError = FormatError;
+
 let AbortException = function AbortExceptionClosure() {
   function AbortException(msg) {
     this.name = 'AbortException';
     this.message = msg;
   }
+
   AbortException.prototype = new Error();
   AbortException.constructor = AbortException;
   return AbortException;
 }();
+
+exports.AbortException = AbortException;
 var NullCharactersRegExp = /\x00/g;
+
 function removeNullCharacters(str) {
   if (typeof str !== 'string') {
     warn('The argument for removeNullCharacters must be a string.');
     return str;
   }
+
   return str.replace(NullCharactersRegExp, '');
 }
+
 function bytesToString(bytes) {
   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);
   }
+
   var strBuf = [];
+
   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));
   }
+
   return strBuf.join('');
 }
+
 function stringToBytes(str) {
   assert(typeof str === 'string', 'Invalid argument for stringToBytes');
   var length = str.length;
   var bytes = new Uint8Array(length);
+
   for (var i = 0; i < length; ++i) {
     bytes[i] = str.charCodeAt(i) & 0xFF;
   }
+
   return bytes;
 }
+
 function arrayByteLength(arr) {
   if (arr.length !== undefined) {
     return arr.length;
   }
+
   assert(arr.byteLength !== undefined);
   return arr.byteLength;
 }
+
 function arraysToBytes(arr) {
   if (arr.length === 1 && arr[0] instanceof Uint8Array) {
     return arr[0];
   }
+
   var resultLength = 0;
   var i,
       ii = arr.length;
   var item, itemLength;
+
   for (i = 0; i < ii; i++) {
     item = arr[i];
     itemLength = arrayByteLength(item);
     resultLength += itemLength;
   }
+
   var pos = 0;
   var data = new Uint8Array(resultLength);
+
   for (i = 0; i < ii; i++) {
     item = arr[i];
+
     if (!(item instanceof Uint8Array)) {
       if (typeof item === 'string') {
         item = stringToBytes(item);
       } else {
         item = new Uint8Array(item);
       }
     }
+
     itemLength = item.byteLength;
     data.set(item, pos);
     pos += itemLength;
   }
+
   return data;
 }
+
 function string32(value) {
   return String.fromCharCode(value >> 24 & 0xff, value >> 16 & 0xff, value >> 8 & 0xff, value & 0xff);
 }
+
 function log2(x) {
   if (x <= 0) {
     return 0;
   }
+
   return Math.ceil(Math.log2(x));
 }
+
 function readInt8(data, start) {
   return data[start] << 24 >> 24;
 }
+
 function readUint16(data, offset) {
   return data[offset] << 8 | data[offset + 1];
 }
+
 function readUint32(data, offset) {
   return (data[offset] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3]) >>> 0;
 }
+
 function isLittleEndian() {
   var buffer8 = new Uint8Array(4);
   buffer8[0] = 1;
   var view32 = new Uint32Array(buffer8.buffer, 0, 1);
   return view32[0] === 1;
 }
+
 function isEvalSupported() {
   try {
     new Function('');
     return true;
   } catch (e) {
     return false;
   }
 }
-function getInheritableProperty({ dict, key, getArray = false, stopWhenFound = true }) {
+
+function getInheritableProperty({
+  dict,
+  key,
+  getArray = false,
+  stopWhenFound = true
+}) {
   const LOOP_LIMIT = 100;
   let loopCount = 0;
   let values;
+
   while (dict) {
     const value = getArray ? dict.getArray(key) : dict.get(key);
+
     if (value !== undefined) {
       if (stopWhenFound) {
         return value;
       }
+
       if (!values) {
         values = [];
       }
+
       values.push(value);
     }
+
     if (++loopCount > LOOP_LIMIT) {
       warn(`getInheritableProperty: maximum loop count exceeded for "${key}"`);
       break;
     }
+
     dict = dict.get('Parent');
   }
+
   return values;
 }
+
 var Util = function UtilClosure() {
   function Util() {}
+
   var rgbBuf = ['rgb(', 0, ',', 0, ',', 0, ')'];
+
   Util.makeCssRgb = function Util_makeCssRgb(r, g, b) {
     rgbBuf[1] = r;
     rgbBuf[3] = g;
     rgbBuf[5] = b;
     return rgbBuf.join('');
   };
+
   Util.transform = function Util_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]];
   };
+
   Util.applyTransform = function Util_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];
   };
+
   Util.applyInverseTransform = function Util_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];
   };
+
   Util.getAxialAlignedBoundingBox = function Util_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])];
   };
+
   Util.inverseTransform = function Util_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];
   };
+
   Util.apply3dTransform = function Util_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]];
   };
+
   Util.singularValueDecompose2dScale = function Util_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)];
   };
+
   Util.normalizeRect = function Util_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;
   };
+
   Util.intersect = function Util_intersect(rect1, rect2) {
     function compare(a, b) {
       return a - b;
     }
+
     var orderedX = [rect1[0], rect1[2], rect2[0], rect2[2]].sort(compare),
         orderedY = [rect1[1], rect1[3], rect2[1], rect2[3]].sort(compare),
         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 false;
     }
+
     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 false;
     }
+
     return result;
   };
+
   return Util;
 }();
+
+exports.Util = Util;
 const ROMAN_NUMBER_MAP = ['', 'C', 'CC', 'CCC', 'CD', 'D', 'DC', 'DCC', 'DCCC', 'CM', '', 'X', 'XX', 'XXX', 'XL', 'L', 'LX', 'LXX', 'LXXX', 'XC', '', 'I', 'II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX'];
+
 function toRomanNumerals(number, lowerCase = false) {
   assert(Number.isInteger(number) && number > 0, 'The number should be a positive integer.');
   let pos,
       romanBuf = [];
+
   while (number >= 1000) {
     number -= 1000;
     romanBuf.push('M');
   }
+
   pos = number / 100 | 0;
   number %= 100;
   romanBuf.push(ROMAN_NUMBER_MAP[pos]);
   pos = number / 10 | 0;
   number %= 10;
   romanBuf.push(ROMAN_NUMBER_MAP[10 + pos]);
   romanBuf.push(ROMAN_NUMBER_MAP[20 + number]);
   const romanStr = romanBuf.join('');
   return lowerCase ? romanStr.toLowerCase() : romanStr;
 }
+
 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];
+
 function stringToPDFString(str) {
   var i,
       n = str.length,
       strBuf = [];
+
   if (str[0] === '\xFE' && str[1] === '\xFF') {
     for (i = 2; i < n; i += 2) {
       strBuf.push(String.fromCharCode(str.charCodeAt(i) << 8 | str.charCodeAt(i + 1)));
     }
   } else {
     for (i = 0; i < n; ++i) {
       var code = PDFStringTranslateTable[str.charCodeAt(i)];
       strBuf.push(code ? String.fromCharCode(code) : str.charAt(i));
     }
   }
+
   return strBuf.join('');
 }
+
 function stringToUTF8String(str) {
   return decodeURIComponent(escape(str));
 }
+
 function utf8StringToString(str) {
   return unescape(encodeURIComponent(str));
 }
+
 function isEmptyObj(obj) {
   for (var key in obj) {
     return false;
   }
+
   return true;
 }
+
 function isBool(v) {
   return typeof v === 'boolean';
 }
+
 function isNum(v) {
   return typeof v === 'number';
 }
+
 function isString(v) {
   return typeof v === 'string';
 }
+
 function isArrayBuffer(v) {
   return typeof v === 'object' && v !== null && v.byteLength !== undefined;
 }
+
 function isSpace(ch) {
   return ch === 0x20 || ch === 0x09 || ch === 0x0D || ch === 0x0A;
 }
+
 function createPromiseCapability() {
   var capability = {};
   capability.promise = new Promise(function (resolve, reject) {
     capability.resolve = resolve;
     capability.reject = reject;
   });
   return capability;
 }
+
 var createObjectURL = function createObjectURLClosure() {
   var digits = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
   return function createObjectURL(data, contentType, forceDataSchema = false) {
     if (!forceDataSchema && _url_polyfill.URL.createObjectURL) {
-      const blob = new Blob([data], { type: contentType });
+      const blob = new Blob([data], {
+        type: contentType
+      });
       return _url_polyfill.URL.createObjectURL(blob);
     }
+
     var buffer = 'data:' + contentType + ';base64,';
+
     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];
     }
+
     return buffer;
   };
 }();
-exports.FONT_IDENTITY_MATRIX = FONT_IDENTITY_MATRIX;
-exports.IDENTITY_MATRIX = IDENTITY_MATRIX;
-exports.OPS = OPS;
-exports.VerbosityLevel = VerbosityLevel;
-exports.UNSUPPORTED_FEATURES = UNSUPPORTED_FEATURES;
-exports.AnnotationBorderStyleType = AnnotationBorderStyleType;
-exports.AnnotationFieldFlag = AnnotationFieldFlag;
-exports.AnnotationFlag = AnnotationFlag;
-exports.AnnotationType = AnnotationType;
-exports.FontType = FontType;
-exports.ImageKind = ImageKind;
-exports.CMapCompressionType = CMapCompressionType;
-exports.AbortException = AbortException;
-exports.InvalidPDFException = InvalidPDFException;
-exports.MissingDataException = MissingDataException;
-exports.MissingPDFException = MissingPDFException;
-exports.NativeImageDecoding = NativeImageDecoding;
-exports.PasswordException = PasswordException;
-exports.PasswordResponses = PasswordResponses;
-exports.PermissionFlag = PermissionFlag;
-exports.StreamType = StreamType;
-exports.TextRenderingMode = TextRenderingMode;
-exports.UnexpectedResponseException = UnexpectedResponseException;
-exports.UnknownErrorException = UnknownErrorException;
-exports.Util = Util;
-exports.toRomanNumerals = toRomanNumerals;
-exports.XRefParseException = XRefParseException;
-exports.FormatError = FormatError;
-exports.arrayByteLength = arrayByteLength;
-exports.arraysToBytes = arraysToBytes;
-exports.assert = assert;
-exports.bytesToString = bytesToString;
-exports.createPromiseCapability = createPromiseCapability;
+
 exports.createObjectURL = createObjectURL;
-exports.deprecated = deprecated;
-exports.getInheritableProperty = getInheritableProperty;
-exports.getLookupTableFactory = getLookupTableFactory;
-exports.getVerbosityLevel = getVerbosityLevel;
-exports.info = info;
-exports.isArrayBuffer = isArrayBuffer;
-exports.isBool = isBool;
-exports.isEmptyObj = isEmptyObj;
-exports.isNum = isNum;
-exports.isString = isString;
-exports.isSpace = isSpace;
-exports.isSameOrigin = isSameOrigin;
-exports.createValidAbsoluteUrl = createValidAbsoluteUrl;
-exports.isLittleEndian = isLittleEndian;
-exports.isEvalSupported = isEvalSupported;
-exports.log2 = log2;
-exports.readInt8 = readInt8;
-exports.readUint16 = readUint16;
-exports.readUint32 = readUint32;
-exports.removeNullCharacters = removeNullCharacters;
-exports.ReadableStream = _streams_polyfill.ReadableStream;
-exports.URL = _url_polyfill.URL;
-exports.setVerbosityLevel = setVerbosityLevel;
-exports.shadow = shadow;
-exports.string32 = string32;
-exports.stringToBytes = stringToBytes;
-exports.stringToPDFString = stringToPDFString;
-exports.stringToUTF8String = stringToUTF8String;
-exports.utf8StringToString = utf8StringToString;
-exports.warn = warn;
-exports.unreachable = unreachable;
 
 /***/ }),
 /* 2 */
 /***/ (function(module, exports, __w_pdfjs_require__) {
 
 "use strict";
 
 
 const globalScope = __w_pdfjs_require__(3);
+
 ;
 
 /***/ }),
 /* 3 */
 /***/ (function(module, exports, __w_pdfjs_require__) {
 
 "use strict";
 
@@ -994,26 +1147,29 @@ module.exports = typeof window !== 'unde
 /***/ }),
 /* 4 */
 /***/ (function(module, exports, __w_pdfjs_require__) {
 
 "use strict";
 
 
 let isReadableStreamSupported = false;
+
 if (typeof ReadableStream !== 'undefined') {
   try {
     new ReadableStream({
       start(controller) {
         controller.close();
       }
+
     });
     isReadableStreamSupported = true;
   } catch (e) {}
 }
+
 if (isReadableStreamSupported) {
   exports.ReadableStream = ReadableStream;
 } else {
   exports.ReadableStream = __w_pdfjs_require__(5).ReadableStream;
 }
 
 /***/ }),
 /* 5 */
@@ -1021,86 +1177,102 @@ if (isReadableStreamSupported) {
 
 "use strict";
 
 
 (function (e, a) {
   for (var i in a) e[i] = a[i];
 })(exports, function (modules) {
   var installedModules = {};
+
   function __w_pdfjs_require__(moduleId) {
     if (installedModules[moduleId]) return installedModules[moduleId].exports;
     var module = installedModules[moduleId] = {
       i: moduleId,
       l: false,
       exports: {}
     };
     modules[moduleId].call(module.exports, module, module.exports, __w_pdfjs_require__);
     module.l = true;
     return module.exports;
   }
+
   __w_pdfjs_require__.m = modules;
   __w_pdfjs_require__.c = installedModules;
+
   __w_pdfjs_require__.i = function (value) {
     return value;
   };
+
   __w_pdfjs_require__.d = function (exports, name, getter) {
     if (!__w_pdfjs_require__.o(exports, name)) {
       Object.defineProperty(exports, name, {
         configurable: false,
         enumerable: true,
         get: getter
       });
     }
   };
+
   __w_pdfjs_require__.n = function (module) {
     var getter = module && module.__esModule ? function getDefault() {
       return module['default'];
     } : function getModuleExports() {
       return module;
     };
+
     __w_pdfjs_require__.d(getter, 'a', getter);
+
     return getter;
   };
+
   __w_pdfjs_require__.o = function (object, property) {
     return Object.prototype.hasOwnProperty.call(object, property);
   };
+
   __w_pdfjs_require__.p = "";
   return __w_pdfjs_require__(__w_pdfjs_require__.s = 7);
 }([function (module, exports, __w_pdfjs_require__) {
   "use strict";
 
   var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
     return typeof obj;
   } : function (obj) {
     return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
   };
+
   var _require = __w_pdfjs_require__(1),
       assert = _require.assert;
+
   function IsPropertyKey(argument) {
     return typeof argument === 'string' || (typeof argument === 'undefined' ? 'undefined' : _typeof(argument)) === 'symbol';
   }
+
   exports.typeIsObject = function (x) {
     return (typeof x === 'undefined' ? 'undefined' : _typeof(x)) === 'object' && x !== null || typeof x === 'function';
   };
+
   exports.createDataProperty = function (o, p, v) {
     assert(exports.typeIsObject(o));
     Object.defineProperty(o, p, {
       value: v,
       writable: true,
       enumerable: true,
       configurable: true
     });
   };
+
   exports.createArrayFromList = function (elements) {
     return elements.slice();
   };
+
   exports.ArrayBufferCopy = function (dest, destOffset, src, srcOffset, n) {
     new Uint8Array(dest).set(new Uint8Array(src, srcOffset, n), destOffset);
   };
+
   exports.CreateIterResultObject = function (value, done) {
     assert(typeof done === 'boolean');
     var obj = {};
     Object.defineProperty(obj, 'value', {
       value: value,
       enumerable: true,
       writable: true,
       configurable: true
@@ -1108,116 +1280,141 @@ if (isReadableStreamSupported) {
     Object.defineProperty(obj, 'done', {
       value: done,
       enumerable: true,
       writable: true,
       configurable: true
     });
     return obj;
   };
+
   exports.IsFiniteNonNegativeNumber = function (v) {
     if (Number.isNaN(v)) {
       return false;
     }
+
     if (v === Infinity) {
       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);
   }
+
   exports.InvokeOrNoop = function (O, P, args) {
     assert(O !== undefined);
     assert(IsPropertyKey(P));
     assert(Array.isArray(args));
     var method = O[P];
+
     if (method === undefined) {
       return undefined;
     }
+
     return Call(method, O, args);
   };
+
   exports.PromiseInvokeOrNoop = function (O, P, args) {
     assert(O !== undefined);
     assert(IsPropertyKey(P));
     assert(Array.isArray(args));
+
     try {
       return Promise.resolve(exports.InvokeOrNoop(O, P, args));
     } catch (returnValueE) {
       return Promise.reject(returnValueE);
     }
   };
+
   exports.PromiseInvokeOrPerformFallback = function (O, P, args, F, argsF) {
     assert(O !== undefined);
     assert(IsPropertyKey(P));
     assert(Array.isArray(args));
     assert(Array.isArray(argsF));
     var method = void 0;
+
     try {
       method = O[P];
     } catch (methodE) {
       return Promise.reject(methodE);
     }
+
     if (method === undefined) {
       return F.apply(null, argsF);
     }
+
     try {
       return Promise.resolve(Call(method, O, args));
     } catch (e) {
       return Promise.reject(e);
     }
   };
+
   exports.TransferArrayBuffer = function (O) {
     return O.slice();
   };
+
   exports.ValidateAndNormalizeHighWaterMark = function (highWaterMark) {
     highWaterMark = Number(highWaterMark);
+
     if (Number.isNaN(highWaterMark) || highWaterMark < 0) {
       throw new RangeError('highWaterMark property of a queuing strategy must be non-negative and non-NaN');
     }
+
     return highWaterMark;
   };
+
   exports.ValidateAndNormalizeQueuingStrategy = function (size, highWaterMark) {
     if (size !== undefined && typeof size !== 'function') {
       throw new TypeError('size property of a queuing strategy must be a function');
     }
+
     highWaterMark = exports.ValidateAndNormalizeHighWaterMark(highWaterMark);
     return {
       size: size,
       highWaterMark: highWaterMark
     };
   };
 }, function (module, exports, __w_pdfjs_require__) {
   "use strict";
 
   function rethrowAssertionErrorRejection(e) {
     if (e && e.constructor === AssertionError) {
       setTimeout(function () {
         throw e;
       }, 0);
     }
   }
+
   function AssertionError(message) {
     this.name = 'AssertionError';
     this.message = message || '';
     this.stack = new Error().stack;
   }
+
   AssertionError.prototype = Object.create(Error.prototype);
   AssertionError.prototype.constructor = AssertionError;
+
   function assert(value, message) {
     if (!value) {
       throw new AssertionError(message);
     }
   }
+
   module.exports = {
     rethrowAssertionErrorRejection: rethrowAssertionErrorRejection,
     AssertionError: AssertionError,
     assert: assert
   };
 }, function (module, exports, __w_pdfjs_require__) {
   "use strict";
 
@@ -1226,855 +1423,1084 @@ if (isReadableStreamSupported) {
       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);
       }
     }
+
     return function (Constructor, protoProps, staticProps) {
       if (protoProps) defineProperties(Constructor.prototype, protoProps);
       if (staticProps) defineProperties(Constructor, staticProps);
       return Constructor;
     };
   }();
+
   function _classCallCheck(instance, Constructor) {
     if (!(instance instanceof Constructor)) {
       throw new TypeError("Cannot call a class as a function");
     }
   }
+
   var _require = __w_pdfjs_require__(0),
       InvokeOrNoop = _require.InvokeOrNoop,
       PromiseInvokeOrNoop = _require.PromiseInvokeOrNoop,
       ValidateAndNormalizeQueuingStrategy = _require.ValidateAndNormalizeQueuingStrategy,
       typeIsObject = _require.typeIsObject;
+
   var _require2 = __w_pdfjs_require__(1),
       assert = _require2.assert,
       rethrowAssertionErrorRejection = _require2.rethrowAssertionErrorRejection;
+
   var _require3 = __w_pdfjs_require__(3),
       DequeueValue = _require3.DequeueValue,
       EnqueueValueWithSize = _require3.EnqueueValueWithSize,
       PeekQueueValue = _require3.PeekQueueValue,
       ResetQueue = _require3.ResetQueue;
+
   var WritableStream = function () {
     function WritableStream() {
       var underlyingSink = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
       var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
           size = _ref.size,
           _ref$highWaterMark = _ref.highWaterMark,
           highWaterMark = _ref$highWaterMark === undefined ? 1 : _ref$highWaterMark;
+
       _classCallCheck(this, WritableStream);
+
       this._state = 'writable';
       this._storedError = undefined;
       this._writer = undefined;
       this._writableStreamController = undefined;
       this._writeRequests = [];
       this._inFlightWriteRequest = undefined;
       this._closeRequest = undefined;
       this._inFlightCloseRequest = undefined;
       this._pendingAbortRequest = undefined;
       this._backpressure = false;
       var type = underlyingSink.type;
+
       if (type !== undefined) {
         throw new RangeError('Invalid type is specified');
       }
+
       this._writableStreamController = new WritableStreamDefaultController(this, underlyingSink, size, highWaterMark);
+
       this._writableStreamController.__startSteps();
     }
+
     _createClass(WritableStream, [{
       key: 'abort',
       value: function abort(reason) {
         if (IsWritableStream(this) === false) {
           return Promise.reject(streamBrandCheckException('abort'));
         }
+
         if (IsWritableStreamLocked(this) === true) {
           return Promise.reject(new TypeError('Cannot abort a stream that already has a writer'));
         }
+
         return WritableStreamAbort(this, reason);
       }
     }, {
       key: 'getWriter',
       value: function getWriter() {
         if (IsWritableStream(this) === false) {
           throw streamBrandCheckException('getWriter');
         }
+
         return AcquireWritableStreamDefaultWriter(this);
       }
     }, {
       key: 'locked',
       get: function get() {
         if (IsWritableStream(this) === false) {
           throw streamBrandCheckException('locked');
         }
+
         return IsWritableStreamLocked(this);
       }
     }]);
+
     return WritableStream;
   }();
+
   module.exports = {
     AcquireWritableStreamDefaultWriter: AcquireWritableStreamDefaultWriter,
     IsWritableStream: IsWritableStream,
     IsWritableStreamLocked: IsWritableStreamLocked,
     WritableStream: WritableStream,
     WritableStreamAbort: WritableStreamAbort,
     WritableStreamDefaultControllerError: WritableStreamDefaultControllerError,
     WritableStreamDefaultWriterCloseWithErrorPropagation: WritableStreamDefaultWriterCloseWithErrorPropagation,
     WritableStreamDefaultWriterRelease: WritableStreamDefaultWriterRelease,
     WritableStreamDefaultWriterWrite: WritableStreamDefaultWriterWrite,
     WritableStreamCloseQueuedOrInFlight: WritableStreamCloseQueuedOrInFlight
   };
+
   function AcquireWritableStreamDefaultWriter(stream) {
     return new WritableStreamDefaultWriter(stream);
   }
+
   function IsWritableStream(x) {
     if (!typeIsObject(x)) {
       return false;
     }
+
     if (!Object.prototype.hasOwnProperty.call(x, '_writableStreamController')) {
       return false;
     }
+
     return true;
   }
+
   function IsWritableStreamLocked(stream) {
     assert(IsWritableStream(stream) === true, 'IsWritableStreamLocked should only be used on known writable streams');
+
     if (stream._writer === undefined) {
       return false;
     }
+
     return true;
   }
+
   function WritableStreamAbort(stream, reason) {
     var state = stream._state;
+
     if (state === 'closed') {
       return Promise.resolve(undefined);
     }
+
     if (state === 'errored') {
       return Promise.reject(stream._storedError);
     }
+
     var error = new TypeError('Requested to abort');
+
     if (stream._pendingAbortRequest !== undefined) {
       return Promise.reject(error);
     }
+
     assert(state === 'writable' || state === 'erroring', 'state must be writable or erroring');
     var wasAlreadyErroring = false;
+
     if (state === 'erroring') {
       wasAlreadyErroring = true;
       reason = undefined;
     }
+
     var promise = new Promise(function (resolve, reject) {
       stream._pendingAbortRequest = {
         _resolve: resolve,
         _reject: reject,
         _reason: reason,
         _wasAlreadyErroring: wasAlreadyErroring
       };
     });
+
     if (wasAlreadyErroring === false) {
       WritableStreamStartErroring(stream, error);
     }
+
     return promise;
   }
+
   function WritableStreamAddWriteRequest(stream) {
     assert(IsWritableStreamLocked(stream) === true);
     assert(stream._state === 'writable');
     var promise = new Promise(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;
     }
+
     assert(state === 'erroring');
     WritableStreamFinishErroring(stream);
   }
+
   function WritableStreamStartErroring(stream, reason) {
     assert(stream._storedError === undefined, 'stream._storedError === undefined');
     assert(stream._state === 'writable', 'state must be writable');
     var controller = stream._writableStreamController;
     assert(controller !== undefined, 'controller must not be undefined');
     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) {
     assert(stream._state === 'erroring', 'stream._state === erroring');
     assert(WritableStreamHasOperationMarkedInFlight(stream) === false, 'WritableStreamHasOperationMarkedInFlight(stream) === false');
     stream._state = 'errored';
+
     stream._writableStreamController.__errorSteps();
+
     var storedError = stream._storedError;
+
     for (var i = 0; i < stream._writeRequests.length; i++) {
       var writeRequest = stream._writeRequests[i];
+
       writeRequest._reject(storedError);
     }
+
     stream._writeRequests = [];
+
     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);
+
     promise.then(function () {
       abortRequest._resolve();
+
       WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
     }, function (reason) {
       abortRequest._reject(reason);
+
       WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
     });
   }
+
   function WritableStreamFinishInFlightWrite(stream) {
     assert(stream._inFlightWriteRequest !== undefined);
+
     stream._inFlightWriteRequest._resolve(undefined);
+
     stream._inFlightWriteRequest = undefined;
   }
+
   function WritableStreamFinishInFlightWriteWithError(stream, error) {
     assert(stream._inFlightWriteRequest !== undefined);
+
     stream._inFlightWriteRequest._reject(error);
+
     stream._inFlightWriteRequest = undefined;
     assert(stream._state === 'writable' || stream._state === 'erroring');
     WritableStreamDealWithRejection(stream, error);
   }
+
   function WritableStreamFinishInFlightClose(stream) {
     assert(stream._inFlightCloseRequest !== undefined);
+
     stream._inFlightCloseRequest._resolve(undefined);
+
     stream._inFlightCloseRequest = undefined;
     var state = stream._state;
     assert(state === 'writable' || state === 'erroring');
+
     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);
     }
+
     assert(stream._pendingAbortRequest === undefined, 'stream._pendingAbortRequest === undefined');
     assert(stream._storedError === undefined, 'stream._storedError === undefined');
   }
+
   function WritableStreamFinishInFlightCloseWithError(stream, error) {
     assert(stream._inFlightCloseRequest !== undefined);
+
     stream._inFlightCloseRequest._reject(error);
+
     stream._inFlightCloseRequest = undefined;
     assert(stream._state === 'writable' || stream._state === 'erroring');
+
     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) {
     assert(stream._inFlightCloseRequest === undefined);
     assert(stream._closeRequest !== undefined);
     stream._inFlightCloseRequest = stream._closeRequest;
     stream._closeRequest = undefined;
   }
+
   function WritableStreamMarkFirstWriteRequestInFlight(stream) {
     assert(stream._inFlightWriteRequest === undefined, 'there must be no pending write request');
     assert(stream._writeRequests.length !== 0, 'writeRequests must not be empty');
     stream._inFlightWriteRequest = stream._writeRequests.shift();
   }
+
   function WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream) {
     assert(stream._state === 'errored', '_stream_.[[state]] is `"errored"`');
+
     if (stream._closeRequest !== undefined) {
       assert(stream._inFlightCloseRequest === undefined);
+
       stream._closeRequest._reject(stream._storedError);
+
       stream._closeRequest = undefined;
     }
+
     var writer = stream._writer;
+
     if (writer !== undefined) {
       defaultWriterClosedPromiseReject(writer, stream._storedError);
+
       writer._closedPromise.catch(function () {});
     }
   }
+
   function WritableStreamUpdateBackpressure(stream, backpressure) {
     assert(stream._state === 'writable');
     assert(WritableStreamCloseQueuedOrInFlight(stream) === false);
     var writer = stream._writer;
+
     if (writer !== undefined && backpressure !== stream._backpressure) {
       if (backpressure === true) {
         defaultWriterReadyPromiseReset(writer);
       } else {
         assert(backpressure === false);
         defaultWriterReadyPromiseResolve(writer);
       }
     }
+
     stream._backpressure = backpressure;
   }
+
   var WritableStreamDefaultWriter = function () {
     function WritableStreamDefaultWriter(stream) {
       _classCallCheck(this, WritableStreamDefaultWriter);
+
       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);
+
         this._readyPromise.catch(function () {});
+
         defaultWriterClosedPromiseInitialize(this);
       } else if (state === 'closed') {
         defaultWriterReadyPromiseInitializeAsResolved(this);
         defaultWriterClosedPromiseInitializeAsResolved(this);
       } else {
         assert(state === 'errored', 'state must be errored');
         var storedError = stream._storedError;
         defaultWriterReadyPromiseInitializeAsRejected(this, storedError);
+
         this._readyPromise.catch(function () {});
+
         defaultWriterClosedPromiseInitializeAsRejected(this, storedError);
+
         this._closedPromise.catch(function () {});
       }
     }
+
     _createClass(WritableStreamDefaultWriter, [{
       key: 'abort',
       value: function abort(reason) {
         if (IsWritableStreamDefaultWriter(this) === false) {
           return Promise.reject(defaultWriterBrandCheckException('abort'));
         }
+
         if (this._ownerWritableStream === undefined) {
           return Promise.reject(defaultWriterLockException('abort'));
         }
+
         return WritableStreamDefaultWriterAbort(this, reason);
       }
     }, {
       key: 'close',
       value: function close() {
         if (IsWritableStreamDefaultWriter(this) === false) {
           return Promise.reject(defaultWriterBrandCheckException('close'));
         }
+
         var stream = this._ownerWritableStream;
+
         if (stream === undefined) {
           return Promise.reject(defaultWriterLockException('close'));
         }
+
         if (WritableStreamCloseQueuedOrInFlight(stream) === true) {
           return Promise.reject(new TypeError('cannot close an already-closing stream'));
         }
+
         return WritableStreamDefaultWriterClose(this);
       }
     }, {
       key: 'releaseLock',
       value: function releaseLock() {
         if (IsWritableStreamDefaultWriter(this) === false) {
           throw defaultWriterBrandCheckException('releaseLock');
         }
+
         var stream = this._ownerWritableStream;
+
         if (stream === undefined) {
           return;
         }
+
         assert(stream._writer !== undefined);
         WritableStreamDefaultWriterRelease(this);
       }
     }, {
       key: 'write',
       value: function write(chunk) {
         if (IsWritableStreamDefaultWriter(this) === false) {
           return Promise.reject(defaultWriterBrandCheckException('write'));
         }
+
         if (this._ownerWritableStream === undefined) {
           return Promise.reject(defaultWriterLockException('write to'));
         }
+
         return WritableStreamDefaultWriterWrite(this, chunk);
       }
     }, {
       key: 'closed',
       get: function get() {
         if (IsWritableStreamDefaultWriter(this) === false) {
           return Promise.reject(defaultWriterBrandCheckException('closed'));
         }
+
         return this._closedPromise;
       }
     }, {
       key: 'desiredSize',
       get: function get() {
         if (IsWritableStreamDefaultWriter(this) === false) {
           throw defaultWriterBrandCheckException('desiredSize');
         }
+
         if (this._ownerWritableStream === undefined) {
           throw defaultWriterLockException('desiredSize');
         }
+
         return WritableStreamDefaultWriterGetDesiredSize(this);
       }
     }, {
       key: 'ready',
       get: function get() {
         if (IsWritableStreamDefaultWriter(this) === false) {
           return Promise.reject(defaultWriterBrandCheckException('ready'));
         }
+
         return this._readyPromise;
       }
     }]);
+
     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;
     assert(stream !== undefined);
     return WritableStreamAbort(stream, reason);
   }
+
   function WritableStreamDefaultWriterClose(writer) {
     var stream = writer._ownerWritableStream;
     assert(stream !== undefined);
     var state = stream._state;
+
     if (state === 'closed' || state === 'errored') {
       return Promise.reject(new TypeError('The stream (in ' + state + ' state) is not in the writable state and cannot be closed'));
     }
+
     assert(state === 'writable' || state === 'erroring');
     assert(WritableStreamCloseQueuedOrInFlight(stream) === false);
     var promise = new Promise(function (resolve, reject) {
       var closeRequest = {
         _resolve: resolve,
         _reject: reject
       };
       stream._closeRequest = closeRequest;
     });
+
     if (stream._backpressure === true && state === 'writable') {
       defaultWriterReadyPromiseResolve(writer);
     }
+
     WritableStreamDefaultControllerClose(stream._writableStreamController);
     return promise;
   }
+
   function WritableStreamDefaultWriterCloseWithErrorPropagation(writer) {
     var stream = writer._ownerWritableStream;
     assert(stream !== undefined);
     var state = stream._state;
+
     if (WritableStreamCloseQueuedOrInFlight(stream) === true || state === 'closed') {
       return Promise.resolve();
     }
+
     if (state === 'errored') {
       return Promise.reject(stream._storedError);
     }
+
     assert(state === 'writable' || state === 'erroring');
     return WritableStreamDefaultWriterClose(writer);
   }
+
   function WritableStreamDefaultWriterEnsureClosedPromiseRejected(writer, error) {
     if (writer._closedPromiseState === 'pending') {
       defaultWriterClosedPromiseReject(writer, error);
     } else {
       defaultWriterClosedPromiseResetToRejected(writer, error);
     }
+
     writer._closedPromise.catch(function () {});
   }
+
   function WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, error) {
     if (writer._readyPromiseState === 'pending') {
       defaultWriterReadyPromiseReject(writer, error);
     } else {
       defaultWriterReadyPromiseResetToRejected(writer, error);
     }
+
     writer._readyPromise.catch(function () {});
   }
+
   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;
     assert(stream !== undefined);
     assert(stream._writer === writer);
     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;
     assert(stream !== undefined);
     var controller = stream._writableStreamController;
     var chunkSize = WritableStreamDefaultControllerGetChunkSize(controller, chunk);
+
     if (stream !== writer._ownerWritableStream) {
       return Promise.reject(defaultWriterLockException('write to'));
     }
+
     var state = stream._state;
+
     if (state === 'errored') {
       return Promise.reject(stream._storedError);
     }
+
     if (WritableStreamCloseQueuedOrInFlight(stream) === true || state === 'closed') {
       return Promise.reject(new TypeError('The stream is closing or closed and cannot be written to'));
     }
+
     if (state === 'erroring') {
       return Promise.reject(stream._storedError);
     }
+
     assert(state === 'writable');
     var promise = WritableStreamAddWriteRequest(stream);
     WritableStreamDefaultControllerWrite(controller, chunk, chunkSize);
     return promise;
   }
+
   var WritableStreamDefaultController = function () {
     function WritableStreamDefaultController(stream, underlyingSink, size, highWaterMark) {
       _classCallCheck(this, WritableStreamDefaultController);
+
       if (IsWritableStream(stream) === false) {
         throw new TypeError('WritableStreamDefaultController can only be constructed with a WritableStream instance');
       }
+
       if (stream._writableStreamController !== undefined) {
         throw new TypeError('WritableStreamDefaultController instances can only be created by the WritableStream constructor');
       }
+
       this._controlledWritableStream = stream;
       this._underlyingSink = underlyingSink;
       this._queue = undefined;
       this._queueTotalSize = undefined;
       ResetQueue(this);
       this._started = false;
       var normalizedStrategy = ValidateAndNormalizeQueuingStrategy(size, highWaterMark);
       this._strategySize = normalizedStrategy.size;
       this._strategyHWM = normalizedStrategy.highWaterMark;
       var backpressure = WritableStreamDefaultControllerGetBackpressure(this);
       WritableStreamUpdateBackpressure(stream, backpressure);
     }
+
     _createClass(WritableStreamDefaultController, [{
       key: 'error',
       value: function error(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);
       }
     }, {
       key: '__abortSteps',
       value: function __abortSteps(reason) {
         return PromiseInvokeOrNoop(this._underlyingSink, 'abort', [reason]);
       }
     }, {
       key: '__errorSteps',
       value: function __errorSteps() {
         ResetQueue(this);
       }
     }, {
       key: '__startSteps',
       value: function __startSteps() {
         var _this = this;
+
         var startResult = InvokeOrNoop(this._underlyingSink, 'start', [this]);
         var stream = this._controlledWritableStream;
         Promise.resolve(startResult).then(function () {
           assert(stream._state === 'writable' || stream._state === 'erroring');
           _this._started = true;
           WritableStreamDefaultControllerAdvanceQueueIfNeeded(_this);
         }, function (r) {
           assert(stream._state === 'writable' || stream._state === 'erroring');
           _this._started = true;
           WritableStreamDealWithRejection(stream, r);
         }).catch(rethrowAssertionErrorRejection);
       }
     }]);
+
     return WritableStreamDefaultController;
   }();
+
   function WritableStreamDefaultControllerClose(controller) {
     EnqueueValueWithSize(controller, 'close', 0);
     WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
   }
+
   function WritableStreamDefaultControllerGetChunkSize(controller, chunk) {
     var strategySize = controller._strategySize;
+
     if (strategySize === undefined) {
       return 1;
     }
+
     try {
       return strategySize(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 };
+    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 IsWritableStreamDefaultController(x) {
     if (!typeIsObject(x)) {
       return false;
     }
+
     if (!Object.prototype.hasOwnProperty.call(x, '_underlyingSink')) {
       return false;
     }
+
     return true;
   }
+
   function WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller) {
     var stream = controller._controlledWritableStream;
+
     if (controller._started === false) {
       return;
     }
+
     if (stream._inFlightWriteRequest !== undefined) {
       return;
     }
+
     var state = stream._state;
+
     if (state === 'closed' || state === 'errored') {
       return;
     }
+
     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);
     assert(controller._queue.length === 0, 'queue must be empty once the final write record is dequeued');
     var sinkClosePromise = PromiseInvokeOrNoop(controller._underlyingSink, 'close', []);
     sinkClosePromise.then(function () {
       WritableStreamFinishInFlightClose(stream);
     }, function (reason) {
       WritableStreamFinishInFlightCloseWithError(stream, reason);
     }).catch(rethrowAssertionErrorRejection);
   }
+
   function WritableStreamDefaultControllerProcessWrite(controller, chunk) {
     var stream = controller._controlledWritableStream;
     WritableStreamMarkFirstWriteRequestInFlight(stream);
     var sinkWritePromise = PromiseInvokeOrNoop(controller._underlyingSink, 'write', [chunk, controller]);
     sinkWritePromise.then(function () {
       WritableStreamFinishInFlightWrite(stream);
       var state = stream._state;
       assert(state === 'writable' || state === 'erroring');
       DequeueValue(controller);
+
       if (WritableStreamCloseQueuedOrInFlight(stream) === false && state === 'writable') {
         var backpressure = WritableStreamDefaultControllerGetBackpressure(controller);
         WritableStreamUpdateBackpressure(stream, backpressure);
       }
+
       WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
     }, function (reason) {
       WritableStreamFinishInFlightWriteWithError(stream, reason);
     }).catch(rethrowAssertionErrorRejection);
   }
+
   function WritableStreamDefaultControllerGetBackpressure(controller) {
     var desiredSize = WritableStreamDefaultControllerGetDesiredSize(controller);
     return desiredSize <= 0;
   }
+
   function WritableStreamDefaultControllerError(controller, error) {
     var stream = controller._controlledWritableStream;
     assert(stream._state === 'writable');
     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 = new Promise(function (resolve, reject) {
       writer._closedPromise_resolve = resolve;
       writer._closedPromise_reject = reject;
       writer._closedPromiseState = 'pending';
     });
   }
+
   function defaultWriterClosedPromiseInitializeAsRejected(writer, reason) {
     writer._closedPromise = Promise.reject(reason);
     writer._closedPromise_resolve = undefined;
     writer._closedPromise_reject = undefined;
     writer._closedPromiseState = 'rejected';
   }
+
   function defaultWriterClosedPromiseInitializeAsResolved(writer) {
     writer._closedPromise = Promise.resolve(undefined);
     writer._closedPromise_resolve = undefined;
     writer._closedPromise_reject = undefined;
     writer._closedPromiseState = 'resolved';
   }
+
   function defaultWriterClosedPromiseReject(writer, reason) {
     assert(writer._closedPromise_resolve !== undefined, 'writer._closedPromise_resolve !== undefined');
     assert(writer._closedPromise_reject !== undefined, 'writer._closedPromise_reject !== undefined');
     assert(writer._closedPromiseState === 'pending', 'writer._closedPromiseState is pending');
+
     writer._closedPromise_reject(reason);
+
     writer._closedPromise_resolve = undefined;
     writer._closedPromise_reject = undefined;
     writer._closedPromiseState = 'rejected';
   }
+
   function defaultWriterClosedPromiseResetToRejected(writer, reason) {
     assert(writer._closedPromise_resolve === undefined, 'writer._closedPromise_resolve === undefined');
     assert(writer._closedPromise_reject === undefined, 'writer._closedPromise_reject === undefined');
     assert(writer._closedPromiseState !== 'pending', 'writer._closedPromiseState is not pending');
     writer._closedPromise = Promise.reject(reason);
     writer._closedPromiseState = 'rejected';
   }
+
   function defaultWriterClosedPromiseResolve(writer) {
     assert(writer._closedPromise_resolve !== undefined, 'writer._closedPromise_resolve !== undefined');
     assert(writer._closedPromise_reject !== undefined, 'writer._closedPromise_reject !== undefined');
     assert(writer._closedPromiseState === 'pending', 'writer._closedPromiseState is pending');
+
     writer._closedPromise_resolve(undefined);
+
     writer._closedPromise_resolve = undefined;
     writer._closedPromise_reject = undefined;
     writer._closedPromiseState = 'resolved';
   }
+
   function defaultWriterReadyPromiseInitialize(writer) {
     writer._readyPromise = new Promise(function (resolve, reject) {
       writer._readyPromise_resolve = resolve;
       writer._readyPromise_reject = reject;
     });
     writer._readyPromiseState = 'pending';
   }
+
   function defaultWriterReadyPromiseInitializeAsRejected(writer, reason) {
     writer._readyPromise = Promise.reject(reason);
     writer._readyPromise_resolve = undefined;
     writer._readyPromise_reject = undefined;
     writer._readyPromiseState = 'rejected';
   }
+
   function defaultWriterReadyPromiseInitializeAsResolved(writer) {
     writer._readyPromise = Promise.resolve(undefined);
     writer._readyPromise_resolve = undefined;
     writer._readyPromise_reject = undefined;
     writer._readyPromiseState = 'fulfilled';
   }
+
   function defaultWriterReadyPromiseReject(writer, reason) {
     assert(writer._readyPromise_resolve !== undefined, 'writer._readyPromise_resolve !== undefined');
     assert(writer._readyPromise_reject !== undefined, 'writer._readyPromise_reject !== undefined');
+
     writer._readyPromise_reject(reason);
+
     writer._readyPromise_resolve = undefined;
     writer._readyPromise_reject = undefined;
     writer._readyPromiseState = 'rejected';
   }
+
   function defaultWriterReadyPromiseReset(writer) {
     assert(writer._readyPromise_resolve === undefined, 'writer._readyPromise_resolve === undefined');
     assert(writer._readyPromise_reject === undefined, 'writer._readyPromise_reject === undefined');
     writer._readyPromise = new Promise(function (resolve, reject) {
       writer._readyPromise_resolve = resolve;
       writer._readyPromise_reject = reject;
     });
     writer._readyPromiseState = 'pending';
   }
+
   function defaultWriterReadyPromiseResetToRejected(writer, reason) {
     assert(writer._readyPromise_resolve === undefined, 'writer._readyPromise_resolve === undefined');
     assert(writer._readyPromise_reject === undefined, 'writer._readyPromise_reject === undefined');
     writer._readyPromise = Promise.reject(reason);
     writer._readyPromiseState = 'rejected';
   }
+
   function defaultWriterReadyPromiseResolve(writer) {
     assert(writer._readyPromise_resolve !== undefined, 'writer._readyPromise_resolve !== undefined');
     assert(writer._readyPromise_reject !== undefined, 'writer._readyPromise_reject !== undefined');
+
     writer._readyPromise_resolve(undefined);
+
     writer._readyPromise_resolve = undefined;
     writer._readyPromise_reject = undefined;
     writer._readyPromiseState = 'fulfilled';
   }
 }, function (module, exports, __w_pdfjs_require__) {
   "use strict";
 
   var _require = __w_pdfjs_require__(0),
       IsFiniteNonNegativeNumber = _require.IsFiniteNonNegativeNumber;
+
   var _require2 = __w_pdfjs_require__(1),
       assert = _require2.assert;
+
   exports.DequeueValue = function (container) {
     assert('_queue' in container && '_queueTotalSize' in container, 'Spec-level failure: DequeueValue should only be used on containers with [[queue]] and [[queueTotalSize]].');
     assert(container._queue.length > 0, 'Spec-level failure: should never dequeue from an empty queue.');
+
     var pair = container._queue.shift();
+
     container._queueTotalSize -= pair.size;
+
     if (container._queueTotalSize < 0) {
       container._queueTotalSize = 0;
     }
+
     return pair.value;
   };
+
   exports.EnqueueValueWithSize = function (container, value, size) {
     assert('_queue' in container && '_queueTotalSize' in container, 'Spec-level failure: EnqueueValueWithSize should only be used on containers with [[queue]] and ' + '[[queueTotalSize]].');
     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;
   };
+
   exports.PeekQueueValue = function (container) {
     assert('_queue' in container && '_queueTotalSize' in container, 'Spec-level failure: PeekQueueValue should only be used on containers with [[queue]] and [[queueTotalSize]].');
     assert(container._queue.length > 0, 'Spec-level failure: should never peek at an empty queue.');
     var pair = container._queue[0];
     return pair.value;
   };
+
   exports.ResetQueue = function (container) {
     assert('_queue' in container && '_queueTotalSize' in container, 'Spec-level failure: ResetQueue should only be used on containers with [[queue]] and [[queueTotalSize]].');
     container._queue = [];
     container._queueTotalSize = 0;
   };
 }, function (module, exports, __w_pdfjs_require__) {
   "use strict";
 
@@ -2083,165 +2509,199 @@ if (isReadableStreamSupported) {
       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);
       }
     }
+
     return function (Constructor, protoProps, staticProps) {
       if (protoProps) defineProperties(Constructor.prototype, protoProps);
       if (staticProps) defineProperties(Constructor, staticProps);
       return Constructor;
     };
   }();
+
   function _classCallCheck(instance, Constructor) {
     if (!(instance instanceof Constructor)) {
       throw new TypeError("Cannot call a class as a function");
     }
   }
+
   var _require = __w_pdfjs_require__(0),
       ArrayBufferCopy = _require.ArrayBufferCopy,
       CreateIterResultObject = _require.CreateIterResultObject,
       IsFiniteNonNegativeNumber = _require.IsFiniteNonNegativeNumber,
       InvokeOrNoop = _require.InvokeOrNoop,
       PromiseInvokeOrNoop = _require.PromiseInvokeOrNoop,
       TransferArrayBuffer = _require.TransferArrayBuffer,
       ValidateAndNormalizeQueuingStrategy = _require.ValidateAndNormalizeQueuingStrategy,
       ValidateAndNormalizeHighWaterMark = _require.ValidateAndNormalizeHighWaterMark;
+
   var _require2 = __w_pdfjs_require__(0),
       createArrayFromList = _require2.createArrayFromList,
       createDataProperty = _require2.createDataProperty,
       typeIsObject = _require2.typeIsObject;
+
   var _require3 = __w_pdfjs_require__(1),
       assert = _require3.assert,
       rethrowAssertionErrorRejection = _require3.rethrowAssertionErrorRejection;
+
   var _require4 = __w_pdfjs_require__(3),
       DequeueValue = _require4.DequeueValue,
       EnqueueValueWithSize = _require4.EnqueueValueWithSize,
       ResetQueue = _require4.ResetQueue;
+
   var _require5 = __w_pdfjs_require__(2),
       AcquireWritableStreamDefaultWriter = _require5.AcquireWritableStreamDefaultWriter,
       IsWritableStream = _require5.IsWritableStream,
       IsWritableStreamLocked = _require5.IsWritableStreamLocked,
       WritableStreamAbort = _require5.WritableStreamAbort,
       WritableStreamDefaultWriterCloseWithErrorPropagation = _require5.WritableStreamDefaultWriterCloseWithErrorPropagation,
       WritableStreamDefaultWriterRelease = _require5.WritableStreamDefaultWriterRelease,
       WritableStreamDefaultWriterWrite = _require5.WritableStreamDefaultWriterWrite,
       WritableStreamCloseQueuedOrInFlight = _require5.WritableStreamCloseQueuedOrInFlight;
+
   var ReadableStream = function () {
     function ReadableStream() {
       var underlyingSource = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
       var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
           size = _ref.size,
           highWaterMark = _ref.highWaterMark;
+
       _classCallCheck(this, ReadableStream);
+
       this._state = 'readable';
       this._reader = undefined;
       this._storedError = undefined;
       this._disturbed = false;
       this._readableStreamController = undefined;
       var type = underlyingSource.type;
       var typeString = String(type);
+
       if (typeString === 'bytes') {
         if (highWaterMark === undefined) {
           highWaterMark = 0;
         }
+
         this._readableStreamController = new ReadableByteStreamController(this, underlyingSource, highWaterMark);
       } else if (type === undefined) {
         if (highWaterMark === undefined) {
           highWaterMark = 1;
         }
+
         this._readableStreamController = new ReadableStreamDefaultController(this, underlyingSource, size, highWaterMark);
       } else {
         throw new RangeError('Invalid type is specified');
       }
     }
+
     _createClass(ReadableStream, [{
       key: 'cancel',
       value: function cancel(reason) {
         if (IsReadableStream(this) === false) {
           return Promise.reject(streamBrandCheckException('cancel'));
         }
+
         if (IsReadableStreamLocked(this) === true) {
           return Promise.reject(new TypeError('Cannot cancel a stream that already has a reader'));
         }
+
         return ReadableStreamCancel(this, reason);
       }
     }, {
       key: 'getReader',
       value: function getReader() {
         var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
             mode = _ref2.mode;
+
         if (IsReadableStream(this) === false) {
           throw streamBrandCheckException('getReader');
         }
+
         if (mode === undefined) {
           return AcquireReadableStreamDefaultReader(this);
         }
+
         mode = String(mode);
+
         if (mode === 'byob') {
           return AcquireReadableStreamBYOBReader(this);
         }
+
         throw new RangeError('Invalid mode is specified');
       }
     }, {
       key: 'pipeThrough',
       value: function pipeThrough(_ref3, options) {
         var writable = _ref3.writable,
             readable = _ref3.readable;
         var promise = this.pipeTo(writable, options);
         ifIsObjectAndHasAPromiseIsHandledInternalSlotSetPromiseIsHandledToTrue(promise);
         return readable;
       }
     }, {
       key: 'pipeTo',
       value: function pipeTo(dest) {
         var _this = this;
+
         var _ref4 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
             preventClose = _ref4.preventClose,
             preventAbort = _ref4.preventAbort,
             preventCancel = _ref4.preventCancel;
+
         if (IsReadableStream(this) === false) {
           return Promise.reject(streamBrandCheckException('pipeTo'));
         }
+
         if (IsWritableStream(dest) === false) {
           return Promise.reject(new TypeError('ReadableStream.prototype.pipeTo\'s first argument must be a WritableStream'));
         }
+
         preventClose = Boolean(preventClose);
         preventAbort = Boolean(preventAbort);
         preventCancel = Boolean(preventCancel);
+
         if (IsReadableStreamLocked(this) === true) {
           return Promise.reject(new TypeError('ReadableStream.prototype.pipeTo cannot be used on a locked ReadableStream'));
         }
+
         if (IsWritableStreamLocked(dest) === true) {
           return Promise.reject(new TypeError('ReadableStream.prototype.pipeTo cannot be used on a locked WritableStream'));
         }
+
         var reader = AcquireReadableStreamDefaultReader(this);
         var writer = AcquireWritableStreamDefaultWriter(dest);
         var shuttingDown = false;
         var currentWrite = Promise.resolve();
         return new Promise(function (resolve, reject) {
           function pipeLoop() {
             currentWrite = Promise.resolve();
+
             if (shuttingDown === true) {
               return Promise.resolve();
             }
+
             return writer._readyPromise.then(function () {
               return ReadableStreamDefaultReaderRead(reader).then(function (_ref5) {
                 var value = _ref5.value,
                     done = _ref5.done;
+
                 if (done === true) {
                   return;
                 }
+
                 currentWrite = WritableStreamDefaultWriterWrite(writer, value).catch(function () {});
               });
             }).then(pipeLoop);
           }
+
           isOrBecomesErrored(_this, reader._closedPromise, function (storedError) {
             if (preventAbort === false) {
               shutdownWithAction(function () {
                 return WritableStreamAbort(dest, storedError);
               }, true, storedError);
             } else {
               shutdown(true, storedError);
             }
@@ -2259,146 +2719,175 @@ if (isReadableStreamSupported) {
             if (preventClose === false) {
               shutdownWithAction(function () {
                 return WritableStreamDefaultWriterCloseWithErrorPropagation(writer);
               });
             } else {
               shutdown();
             }
           });
+
           if (WritableStreamCloseQueuedOrInFlight(dest) === true || dest._state === 'closed') {
             var destClosed = new TypeError('the destination writable stream closed before all data could be piped to it');
+
             if (preventCancel === false) {
               shutdownWithAction(function () {
                 return ReadableStreamCancel(_this, destClosed);
               }, true, destClosed);
             } else {
               shutdown(true, destClosed);
             }
           }
+
           pipeLoop().catch(function (err) {
             currentWrite = Promise.resolve();
             rethrowAssertionErrorRejection(err);
           });
+
           function waitForWritesToFinish() {
             var oldCurrentWrite = currentWrite;
             return currentWrite.then(function () {
               return oldCurrentWrite !== currentWrite ? waitForWritesToFinish() : undefined;
             });
           }
+
           function isOrBecomesErrored(stream, promise, action) {
             if (stream._state === 'errored') {
               action(stream._storedError);
             } else {
               promise.catch(action).catch(rethrowAssertionErrorRejection);
             }
           }
+
           function isOrBecomesClosed(stream, promise, action) {
             if (stream._state === 'closed') {
               action();
             } else {
               promise.then(action).catch(rethrowAssertionErrorRejection);
             }
           }
+
           function shutdownWithAction(action, originalIsError, originalError) {
             if (shuttingDown === true) {
               return;
             }
+
             shuttingDown = true;
+
             if (dest._state === 'writable' && WritableStreamCloseQueuedOrInFlight(dest) === false) {
               waitForWritesToFinish().then(doTheRest);
             } else {
               doTheRest();
             }
+
             function doTheRest() {
               action().then(function () {
                 return finalize(originalIsError, originalError);
               }, function (newError) {
                 return finalize(true, newError);
               }).catch(rethrowAssertionErrorRejection);
             }
           }
+
           function shutdown(isError, error) {
             if (shuttingDown === true) {
               return;
             }
+
             shuttingDown = true;
+
             if (dest._state === 'writable' && WritableStreamCloseQueuedOrInFlight(dest) === false) {
               waitForWritesToFinish().then(function () {
                 return finalize(isError, error);
               }).catch(rethrowAssertionErrorRejection);
             } else {
               finalize(isError, error);
             }
           }
+
           function finalize(isError, error) {
             WritableStreamDefaultWriterRelease(writer);
             ReadableStreamReaderGenericRelease(reader);
+
             if (isError) {
               reject(error);
             } else {
               resolve(undefined);
             }
           }
         });
       }
     }, {
       key: 'tee',
       value: function tee() {
         if (IsReadableStream(this) === false) {
           throw streamBrandCheckException('tee');
         }
+
         var branches = ReadableStreamTee(this, false);
         return createArrayFromList(branches);
       }
     }, {
       key: 'locked',
       get: function get() {
         if (IsReadableStream(this) === false) {
           throw streamBrandCheckException('locked');
         }
+
         return IsReadableStreamLocked(this);
       }
     }]);
+
     return ReadableStream;
   }();
+
   module.exports = {
     ReadableStream: ReadableStream,
     IsReadableStreamDisturbed: IsReadableStreamDisturbed,
     ReadableStreamDefaultControllerClose: ReadableStreamDefaultControllerClose,
     ReadableStreamDefaultControllerEnqueue: ReadableStreamDefaultControllerEnqueue,
     ReadableStreamDefaultControllerError: ReadableStreamDefaultControllerError,
     ReadableStreamDefaultControllerGetDesiredSize: ReadableStreamDefaultControllerGetDesiredSize
   };
+
   function AcquireReadableStreamBYOBReader(stream) {
     return new ReadableStreamBYOBReader(stream);
   }
+
   function AcquireReadableStreamDefaultReader(stream) {
     return new ReadableStreamDefaultReader(stream);
   }
+
   function IsReadableStream(x) {
     if (!typeIsObject(x)) {
       return false;
     }
+
     if (!Object.prototype.hasOwnProperty.call(x, '_readableStreamController')) {
       return false;
     }
+
     return true;
   }
+
   function IsReadableStreamDisturbed(stream) {
     assert(IsReadableStream(stream) === true, 'IsReadableStreamDisturbed should only be used on known readable streams');
     return stream._disturbed;
   }
+
   function IsReadableStreamLocked(stream) {
     assert(IsReadableStream(stream) === true, 'IsReadableStreamLocked should only be used on known readable streams');
+
     if (stream._reader === undefined) {
       return false;
     }
+
     return true;
   }
+
   function ReadableStreamTee(stream, cloneForBranch2) {
     assert(IsReadableStream(stream) === true);
     assert(typeof cloneForBranch2 === 'boolean');
     var reader = AcquireReadableStreamDefaultReader(stream);
     var teeState = {
       closedOrErrored: false,
       canceled1: false,
       canceled2: false,
@@ -2423,416 +2912,536 @@ if (isReadableStreamSupported) {
     createDataProperty(underlyingSource1, 'cancel', cancel1);
     var branch1Stream = new ReadableStream(underlyingSource1);
     var underlyingSource2 = Object.create(Object.prototype);
     createDataProperty(underlyingSource2, 'pull', pull);
     createDataProperty(underlyingSource2, 'cancel', cancel2);
     var branch2Stream = new ReadableStream(underlyingSource2);
     pull._branch1 = branch1Stream._readableStreamController;
     pull._branch2 = branch2Stream._readableStreamController;
+
     reader._closedPromise.catch(function (r) {
       if (teeState.closedOrErrored === true) {
         return;
       }
+
       ReadableStreamDefaultControllerError(pull._branch1, r);
       ReadableStreamDefaultControllerError(pull._branch2, r);
       teeState.closedOrErrored = true;
     });
+
     return [branch1Stream, branch2Stream];
   }
+
   function create_ReadableStreamTeePullFunction() {
     function f() {
       var reader = f._reader,
           branch1 = f._branch1,
           branch2 = f._branch2,
           teeState = f._teeState;
       return ReadableStreamDefaultReaderRead(reader).then(function (result) {
         assert(typeIsObject(result));
         var value = result.value;
         var done = result.done;
         assert(typeof done === 'boolean');
+
         if (done === true && teeState.closedOrErrored === false) {
           if (teeState.canceled1 === false) {
             ReadableStreamDefaultControllerClose(branch1);
           }
+
           if (teeState.canceled2 === false) {
             ReadableStreamDefaultControllerClose(branch2);
           }
+
           teeState.closedOrErrored = true;
         }
+
         if (teeState.closedOrErrored === true) {
           return;
         }
+
         var value1 = value;
         var value2 = value;
+
         if (teeState.canceled1 === false) {
           ReadableStreamDefaultControllerEnqueue(branch1, value1);
         }
+
         if (teeState.canceled2 === false) {
           ReadableStreamDefaultControllerEnqueue(branch2, value2);
         }
       });
     }
+
     return f;
   }
+
   function create_ReadableStreamTeeBranch1CancelFunction() {
     function f(reason) {
       var stream = f._stream,
           teeState = f._teeState;
       teeState.canceled1 = true;
       teeState.reason1 = reason;
+
       if (teeState.canceled2 === true) {
         var compositeReason = createArrayFromList([teeState.reason1, teeState.reason2]);
         var cancelResult = ReadableStreamCancel(stream, compositeReason);
+
         teeState._resolve(cancelResult);
       }
+
       return teeState.promise;
     }
+
     return f;
   }
+
   function create_ReadableStreamTeeBranch2CancelFunction() {
     function f(reason) {
       var stream = f._stream,
           teeState = f._teeState;
       teeState.canceled2 = true;
       teeState.reason2 = reason;
+
       if (teeState.canceled1 === true) {
         var compositeReason = createArrayFromList([teeState.reason1, teeState.reason2]);
         var cancelResult = ReadableStreamCancel(stream, compositeReason);
+
         teeState._resolve(cancelResult);
       }
+
       return teeState.promise;
     }
+
     return f;
   }
+
   function ReadableStreamAddReadIntoRequest(stream) {
     assert(IsReadableStreamBYOBReader(stream._reader) === true);
     assert(stream._state === 'readable' || stream._state === 'closed');
     var promise = new Promise(function (resolve, reject) {
       var readIntoRequest = {
         _resolve: resolve,
         _reject: reject
       };
+
       stream._reader._readIntoRequests.push(readIntoRequest);
     });
     return promise;
   }
+
   function ReadableStreamAddReadRequest(stream) {
     assert(IsReadableStreamDefaultReader(stream._reader) === true);
     assert(stream._state === 'readable');
     var promise = new Promise(function (resolve, reject) {
       var readRequest = {
         _resolve: resolve,
         _reject: reject
       };
+
       stream._reader._readRequests.push(readRequest);
     });
     return promise;
   }
+
   function ReadableStreamCancel(stream, reason) {
     stream._disturbed = true;
+
     if (stream._state === 'closed') {
       return Promise.resolve(undefined);
     }
+
     if (stream._state === 'errored') {
       return Promise.reject(stream._storedError);
     }
+
     ReadableStreamClose(stream);
+
     var sourceCancelPromise = stream._readableStreamController.__cancelSteps(reason);
+
     return sourceCancelPromise.then(function () {
       return undefined;
     });
   }
+
   function ReadableStreamClose(stream) {
     assert(stream._state === 'readable');
     stream._state = 'closed';
     var reader = stream._reader;
+
     if (reader === undefined) {
       return undefined;
     }
+
     if (IsReadableStreamDefaultReader(reader) === true) {
       for (var i = 0; i < reader._readRequests.length; i++) {
         var _resolve = reader._readRequests[i]._resolve;
+
         _resolve(CreateIterResultObject(undefined, true));
       }
+
       reader._readRequests = [];
     }
+
     defaultReaderClosedPromiseResolve(reader);
     return undefined;
   }
+
   function ReadableStreamError(stream, e) {
     assert(IsReadableStream(stream) === true, 'stream must be ReadableStream');
     assert(stream._state === 'readable', 'state must be readable');
     stream._state = 'errored';
     stream._storedError = e;
     var reader = stream._reader;
+
     if (reader === undefined) {
       return undefined;
     }
+
     if (IsReadableStreamDefaultReader(reader) === true) {
       for (var i = 0; i < reader._readRequests.length; i++) {
         var readRequest = reader._readRequests[i];
+
         readRequest._reject(e);
       }
+
       reader._readRequests = [];
     } else {
       assert(IsReadableStreamBYOBReader(reader), 'reader must be ReadableStreamBYOBReader');
+
       for (var _i = 0; _i < reader._readIntoRequests.length; _i++) {
         var readIntoRequest = reader._readIntoRequests[_i];
+
         readIntoRequest._reject(e);
       }
+
       reader._readIntoRequests = [];
     }
+
     defaultReaderClosedPromiseReject(reader, e);
+
     reader._closedPromise.catch(function () {});
   }
+
   function ReadableStreamFulfillReadIntoRequest(stream, chunk, done) {
     var reader = stream._reader;
     assert(reader._readIntoRequests.length > 0);
+
     var readIntoRequest = reader._readIntoRequests.shift();
+
     readIntoRequest._resolve(CreateIterResultObject(chunk, done));
   }
+
   function ReadableStreamFulfillReadRequest(stream, chunk, done) {
     var reader = stream._reader;
     assert(reader._readRequests.length > 0);
+
     var readRequest = reader._readRequests.shift();
+
     readRequest._resolve(CreateIterResultObject(chunk, done));
   }
+
   function ReadableStreamGetNumReadIntoRequests(stream) {
     return stream._reader._readIntoRequests.length;
   }
+
   function ReadableStreamGetNumReadRequests(stream) {
     return stream._reader._readRequests.length;
   }
+
   function ReadableStreamHasBYOBReader(stream) {
     var reader = stream._reader;
+
     if (reader === undefined) {
       return false;
     }
+
     if (IsReadableStreamBYOBReader(reader) === false) {
       return false;
     }
+
     return true;
   }
+
   function ReadableStreamHasDefaultReader(stream) {
     var reader = stream._reader;
+
     if (reader === undefined) {
       return false;
     }
+
     if (IsReadableStreamDefaultReader(reader) === false) {
       return false;
     }
+
     return true;
   }
+
   var ReadableStreamDefaultReader = function () {
     function ReadableStreamDefaultReader(stream) {
       _classCallCheck(this, ReadableStreamDefaultReader);
+
       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 = [];
     }
+
     _createClass(ReadableStreamDefaultReader, [{
       key: 'cancel',
       value: function cancel(reason) {
         if (IsReadableStreamDefaultReader(this) === false) {
           return Promise.reject(defaultReaderBrandCheckException('cancel'));
         }
+
         if (this._ownerReadableStream === undefined) {
           return Promise.reject(readerLockException('cancel'));
         }
+
         return ReadableStreamReaderGenericCancel(this, reason);
       }
     }, {
       key: 'read',
       value: function read() {
         if (IsReadableStreamDefaultReader(this) === false) {
           return Promise.reject(defaultReaderBrandCheckException('read'));
         }
+
         if (this._ownerReadableStream === undefined) {
           return Promise.reject(readerLockException('read from'));
         }
+
         return ReadableStreamDefaultReaderRead(this);
       }
     }, {
       key: 'releaseLock',
       value: function releaseLock() {
         if (IsReadableStreamDefaultReader(this) === false) {
           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);
       }
     }, {
       key: 'closed',
       get: function get() {
         if (IsReadableStreamDefaultReader(this) === false) {
           return Promise.reject(defaultReaderBrandCheckException('closed'));
         }
+
         return this._closedPromise;
       }
     }]);
+
     return ReadableStreamDefaultReader;
   }();
+
   var ReadableStreamBYOBReader = function () {
     function ReadableStreamBYOBReader(stream) {
       _classCallCheck(this, ReadableStreamBYOBReader);
+
       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 = [];
     }
+
     _createClass(ReadableStreamBYOBReader, [{
       key: 'cancel',
       value: function cancel(reason) {
         if (!IsReadableStreamBYOBReader(this)) {
           return Promise.reject(byobReaderBrandCheckException('cancel'));
         }
+
         if (this._ownerReadableStream === undefined) {
           return Promise.reject(readerLockException('cancel'));
         }
+
         return ReadableStreamReaderGenericCancel(this, reason);
       }
     }, {
       key: 'read',
       value: function read(view) {
         if (!IsReadableStreamBYOBReader(this)) {
           return Promise.reject(byobReaderBrandCheckException('read'));
         }
+
         if (this._ownerReadableStream === undefined) {
           return Promise.reject(readerLockException('read from'));
         }
+
         if (!ArrayBuffer.isView(view)) {
           return Promise.reject(new TypeError('view must be an array buffer view'));
         }
+
         if (view.byteLength === 0) {
           return Promise.reject(new TypeError('view must have non-zero byteLength'));
         }
+
         return ReadableStreamBYOBReaderRead(this, view);
       }
     }, {
       key: 'releaseLock',
       value: function releaseLock() {
         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);
       }
     }, {
       key: 'closed',
       get: function get() {
         if (!IsReadableStreamBYOBReader(this)) {
           return Promise.reject(byobReaderBrandCheckException('closed'));
         }
+
         return this._closedPromise;
       }
     }]);
+
     return ReadableStreamBYOBReader;
   }();
+
   function IsReadableStreamBYOBReader(x) {
     if (!typeIsObject(x)) {
       return false;
     }
+
     if (!Object.prototype.hasOwnProperty.call(x, '_readIntoRequests')) {
       return false;
     }
+
     return true;
   }
+
   function IsReadableStreamDefaultReader(x) {
     if (!typeIsObject(x)) {
       return false;
     }
+
     if (!Object.prototype.hasOwnProperty.call(x, '_readRequests')) {
       return false;
     }
+
     return true;
   }
+
   function ReadableStreamReaderGenericInitialize(reader, stream) {
     reader._ownerReadableStream = stream;
     stream._reader = reader;
+
     if (stream._state === 'readable') {
       defaultReaderClosedPromiseInitialize(reader);
     } else if (stream._state === 'closed') {
       defaultReaderClosedPromiseInitializeAsResolved(reader);
     } else {
       assert(stream._state === 'errored', 'state must be errored');
       defaultReaderClosedPromiseInitializeAsRejected(reader, stream._storedError);
+
       reader._closedPromise.catch(function () {});
     }
   }
+
   function ReadableStreamReaderGenericCancel(reader, reason) {
     var stream = reader._ownerReadableStream;
     assert(stream !== undefined);
     return ReadableStreamCancel(stream, reason);
   }
+
   function ReadableStreamReaderGenericRelease(reader) {
     assert(reader._ownerReadableStream !== undefined);
     assert(reader._ownerReadableStream._reader === 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._closedPromise.catch(function () {});
+
     reader._ownerReadableStream._reader = undefined;
     reader._ownerReadableStream = undefined;
   }
+
   function ReadableStreamBYOBReaderRead(reader, view) {
     var stream = reader._ownerReadableStream;
     assert(stream !== undefined);
     stream._disturbed = true;
+
     if (stream._state === 'errored') {
       return Promise.reject(stream._storedError);
     }
+
     return ReadableByteStreamControllerPullInto(stream._readableStreamController, view);
   }
+
   function ReadableStreamDefaultReaderRead(reader) {
     var stream = reader._ownerReadableStream;
     assert(stream !== undefined);
     stream._disturbed = true;
+
     if (stream._state === 'closed') {
       return Promise.resolve(CreateIterResultObject(undefined, true));
     }
+
     if (stream._state === 'errored') {
       return Promise.reject(stream._storedError);
     }
+
     assert(stream._state === 'readable');
     return stream._readableStreamController.__pullSteps();
   }
+
   var ReadableStreamDefaultController = function () {
     function ReadableStreamDefaultController(stream, underlyingSource, size, highWaterMark) {
       _classCallCheck(this, ReadableStreamDefaultController);
+
       if (IsReadableStream(stream) === false) {
         throw new TypeError('ReadableStreamDefaultController can only be constructed with a ReadableStream instance');
       }
+
       if (stream._readableStreamController !== undefined) {
         throw new TypeError('ReadableStreamDefaultController instances can only be created by the ReadableStream constructor');
       }
+
       this._controlledReadableStream = stream;
       this._underlyingSource = underlyingSource;
       this._queue = undefined;
       this._queueTotalSize = undefined;
       ResetQueue(this);
       this._started = false;
       this._closeRequested = false;
       this._pullAgain = false;
@@ -2846,809 +3455,1011 @@ if (isReadableStreamSupported) {
         controller._started = true;
         assert(controller._pulling === false);
         assert(controller._pullAgain === false);
         ReadableStreamDefaultControllerCallPullIfNeeded(controller);
       }, function (r) {
         ReadableStreamDefaultControllerErrorIfNeeded(controller, r);
       }).catch(rethrowAssertionErrorRejection);
     }
+
     _createClass(ReadableStreamDefaultController, [{
       key: 'close',
       value: function close() {
         if (IsReadableStreamDefaultController(this) === false) {
           throw defaultControllerBrandCheckException('close');
         }
+
         if (this._closeRequested === true) {
           throw new TypeError('The stream has already been closed; do not close it again!');
         }
+
         var state = this._controlledReadableStream._state;
+
         if (state !== 'readable') {
           throw new TypeError('The stream (in ' + state + ' state) is not in the readable state and cannot be closed');
         }
+
         ReadableStreamDefaultControllerClose(this);
       }
     }, {
       key: 'enqueue',
       value: function enqueue(chunk) {
         if (IsReadableStreamDefaultController(this) === false) {
           throw defaultControllerBrandCheckException('enqueue');
         }
+
         if (this._closeRequested === true) {
           throw new TypeError('stream is closed or draining');
         }
+
         var state = this._controlledReadableStream._state;
+
         if (state !== 'readable') {
           throw new TypeError('The stream (in ' + state + ' state) is not in the readable state and cannot be enqueued to');
         }
+
         return ReadableStreamDefaultControllerEnqueue(this, chunk);
       }
     }, {
       key: 'error',
       value: function error(e) {
         if (IsReadableStreamDefaultController(this) === false) {
           throw defaultControllerBrandCheckException('error');
         }
+
         var stream = this._controlledReadableStream;
+
         if (stream._state !== 'readable') {
           throw new TypeError('The stream is ' + stream._state + ' and so cannot be errored');
         }
+
         ReadableStreamDefaultControllerError(this, e);
       }
     }, {
       key: '__cancelSteps',
       value: function __cancelSteps(reason) {
         ResetQueue(this);
         return PromiseInvokeOrNoop(this._underlyingSource, 'cancel', [reason]);
       }
     }, {
       key: '__pullSteps',
       value: function __pullSteps() {
         var stream = this._controlledReadableStream;
+
         if (this._queue.length > 0) {
           var chunk = DequeueValue(this);
+
           if (this._closeRequested === true && this._queue.length === 0) {
             ReadableStreamClose(stream);
           } else {
             ReadableStreamDefaultControllerCallPullIfNeeded(this);
           }
+
           return Promise.resolve(CreateIterResultObject(chunk, false));
         }
+
         var pendingPromise = ReadableStreamAddReadRequest(stream);
         ReadableStreamDefaultControllerCallPullIfNeeded(this);
         return pendingPromise;
       }
     }, {
       key: 'desiredSize',
       get: function get() {
         if (IsReadableStreamDefaultController(this) === false) {
           throw defaultControllerBrandCheckException('desiredSize');
         }
+
         return ReadableStreamDefaultControllerGetDesiredSize(this);
       }
     }]);
+
     return ReadableStreamDefaultController;
   }();
+
   function IsReadableStreamDefaultController(x) {
     if (!typeIsObject(x)) {
       return false;
     }
+
     if (!Object.prototype.hasOwnProperty.call(x, '_underlyingSource')) {
       return false;
     }
+
     return true;
   }
+
   function ReadableStreamDefaultControllerCallPullIfNeeded(controller) {
     var shouldPull = ReadableStreamDefaultControllerShouldCallPull(controller);
+
     if (shouldPull === false) {
       return undefined;
     }
+
     if (controller._pulling === true) {
       controller._pullAgain = true;
       return undefined;
     }
+
     assert(controller._pullAgain === false);
     controller._pulling = true;
     var pullPromise = PromiseInvokeOrNoop(controller._underlyingSource, 'pull', [controller]);
     pullPromise.then(function () {
       controller._pulling = false;
+
       if (controller._pullAgain === true) {
         controller._pullAgain = false;
         return ReadableStreamDefaultControllerCallPullIfNeeded(controller);
       }
+
       return undefined;
     }, function (e) {
       ReadableStreamDefaultControllerErrorIfNeeded(controller, e);
     }).catch(rethrowAssertionErrorRejection);
     return undefined;
   }
+
   function ReadableStreamDefaultControllerShouldCallPull(controller) {
     var stream = controller._controlledReadableStream;
+
     if (stream._state === 'closed' || stream._state === 'errored') {
       return false;
     }
+
     if (controller._closeRequested === true) {
       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 ReadableStreamDefaultControllerClose(controller) {
     var stream = controller._controlledReadableStream;
     assert(controller._closeRequested === false);
     assert(stream._state === 'readable');
     controller._closeRequested = true;
+
     if (controller._queue.length === 0) {
       ReadableStreamClose(stream);
     }
   }
+
   function ReadableStreamDefaultControllerEnqueue(controller, chunk) {
     var stream = controller._controlledReadableStream;
     assert(controller._closeRequested === false);
     assert(stream._state === 'readable');
+
     if (IsReadableStreamLocked(stream) === true && ReadableStreamGetNumReadRequests(stream) > 0) {
       ReadableStreamFulfillReadRequest(stream, chunk, false);
     } else {
       var chunkSize = 1;
+
       if (controller._strategySize !== undefined) {
         var strategySize = controller._strategySize;
+
         try {
           chunkSize = strategySize(chunk);
         } catch (chunkSizeE) {
           ReadableStreamDefaultControllerErrorIfNeeded(controller, chunkSizeE);
           throw chunkSizeE;
         }
       }
+
       try {
         EnqueueValueWithSize(controller, chunk, chunkSize);
       } catch (enqueueE) {
         ReadableStreamDefaultControllerErrorIfNeeded(controller, enqueueE);
         throw enqueueE;
       }
     }
+
     ReadableStreamDefaultControllerCallPullIfNeeded(controller);
     return undefined;
   }
+
   function ReadableStreamDefaultControllerError(controller, e) {
     var stream = controller._controlledReadableStream;
     assert(stream._state === 'readable');
     ResetQueue(controller);
     ReadableStreamError(stream, e);
   }
+
   function ReadableStreamDefaultControllerErrorIfNeeded(controller, e) {
     if (controller._controlledReadableStream._state === 'readable') {
       ReadableStreamDefaultControllerError(controller, 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;
   }
+
   var ReadableStreamBYOBRequest = function () {
     function ReadableStreamBYOBRequest(controller, view) {
       _classCallCheck(this, ReadableStreamBYOBRequest);
+
       this._associatedReadableByteStreamController = controller;
       this._view = view;
     }
+
     _createClass(ReadableStreamBYOBRequest, [{
       key: 'respond',
       value: function respond(bytesWritten) {
         if (IsReadableStreamBYOBRequest(this) === false) {
           throw byobRequestBrandCheckException('respond');
         }
+
         if (this._associatedReadableByteStreamController === undefined) {
           throw new TypeError('This BYOB request has been invalidated');
         }
+
         ReadableByteStreamControllerRespond(this._associatedReadableByteStreamController, bytesWritten);
       }
     }, {
       key: 'respondWithNewView',
       value: function respondWithNewView(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');
         }
+
         ReadableByteStreamControllerRespondWithNewView(this._associatedReadableByteStreamController, view);
       }
     }, {
       key: 'view',
       get: function get() {
         return this._view;
       }
     }]);
+
     return ReadableStreamBYOBRequest;
   }();
+
   var ReadableByteStreamController = function () {
     function ReadableByteStreamController(stream, underlyingByteSource, highWaterMark) {
       _classCallCheck(this, ReadableByteStreamController);
+
       if (IsReadableStream(stream) === false) {
         throw new TypeError('ReadableByteStreamController can only be constructed with a ReadableStream instance given ' + 'a byte source');
       }
+
       if (stream._readableStreamController !== undefined) {
         throw new TypeError('ReadableByteStreamController instances can only be created by the ReadableStream constructor given a byte ' + 'source');
       }
+
       this._controlledReadableStream = stream;
       this._underlyingByteSource = underlyingByteSource;
       this._pullAgain = false;
       this._pulling = false;
       ReadableByteStreamControllerClearPendingPullIntos(this);
       this._queue = this._queueTotalSize = undefined;
       ResetQueue(this);
       this._closeRequested = false;
       this._started = false;
       this._strategyHWM = ValidateAndNormalizeHighWaterMark(highWaterMark);
       var autoAllocateChunkSize = underlyingByteSource.autoAllocateChunkSize;
+
       if (autoAllocateChunkSize !== undefined) {
         if (Number.isInteger(autoAllocateChunkSize) === false || autoAllocateChunkSize <= 0) {
           throw new RangeError('autoAllocateChunkSize must be a positive integer');
         }
       }
+
       this._autoAllocateChunkSize = autoAllocateChunkSize;
       this._pendingPullIntos = [];
       var controller = this;
       var startResult = InvokeOrNoop(underlyingByteSource, 'start', [this]);
       Promise.resolve(startResult).then(function () {
         controller._started = true;
         assert(controller._pulling === false);
         assert(controller._pullAgain === false);
         ReadableByteStreamControllerCallPullIfNeeded(controller);
       }, function (r) {
         if (stream._state === 'readable') {
           ReadableByteStreamControllerError(controller, r);
         }
       }).catch(rethrowAssertionErrorRejection);
     }
+
     _createClass(ReadableByteStreamController, [{
       key: 'close',
       value: function close() {
         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._controlledReadableStream._state;
+
         if (state !== 'readable') {
           throw new TypeError('The stream (in ' + state + ' state) is not in the readable state and cannot be closed');
         }
+
         ReadableByteStreamControllerClose(this);
       }
     }, {
       key: 'enqueue',
       value: function enqueue(chunk) {
         if (IsReadableByteStreamController(this) === false) {
           throw byteStreamControllerBrandCheckException('enqueue');
         }
+
         if (this._closeRequested === true) {
           throw new TypeError('stream is closed or draining');
         }
+
         var state = this._controlledReadableStream._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');
         }
+
         ReadableByteStreamControllerEnqueue(this, chunk);
       }
     }, {
       key: 'error',
       value: function error(e) {
         if (IsReadableByteStreamController(this) === false) {
           throw byteStreamControllerBrandCheckException('error');
         }
+
         var stream = this._controlledReadableStream;
+
         if (stream._state !== 'readable') {
           throw new TypeError('The stream is ' + stream._state + ' and so cannot be errored');
         }
+
         ReadableByteStreamControllerError(this, e);
       }
     }, {
       key: '__cancelSteps',
       value: function __cancelSteps(reason) {
         if (this._pendingPullIntos.length > 0) {
           var firstDescriptor = this._pendingPullIntos[0];
           firstDescriptor.bytesFilled = 0;
         }
+
         ResetQueue(this);
         return PromiseInvokeOrNoop(this._underlyingByteSource, 'cancel', [reason]);
       }
     }, {
       key: '__pullSteps',
       value: function __pullSteps() {
         var stream = this._controlledReadableStream;
         assert(ReadableStreamHasDefaultReader(stream) === true);
+
         if (this._queueTotalSize > 0) {
           assert(ReadableStreamGetNumReadRequests(stream) === 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 Promise.reject(viewE);
           }
+
           return Promise.resolve(CreateIterResultObject(view, false));
         }
+
         var autoAllocateChunkSize = this._autoAllocateChunkSize;
+
         if (autoAllocateChunkSize !== undefined) {
           var buffer = void 0;
+
           try {
             buffer = new ArrayBuffer(autoAllocateChunkSize);
           } catch (bufferE) {
             return Promise.reject(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;
       }
     }, {
       key: 'byobRequest',
       get: function get() {
         if (IsReadableByteStreamController(this) === false) {
           throw byteStreamControllerBrandCheckException('byobRequest');
         }
+
         if (this._byobRequest === undefined && this._pendingPullIntos.length > 0) {
           var firstDescriptor = this._pendingPullIntos[0];
           var view = new Uint8Array(firstDescriptor.buffer, firstDescriptor.byteOffset + firstDescriptor.bytesFilled, firstDescriptor.byteLength - firstDescriptor.bytesFilled);
           this._byobRequest = new ReadableStreamBYOBRequest(this, view);
         }
+
         return this._byobRequest;
       }
     }, {
       key: 'desiredSize',
       get: function get() {
         if (IsReadableByteStreamController(this) === false) {
           throw byteStreamControllerBrandCheckException('desiredSize');
         }
+
         return ReadableByteStreamControllerGetDesiredSize(this);
       }
     }]);
+
     return ReadableByteStreamController;
   }();
+
   function IsReadableByteStreamController(x) {
     if (!typeIsObject(x)) {
       return false;
     }
+
     if (!Object.prototype.hasOwnProperty.call(x, '_underlyingByteSource')) {
       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 undefined;
     }
+
     if (controller._pulling === true) {
       controller._pullAgain = true;
       return undefined;
     }
+
     assert(controller._pullAgain === false);
     controller._pulling = true;
     var pullPromise = PromiseInvokeOrNoop(controller._underlyingByteSource, 'pull', [controller]);
     pullPromise.then(function () {
       controller._pulling = false;
+
       if (controller._pullAgain === true) {
         controller._pullAgain = false;
         ReadableByteStreamControllerCallPullIfNeeded(controller);
       }
     }, function (e) {
       if (controller._controlledReadableStream._state === 'readable') {
         ReadableByteStreamControllerError(controller, e);
       }
     }).catch(rethrowAssertionErrorRejection);
     return undefined;
   }
+
   function ReadableByteStreamControllerClearPendingPullIntos(controller) {
     ReadableByteStreamControllerInvalidateBYOBRequest(controller);
     controller._pendingPullIntos = [];
   }
+
   function ReadableByteStreamControllerCommitPullIntoDescriptor(stream, pullIntoDescriptor) {
     assert(stream._state !== 'errored', 'state must not be errored');
     var done = false;
+
     if (stream._state === 'closed') {
       assert(pullIntoDescriptor.bytesFilled === 0);
       done = true;
     }
+
     var filledView = ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor);
+
     if (pullIntoDescriptor.readerType === 'default') {
       ReadableStreamFulfillReadRequest(stream, filledView, done);
     } else {
       assert(pullIntoDescriptor.readerType === 'byob');
       ReadableStreamFulfillReadIntoRequest(stream, filledView, done);
     }
   }
+
   function ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor) {
     var bytesFilled = pullIntoDescriptor.bytesFilled;
     var elementSize = pullIntoDescriptor.elementSize;
     assert(bytesFilled <= pullIntoDescriptor.byteLength);
     assert(bytesFilled % elementSize === 0);
     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[0];
       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;
     }
+
     if (ready === false) {
       assert(controller._queueTotalSize === 0, 'queue must be empty');
       assert(pullIntoDescriptor.bytesFilled > 0);
       assert(pullIntoDescriptor.bytesFilled < pullIntoDescriptor.elementSize);
     }
+
     return ready;
   }
+
   function ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, size, pullIntoDescriptor) {
     assert(controller._pendingPullIntos.length === 0 || controller._pendingPullIntos[0] === pullIntoDescriptor);
     ReadableByteStreamControllerInvalidateBYOBRequest(controller);
     pullIntoDescriptor.bytesFilled += size;
   }
+
   function ReadableByteStreamControllerHandleQueueDrain(controller) {
     assert(controller._controlledReadableStream._state === 'readable');
+
     if (controller._queueTotalSize === 0 && controller._closeRequested === true) {
       ReadableStreamClose(controller._controlledReadableStream);
     } 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) {
     assert(controller._closeRequested === false);
+
     while (controller._pendingPullIntos.length > 0) {
       if (controller._queueTotalSize === 0) {
         return;
       }
+
       var pullIntoDescriptor = controller._pendingPullIntos[0];
+
       if (ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) === true) {
         ReadableByteStreamControllerShiftPendingPullInto(controller);
         ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadableStream, pullIntoDescriptor);
       }
     }
   }
+
   function ReadableByteStreamControllerPullInto(controller, view) {
     var stream = controller._controlledReadableStream;
     var elementSize = 1;
+
     if (view.constructor !== DataView) {
       elementSize = view.constructor.BYTES_PER_ELEMENT;
     }
+
     var ctor = view.constructor;
     var pullIntoDescriptor = {
       buffer: view.buffer,
       byteOffset: view.byteOffset,
       byteLength: view.byteLength,
       bytesFilled: 0,
       elementSize: elementSize,
       ctor: ctor,
       readerType: 'byob'
     };
+
     if (controller._pendingPullIntos.length > 0) {
       pullIntoDescriptor.buffer = TransferArrayBuffer(pullIntoDescriptor.buffer);
+
       controller._pendingPullIntos.push(pullIntoDescriptor);
+
       return ReadableStreamAddReadIntoRequest(stream);
     }
+
     if (stream._state === 'closed') {
       var emptyView = new view.constructor(pullIntoDescriptor.buffer, pullIntoDescriptor.byteOffset, 0);
       return Promise.resolve(CreateIterResultObject(emptyView, true));
     }
+
     if (controller._queueTotalSize > 0) {
       if (ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) === true) {
         var filledView = ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor);
         ReadableByteStreamControllerHandleQueueDrain(controller);
         return Promise.resolve(CreateIterResultObject(filledView, false));
       }
+
       if (controller._closeRequested === true) {
         var e = new TypeError('Insufficient bytes to fill elements in the given buffer');
         ReadableByteStreamControllerError(controller, e);
         return Promise.reject(e);
       }
     }
+
     pullIntoDescriptor.buffer = TransferArrayBuffer(pullIntoDescriptor.buffer);
+
     controller._pendingPullIntos.push(pullIntoDescriptor);
+
     var promise = ReadableStreamAddReadIntoRequest(stream);
     ReadableByteStreamControllerCallPullIfNeeded(controller);
     return promise;
   }
+
   function ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor) {
     firstDescriptor.buffer = TransferArrayBuffer(firstDescriptor.buffer);
     assert(firstDescriptor.bytesFilled === 0, 'bytesFilled must be 0');
     var stream = controller._controlledReadableStream;
+
     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._controlledReadableStream, pullIntoDescriptor);
     ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller);
   }
+
   function ReadableByteStreamControllerRespondInternal(controller, bytesWritten) {
     var firstDescriptor = controller._pendingPullIntos[0];
     var stream = controller._controlledReadableStream;
+
     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 {
       assert(stream._state === 'readable');
       ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, firstDescriptor);
     }
   }
+
   function ReadableByteStreamControllerShiftPendingPullInto(controller) {
     var descriptor = controller._pendingPullIntos.shift();
+
     ReadableByteStreamControllerInvalidateBYOBRequest(controller);
     return descriptor;
   }
+
   function ReadableByteStreamControllerShouldCallPull(controller) {
     var stream = controller._controlledReadableStream;
+
     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;
     }
+
     if (ReadableByteStreamControllerGetDesiredSize(controller) > 0) {
       return true;
     }
+
     return false;
   }
+
   function ReadableByteStreamControllerClose(controller) {
     var stream = controller._controlledReadableStream;
     assert(controller._closeRequested === false);
     assert(stream._state === 'readable');
+
     if (controller._queueTotalSize > 0) {
       controller._closeRequested = true;
       return;
     }
+
     if (controller._pendingPullIntos.length > 0) {
       var firstPendingPullInto = controller._pendingPullIntos[0];
+
       if (firstPendingPullInto.bytesFilled > 0) {
         var e = new TypeError('Insufficient bytes to fill elements in the given buffer');
         ReadableByteStreamControllerError(controller, e);
         throw e;
       }
     }
+
     ReadableStreamClose(stream);
   }
+
   function ReadableByteStreamControllerEnqueue(controller, chunk) {
     var stream = controller._controlledReadableStream;
     assert(controller._closeRequested === false);
     assert(stream._state === 'readable');
     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 {
         assert(controller._queue.length === 0);
         var transferredView = new Uint8Array(transferredBuffer, byteOffset, byteLength);
         ReadableStreamFulfillReadRequest(stream, transferredView, false);
       }
     } else if (ReadableStreamHasBYOBReader(stream) === true) {
       ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);
       ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller);
     } else {
       assert(IsReadableStreamLocked(stream) === false, 'stream must not be locked');
       ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);
     }
   }
+
   function ReadableByteStreamControllerError(controller, e) {
     var stream = controller._controlledReadableStream;
     assert(stream._state === 'readable');
     ReadableByteStreamControllerClearPendingPullIntos(controller);
     ResetQueue(controller);
     ReadableStreamError(stream, e);
   }
+
   function ReadableByteStreamControllerGetDesiredSize(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 ReadableByteStreamControllerRespond(controller, bytesWritten) {
     bytesWritten = Number(bytesWritten);
+
     if (IsFiniteNonNegativeNumber(bytesWritten) === false) {
       throw new RangeError('bytesWritten must be a finite');
     }
+
     assert(controller._pendingPullIntos.length > 0);
     ReadableByteStreamControllerRespondInternal(controller, bytesWritten);
   }
+
   function ReadableByteStreamControllerRespondWithNewView(controller, view) {
     assert(controller._pendingPullIntos.length > 0);
     var firstDescriptor = controller._pendingPullIntos[0];
+
     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 streamBrandCheckException(name) {
     return new TypeError('ReadableStream.prototype.' + name + ' can only be used on a ReadableStream');
   }
+
   function readerLockException(name) {
     return new TypeError('Cannot ' + name + ' a stream using a released reader');
   }
+
   function defaultReaderBrandCheckException(name) {
     return new TypeError('ReadableStreamDefaultReader.prototype.' + name + ' can only be used on a ReadableStreamDefaultReader');
   }
+
   function defaultReaderClosedPromiseInitialize(reader) {
     reader._closedPromise = new Promise(function (resolve, reject) {
       reader._closedPromise_resolve = resolve;
       reader._closedPromise_reject = reject;
     });
   }
+
   function defaultReaderClosedPromiseInitializeAsRejected(reader, reason) {
     reader._closedPromise = Promise.reject(reason);
     reader._closedPromise_resolve = undefined;
     reader._closedPromise_reject = undefined;
   }
+
   function defaultReaderClosedPromiseInitializeAsResolved(reader) {
     reader._closedPromise = Promise.resolve(undefined);
     reader._closedPromise_resolve = undefined;
     reader._closedPromise_reject = undefined;
   }
+
   function defaultReaderClosedPromiseReject(reader, reason) {
     assert(reader._closedPromise_resolve !== undefined);
     assert(reader._closedPromise_reject !== undefined);
+
     reader._closedPromise_reject(reason);
+
     reader._closedPromise_resolve = undefined;
     reader._closedPromise_reject = undefined;
   }
+
   function defaultReaderClosedPromiseResetToRejected(reader, reason) {
     assert(reader._closedPromise_resolve === undefined);
     assert(reader._closedPromise_reject === undefined);
     reader._closedPromise = Promise.reject(reason);
   }
+
   function defaultReaderClosedPromiseResolve(reader) {
     assert(reader._closedPromise_resolve !== undefined);
     assert(reader._closedPromise_reject !== undefined);
+
     reader._closedPromise_resolve(undefined);
+
     reader._closedPromise_resolve = undefined;
     reader._closedPromise_reject = undefined;
   }
+
   function byobReaderBrandCheckException(name) {
     return new TypeError('ReadableStreamBYOBReader.prototype.' + name + ' can only be used on a ReadableStreamBYOBReader');
   }
+
   function defaultControllerBrandCheckException(name) {
     return new TypeError('ReadableStreamDefaultController.prototype.' + name + ' can only be used on a ReadableStreamDefaultController');
   }
+
   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 ifIsObjectAndHasAPromiseIsHandledInternalSlotSetPromiseIsHandledToTrue(promise) {
     try {
       Promise.prototype.then.call(promise, undefined, function () {});
     } catch (e) {}
   }
 }, function (module, exports, __w_pdfjs_require__) {
   "use strict";
 
   var transformStream = __w_pdfjs_require__(6);
+
   var readableStream = __w_pdfjs_require__(4);
+
   var writableStream = __w_pdfjs_require__(2);
+
   exports.TransformStream = transformStream.TransformStream;
   exports.ReadableStream = readableStream.ReadableStream;
   exports.IsReadableStreamDisturbed = readableStream.IsReadableStreamDisturbed;
   exports.ReadableStreamDefaultControllerClose = readableStream.ReadableStreamDefaultControllerClose;
   exports.ReadableStreamDefaultControllerEnqueue = readableStream.ReadableStreamDefaultControllerEnqueue;
   exports.ReadableStreamDefaultControllerError = readableStream.ReadableStreamDefaultControllerError;
   exports.ReadableStreamDefaultControllerGetDesiredSize = readableStream.ReadableStreamDefaultControllerGetDesiredSize;
   exports.AcquireWritableStreamDefaultWriter = writableStream.AcquireWritableStreamDefaultWriter;
@@ -3668,171 +4479,214 @@ if (isReadableStreamSupported) {
       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);
       }
     }
+
     return function (Constructor, protoProps, staticProps) {
       if (protoProps) defineProperties(Constructor.prototype, protoProps);
       if (staticProps) defineProperties(Constructor, staticProps);
       return Constructor;
     };
   }();
+
   function _classCallCheck(instance, Constructor) {
     if (!(instance instanceof Constructor)) {
       throw new TypeError("Cannot call a class as a function");
     }
   }
+
   var _require = __w_pdfjs_require__(1),
       assert = _require.assert;
+
   var _require2 = __w_pdfjs_require__(0),
       InvokeOrNoop = _require2.InvokeOrNoop,
       PromiseInvokeOrPerformFallback = _require2.PromiseInvokeOrPerformFallback,
       PromiseInvokeOrNoop = _require2.PromiseInvokeOrNoop,
       typeIsObject = _require2.typeIsObject;
+
   var _require3 = __w_pdfjs_require__(4),
       ReadableStream = _require3.ReadableStream,
       ReadableStreamDefaultControllerClose = _require3.ReadableStreamDefaultControllerClose,
       ReadableStreamDefaultControllerEnqueue = _require3.ReadableStreamDefaultControllerEnqueue,
       ReadableStreamDefaultControllerError = _require3.ReadableStreamDefaultControllerError,
       ReadableStreamDefaultControllerGetDesiredSize = _require3.ReadableStreamDefaultControllerGetDesiredSize;
+
   var _require4 = __w_pdfjs_require__(2),
       WritableStream = _require4.WritableStream,
       WritableStreamDefaultControllerError = _require4.WritableStreamDefaultControllerError;
+
   function TransformStreamCloseReadable(transformStream) {
     if (transformStream._errored === true) {
       throw new TypeError('TransformStream is already errored');
     }
+
     if (transformStream._readableClosed === true) {
       throw new TypeError('Readable side is already closed');
     }
+
     TransformStreamCloseReadableInternal(transformStream);
   }
+
   function TransformStreamEnqueueToReadable(transformStream, chunk) {
     if (transformStream._errored === true) {
       throw new TypeError('TransformStream is already errored');
     }
+
     if (transformStream._readableClosed === true) {
       throw new TypeError('Readable side is already closed');
     }
+
     var controller = transformStream._readableController;
+
     try {
       ReadableStreamDefaultControllerEnqueue(controller, chunk);
     } catch (e) {
       transformStream._readableClosed = true;
       TransformStreamErrorIfNeeded(transformStream, e);
       throw transformStream._storedError;
     }
+
     var desiredSize = ReadableStreamDefaultControllerGetDesiredSize(controller);
     var maybeBackpressure = desiredSize <= 0;
+
     if (maybeBackpressure === true && transformStream._backpressure === false) {
       TransformStreamSetBackpressure(transformStream, true);
     }
   }
+
   function TransformStreamError(transformStream, e) {
     if (transformStream._errored === true) {
       throw new TypeError('TransformStream is already errored');
     }
+
     TransformStreamErrorInternal(transformStream, e);
   }
+
   function TransformStreamCloseReadableInternal(transformStream) {
     assert(transformStream._errored === false);
     assert(transformStream._readableClosed === false);
+
     try {
       ReadableStreamDefaultControllerClose(transformStream._readableController);
     } catch (e) {
       assert(false);
     }
+
     transformStream._readableClosed = true;
   }
+
   function TransformStreamErrorIfNeeded(transformStream, e) {
     if (transformStream._errored === false) {
       TransformStreamErrorInternal(transformStream, e);
     }
   }
+
   function TransformStreamErrorInternal(transformStream, e) {
     assert(transformStream._errored === false);
     transformStream._errored = true;
     transformStream._storedError = e;
+
     if (transformStream._writableDone === false) {
       WritableStreamDefaultControllerError(transformStream._writableController, e);
     }
+
     if (transformStream._readableClosed === false) {
       ReadableStreamDefaultControllerError(transformStream._readableController, e);
     }
   }
+
   function TransformStreamReadableReadyPromise(transformStream) {
     assert(transformStream._backpressureChangePromise !== undefined, '_backpressureChangePromise should have been initialized');
+
     if (transformStream._backpressure === false) {
       return Promise.resolve();
     }
+
     assert(transformStream._backpressure === true, '_backpressure should have been initialized');
     return transformStream._backpressureChangePromise;
   }
+
   function TransformStreamSetBackpressure(transformStream, backpressure) {
     assert(transformStream._backpressure !== backpressure, 'TransformStreamSetBackpressure() should be called only when backpressure is changed');
+
     if (transformStream._backpressureChangePromise !== undefined) {
       transformStream._backpressureChangePromise_resolve(backpressure);
     }
+
     transformStream._backpressureChangePromise = new Promise(function (resolve) {
       transformStream._backpressureChangePromise_resolve = resolve;
     });
+
     transformStream._backpressureChangePromise.then(function (resolution) {
       assert(resolution !== backpressure, '_backpressureChangePromise should be fulfilled only when backpressure is changed');
     });
+
     transformStream._backpressure = backpressure;
   }
+
   function TransformStreamDefaultTransform(chunk, transformStreamController) {
     var transformStream = transformStreamController._controlledTransformStream;
     TransformStreamEnqueueToReadable(transformStream, chunk);
     return Promise.resolve();
   }
+
   function TransformStreamTransform(transformStream, chunk) {
     assert(transformStream._errored === false);
     assert(transformStream._transforming === false);
     assert(transformStream._backpressure === false);
     transformStream._transforming = true;
     var transformer = transformStream._transformer;
     var controller = transformStream._transformStreamController;
     var transformPromise = PromiseInvokeOrPerformFallback(transformer, 'transform', [chunk, controller], TransformStreamDefaultTransform, [chunk, controller]);
     return transformPromise.then(function () {
       transformStream._transforming = false;
       return TransformStreamReadableReadyPromise(transformStream);
     }, function (e) {
       TransformStreamErrorIfNeeded(transformStream, e);
       return Promise.reject(e);
     });
   }
+
   function IsTransformStreamDefaultController(x) {
     if (!typeIsObject(x)) {
       return false;
     }
+
     if (!Object.prototype.hasOwnProperty.call(x, '_controlledTransformStream')) {
       return false;
     }
+
     return true;
   }
+
   function IsTransformStream(x) {
     if (!typeIsObject(x)) {
       return false;
     }
+
     if (!Object.prototype.hasOwnProperty.call(x, '_transformStreamController')) {
       return false;
     }
+
     return true;
   }
+
   var TransformStreamSink = function () {
     function TransformStreamSink(transformStream, startPromise) {
       _classCallCheck(this, TransformStreamSink);
+
       this._transformStream = transformStream;
       this._startPromise = startPromise;
     }
+
     _createClass(TransformStreamSink, [{
       key: 'start',
       value: function start(c) {
         var transformStream = this._transformStream;
         transformStream._writableController = c;
         return this._startPromise.then(function () {
           return TransformStreamReadableReadyPromise(transformStream);
         });
@@ -3856,44 +4710,52 @@ if (isReadableStreamSupported) {
         var transformStream = this._transformStream;
         assert(transformStream._transforming === false);
         transformStream._writableDone = true;
         var flushPromise = PromiseInvokeOrNoop(transformStream._transformer, 'flush', [transformStream._transformStreamController]);
         return flushPromise.then(function () {
           if (transformStream._errored === true) {
             return Promise.reject(transformStream._storedError);
           }
+
           if (transformStream._readableClosed === false) {
             TransformStreamCloseReadableInternal(transformStream);
           }
+
           return Promise.resolve();
         }).catch(function (r) {
           TransformStreamErrorIfNeeded(transformStream, r);
           return Promise.reject(transformStream._storedError);
         });
       }
     }]);
+
     return TransformStreamSink;
   }();
+
   var TransformStreamSource = function () {
     function TransformStreamSource(transformStream, startPromise) {
       _classCallCheck(this, TransformStreamSource);
+
       this._transformStream = transformStream;
       this._startPromise = startPromise;
     }
+
     _createClass(TransformStreamSource, [{
       key: 'start',
       value: function start(c) {
         var transformStream = this._transformStream;
         transformStream._readableController = c;
         return this._startPromise.then(function () {
           assert(transformStream._backpressureChangePromise !== undefined, '_backpressureChangePromise should have been initialized');
+
           if (transformStream._backpressure === true) {
             return Promise.resolve();
           }
+
           assert(transformStream._backpressure === false, '_backpressure should have been initialized');
           return transformStream._backpressureChangePromise;
         });
       }
     }, {
       key: 'pull',
       value: function pull() {
         var transformStream = this._transformStream;
@@ -3905,70 +4767,84 @@ if (isReadableStreamSupported) {
     }, {
       key: 'cancel',
       value: function cancel() {
         var transformStream = this._transformStream;
         transformStream._readableClosed = true;
         TransformStreamErrorInternal(transformStream, new TypeError('Readable side canceled'));
       }
     }]);
+
     return TransformStreamSource;
   }();
+
   var TransformStreamDefaultController = function () {
     function TransformStreamDefaultController(transformStream) {
       _classCallCheck(this, TransformStreamDefaultController);
+
       if (IsTransformStream(transformStream) === false) {
         throw new TypeError('TransformStreamDefaultController can only be ' + 'constructed with a TransformStream instance');
       }
+
       if (transformStream._transformStreamController !== undefined) {
         throw new TypeError('TransformStreamDefaultController instances can ' + 'only be created by the TransformStream constructor');
       }
+
       this._controlledTransformStream = transformStream;
     }
+
     _createClass(TransformStreamDefaultController, [{
       key: 'enqueue',
       value: function enqueue(chunk) {
         if (IsTransformStreamDefaultController(this) === false) {
           throw defaultControllerBrandCheckException('enqueue');
         }
+
         TransformStreamEnqueueToReadable(this._controlledTransformStream, chunk);
       }
     }, {
       key: 'close',
       value: function close() {
         if (IsTransformStreamDefaultController(this) === false) {
           throw defaultControllerBrandCheckException('close');
         }
+
         TransformStreamCloseReadable(this._controlledTransformStream);
       }
     }, {
       key: 'error',
       value: function error(reason) {
         if (IsTransformStreamDefaultController(this) === false) {
           throw defaultControllerBrandCheckException('error');
         }
+
         TransformStreamError(this._controlledTransformStream, reason);
       }
     }, {
       key: 'desiredSize',
       get: function get() {
         if (IsTransformStreamDefaultController(this) === false) {
           throw defaultControllerBrandCheckException('desiredSize');
         }
+
         var transformStream = this._controlledTransformStream;
         var readableController = transformStream._readableController;
         return ReadableStreamDefaultControllerGetDesiredSize(readableController);
       }
     }]);
+
     return TransformStreamDefaultController;
   }();
+
   var TransformStream = function () {
     function TransformStream() {
       var transformer = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
       _classCallCheck(this, TransformStream);
+
       this._transformer = transformer;
       var readableStrategy = transformer.readableStrategy,
           writableStrategy = transformer.writableStrategy;
       this._transforming = false;
       this._errored = false;
       this._storedError = undefined;
       this._writableController = undefined;
       this._readableController = undefined;
@@ -3996,39 +4872,48 @@ if (isReadableStreamSupported) {
       startPromise_resolve(startResult);
       startPromise.catch(function (e) {
         if (transformStream._errored === false) {
           transformStream._errored = true;
           transformStream._storedError = e;
         }
       });
     }
+
     _createClass(TransformStream, [{
       key: 'readable',
       get: function get() {
         if (IsTransformStream(this) === false) {
           throw streamBrandCheckException('readable');
         }
+
         return this._readable;
       }
     }, {
       key: 'writable',
       get: function get() {
         if (IsTransformStream(this) === false) {
           throw streamBrandCheckException('writable');
         }
+
         return this._writable;
       }
     }]);
+
     return TransformStream;
   }();
-  module.exports = { TransformStream: TransformStream };
+
+  module.exports = {
+    TransformStream: TransformStream
+  };
+
   function defaultControllerBrandCheckException(name) {
     return new TypeError('TransformStreamDefaultController.prototype.' + name + ' can only be used on a TransformStreamDefaultController');
   }
+
   function streamBrandCheckException(name) {
     return new TypeError('TransformStream.prototype.' + name + ' can only be used on a TransformStream');
   }
 }, function (module, exports, __w_pdfjs_require__) {
   module.exports = __w_pdfjs_require__(5);
 }]));
 
 /***/ }),
@@ -4047,31 +4932,31 @@ if (isReadableStreamSupported) {
 /***/ (function(module, exports, __w_pdfjs_require__) {
 
 "use strict";
 
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.build = exports.version = exports.setPDFNetworkStreamFactory = exports.PDFPageProxy = exports.PDFDocumentProxy = exports.PDFWorker = exports.PDFDataRangeTransport = exports.LoopbackPort = exports.getDocument = undefined;
+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__(1);
 
 var _dom_utils = __w_pdfjs_require__(8);
 
 var _font_loader = __w_pdfjs_require__(9);
 
 var _api_compatibility = __w_pdfjs_require__(10);
 
 var _canvas = __w_pdfjs_require__(11);
 
-var _global_scope = __w_pdfjs_require__(3);
-
-var _global_scope2 = _interopRequireDefault(_global_scope);
+var _global_scope = _interopRequireDefault(__w_pdfjs_require__(3));
 
 var _worker_options = __w_pdfjs_require__(13);
 
 var _message_handler = __w_pdfjs_require__(14);
 
 var _metadata = __w_pdfjs_require__(15);
 
 var _transport_stream = __w_pdfjs_require__(17);
@@ -4081,114 +4966,145 @@ var _webgl = __w_pdfjs_require__(18);
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 const DEFAULT_RANGE_CHUNK_SIZE = 65536;
 let isWorkerDisabled = false;
 let fallbackWorkerSrc;
 let fakeWorkerFilesLoader = null;
 ;
 let createPDFNetworkStream;
+
 function setPDFNetworkStreamFactory(pdfNetworkStreamFactory) {
   createPDFNetworkStream = pdfNetworkStreamFactory;
 }
+
 function getDocument(src) {
   const task = new PDFDocumentLoadingTask();
   let source;
+
   if (typeof src === 'string') {
-    source = { url: src };
+    source = {
+      url: src
+    };
   } else if ((0, _util.isArrayBuffer)(src)) {
-    source = { data: src };
+    source = {
+      data: src
+    };
   } else if (src instanceof PDFDataRangeTransport) {
-    source = { range: src };
+    source = {
+      range: src
+    };
   } else {
     if (typeof src !== 'object') {
       throw new Error('Invalid parameter in getDocument, ' + 'need either Uint8Array, string or a parameter object');
     }
+
     if (!src.url && !src.data && !src.range) {
       throw new Error('Invalid parameter object: need either .data, .range or .url');
     }
+
     source = src;
   }
+
   const params = Object.create(null);
   let rangeTransport = null,
       worker = null;
+
   for (const key in source) {
     if (key === 'url' && typeof window !== 'undefined') {
       params[key] = new _util.URL(source[key], window.location).href;
       continue;
     } else if (key === 'range') {
       rangeTransport = source[key];
       continue;
     } else if (key === 'worker') {
       worker = source[key];
       continue;
     } else if (key === 'data' && !(source[key] instanceof Uint8Array)) {
       const pdfBytes = source[key];
+
       if (typeof pdfBytes === 'string') {
         params[key] = (0, _util.stringToBytes)(pdfBytes);
       } 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);
       } else {
         throw new Error('Invalid PDF binary data: either typed array, ' + 'string or array-like object is expected in the ' + 'data property.');
       }
+
       continue;
     }
+
     params[key] = source[key];
   }
+
   params.rangeChunkSize = params.rangeChunkSize || DEFAULT_RANGE_CHUNK_SIZE;
   params.CMapReaderFactory = params.CMapReaderFactory || _dom_utils.DOMCMapReaderFactory;
   params.ignoreErrors = params.stopAtErrors !== true;
   params.pdfBug = params.pdfBug === true;
   const NativeImageDecoderValues = Object.values(_util.NativeImageDecoding);
+
   if (params.nativeImageDecoderSupport === undefined || !NativeImageDecoderValues.includes(params.nativeImageDecoderSupport)) {
     params.nativeImageDecoderSupport = _api_compatibility.apiCompatibilityParams.nativeImageDecoderSupport || _util.NativeImageDecoding.DECODE;
   }
+
   if (!Number.isInteger(params.maxImageSize)) {
     params.maxImageSize = -1;
   }
+
   if (typeof params.isEvalSupported !== 'boolean') {
     params.isEvalSupported = true;
   }
+
   if (typeof params.disableFontFace !== 'boolean') {
     params.disableFontFace = _api_compatibility.apiCompatibilityParams.disableFontFace || false;
   }
+
   if (typeof params.disableRange !== 'boolean') {
     params.disableRange = false;
   }
+
   if (typeof params.disableStream !== 'boolean') {
     params.disableStream = false;
   }
+
   if (typeof params.disableAutoFetch !== 'boolean') {
     params.disableAutoFetch = false;
   }
+
   if (typeof params.disableCreateObjectURL !== 'boolean') {
     params.disableCreateObjectURL = _api_compatibility.apiCompatibilityParams.disableCreateObjectURL || false;
   }
+
   (0, _util.setVerbosityLevel)(params.verbosity);
+
   if (!worker) {
     const workerParams = {
       postMessageTransfers: params.postMessageTransfers,
       verbosity: params.verbosity,
       port: _worker_options.GlobalWorkerOptions.workerPort
     };
     worker = workerParams.port ? PDFWorker.fromPort(workerParams) : new PDFWorker(workerParams);
     task._worker = worker;
   }
+
   const docId = task.docId;
   worker.promise.then(function () {
     if (task.destroyed) {
       throw new Error('Loading aborted');
     }
+
     return _fetchDocument(worker, params, rangeTransport, docId).then(function (workerId) {
       if (task.destroyed) {
         throw new Error('Loading aborted');
       }
+
       let networkStream;
+
       if (rangeTransport) {
         networkStream = new _transport_stream.PDFDataTransportStream({
           length: params.length,
           initialData: params.initialData,
           disableRange: params.disableRange,
           disableStream: params.disableStream
         }, rangeTransport);
       } else if (!params.data) {
@@ -4197,36 +5113,40 @@ function getDocument(src) {
           length: params.length,
           httpHeaders: params.httpHeaders,
           withCredentials: params.withCredentials,
           rangeChunkSize: params.rangeChunkSize,
           disableRange: params.disableRange,
           disableStream: params.disableStream
         });
       }
+
       const messageHandler = new _message_handler.MessageHandler(docId, workerId, worker.port);
       messageHandler.postMessageTransfers = worker.postMessageTransfers;
       const transport = new WorkerTransport(messageHandler, task, networkStream, params);
       task._transport = transport;
       messageHandler.send('Ready', null);
     });
   }).catch(task._capability.reject);
   return task;
 }
+
 function _fetchDocument(worker, source, pdfDataRangeTransport, docId) {
   if (worker.destroyed) {
     return Promise.reject(new Error('Worker was destroyed'));
   }
+
   if (pdfDataRangeTransport) {
     source.length = pdfDataRangeTransport.length;
     source.initialData = pdfDataRangeTransport.initialData;
   }
+
   return worker.messageHandler.sendWithPromise('GetDocRequest', {
     docId,
-    apiVersion: '2.1.70',
+    apiVersion: '2.1.86',
     source: {
       data: source.data,
       url: source.url,
       password: source.password,
       disableAutoFetch: source.disableAutoFetch,
       rangeChunkSize: source.rangeChunkSize,
       length: source.length
     },
@@ -4237,251 +5157,330 @@ function _fetchDocument(worker, source, 
     docBaseUrl: source.docBaseUrl,
     nativeImageDecoderSupport: source.nativeImageDecoderSupport,
     ignoreErrors: source.ignoreErrors,
     isEvalSupported: source.isEvalSupported
   }).then(function (workerId) {
     if (worker.destroyed) {
       throw new Error('Worker was destroyed');
     }
+
     return workerId;
   });
 }
+
 const PDFDocumentLoadingTask = function PDFDocumentLoadingTaskClosure() {
   let nextDocumentId = 0;
+
   class PDFDocumentLoadingTask {
     constructor() {
       this._capability = (0, _util.createPromiseCapability)();
       this._transport = null;
       this._worker = null;
       this.docId = 'd' + nextDocumentId++;
       this.destroyed = false;
       this.onPassword = null;
       this.onProgress = null;
       this.onUnsupportedFeature = null;
     }
+
     get promise() {
       return this._capability.promise;
     }
+
     destroy() {
       this.destroyed = true;
       const transportDestroyed = !this._transport ? Promise.resolve() : this._transport.destroy();
       return transportDestroyed.then(() => {
         this._transport = null;
+
         if (this._worker) {
           this._worker.destroy();
+
           this._worker = null;
         }
       });
     }
+
     then(onFulfilled, onRejected) {
       (0, _util.deprecated)('PDFDocumentLoadingTask.then method, ' + 'use the `promise` getter instead.');
       return this.promise.then.apply(this.promise, arguments);
     }
-  }
+
+  }
+
   return PDFDocumentLoadingTask;
 }();
+
 class PDFDataRangeTransport {
   constructor(length, initialData) {
     this.length = length;
     this.initialData = initialData;
     this._rangeListeners = [];
     this._progressListeners = [];
     this._progressiveReadListeners = [];
     this._readyCapability = (0, _util.createPromiseCapability)();
   }
+
   addRangeListener(listener) {
     this._rangeListeners.push(listener);
   }
+
   addProgressListener(listener) {
     this._progressListeners.push(listener);
   }
+
   addProgressiveReadListener(listener) {
     this._progressiveReadListeners.push(listener);
   }
+
   onDataRange(begin, chunk) {
     for (const listener of this._rangeListeners) {
       listener(begin, chunk);
     }
   }
+
   onDataProgress(loaded) {
     this._readyCapability.promise.then(() => {
       for (const listener of this._progressListeners) {
         listener(loaded);
       }
     });
   }
+
   onDataProgressiveRead(chunk) {
     this._readyCapability.promise.then(() => {
       for (const listener of this._progressiveReadListeners) {
         listener(chunk);
       }
     });
   }
+
   transportReady() {
     this._readyCapability.resolve();
   }
+
   requestDataRange(begin, end) {
     (0, _util.unreachable)('Abstract method PDFDataRangeTransport.requestDataRange');
   }
+
   abort() {}
-}
+
+}
+
+exports.PDFDataRangeTransport = PDFDataRangeTransport;
+
 class PDFDocumentProxy {
   constructor(pdfInfo, transport, loadingTask) {
     this.loadingTask = loadingTask;
     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();
   }
+
   getPageMode() {
     return this._transport.getPageMode();
   }
+
   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() {
     this._transport.startCleanup();
   }
+
   destroy() {
     return this.loadingTask.destroy();
   }
+
   get loadingParams() {
     return this._transport.loadingParams;
   }
-}
+
+}
+
+exports.PDFDocumentProxy = PDFDocumentProxy;
+
 class PDFPageProxy {
   constructor(pageIndex, pageInfo, transport, pdfBug = false) {
     this.pageIndex = pageIndex;
     this._pageInfo = pageInfo;
     this._transport = transport;
     this._stats = pdfBug ? new _dom_utils.StatTimer() : _dom_utils.DummyStatTimer;
     this._pdfBug = pdfBug;
     this.commonObjs = transport.commonObjs;
     this.objs = new PDFObjects();
     this.cleanupAfterRender = false;
     this.pendingCleanup = false;
     this.intentStates = Object.create(null);
     this.destroyed = false;
   }
+
   get pageNumber() {
     return this.pageIndex + 1;
   }
+
   get rotate() {
     return this._pageInfo.rotate;
   }
+
   get ref() {
     return this._pageInfo.ref;
   }
+
   get userUnit() {
     return this._pageInfo.userUnit;
   }
+
   get view() {
     return this._pageInfo.view;
   }
+
   getViewport(scale, rotate = this.rotate, dontFlip = false) {
     return new _dom_utils.PageViewport({
       viewBox: this.view,
       scale,
       rotation: rotate,
       dontFlip
     });
   }
+
   getAnnotations({
     intent = null
   } = {}) {
     if (!this.annotationsPromise || this.annotationsIntent !== intent) {
       this.annotationsPromise = this._transport.getAnnotations(this.pageIndex, intent);
       this.annotationsIntent = intent;
     }
+
     return this.annotationsPromise;
   }
-  render({ canvasContext, viewport, intent = 'display', enableWebGL = false, renderInteractiveForms = false, transform = null, imageLayer = null, canvasFactory = null, background = null }) {
+
+  render({
+    canvasContext,
+    viewport,
+    intent = 'display',
+    enableWebGL = false,
+    renderInteractiveForms = false,
+    transform = null,
+    imageLayer = null,
+    canvasFactory = null,
+    background = null
+  }) {
     const stats = this._stats;
     stats.time('Overall');
     this.pendingCleanup = false;
     const renderingIntent = intent === 'print' ? 'print' : 'display';
     const canvasFactoryInstance = canvasFactory || new _dom_utils.DOMCanvasFactory();
-    const webGLContext = new _webgl.WebGLContext({ enable: enableWebGL });
+    const webGLContext = new _webgl.WebGLContext({
+      enable: enableWebGL
+    });
+
     if (!this.intentStates[renderingIntent]) {
       this.intentStates[renderingIntent] = Object.create(null);
     }
+
     const intentState = this.intentStates[renderingIntent];
+
     if (!intentState.displayReadyCapability) {
       intentState.receivingOperatorList = true;
       intentState.displayReadyCapability = (0, _util.createPromiseCapability)();
       intentState.operatorList = {
         fnArray: [],
         argsArray: [],
         lastChunk: false
       };
       stats.time('Page Request');
+
       this._transport.messageHandler.send('RenderPageRequest', {
         pageIndex: this.pageNumber - 1,
         intent: renderingIntent,
         renderInteractiveForms: renderInteractiveForms === true
       });
     }
+
     const complete = error => {
       const i = intentState.renderTasks.indexOf(internalRenderTask);
+
       if (i >= 0) {
         intentState.renderTasks.splice(i, 1);
       }
+
       if (this.cleanupAfterRender) {
         this.pendingCleanup = true;
       }
+
       this._tryCleanup();
+
       if (error) {
         internalRenderTask.capability.reject(error);
       } else {
         internalRenderTask.capability.resolve();
       }
+
       stats.timeEnd('Rendering');
       stats.timeEnd('Overall');
     };
+
     const internalRenderTask = new InternalRenderTask({
       callback: complete,
       params: {
         canvasContext,
         viewport,
         transform,
         imageLayer,
         background
@@ -4490,437 +5489,578 @@ class PDFPageProxy {
       commonObjs: this.commonObjs,
       operatorList: intentState.operatorList,
       pageNumber: this.pageNumber,
       canvasFactory: canvasFactoryInstance,
       webGLContext,
       useRequestAnimationFrame: renderingIntent !== 'print',
       pdfBug: this._pdfBug
     });
+
     if (!intentState.renderTasks) {
       intentState.renderTasks = [];
     }
+
     intentState.renderTasks.push(internalRenderTask);
     const renderTask = internalRenderTask.task;
     intentState.displayReadyCapability.promise.then(transparency => {
       if (this.pendingCleanup) {
         complete();
         return;
       }
+
       stats.time('Rendering');
       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);
+
         if (i >= 0) {
           intentState.renderTasks.splice(i, 1);
         }
       }
     }
+
     const renderingIntent = 'oplist';
+
     if (!this.intentStates[renderingIntent]) {
       this.intentStates[renderingIntent] = Object.create(null);
     }
+
     const intentState = this.intentStates[renderingIntent];
     let opListTask;
+
     if (!intentState.opListReadCapability) {
       opListTask = {};
       opListTask.operatorListChanged = operatorListChanged;
       intentState.receivingOperatorList = true;
       intentState.opListReadCapability = (0, _util.createPromiseCapability)();
       intentState.renderTasks = [];
       intentState.renderTasks.push(opListTask);
       intentState.operatorList = {
         fnArray: [],
         argsArray: [],
         lastChunk: false
       };
+
       this._stats.time('Page Request');
+
       this._transport.messageHandler.send('RenderPageRequest', {
         pageIndex: this.pageIndex,
         intent: renderingIntent
       });
     }
+
     return intentState.opListReadCapability.promise;
   }
-  streamTextContent({ normalizeWhitespace = false, disableCombineTextItems = false } = {}) {
+
+  streamTextContent({
+    normalizeWhitespace = false,
+    disableCombineTextItems = false
+  } = {}) {
     const TEXT_CONTENT_CHUNK_SIZE = 100;
     return this._transport.messageHandler.sendWithStream('GetTextContent', {
       pageIndex: this.pageNumber - 1,
       normalizeWhitespace: normalizeWhitespace === true,
       combineTextItems: disableCombineTextItems !== true
     }, {
       highWaterMark: TEXT_CONTENT_CHUNK_SIZE,
+
       size(textContent) {
         return textContent.items.length;
       }
+
     });
   }
+
   getTextContent(params = {}) {
     const readableStream = this.streamTextContent(params);
     return new Promise(function (resolve, reject) {
       function pump() {
-        reader.read().then(function ({ value, done }) {
+        reader.read().then(function ({
+          value,
+          done
+        }) {
           if (done) {
             resolve(textContent);
             return;
           }
+
           Object.assign(textContent.styles, value.styles);
           textContent.items.push(...value.items);
           pump();
         }, reject);
       }
+
       const reader = readableStream.getReader();
       const textContent = {
         items: [],
         styles: Object.create(null)
       };
       pump();
     });
   }
+
   _destroy() {
     this.destroyed = true;
     this._transport.pageCache[this.pageIndex] = null;
     const waitOn = [];
     Object.keys(this.intentStates).forEach(function (intent) {
       if (intent === 'oplist') {
         return;
       }
+
       const intentState = this.intentStates[intent];
       intentState.renderTasks.forEach(function (renderTask) {
         const renderCompleted = renderTask.capability.promise.catch(function () {});
         waitOn.push(renderCompleted);
         renderTask.cancel();
       });
     }, this);
     this.objs.clear();
     this.annotationsPromise = null;
     this.pendingCleanup = false;
     return Promise.all(waitOn);
   }
+
   cleanup(resetStats = false) {
     this.pendingCleanup = true;
+
     this._tryCleanup(resetStats);
   }
+
   _tryCleanup(resetStats = false) {
     if (!this.pendingCleanup || Object.keys(this.intentStates).some(function (intent) {
       const intentState = this.intentStates[intent];
       return intentState.renderTasks.length !== 0 || intentState.receivingOperatorList;
     }, this)) {
       return;
     }
+
     Object.keys(this.intentStates).forEach(function (intent) {
       delete this.intentStates[intent];
     }, this);
     this.objs.clear();
     this.annotationsPromise = null;
+
     if (resetStats && this._stats instanceof _dom_utils.StatTimer) {
       this._stats = new _dom_utils.StatTimer();
     }
+
     this.pendingCleanup = false;
   }
+
   _startRenderPage(transparency, intent) {
     const intentState = this.intentStates[intent];
+
     if (intentState.displayReadyCapability) {
       intentState.displayReadyCapability.resolve(transparency);
     }
   }
+
   _renderPageChunk(operatorListChunk, intent) {
     const intentState = this.intentStates[intent];
+
     for (let i = 0, ii = operatorListChunk.length; i < ii; i++) {
       intentState.operatorList.fnArray.push(operatorListChunk.fnArray[i]);
       intentState.operatorList.argsArray.push(operatorListChunk.argsArray[i]);
     }
+
     intentState.operatorList.lastChunk = operatorListChunk.lastChunk;
+
     for (let i = 0; i < intentState.renderTasks.length; i++) {
       intentState.renderTasks[i].operatorListChanged();
     }
+
     if (operatorListChunk.lastChunk) {
       intentState.receivingOperatorList = false;
+
       this._tryCleanup();
     }
   }
+
   get stats() {
     return this._stats instanceof _dom_utils.StatTimer ? this._stats : null;
   }
-}
+
+}
+
+exports.PDFPageProxy = PDFPageProxy;
+
 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;
       }
+
       if (cloned.has(value)) {
         return cloned.get(value);
       }
+
       let buffer, result;
+
       if ((buffer = value.buffer) && (0, _util.isArrayBuffer)(buffer)) {
         const transferable = transfers && transfers.includes(buffer);
+
         if (value === buffer) {
           result = value;
         } else 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);
+
       for (const i in value) {
         let desc,
             p = value;
+
         while (!(desc = Object.getOwnPropertyDescriptor(p, i))) {
           p = Object.getPrototypeOf(p);
         }
+
         if (typeof desc.value === 'undefined' || typeof desc.value === 'function') {
           continue;
         }
+
         result[i] = cloneValue(desc.value);
       }
+
       return result;
     }
+
     if (!this._defer) {
       this._listeners.forEach(function (listener) {
-        listener.call(this, { data: obj });
+        listener.call(this, {
+          data: obj
+        });
       }, this);
+
       return;
     }
+
     const cloned = new WeakMap();
-    const e = { data: cloneValue(obj) };
+    const e = {
+      data: cloneValue(obj)
+    };
+
     this._deferred.then(() => {
       this._listeners.forEach(function (listener) {
         listener.call(this, e);
       }, this);
     });
   }
+
   addEventListener(name, listener) {
     this._listeners.push(listener);
   }
+
   removeEventListener(name, listener) {
     const i = this._listeners.indexOf(listener);
+
     this._listeners.splice(i, 1);
   }
+
   terminate() {
     this._listeners = [];
   }
-}
+
+}
+
+exports.LoopbackPort = LoopbackPort;
+
 const PDFWorker = function PDFWorkerClosure() {
   const pdfWorkerPorts = new WeakMap();
   let nextFakeWorkerId = 0;
   let fakeWorkerFilesLoadedCapability;
+
   function getWorkerSrc() {
     if (_worker_options.GlobalWorkerOptions.workerSrc) {
       return _worker_options.GlobalWorkerOptions.workerSrc;
     }
+
     if (typeof fallbackWorkerSrc !== 'undefined') {
       return fallbackWorkerSrc;
     }
+
     throw new Error('No "GlobalWorkerOptions.workerSrc" specified.');
   }
+
   function getMainThreadWorkerMessageHandler() {
     try {
       if (typeof window !== 'undefined') {
         return window.pdfjsWorker && window.pdfjsWorker.WorkerMessageHandler;
       }
     } catch (ex) {}
+
     return null;
   }
+
   function setupFakeWorkerGlobal() {
     if (fakeWorkerFilesLoadedCapability) {
       return fakeWorkerFilesLoadedCapability.promise;
     }
+
     fakeWorkerFilesLoadedCapability = (0, _util.createPromiseCapability)();
     const mainWorkerMessageHandler = getMainThreadWorkerMessageHandler();
+
     if (mainWorkerMessageHandler) {
       fakeWorkerFilesLoadedCapability.resolve(mainWorkerMessageHandler);
       return fakeWorkerFilesLoadedCapability.promise;
     }
+
     const loader = fakeWorkerFilesLoader || function () {
       return (0, _dom_utils.loadScript)(getWorkerSrc()).then(function () {
         return window.pdfjsWorker.WorkerMessageHandler;
       });
     };
+
     loader().then(fakeWorkerFilesLoadedCapability.resolve, fakeWorkerFilesLoadedCapability.reject);
     return fakeWorkerFilesLoadedCapability.promise;
   }
+
   function createCDNWrapper(url) {
     const wrapper = 'importScripts(\'' + url + '\');';
     return _util.URL.createObjectURL(new Blob([wrapper]));
   }
+
   class PDFWorker {
-    constructor({ name = null, port = null, postMessageTransfers = true, verbosity = (0, _util.getVerbosityLevel)() } = {}) {
+    constructor({
+      name = null,
+      port = null,
+      postMessageTransfers = true,
+      verbosity = (0, _util.getVerbosityLevel)()
+    } = {}) {
       if (port && pdfWorkerPorts.has(port)) {
         throw new Error('Cannot use more than one PDFWorker per port');
       }
+
       this.name = name;
       this.destroyed = false;
       this.postMessageTransfers = postMessageTransfers !== false;
       this.verbosity = verbosity;
       this._readyCapability = (0, _util.createPromiseCapability)();
       this._port = null;
       this._webWorker = null;
       this._messageHandler = null;
+
       if (port) {
         pdfWorkerPorts.set(port, this);
+
         this._initializeFromPort(port);
+
         return;
       }
+
       this._initialize();
     }
+
     get promise() {
       return this._readyCapability.promise;
     }
+
     get port() {
       return this._port;
     }
+
     get messageHandler() {
       return this._messageHandler;
     }
+
     _initializeFromPort(port) {
       this._port = port;
       this._messageHandler = new _message_handler.MessageHandler('main', 'worker', port);
+
       this._messageHandler.on('ready', function () {});
+
       this._readyCapability.resolve();
     }
+
     _initialize() {
       if (typeof Worker !== 'undefined' && !isWorkerDisabled && !getMainThreadWorkerMessageHandler()) {
         let workerSrc = getWorkerSrc();
+
         try {
           const worker = new Worker(workerSrc);
           const messageHandler = new _message_handler.MessageHandler('main', 'worker', worker);
+
           const terminateEarly = () => {
             worker.removeEventListener('error', onWorkerError);
             messageHandler.destroy();
             worker.terminate();
+
             if (this.destroyed) {
               this._readyCapability.reject(new Error('Worker was destroyed'));
             } else {
               this._setupFakeWorker();
             }
           };
+
           const onWorkerError = () => {
             if (!this._webWorker) {
               terminateEarly();
             }
           };
+
           worker.addEventListener('error', onWorkerError);
           messageHandler.on('test', data => {
             worker.removeEventListener('error', onWorkerError);
+
             if (this.destroyed) {
               terminateEarly();
               return;
             }
+
             if (data && data.supportTypedArray) {
               this._messageHandler = messageHandler;
               this._port = worker;
               this._webWorker = worker;
+
               if (!data.supportTransfers) {
                 this.postMessageTransfers = false;
               }
+
               this._readyCapability.resolve();
-              messageHandler.send('configure', { verbosity: this.verbosity });
+
+              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;
             }
+
             try {
               sendTest();
             } catch (e) {
               this._setupFakeWorker();
             }
           });
+
           const sendTest = () => {
             let testObj = new Uint8Array([this.postMessageTransfers ? 255 : 0]);
+
             try {
               messageHandler.send('test', testObj, [testObj.buffer]);
             } catch (ex) {
               (0, _util.info)('Cannot use postMessage transfers');
               testObj[0] = 0;
               messageHandler.send('test', testObj);
             }
           };
+
           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;
       }
+
       setupFakeWorkerGlobal().then(WorkerMessageHandler => {
         if (this.destroyed) {
           this._readyCapability.reject(new Error('Worker was destroyed'));
+
           return;
         }
+
         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();
       }).catch(reason => {
         this._readyCapability.reject(new Error(`Setting up fake worker failed: "${reason.message}".`));
       });
     }
+
     destroy() {
       this.destroyed = true;
+
       if (this._webWorker) {
         this._webWorker.terminate();
+
         this._webWorker = null;
       }
+
       pdfWorkerPorts.delete(this._port);
       this._port = null;
+
       if (this._messageHandler) {
         this._messageHandler.destroy();
+
         this._messageHandler = null;
       }
     }
+
     static fromPort(params) {
       if (!params || !params.port) {
         throw new Error('PDFWorker.fromPort - invalid method signature.');
       }
+
       if (pdfWorkerPorts.has(params.port)) {
         return pdfWorkerPorts.get(params.port);
       }
+
       return new PDFWorker(params);
     }
+
     static getWorkerSrc() {
       return getWorkerSrc();
     }
-  }
+
+  }
+
   return PDFWorker;
 }();
+
+exports.PDFWorker = PDFWorker;
+
 class WorkerTransport {
   constructor(messageHandler, loadingTask, networkStream, params) {
     this.messageHandler = messageHandler;
     this.loadingTask = loadingTask;
     this.commonObjs = new PDFObjects();
     this.fontLoader = new _font_loader.FontLoader(loadingTask.docId);
     this._params = params;
     this.CMapReaderFactory = new params.CMapReaderFactory({
@@ -4933,138 +6073,173 @@ class WorkerTransport {
     this._networkStream = networkStream;
     this._fullReader = null;
     this._lastProgress = null;
     this.pageCache = [];
     this.pagePromises = [];
     this.downloadInfoCapability = (0, _util.createPromiseCapability)();
     this.setupMessageHandler();
   }
+
   destroy() {
     if (this.destroyCapability) {
       return this.destroyCapability.promise;
     }
+
     this.destroyed = true;
     this.destroyCapability = (0, _util.createPromiseCapability)();
+
     if (this._passwordCapability) {
       this._passwordCapability.reject(new Error('Worker was destroyed during onPassword callback'));
     }
+
     const waitOn = [];
     this.pageCache.forEach(function (page) {
       if (page) {
         waitOn.push(page._destroy());
       }
     });
     this.pageCache = [];
     this.pagePromises = [];
     const terminated = this.messageHandler.sendWithPromise('Terminate', null);
     waitOn.push(terminated);
     Promise.all(waitOn).then(() => {
       this.fontLoader.clear();
+
       if (this._networkStream) {
         this._networkStream.cancelAllRequests();
       }
+
       if (this.messageHandler) {
         this.messageHandler.destroy();
         this.messageHandler = null;
       }
+
       this.destroyCapability.resolve();
     }, this.destroyCapability.reject);
     return this.destroyCapability.promise;
   }
+
   setupMessageHandler() {
-    const { messageHandler, loadingTask } = this;
+    const {
+      messageHandler,
+      loadingTask
+    } = this;
     messageHandler.on('GetReader', function (data, sink) {
       (0, _util.assert)(this._networkStream);
       this._fullReader = this._networkStream.getFullReader();
+
       this._fullReader.onProgress = evt => {
         this._lastProgress = {
           loaded: evt.loaded,
           total: evt.total
         };
       };
+
       sink.onPull = () => {
-        this._fullReader.read().then(function ({ value, done }) {
+        this._fullReader.read().then(function ({
+          value,
+          done
+        }) {
           if (done) {
             sink.close();
             return;
           }
+
           (0, _util.assert)((0, _util.isArrayBuffer)(value));
           sink.enqueue(new Uint8Array(value), 1, [value]);
         }).catch(reason => {
           sink.error(reason);
         });
       };
+
       sink.onCancel = reason => {
         this._fullReader.cancel(reason);
       };
     }, this);
     messageHandler.on('ReaderHeadersReady', function (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);
           }
+
           fullReader.onProgress = evt => {
             if (loadingTask.onProgress) {
               loadingTask.onProgress({
                 loaded: evt.loaded,
                 total: evt.total
               });
             }
           };
         }
+
         headersCapability.resolve({
           isStreamingSupported: fullReader.isStreamingSupported,
           isRangeSupported: fullReader.isRangeSupported,
           contentLength: fullReader.contentLength
         });
       }, headersCapability.reject);
       return headersCapability.promise;
     }, this);
     messageHandler.on('GetRangeReader', function (data, sink) {
       (0, _util.assert)(this._networkStream);
+
       const rangeReader = this._networkStream.getRangeReader(data.begin, data.end);
+
       sink.onPull = () => {
-        rangeReader.read().then(function ({ value, done }) {
+        rangeReader.read().then(function ({
+          value,
+          done
+        }) {
           if (done) {
             sink.close();
             return;
           }
+
           (0, _util.assert)((0, _util.isArrayBuffer)(value));
           sink.enqueue(new Uint8Array(value), 1, [value]);
         }).catch(reason => {
           sink.error(reason);
         });
       };
+
       sink.onCancel = reason => {
         rangeReader.cancel(reason);
       };
     }, this);
-    messageHandler.on('GetDoc', function ({ pdfInfo }) {
+    messageHandler.on('GetDoc', function ({
+      pdfInfo
+    }) {
       this.numPages = pdfInfo.numPages;
       this.pdfDocument = new PDFDocumentProxy(pdfInfo, this, loadingTask);
+
       loadingTask._capability.resolve(this.pdfDocument);
     }, this);
     messageHandler.on('PasswordRequest', function (exception) {
       this._passwordCapability = (0, _util.createPromiseCapability)();
+
       if (loadingTask.onPassword) {
         const updatePassword = password => {
-          this._passwordCapability.resolve({ password });
+          this._passwordCapability.resolve({
+            password
+          });
         };
+
         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;
     }, this);
     messageHandler.on('PasswordException', function (exception) {
       loadingTask._capability.reject(new _util.PasswordException(exception.message, exception.code));
     }, this);
     messageHandler.on('InvalidPDF', function (exception) {
       loadingTask._capability.reject(new _util.InvalidPDFException(exception.message));
     }, this);
@@ -5079,357 +6254,467 @@ class WorkerTransport {
     }, this);
     messageHandler.on('DataLoaded', function (data) {
       if (loadingTask.onProgress) {
         loadingTask.onProgress({
           loaded: data.length,
           total: data.length
         });
       }
+
       this.downloadInfoCapability.resolve(data);
     }, this);
     messageHandler.on('StartRenderPage', function (data) {
       if (this.destroyed) {
         return;
       }
+
       const page = this.pageCache[data.pageIndex];
+
       page._stats.timeEnd('Page Request');
+
       page._startRenderPage(data.transparency, data.intent);
     }, this);
     messageHandler.on('RenderPageChunk', function (data) {
       if (this.destroyed) {
         return;
       }
+
       const page = this.pageCache[data.pageIndex];
+
       page._renderPageChunk(data.operatorList, data.intent);
     }, this);
     messageHandler.on('commonobj', function (data) {
       if (this.destroyed) {
         return;
       }
+
       const [id, type, exportedData] = data;
+
       if (this.commonObjs.has(id)) {
         return;
       }
+
       switch (type) {
         case 'Font':
           const params = this._params;
+
           if ('error' in exportedData) {
             const exportedError = exportedData.error;
             (0, _util.warn)(`Error during font loading: ${exportedError}`);
             this.commonObjs.resolve(id, exportedError);
             break;
           }
+
           let fontRegistry = null;
-          if (params.pdfBug && _global_scope2.default.FontInspector && _global_scope2.default.FontInspector.enabled) {
+
+          if (params.pdfBug && _global_scope.default.FontInspector && _global_scope.default.FontInspector.enabled) {
             fontRegistry = {
               registerFont(font, url) {
-                _global_scope2.default['FontInspector'].fontAdded(font, url);
+                _global_scope.default['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
           });
+
           const fontReady = fontObjs => {
             this.commonObjs.resolve(id, font);
           };
+
           this.fontLoader.bind([font], fontReady);
           break;
+
         case 'FontPath':
           this.commonObjs.resolve(id, exportedData);
           break;
+
         default:
           throw new Error(`Got unknown common object type ${type}`);
       }
     }, this);
     messageHandler.on('obj', function (data) {
       if (this.destroyed) {
         return;
       }
+
       const [id, pageIndex, type, imageData] = data;
       const pageProxy = this.pageCache[pageIndex];
+
       if (pageProxy.objs.has(id)) {
         return;
       }
+
       switch (type) {
         case 'JpegStream':
           return new Promise((resolve, reject) => {
             const img = new Image();
+
             img.onload = function () {
               resolve(img);
             };
+
             img.onerror = function () {
               reject(new Error('Error during JPEG image loading'));
             };
+
             img.src = imageData;
           }).then(img => {
             pageProxy.objs.resolve(id, img);
           });
+
         case 'Image':
           pageProxy.objs.resolve(id, imageData);
           const MAX_IMAGE_SIZE_TO_STORE = 8000000;
+
           if (imageData && 'data' in imageData && imageData.data.length > MAX_IMAGE_SIZE_TO_STORE) {
             pageProxy.cleanupAfterRender = true;
           }
+
           break;
+
         default:
           throw new Error(`Got unknown object type ${type}`);
       }
     }, this);
     messageHandler.on('DocProgress', function (data) {
       if (this.destroyed) {
         return;
       }
+
       if (loadingTask.onProgress) {
         loadingTask.onProgress({
           loaded: data.loaded,
           total: data.total
         });
       }
     }, this);
     messageHandler.on('PageError', function (data) {
       if (this.destroyed) {
         return;
       }
+
       const page = this.pageCache[data.pageNum - 1];
       const intentState = page.intentStates[data.intent];
+
       if (intentState.displayReadyCapability) {
         intentState.displayReadyCapability.reject(data.error);
       } else {
         throw new Error(data.error);
       }
+
       if (intentState.operatorList) {
         intentState.operatorList.lastChunk = true;
+
         for (let i = 0; i < intentState.renderTasks.length; i++) {
           intentState.renderTasks[i].operatorListChanged();
         }
       }
     }, this);
     messageHandler.on('UnsupportedFeature', this._onUnsupportedFeature, this);
     messageHandler.on('JpegDecode', function (data) {
       if (this.destroyed) {
         return Promise.reject(new Error('Worker was destroyed'));
       }
+
       if (typeof document === 'undefined') {
         return Promise.reject(new Error('"document" is not defined.'));
       }
+
       const [imageUrl, components] = data;
+
       if (components !== 3 && components !== 1) {
         return Promise.reject(new Error('Only 3 components or 1 component can be returned'));
       }
+
       return new Promise(function (resolve, reject) {
         const img = new Image();
+
         img.onload = function () {
           const width = img.width;
           const height = img.height;
           const size = width * height;
           const rgbaLength = size * 4;
           const buf = new Uint8ClampedArray(size * components);
           const tmpCanvas = document.createElement('canvas');
           tmpCanvas.width = width;
           tmpCanvas.height = height;
           const tmpCtx = tmpCanvas.getContext('2d');
           tmpCtx.drawImage(img, 0, 0);
           const data = tmpCtx.getImageData(0, 0, width, height).data;
+
           if (components === 3) {
             for (let i = 0, j = 0; i < rgbaLength; i += 4, j += 3) {
               buf[j] = data[i];
               buf[j + 1] = data[i + 1];
               buf[j + 2] = data[i + 2];
             }
           } else if (components === 1) {
             for (let i = 0, j = 0; i < rgbaLength; i += 4, j++) {
               buf[j] = data[i];
             }
           }
+
           resolve({
             data: buf,
             width,
             height
           });
         };
+
         img.onerror = function () {
           reject(new Error('JpegDecode failed to load image'));
         };
+
         img.src = imageUrl;
       });
     }, this);
     messageHandler.on('FetchBuiltInCMap', function (data) {
       if (this.destroyed) {
         return Promise.reject(new Error('Worker was destroyed'));
       }
-      return this.CMapReaderFactory.fetch({ name: data.name });
+
+      return this.CMapReaderFactory.fetch({
+        name: data.name
+      });
     }, this);
   }
-  _onUnsupportedFeature({ featureId }) {
+
+  _onUnsupportedFeature({
+    featureId
+  }) {
     if (this.destroyed) {
       return;
     }
+
     if (this.loadingTask.onUnsupportedFeature) {
       this.loadingTask.onUnsupportedFeature(featureId);
     }
   }
+
   getData() {
     return this.messageHandler.sendWithPromise('GetData', null);
   }
+
   getPage(pageNumber) {
     if (!Number.isInteger(pageNumber) || pageNumber <= 0 || pageNumber > this.numPages) {
       return Promise.reject(new Error('Invalid page request'));
     }
+
     const pageIndex = pageNumber - 1;
+
     if (pageIndex in this.pagePromises) {
       return this.pagePromises[pageIndex];
     }
-    const promise = this.messageHandler.sendWithPromise('GetPage', { pageIndex }).then(pageInfo => {
+
+    const promise = this.messageHandler.sendWithPromise('GetPage', {
+      pageIndex
+    }).then(pageInfo => {
       if (this.destroyed) {
         throw new Error('Transport destroyed');
       }
+
       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 this.messageHandler.sendWithPromise('GetPageIndex', {
+      ref
+    }).catch(function (reason) {
       return Promise.reject(new Error(reason));
     });
   }
+
   getAnnotations(pageIndex, intent) {
     return this.messageHandler.sendWithPromise('GetAnnotations', {
       pageIndex,
       intent
     });
   }
+
   getDestinations() {
     return this.messageHandler.sendWithPromise('GetDestinations', null);
   }
+
   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
+    });
+  }
+
   getPageLabels() {
     return this.messageHandler.sendWithPromise('GetPageLabels', null);
   }
+
   getPageMode() {
     return this.messageHandler.sendWithPromise('GetPageMode', null);
   }
+
   getAttachments() {
     return this.messageHandler.sendWithPromise('GetAttachments', null);
   }
+
   getJavaScript() {
     return this.messageHandler.sendWithPromise('GetJavaScript', null);
   }
+
   getOutline() {
     return this.messageHandler.sendWithPromise('GetOutline', null);
   }
+
   getPermissions() {
     return this.messageHandler.sendWithPromise('GetPermissions', null);
   }
+
   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
       };
     });
   }
+
   getStats() {
     return this.messageHandler.sendWithPromise('GetStats', null);
   }
+
   startCleanup() {
     this.messageHandler.sendWithPromise('Cleanup', null).then(() => {
       for (let i = 0, ii = this.pageCache.length; i < ii; i++) {
         const page = this.pageCache[i];
+
         if (page) {
           page.cleanup();
         }
       }
+
       this.commonObjs.clear();
       this.fontLoader.clear();
     });
   }
+
   get loadingParams() {
     const params = this._params;
     return (0, _util.shadow)(this, 'loadingParams', {
       disableAutoFetch: params.disableAutoFetch,
       disableCreateObjectURL: params.disableCreateObjectURL,
       disableFontFace: params.disableFontFace,
       nativeImageDecoderSupport: params.nativeImageDecoderSupport
     });
   }
-}
+
+}
+
 class PDFObjects {
   constructor() {
     this._objs = Object.create(null);
   }
+
   _ensureObj(objId) {
     if (this._objs[objId]) {
       return this._objs[objId];
     }
+
     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;
     }
+
     const obj = this._objs[objId];
+
     if (!obj || !obj.resolved) {
       throw new Error(`Requesting object that isn't resolved yet ${objId}.`);
     }
+
     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);
   }
-}
+
+}
+
 class RenderTask {
   constructor(internalRenderTask) {
     this._internalRenderTask = internalRenderTask;
     this.onContinue = null;
   }
+
   get promise() {
     return this._internalRenderTask.capability.promise;
   }
+
   cancel() {
     this._internalRenderTask.cancel();
   }
+
   then(onFulfilled, onRejected) {
     (0, _util.deprecated)('RenderTask.then method, use the `promise` getter instead.');
     return this.promise.then.apply(this.promise, arguments);
   }
-}
+
+}
+
 const InternalRenderTask = function InternalRenderTaskClosure() {
   const canvasInRendering = new WeakSet();
+
   class InternalRenderTask {
-    constructor({ callback, params, objs, commonObjs, operatorList, pageNumber, canvasFactory, webGLContext, useRequestAnimationFrame = false, pdfBug = false }) {
+    constructor({
+      callback,
+      params,
+      objs,
+      commonObjs,
+      operatorList,
+      pageNumber,
+      canvasFactory,
+      webGLContext,
+      useRequestAnimationFrame = false,
+      pdfBug = false
+    }) {
       this.callback = callback;
       this.params = params;
       this.objs = objs;
       this.commonObjs = commonObjs;
       this.operatorListIdx = null;
       this.operatorList = operatorList;
       this.pageNumber = pageNumber;
       this.canvasFactory = canvasFactory;
@@ -5442,642 +6727,823 @@ const InternalRenderTask = function Inte
       this.cancelled = false;
       this.capability = (0, _util.createPromiseCapability)();
       this.task = new RenderTask(this);
       this._continueBound = this._continue.bind(this);
       this._scheduleNextBound = this._scheduleNext.bind(this);
       this._nextBound = this._next.bind(this);
       this._canvas = params.canvasContext.canvas;
     }
+
     initializeGraphics(transparency = false) {
       if (this.cancelled) {
         return;
       }
+
       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.');
         }
+
         canvasInRendering.add(this._canvas);
       }
-      if (this._pdfBug && _global_scope2.default.StepperManager && _global_scope2.default.StepperManager.enabled) {
-        this.stepper = _global_scope2.default.StepperManager.create(this.pageNumber - 1);
+
+      if (this._pdfBug && _global_scope.default.StepperManager && _global_scope.default.StepperManager.enabled) {
+        this.stepper = _global_scope.default.StepperManager.create(this.pageNumber - 1);
         this.stepper.init(this.operatorList);
         this.stepper.nextBreakPoint = this.stepper.getNextBreakPoint();
       }
-      const { canvasContext, viewport, transform, imageLayer, background } = this.params;
+
+      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.graphicsReadyCallback) {
         this.graphicsReadyCallback();
       }
     }
+
     cancel() {
       this.running = false;
       this.cancelled = true;
+
       if (this.gfx) {
         this.gfx.endDrawing();
       }
+
       if (this._canvas) {
         canvasInRendering.delete(this._canvas);
       }
+
       this.callback(new _dom_utils.RenderingCancelledException('Rendering cancelled, page ' + this.pageNumber, 'canvas'));
     }
+
     operatorListChanged() {
       if (!this.graphicsReady) {
         if (!this.graphicsReadyCallback) {
           this.graphicsReadyCallback = this._continueBound;
         }
+
         return;
       }
+
       if (this.stepper) {
         this.stepper.updateOperatorList(this.operatorList);
       }
+
       if (this.running) {
         return;
       }
+
       this._continue();
     }
+
     _continue() {
       this.running = true;
+
       if (this.cancelled) {
         return;
       }
+
       if (this.task.onContinue) {
         this.task.onContinue(this._scheduleNextBound);
       } else {
         this._scheduleNext();
       }
     }
+
     _scheduleNext() {
       if (this._useRequestAnimationFrame) {
         window.requestAnimationFrame(() => {
           this._nextBound().catch(this.callback);
         });
       } else {
         Promise.resolve().then(this._nextBound).catch(this.callback);
       }
     }
+
     async _next() {
       if (this.cancelled) {
         return;
       }
+
       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();
         }
       }
     }
-  }
+
+  }
+
   return InternalRenderTask;
 }();
-const version = '2.1.70';
-const build = '6ebdbb24';
-exports.getDocument = getDocument;
-exports.LoopbackPort = LoopbackPort;
-exports.PDFDataRangeTransport = PDFDataRangeTransport;
-exports.PDFWorker = PDFWorker;
-exports.PDFDocumentProxy = PDFDocumentProxy;
-exports.PDFPageProxy = PDFPageProxy;
-exports.setPDFNetworkStreamFactory = setPDFNetworkStreamFactory;
+
+const version = '2.1.86';
 exports.version = version;
+const build = '1cb7cc9b';
 exports.build = build;
 
 /***/ }),
 /* 8 */
 /***/ (function(module, exports, __w_pdfjs_require__) {
 
 "use strict";
 
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.loadScript = exports.DummyStatTimer = exports.StatTimer = exports.DOMSVGFactory = exports.DOMCMapReaderFactory = exports.DOMCanvasFactory = exports.DEFAULT_LINK_REL = exports.LinkTarget = exports.getFilenameFromUrl = exports.addLinkAttributes = exports.RenderingCancelledException = exports.PageViewport = undefined;
+exports.addLinkAttributes = addLinkAttributes;
+exports.getFilenameFromUrl = getFilenameFromUrl;
+exports.loadScript = loadScript;
+exports.DummyStatTimer = 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__(1);
 
 const DEFAULT_LINK_REL = 'noopener noreferrer nofollow';
+exports.DEFAULT_LINK_REL = DEFAULT_LINK_REL;
 const SVG_NS = 'http://www.w3.org/2000/svg';
+
 class DOMCanvasFactory {
   create(width, height) {
     if (width <= 0 || height <= 0) {
       throw new Error('invalid canvas size');
     }
+
     let canvas = document.createElement('canvas');
     let context = canvas.getContext('2d');
     canvas.width = width;
     canvas.height = height;
     return {
       canvas,
       context
     };
   }
+
   reset(canvasAndContext, width, height) {
     if (!canvasAndContext.canvas) {
       throw new Error('canvas is not specified');
     }
+
     if (width <= 0 || height <= 0) {
       throw new Error('invalid canvas size');
     }
+
     canvasAndContext.canvas.width = width;
     canvasAndContext.canvas.height = height;
   }
+
   destroy(canvasAndContext) {
     if (!canvasAndContext.canvas) {
       throw new Error('canvas is not specified');
     }
+
     canvasAndContext.canvas.width = 0;
     canvasAndContext.canvas.height = 0;
     canvasAndContext.canvas = null;
     canvasAndContext.context = null;
   }
-}
+
+}
+
+exports.DOMCanvasFactory = DOMCanvasFactory;
+
 class DOMCMapReaderFactory {
-  constructor({ baseUrl = null, isCompressed = false }) {
+  constructor({
+    baseUrl = null,
+    isCompressed = false
+  }) {
     this.baseUrl = baseUrl;
     this.isCompressed = isCompressed;
   }
-  fetch({ name }) {
+
+  fetch({
+    name
+  }) {
     if (!this.baseUrl) {
       return Promise.reject(new Error('The CMap "baseUrl" parameter must be specified, ensure that ' + 'the "cMapUrl" and "cMapPacked" API parameters are provided.'));
     }
+
     if (!name) {
       return Promise.reject(new Error('CMap name must be specified.'));
     }
+
     return new Promise((resolve, reject) => {
       let url = this.baseUrl + name + (this.isCompressed ? '.bcmap' : '');
       let request = new XMLHttpRequest();
       request.open('GET', url, true);
+
       if (this.isCompressed) {
         request.responseType = 'arraybuffer';
       }
+
       request.onreadystatechange = () => {
         if (request.readyState !== XMLHttpRequest.DONE) {
           return;
         }
+
         if (request.status === 200 || request.status === 0) {
           let data;
+
           if (this.isCompressed && request.response) {
             data = new Uint8Array(request.response);
           } else if (!this.isCompressed && request.responseText) {
             data = (0, _util.stringToBytes)(request.responseText);
           }
+
           if (data) {
             resolve({
               cMapData: data,
               compressionType: this.isCompressed ? _util.CMapCompressionType.BINARY : _util.CMapCompressionType.NONE
             });
             return;
           }
         }
+
         reject(new Error('Unable to load ' + (this.isCompressed ? 'binary ' : '') + 'CMap at: ' + url));
       };
+
       request.send(null);
     });
   }
-}
+
+}
+
+exports.DOMCMapReaderFactory = DOMCMapReaderFactory;
+
 class DOMSVGFactory {
   create(width, height) {
     (0, _util.assert)(width > 0 && height > 0, 'Invalid SVG dimensions');
     let 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);
   }
-}
+
+}
+
+exports.DOMSVGFactory = DOMSVGFactory;
+
 class PageViewport {
-  constructor({ viewBox, scale, rotation, offsetX = 0, offsetY = 0, dontFlip = false }) {
+  constructor({
+    viewBox,
+    scale,
+    rotation,
+    offsetX = 0,
+    offsetY = 0,
+    dontFlip = false
+  }) {
     this.viewBox = viewBox;
     this.scale = scale;
     this.rotation = rotation;
     this.offsetX = offsetX;
     this.offsetY = offsetY;
     let centerX = (viewBox[2] + viewBox[0]) / 2;
     let centerY = (viewBox[3] + viewBox[1]) / 2;
     let rotateA, rotateB, rotateC, rotateD;
     rotation = rotation % 360;
     rotation = rotation < 0 ? rotation + 360 : rotation;
+
     switch (rotation) {
       case 180:
         rotateA = -1;
         rotateB = 0;
         rotateC = 0;
         rotateD = 1;
         break;
+
       case 90:
         rotateA = 0;
         rotateB = 1;
         rotateC = 1;
         rotateD = 0;
         break;
+
       case 270:
         rotateA = 0;
         rotateB = -1;
         rotateC = -1;
         rotateD = 0;
         break;
+
       default:
         rotateA = 1;
         rotateB = 0;
         rotateC = 0;
         rotateD = -1;
         break;
     }
+
     if (dontFlip) {
       rotateC = -rotateC;
       rotateD = -rotateD;
     }
+
     let offsetCanvasX, offsetCanvasY;
     let width, height;
+
     if (rotateA === 0) {
       offsetCanvasX = Math.abs(centerY - viewBox[1]) * scale + offsetX;
       offsetCanvasY = Math.abs(centerX - viewBox[0]) * scale + offsetY;
       width = Math.abs(viewBox[3] - viewBox[1]) * scale;
       height = Math.abs(viewBox[2] - viewBox[0]) * scale;
     } else {
       offsetCanvasX = Math.abs(centerX - viewBox[0]) * scale + offsetX;
       offsetCanvasY = Math.abs(centerY - viewBox[1]) * scale + offsetY;
       width = Math.abs(viewBox[2] - viewBox[0]) * scale;
       height = Math.abs(viewBox[3] - viewBox[1]) * scale;
     }
+
     this.transform = [rotateA * scale, rotateB * scale, rotateC * scale, rotateD * scale, offsetCanvasX - rotateA * scale * centerX - rotateC * scale * centerY, offsetCanvasY - rotateB * scale * centerX - rotateD * scale * centerY];
     this.width = width;
     this.height = height;
   }
-  clone({ scale = this.scale, rotation = this.rotation, dontFlip = false } = {}) {
+
+  clone({
+    scale = this.scale,
+    rotation = this.rotation,
+    dontFlip = false
+  } = {}) {
     return new PageViewport({
       viewBox: this.viewBox.slice(),
       scale,
       rotation,
       offsetX: this.offsetX,
       offsetY: this.offsetY,
       dontFlip
     });
   }
+
   convertToViewportPoint(x, y) {
     return _util.Util.applyTransform([x, y], this.transform);
   }
+
   convertToViewportRectangle(rect) {
     let tl = _util.Util.applyTransform([rect[0], rect[1]], this.transform);
+
     let br = _util.Util.applyTransform([rect[2], rect[3]], this.transform);
+
     return [tl[0], tl[1], br[0], br[1]];
   }
+
   convertToPdfPoint(x, y) {
     return _util.Util.applyInverseTransform([x, y], this.transform);
   }
-}
+
+}
+
+exports.PageViewport = PageViewport;
+
 var RenderingCancelledException = function RenderingCancelledException() {
   function RenderingCancelledException(msg, type) {
     this.message = msg;
     this.type = type;
   }
+
   RenderingCancelledException.prototype = new Error();
   RenderingCancelledException.prototype.name = 'RenderingCancelledException';
   RenderingCancelledException.constructor = RenderingCancelledException;
   return RenderingCancelledException;
 }();
+
+exports.RenderingCancelledException = RenderingCancelledException;
 const LinkTarget = {
   NONE: 0,
   SELF: 1,
   BLANK: 2,
   PARENT: 3,
   TOP: 4
 };
+exports.LinkTarget = LinkTarget;
 const LinkTargetStringMap = ['', '_self', '_blank', '_parent', '_top'];
-function addLinkAttributes(link, { url, target, rel } = {}) {
+
+function addLinkAttributes(link, {
+  url,
+  target,
+  rel
+} = {}) {
   link.href = link.title = url ? (0, _util.removeNullCharacters)(url) : '';
+
   if (url) {
     const LinkTargetValues = Object.values(LinkTarget);
     let targetIndex = LinkTargetValues.includes(target) ? target : LinkTarget.NONE;
     link.target = LinkTargetStringMap[targetIndex];
     link.rel = typeof rel === 'string' ? rel : DEFAULT_LINK_REL;
   }
 }
+
 function getFilenameFromUrl(url) {
   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(enable = true) {
     this.enabled = !!enable;
     this.started = Object.create(null);
     this.times = [];
   }
+
   time(name) {
     if (!this.enabled) {
       return;
     }
+
     if (name in this.started) {
       (0, _util.warn)('Timer is already running for ' + name);
     }
+
     this.started[name] = Date.now();
   }
+
   timeEnd(name) {
     if (!this.enabled) {
       return;
     }
+
     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];
   }
+
   toString() {
     let times = this.times;
     let out = '',
         longest = 0;
+
     for (let i = 0, ii = times.length; i < ii; ++i) {
       let name = times[i]['name'];
+
       if (name.length > longest) {
         longest = name.length;
       }
     }
+
     for (let i = 0, ii = times.length; i < ii; ++i) {
       let span = times[i];
       let duration = span.end - span.start;
       out += `${span['name'].padEnd(longest)} ${duration}ms\n`;
     }
+
     return out;
   }
-}
+
+}
+
+exports.StatTimer = StatTimer;
+
 class DummyStatTimer {
   constructor() {
     (0, _util.unreachable)('Cannot initialize DummyStatTimer.');
   }
+
   static time(name) {}
+
   static timeEnd(name) {}
+
   static toString() {
     return '';
   }
-}
+
+}
+
+exports.DummyStatTimer = DummyStatTimer;
+
 function loadScript(src) {
   return new Promise((resolve, reject) => {
     let script = document.createElement('script');
     script.src = src;
     script.onload = resolve;
+
     script.onerror = function () {
       reject(new Error(`Cannot load script at: ${script.src}`));
     };
+
     (document.head || document.documentElement).appendChild(script);
   });
 }
-exports.PageViewport = PageViewport;
-exports.RenderingCancelledException = RenderingCancelledException;
-exports.addLinkAttributes = addLinkAttributes;
-exports.getFilenameFromUrl = getFilenameFromUrl;
-exports.LinkTarget = LinkTarget;
-exports.DEFAULT_LINK_REL = DEFAULT_LINK_REL;
-exports.DOMCanvasFactory = DOMCanvasFactory;
-exports.DOMCMapReaderFactory = DOMCMapReaderFactory;
-exports.DOMSVGFactory = DOMSVGFactory;
-exports.StatTimer = StatTimer;
-exports.DummyStatTimer = DummyStatTimer;
-exports.loadScript = loadScript;
 
 /***/ }),
 /* 9 */
 /***/ (function(module, exports, __w_pdfjs_require__) {
 
 "use strict";
 
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.FontLoader = exports.FontFaceObject = undefined;
+exports.FontLoader = exports.FontFaceObject = void 0;
 
 var _util = __w_pdfjs_require__(1);
 
 class BaseFontLoader {
   constructor(docId) {
     if (this.constructor === BaseFontLoader) {
       (0, _util.unreachable)('Cannot initialize BaseFontLoader.');
     }
+
     this.docId = docId;
     this.nativeFontFaces = [];
     this.styleElement = null;
     this.loadingContext = {
       requests: [],
       nextRequestId: 0
     };
   }
+
   addNativeFontFace(nativeFontFace) {
     this.nativeFontFaces.push(nativeFontFace);
     document.fonts.add(nativeFontFace);
   }
+
   insertRule(rule) {
     let styleElement = this.styleElement;
+
     if (!styleElement) {
       styleElement = this.styleElement = document.createElement('style');
       styleElement.id = `PDFJS_FONT_STYLE_TAG_${this.docId}`;
       document.documentElement.getElementsByTagName('head')[0].appendChild(styleElement);
     }
+
     const styleSheet = styleElement.sheet;
     styleSheet.insertRule(rule, styleSheet.cssRules.length);
   }
+
   clear() {
     this.nativeFontFaces.forEach(function (nativeFontFace) {
       document.fonts.delete(nativeFontFace);
     });
     this.nativeFontFaces.length = 0;
+
     if (this.styleElement) {
       this.styleElement.remove();
       this.styleElement = null;
     }
   }
+
   bind(fonts, callback) {
     const rules = [];
     const fontsToLoad = [];
     const fontLoadPromises = [];
+
     const getNativeFontPromise = function (nativeFontFace) {
       return nativeFontFace.loaded.catch(function (reason) {
         (0, _util.warn)(`Failed to load font "${nativeFontFace.family}": ${reason}`);
       });
     };
+
     for (const font of fonts) {
       if (font.attached || font.missingFile) {
         continue;
       }
+
       font.attached = true;
+
       if (this.isFontLoadingAPISupported) {
         const nativeFontFace = font.createNativeFontFace();
+
         if (nativeFontFace) {
           this.addNativeFontFace(nativeFontFace);
           fontLoadPromises.push(getNativeFontPromise(nativeFontFace));
         }
       } else {
         const rule = font.createFontFaceRule();
+
         if (rule) {
           this.insertRule(rule);
           rules.push(rule);
           fontsToLoad.push(font);
         }
       }
     }
+
     const request = this._queueLoadingCallback(callback);
+
     if (this.isFontLoadingAPISupported) {
       Promise.all(fontLoadPromises).then(request.complete);
     } else if (rules.length > 0 && !this.isSyncFontLoadingSupported) {
       this._prepareFontLoadEvent(rules, fontsToLoad, request);
     } else {
       request.complete();
     }
   }
+
   _queueLoadingCallback(callback) {
     function completeRequest() {
       (0, _util.assert)(!request.done, 'completeRequest() cannot be called twice.');
       request.done = true;
+
       while (context.requests.length > 0 && context.requests[0].done) {
         const otherRequest = context.requests.shift();
         setTimeout(otherRequest.callback, 0);
       }
     }
+
     const context = this.loadingContext;
     const request = {
       id: `pdfjs-font-loading-${context.nextRequestId++}`,
       done: false,
       complete: completeRequest,
       callback
     };
     context.requests.push(request);
     return request;
   }
+
   get isFontLoadingAPISupported() {
     (0, _util.unreachable)('Abstract method `isFontLoadingAPISupported`.');
   }
+
   get isSyncFontLoadingSupported() {
     (0, _util.unreachable)('Abstract method `isSyncFontLoadingSupported`.');
   }
+
   get _loadTestFont() {
     (0, _util.unreachable)('Abstract method `_loadTestFont`.');
   }
+
   _prepareFontLoadEvent(rules, fontsToLoad, request) {
     (0, _util.unreachable)('Abstract method `_prepareFontLoadEvent`.');
   }
-}
+
+}
+
 let FontLoader;
+exports.FontLoader = FontLoader;
 {
   exports.FontLoader = FontLoader = class MozcentralFontLoader extends BaseFontLoader {
     get isFontLoadingAPISupported() {
       return (0, _util.shadow)(this, 'isFontLoadingAPISupported', typeof document !== 'undefined' && !!document.fonts);
     }
+
     get isSyncFontLoadingSupported() {
       return (0, _util.shadow)(this, 'isSyncFontLoadingSupported', true);
     }
+
   };
 }
 const IsEvalSupportedCached = {
   get value() {
     return (0, _util.shadow)(this, 'value', (0, _util.isEvalSupported)());
   }
+
 };
+
 class FontFaceObject {
-  constructor(translatedData, { isEvalSupported = true, disableFontFace = false, ignoreErrors = false, onUnsupportedFeature = null, fontRegistry = null }) {
+  constructor(translatedData, {
+    isEvalSupported = true,
+    disableFontFace = false,
+    ignoreErrors = false,
+    onUnsupportedFeature = null,
+    fontRegistry = null
+  }) {
     this.compiledGlyphs = Object.create(null);
+
     for (let i in translatedData) {
       this[i] = translatedData[i];
     }
+
     this.isEvalSupported = isEvalSupported !== false;
     this.disableFontFace = disableFontFace === true;
     this.ignoreErrors = ignoreErrors === true;
     this._onUnsupportedFeature = onUnsupportedFeature;
     this.fontRegistry = fontRegistry;
   }
+
   createNativeFontFace() {
     if (!this.data || this.disableFontFace) {
       return null;
     }
+
     const nativeFontFace = new FontFace(this.loadedName, this.data, {});
+
     if (this.fontRegistry) {
       this.fontRegistry.registerFont(this);
     }
+
     return nativeFontFace;
   }
+
   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);
     }
+
     return rule;
   }
+
   getPathGenerator(objs, character) {
     if (this.compiledGlyphs[character] !== undefined) {
       return this.compiledGlyphs[character];
     }
+
     let cmds, current;
+
     try {
       cmds = objs.get(this.loadedName + '_path_' + character);
     } catch (ex) {
       if (!this.ignoreErrors) {
         throw ex;
       }
+
       if (this._onUnsupportedFeature) {
-        this._onUnsupportedFeature({ featureId: _util.UNSUPPORTED_FEATURES.font });
-      }
+        this._onUnsupportedFeature({
+          featureId: _util.UNSUPPORTED_FEATURES.font
+        });
+      }
+
       (0, _util.warn)(`getPathGenerator - ignoring character: "${ex}".`);
       return this.compiledGlyphs[character] = function (c, size) {};
     }
+
     if (this.isEvalSupported && IsEvalSupportedCached.value) {
       let args,
           js = '';
+
       for (let i = 0, ii = cmds.length; i < ii; i++) {
         current = cmds[i];
+
         if (current.args !== undefined) {
           args = current.args.join(',');
         } else {
           args = '';
         }
+
         js += 'c.' + current.cmd + '(' + args + ');\n';
       }
+
       return this.compiledGlyphs[character] = new Function('c', 'size', js);
     }
+
     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];
         }
+
         c[current.cmd].apply(c, current.args);
       }
     };
   }
-}
+
+}
+
 exports.FontFaceObject = FontFaceObject;
-exports.FontLoader = FontLoader;
 
 /***/ }),
 /* 10 */
 /***/ (function(module, exports, __w_pdfjs_require__) {
 
 "use strict";
 
 
@@ -6090,34 +7556,36 @@ exports.apiCompatibilityParams = Object.
 /***/ (function(module, exports, __w_pdfjs_require__) {
 
 "use strict";
 
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.CanvasGraphics = undefined;
+exports.CanvasGraphics = void 0;
 
 var _util = __w_pdfjs_require__(1);
 
 var _pattern_helper = __w_pdfjs_require__(12);
 
 var MIN_FONT_SIZE = 16;
 var MAX_FONT_SIZE = 100;
 var MAX_GROUP_SIZE = 4096;
 var MIN_WIDTH_FACTOR = 0.65;
 var COMPILE_TYPE3_GLYPHS = true;
 var MAX_SIZE_TO_COMPILE = 1000;
 var FULL_CHUNK_HEIGHT = 16;
 var IsLittleEndianCached = {
   get value() {
     return (0, _util.shadow)(IsLittleEndianCached, 'value', (0, _util.isLittleEndian)());
   }
+
 };
+
 function addContextCurrentTransform(ctx) {
   if (!ctx.mozCurrentTransform) {
     ctx._originalSave = ctx.save;
     ctx._originalRestore = ctx.restore;
     ctx._originalRotate = ctx.rotate;
     ctx._originalScale = ctx.scale;
     ctx._originalTranslate = ctx.translate;
     ctx._originalTransform = ctx.transform;
@@ -6138,229 +7606,292 @@ function addContextCurrentTransform(ctx)
             d = m[3],
             e = m[4],
             f = m[5];
         var ad_bc = a * d - b * c;
         var bc_ad = b * c - a * d;
         return [d / ad_bc, b / bc_ad, c / bc_ad, a / ad_bc, (d * e - c * f) / bc_ad, (b * e - a * f) / ad_bc];
       }
     });
+
     ctx.save = function ctxSave() {
       var old = this._transformMatrix;
+
       this._transformStack.push(old);
+
       this._transformMatrix = old.slice(0, 6);
+
       this._originalSave();
     };
+
     ctx.restore = function ctxRestore() {
       var prev = this._transformStack.pop();
+
       if (prev) {
         this._transformMatrix = prev;
+
         this._originalRestore();
       }
     };
+
     ctx.translate = function ctxTranslate(x, y) {
       var m = this._transformMatrix;
       m[4] = m[0] * x + m[2] * y + m[4];
       m[5] = m[1] * x + m[3] * y + m[5];
+
       this._originalTranslate(x, y);
     };
+
     ctx.scale = function ctxScale(x, y) {
       var m = this._transformMatrix;
       m[0] = m[0] * x;
       m[1] = m[1] * x;
       m[2] = m[2] * y;
       m[3] = m[3] * y;
+
       this._originalScale(x, y);
     };
+
     ctx.transform = function ctxTransform(a, b, c, d, e, f) {
       var m = this._transformMatrix;
       this._transformMatrix = [m[0] * a + m[2] * b, m[1] * a + m[3] * b, m[0] * c + m[2] * d, m[1] * c + m[3] * d, m[0] * e + m[2] * f + m[4], m[1] * e + m[3] * f + m[5]];
+
       ctx._originalTransform(a, b, c, d, e, f);
     };
+
     ctx.setTransform = function ctxSetTransform(a, b, c, d, e, f) {
       this._transformMatrix = [a, b, c, d, e, f];
+
       ctx._originalSetTransform(a, b, c, d, e, f);
     };
+
     ctx.rotate = function ctxRotate(angle) {
       var cosValue = Math.cos(angle);
       var sinValue = Math.sin(angle);
       var m = this._transformMatrix;
       this._transformMatrix = [m[0] * cosValue + m[2] * sinValue, m[1] * cosValue + m[3] * sinValue, m[0] * -sinValue + m[2] * cosValue, m[1] * -sinValue + m[3] * cosValue, m[4], m[5]];
+
       this._originalRotate(angle);
     };
   }
 }
+
 var CachedCanvases = function CachedCanvasesClosure() {
   function CachedCanvases(canvasFactory) {
     this.canvasFactory = canvasFactory;
     this.cache = Object.create(null);
   }
+
   CachedCanvases.prototype = {
     getCanvas: function CachedCanvases_getCanvas(id, width, height, trackTransform) {
       var canvasEntry;
+
       if (this.cache[id] !== undefined) {
         canvasEntry = this.cache[id];
         this.canvasFactory.reset(canvasEntry, width, height);
         canvasEntry.context.setTransform(1, 0, 0, 1, 0, 0);
       } else {
         canvasEntry = this.canvasFactory.create(width, height);
         this.cache[id] = canvasEntry;
       }
+
       if (trackTransform) {
         addContextCurrentTransform(canvasEntry.context);
       }
+
       return canvasEntry;
     },
+
     clear() {
       for (var id in this.cache) {
         var canvasEntry = this.cache[id];
         this.canvasFactory.destroy(canvasEntry);
         delete this.cache[id];
       }
     }
+
   };
   return CachedCanvases;
 }();
+
 function compileType3Glyph(imgData) {
   var POINT_TO_PROCESS_LIMIT = 1000;
   var width = imgData.width,
       height = imgData.height;
   var i,
       j,
       j0,
       width1 = width + 1;
   var points = new Uint8Array(width1 * (height + 1));
   var POINT_TYPES = new Uint8Array([0, 2, 4, 0, 1, 0, 5, 4, 8, 10, 0, 8, 0, 2, 1, 0]);
   var lineSize = width + 7 & ~7,
       data0 = imgData.data;
   var data = new Uint8Array(lineSize * height),
       pos = 0,
       ii;
+
   for (i = 0, ii = data0.length; i < ii; i++) {
     var mask = 128,
         elem = data0[i];
+
     while (mask > 0) {
       data[pos++] = elem & mask ? 0 : 255;
       mask >>= 1;
     }
   }
+
   var count = 0;
   pos = 0;
+
   if (data[pos] !== 0) {
     points[0] = 1;
     ++count;
   }
+
   for (j = 1; j < width; j++) {
     if (data[pos] !== data[pos + 1]) {
       points[j] = data[pos] ? 2 : 1;
       ++count;
     }
+
     pos++;
   }
+
   if (data[pos] !== 0) {
     points[j] = 2;
     ++count;
   }
+
   for (i = 1; i < height; i++) {
     pos = i * lineSize;
     j0 = i * width1;
+
     if (data[pos - lineSize] !== data[pos]) {
       points[j0] = data[pos] ? 1 : 8;
       ++count;
     }
+
     var sum = (data[pos] ? 4 : 0) + (data[pos - lineSize] ? 8 : 0);
+
     for (j = 1; j < width; j++) {
       sum = (sum >> 2) + (data[pos + 1] ? 4 : 0) + (data[pos - lineSize + 1] ? 8 : 0);
+
       if (POINT_TYPES[sum]) {
         points[j0 + j] = POINT_TYPES[sum];
         ++count;
       }
+
       pos++;
     }
+
     if (data[pos - lineSize] !== data[pos]) {
       points[j0 + j] = data[pos] ? 2 : 4;
       ++count;
     }
+
     if (count > POINT_TO_PROCESS_LIMIT) {
       return null;
     }
   }
+
   pos = lineSize * (height - 1);
   j0 = i * width1;
+
   if (data[pos] !== 0) {
     points[j0] = 8;
     ++count;
   }
+
   for (j = 1; j < width; j++) {
     if (data[pos] !== data[pos + 1]) {
       points[j0 + j] = data[pos] ? 4 : 8;
       ++count;
     }
+
     pos++;
   }
+
   if (data[pos] !== 0) {
     points[j0 + j] = 4;
     ++count;
   }
+
   if (count > POINT_TO_PROCESS_LIMIT) {
     return null;
   }
+
   var steps = new Int32Array([0, width1, -1, 0, -width1, 0, 0, 0, 1]);
   var outlines = [];
+
   for (i = 0; count && i <= height; i++) {
     var p = i * width1;
     var end = p + width;
+
     while (p < end && !points[p]) {
       p++;
     }
+
     if (p === end) {
       continue;
     }
+
     var coords = [p % width1, i];
     var type = points[p],
         p0 = p,
         pp;
+
     do {
       var step = steps[type];
+
       do {
         p += step;
       } while (!points[p]);
+
       pp = points[p];
+
       if (pp !== 5 && pp !== 10) {
         type = pp;
         points[p] = 0;
       } else {
         type = pp & 0x33 * type >> 4;
         points[p] &= type >> 2 | type << 2;
       }
+
       coords.push(p % width1);
       coords.push(p / width1 | 0);
       --count;
     } while (p0 !== p);
+
     outlines.push(coords);
     --i;
   }
+
   var drawOutline = function (c) {
     c.save();
     c.scale(1 / width, -1 / height);
     c.translate(0, -height);
     c.beginPath();
+
     for (var i = 0, ii = outlines.length; i < ii; i++) {
       var o = outlines[i];
       c.moveTo(o[0], o[1]);
+
       for (var j = 2, jj = o.length; j < jj; j += 2) {
         c.lineTo(o[j], o[j + 1]);
       }
     }
+
     c.fill();
     c.beginPath();
     c.restore();
   };
+
   return drawOutline;
 }
+
 var CanvasExtraState = function CanvasExtraStateClosure() {
   function CanvasExtraState() {
     this.alphaIsShape = false;
     this.fontSize = 0;
     this.fontSizeScale = 1;
     this.textMatrix = _util.IDENTITY_MATRIX;
     this.textMatrixScale = 1;
     this.fontMatrix = _util.FONT_IDENTITY_MATRIX;
@@ -6378,30 +7909,33 @@ var CanvasExtraState = function CanvasEx
     this.strokeColor = '#000000';
     this.patternFill = false;
     this.fillAlpha = 1;
     this.strokeAlpha = 1;
     this.lineWidth = 1;
     this.activeSMask = null;
     this.resumeSMaskCtx = null;
   }
+
   CanvasExtraState.prototype = {
     clone: function CanvasExtraState_clone() {
       return Object.create(this);
     },
     setCurrentPoint: function CanvasExtraState_setCurrentPoint(x, y) {
       this.x = x;
       this.y = y;
     }
   };
   return CanvasExtraState;
 }();
+
 var CanvasGraphics = function CanvasGraphicsClosure() {
   var EXECUTION_TIME = 15;
   var EXECUTION_STEPS = 10;
+
   function CanvasGraphics(canvasCtx, commonObjs, objs, canvasFactory, webGLContext, imageLayer) {
     this.ctx = canvasCtx;
     this.current = new CanvasExtraState();
     this.stateStack = [];
     this.pendingClip = null;
     this.pendingEOFill = false;
     this.res = null;
     this.xobjs = null;
@@ -6414,340 +7948,413 @@ var CanvasGraphics = function CanvasGrap
     this.processingType3 = null;
     this.baseTransform = null;
     this.baseTransformStack = [];
     this.groupLevel = 0;
     this.smaskStack = [];
     this.smaskCounter = 0;
     this.tempSMask = null;
     this.cachedCanvases = new CachedCanvases(this.canvasFactory);
+
     if (canvasCtx) {
       addContextCurrentTransform(canvasCtx);
     }
+
     this._cachedGetSinglePixelWidth = null;
   }
+
   function putBinaryImageData(ctx, imgData) {
     if (typeof ImageData !== 'undefined' && imgData instanceof ImageData) {
       ctx.putImageData(imgData, 0, 0);
       return;
     }
+
     var height = imgData.height,
         width = imgData.width;
     var partialChunkHeight = height % FULL_CHUNK_HEIGHT;
     var fullChunks = (height - partialChunkHeight) / FULL_CHUNK_HEIGHT;
     var totalChunks = partialChunkHeight === 0 ? fullChunks : fullChunks + 1;
     var chunkImgData = ctx.createImageData(width, FULL_CHUNK_HEIGHT);
     var srcPos = 0,
         destPos;
     var src = imgData.data;
     var dest = chunkImgData.data;
     var i, j, thisChunkHeight, elemsInThisChunk;
+
     if (imgData.kind === _util.ImageKind.GRAYSCALE_1BPP) {
       var srcLength = src.byteLength;
       var dest32 = new Uint32Array(dest.buffer, 0, dest.byteLength >> 2);
       var dest32DataLength = dest32.length;
       var fullSrcDiff = width + 7 >> 3;
       var white = 0xFFFFFFFF;
       var black = IsLittleEndianCached.value ? 0xFF000000 : 0x000000FF;
+
       for (i = 0; i < totalChunks; i++) {
         thisChunkHeight = i < fullChunks ? FULL_CHUNK_HEIGHT : partialChunkHeight;
         destPos = 0;
+
         for (j = 0; j < thisChunkHeight; j++) {
           var srcDiff = srcLength - srcPos;
           var k = 0;
           var kEnd = srcDiff > fullSrcDiff ? width : srcDiff * 8 - 7;
           var kEndUnrolled = kEnd & ~7;
           var mask = 0;
           var srcByte = 0;
+
           for (; k < kEndUnrolled; k += 8) {
             srcByte = src[srcPos++];
             dest32[destPos++] = srcByte & 128 ? white : black;
             dest32[destPos++] = srcByte & 64 ? white : black;
             dest32[destPos++] = srcByte & 32 ? white : black;
             dest32[destPos++] = srcByte & 16 ? white : black;
             dest32[destPos++] = srcByte & 8 ? white : black;
             dest32[destPos++] = srcByte & 4 ? white : black;
             dest32[destPos++] = srcByte & 2 ? white : black;
             dest32[destPos++] = srcByte & 1 ? white : black;
           }
+
           for (; k < kEnd; k++) {
             if (mask === 0) {
               srcByte = src[srcPos++];
               mask = 128;
             }
+
             dest32[destPos++] = srcByte & mask ? white : black;
             mask >>= 1;
           }
         }
+
         while (destPos < dest32DataLength) {
           dest32[destPos++] = 0;
         }
+
         ctx.putImageData(chunkImgData, 0, i * FULL_CHUNK_HEIGHT);
       }
     } else if (imgData.kind === _util.ImageKind.RGBA_32BPP) {
       j = 0;
       elemsInThisChunk = width * FULL_CHUNK_HEIGHT * 4;
+
       for (i = 0; i < fullChunks; i++) {
         dest.set(src.subarray(srcPos, srcPos + elemsInThisChunk));
         srcPos += elemsInThisChunk;
         ctx.putImageData(chunkImgData, 0, j);
         j += FULL_CHUNK_HEIGHT;
       }
+
       if (i < totalChunks) {
         elemsInThisChunk = width * partialChunkHeight * 4;
         dest.set(src.subarray(srcPos, srcPos + elemsInThisChunk));
         ctx.putImageData(chunkImgData, 0, j);
       }
     } else if (imgData.kind === _util.ImageKind.RGB_24BPP) {
       thisChunkHeight = FULL_CHUNK_HEIGHT;
       elemsInThisChunk = width * thisChunkHeight;
+
       for (i = 0; i < totalChunks; i++) {
         if (i >= fullChunks) {
           thisChunkHeight = partialChunkHeight;
           elemsInThisChunk = width * thisChunkHeight;
         }
+
         destPos = 0;
+
         for (j = elemsInThisChunk; j--;) {
           dest[destPos++] = src[srcPos++];
           dest[destPos++] = src[srcPos++];
           dest[destPos++] = src[srcPos++];
           dest[destPos++] = 255;
         }
+
         ctx.putImageData(chunkImgData, 0, i * FULL_CHUNK_HEIGHT);
       }
     } else {
       throw new Error(`bad image kind: ${imgData.kind}`);
     }
   }
+
   function putBinaryImageMask(ctx, imgData) {
     var height = imgData.height,
         width = imgData.width;
     var partialChunkHeight = height % FULL_CHUNK_HEIGHT;
     var fullChunks = (height - partialChunkHeight) / FULL_CHUNK_HEIGHT;
     var totalChunks = partialChunkHeight === 0 ? fullChunks : fullChunks + 1;
     var chunkImgData = ctx.createImageData(width, FULL_CHUNK_HEIGHT);
     var srcPos = 0;
     var src = imgData.data;
     var dest = chunkImgData.data;
+
     for (var i = 0; i < totalChunks; i++) {
       var thisChunkHeight = i < fullChunks ? FULL_CHUNK_HEIGHT : partialChunkHeight;
       var destPos = 3;
+
       for (var j = 0; j < thisChunkHeight; j++) {
         var mask = 0;
+
         for (var k = 0; k < width; k++) {
           if (!mask) {
             var elem = src[srcPos++];
             mask = 128;
           }
+
           dest[destPos] = elem & mask ? 0 : 255;
           destPos += 4;
           mask >>= 1;
         }
       }
+
       ctx.putImageData(chunkImgData, 0, i * FULL_CHUNK_HEIGHT);
     }
   }
+
   function copyCtxState(sourceCtx, destCtx) {
     var properties = ['strokeStyle', 'fillStyle', 'fillRule', 'globalAlpha', 'lineWidth', 'lineCap', 'lineJoin', 'miterLimit', 'globalCompositeOperation', 'font'];
+
     for (var i = 0, ii = properties.length; i < ii; i++) {
       var property = properties[i];
+
       if (sourceCtx[property] !== undefined) {
         destCtx[property] = sourceCtx[property];
       }
     }
+
     if (sourceCtx.setLineDash !== undefined) {
       destCtx.setLineDash(sourceCtx.getLineDash());
       destCtx.lineDashOffset = sourceCtx.lineDashOffset;
     }
   }
+
   function resetCtxToDefault(ctx) {
     ctx.strokeStyle = '#000000';
     ctx.fillStyle = '#000000';
     ctx.fillRule = 'nonzero';
     ctx.globalAlpha = 1;
     ctx.lineWidth = 1;
     ctx.lineCap = 'butt';
     ctx.lineJoin = 'miter';
     ctx.miterLimit = 10;
     ctx.globalCompositeOperation = 'source-over';
     ctx.font = '10px sans-serif';
+
     if (ctx.setLineDash !== undefined) {
       ctx.setLineDash([]);
       ctx.lineDashOffset = 0;
     }
   }
+
   function composeSMaskBackdrop(bytes, r0, g0, b0) {
     var length = bytes.length;
+
     for (var i = 3; i < length; i += 4) {
       var alpha = bytes[i];
+
       if (alpha === 0) {
         bytes[i - 3] = r0;
         bytes[i - 2] = g0;
         bytes[i - 1] = b0;
       } else if (alpha < 255) {
         var alpha_ = 255 - alpha;
         bytes[i - 3] = bytes[i - 3] * alpha + r0 * alpha_ >> 8;
         bytes[i - 2] = bytes[i - 2] * alpha + g0 * alpha_ >> 8;
         bytes[i - 1] = bytes[i - 1] * alpha + b0 * alpha_ >> 8;
       }
     }
   }
+
   function composeSMaskAlpha(maskData, layerData, transferMap) {
     var length = maskData.length;
     var scale = 1 / 255;
+
     for (var i = 3; i < length; i += 4) {
       var alpha = transferMap ? transferMap[maskData[i]] : maskData[i];
       layerData[i] = layerData[i] * alpha * scale | 0;
     }
   }
+
   function composeSMaskLuminosity(maskData, layerData, transferMap) {
     var length = maskData.length;
+
     for (var i = 3; i < length; i += 4) {
       var y = maskData[i - 3] * 77 + maskData[i - 2] * 152 + maskData[i - 1] * 28;
       layerData[i] = transferMap ? layerData[i] * transferMap[y >> 8] >> 8 : layerData[i] * y >> 16;
     }
   }
+
   function genericComposeSMask(maskCtx, layerCtx, width, height, subtype, backdrop, transferMap) {
     var hasBackdrop = !!backdrop;
     var r0 = hasBackdrop ? backdrop[0] : 0;
     var g0 = hasBackdrop ? backdrop[1] : 0;
     var b0 = hasBackdrop ? backdrop[2] : 0;
     var composeFn;
+
     if (subtype === 'Luminosity') {
       composeFn = composeSMaskLuminosity;
     } else {
       composeFn = composeSMaskAlpha;
     }
+
     var PIXELS_TO_PROCESS = 1048576;
     var chunkSize = Math.min(height, Math.ceil(PIXELS_TO_PROCESS / width));
+
     for (var row = 0; row < height; row += chunkSize) {
       var chunkHeight = Math.min(chunkSize, height - row);
       var maskData = maskCtx.getImageData(0, row, width, chunkHeight);
       var layerData = layerCtx.getImageData(0, row, width, chunkHeight);
+
       if (hasBackdrop) {
         composeSMaskBackdrop(maskData.data, r0, g0, b0);
       }
+
       composeFn(maskData.data, layerData.data, transferMap);
       maskCtx.putImageData(layerData, 0, row);
     }
   }
+
   function composeSMask(ctx, smask, layerCtx, webGLContext) {
     var mask = smask.canvas;
     var maskCtx = smask.context;
     ctx.setTransform(smask.scaleX, 0, 0, smask.scaleY, smask.offsetX, smask.offsetY);
     var backdrop = smask.backdrop || null;
+
     if (!smask.transferMap && webGLContext.isEnabled) {
       let composed = webGLContext.composeSMask({
         layer: layerCtx.canvas,
         mask,
         properties: {
           subtype: smask.subtype,
           backdrop
         }
       });
       ctx.setTransform(1, 0, 0, 1, 0, 0);
       ctx.drawImage(composed, smask.offsetX, smask.offsetY);
       return;
     }
+
     genericComposeSMask(maskCtx, layerCtx, mask.width, mask.height, smask.subtype, backdrop, smask.transferMap);
     ctx.drawImage(mask, 0, 0);
   }
+
   var LINE_CAP_STYLES = ['butt', 'round', 'square'];
   var LINE_JOIN_STYLES = ['miter', 'round', 'bevel'];
   var NORMAL_CLIP = {};
   var EO_CLIP = {};
   CanvasGraphics.prototype = {
-    beginDrawing({ transform, viewport, transparency = false, background = null }) {
+    beginDrawing({
+      transform,
+      viewport,
+      transparency = false,
+      background = null
+    }) {
       var width = this.ctx.canvas.width;
       var height = this.ctx.canvas.height;
       this.ctx.save();
       this.ctx.fillStyle = background || 'rgb(255, 255, 255)';
       this.ctx.fillRect(0, 0, width, height);
       this.ctx.restore();
+
       if (transparency) {
         var transparentCanvas = this.cachedCanvases.getCanvas('transparent', width, height, true);
         this.compositeCtx = this.ctx;
         this.transparentCanvas = transparentCanvas.canvas;
         this.ctx = transparentCanvas.context;
         this.ctx.save();
         this.ctx.transform.apply(this.ctx, this.compositeCtx.mozCurrentTransform);
       }
+
       this.ctx.save();
       resetCtxToDefault(this.ctx);
+
       if (transform) {
         this.ctx.transform.apply(this.ctx, transform);
       }
+
       this.ctx.transform.apply(this.ctx, viewport.transform);
       this.baseTransform = this.ctx.mozCurrentTransform.slice();
+
       if (this.imageLayer) {
         this.imageLayer.beginLayout();
       }
     },
+
     executeOperatorList: function CanvasGraphics_executeOperatorList(operatorList, executionStartIdx, continueCallback, stepper) {
       var argsArray = operatorList.argsArray;
       var fnArray = operatorList.fnArray;
       var i = executionStartIdx || 0;
       var argsArrayLen = argsArray.length;
+
       if (argsArrayLen === i) {
         return i;
       }
+
       var chunkOperations = argsArrayLen - i > EXECUTION_STEPS && typeof continueCallback === 'function';
       var endTime = chunkOperations ? Date.now() + EXECUTION_TIME : 0;
       var steps = 0;
       var commonObjs = this.commonObjs;
       var objs = this.objs;
       var fnId;
+
       while (true) {
         if (stepper !== undefined && i === stepper.nextBreakPoint) {
           stepper.breakIt(i, continueCallback);
           return i;
         }
+
         fnId = fnArray[i];
+
         if (fnId !== _util.OPS.dependency) {
           this[fnId].apply(this, argsArray[i]);
         } else {
           var deps = argsArray[i];
+
           for (var n = 0, nn = deps.length; n < nn; n++) {
             var depObjId = deps[n];
             var common = depObjId[0] === 'g' && depObjId[1] === '_';
             var objsPool = common ? commonObjs : objs;
+
             if (!objsPool.has(depObjId)) {
               objsPool.get(depObjId, continueCallback);
               return i;
             }
           }
         }
+
         i++;
+
         if (i === argsArrayLen) {
           return i;
         }
+
         if (chunkOperations && ++steps > EXECUTION_STEPS) {
           if (Date.now() > endTime) {
             continueCallback();
             return i;
           }
+
           steps = 0;
         }
       }
     },
     endDrawing: function CanvasGraphics_endDrawing() {
       if (this.current.activeSMask !== null) {
         this.endSMaskGroup();
       }
+
       this.ctx.restore();
+
       if (this.transparentCanvas) {
         this.ctx = this.compositeCtx;
         this.ctx.save();
         this.ctx.setTransform(1, 0, 0, 1, 0, 0);
         this.ctx.drawImage(this.transparentCanvas, 0, 0);
         this.ctx.restore();
         this.transparentCanvas = null;
       }
+
       this.cachedCanvases.clear();
       this.webGLContext.clear();
+
       if (this.imageLayer) {
         this.imageLayer.endLayout();
       }
     },
     setLineWidth: function CanvasGraphics_setLineWidth(width) {
       this.current.lineWidth = width;
       this.ctx.lineWidth = width;
     },
@@ -6757,75 +8364,91 @@ var CanvasGraphics = function CanvasGrap
     setLineJoin: function CanvasGraphics_setLineJoin(style) {
       this.ctx.lineJoin = LINE_JOIN_STYLES[style];
     },
     setMiterLimit: function CanvasGraphics_setMiterLimit(limit) {
       this.ctx.miterLimit = limit;
     },
     setDash: function CanvasGraphics_setDash(dashArray, dashPhase) {
       var ctx = this.ctx;
+
       if (ctx.setLineDash !== undefined) {
         ctx.setLineDash(dashArray);
         ctx.lineDashOffset = dashPhase;
       }
     },
     setRenderingIntent: function CanvasGraphics_setRenderingIntent(intent) {},
     setFlatness: function CanvasGraphics_setFlatness(flatness) {},
     setGState: function CanvasGraphics_setGState(states) {
       for (var i = 0, ii = states.length; i < ii; i++) {
         var state = states[i];
         var key = state[0];
         var value = state[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[0], value[1]);
             break;
+
           case 'CA':
             this.current.strokeAlpha = state[1];
             break;
+
           case 'ca':
             this.current.fillAlpha = state[1];
             this.ctx.globalAlpha = state[1];
             break;
+
           case 'BM':
             this.ctx.globalCompositeOperation = value;
             break;
+
           case 'SMask':
             if (this.current.activeSMask) {
               if (this.stateStack.length > 0 && this.stateStack[this.stateStack.length - 1].activeSMask === this.current.activeSMask) {
                 this.suspendSMaskGroup();
               } else {
                 this.endSMaskGroup();
               }
             }
+
             this.current.activeSMask = value ? this.tempSMask : null;
+
             if (this.current.activeSMask) {
               this.beginSMaskGroup();
             }
+
             this.tempSMask = null;
             break;
         }
       }
     },
     beginSMaskGroup: function CanvasGraphics_beginSMaskGroup() {
       var activeSMask = this.current.activeSMask;
       var drawnWidth = activeSMask.canvas.width;
@@ -6850,17 +8473,19 @@ var CanvasGraphics = function CanvasGrap
       var groupCtx = this.ctx;
       this.groupLevel--;
       this.ctx = this.groupStack.pop();
       composeSMask(this.ctx, this.current.activeSMask, groupCtx, this.webGLContext);
       this.ctx.restore();
       this.ctx.save();
       copyCtxState(groupCtx, this.ctx);
       this.current.resumeSMaskCtx = groupCtx;
+
       var deltaTransform = _util.Util.transform(this.current.activeSMask.startTransformInverse, groupCtx.mozCurrentTransform);
+
       this.ctx.transform.apply(this.ctx, deltaTransform);
       groupCtx.save();
       groupCtx.setTransform(1, 0, 0, 1, 0, 0);
       groupCtx.clearRect(0, 0, groupCtx.canvas.width, groupCtx.canvas.height);
       groupCtx.restore();
     },
     resumeSMaskGroup: function CanvasGraphics_endSMaskGroup() {
       var groupCtx = this.current.resumeSMaskCtx;
@@ -6871,155 +8496,179 @@ var CanvasGraphics = function CanvasGrap
     },
     endSMaskGroup: function CanvasGraphics_endSMaskGroup() {
       var groupCtx = this.ctx;
       this.groupLevel--;
       this.ctx = this.groupStack.pop();
       composeSMask(this.ctx, this.current.activeSMask, groupCtx, this.webGLContext);
       this.ctx.restore();
       copyCtxState(groupCtx, this.ctx);
+
       var deltaTransform = _util.Util.transform(this.current.activeSMask.startTransformInverse, groupCtx.mozCurrentTransform);
+
       this.ctx.transform.apply(this.ctx, deltaTransform);
     },
     save: function CanvasGraphics_save() {
       this.ctx.save();
       var old = this.current;
       this.stateStack.push(old);
       this.current = old.clone();
       this.current.resumeSMaskCtx = null;
     },
     restore: function CanvasGraphics_restore() {
       if (this.current.resumeSMaskCtx) {
         this.resumeSMaskGroup();
       }
+
       if (this.current.activeSMask !== null && (this.stateStack.length === 0 || this.stateStack[this.stateStack.length - 1].activeSMask !== this.current.activeSMask)) {
         this.endSMaskGroup();
       }
+
       if (this.stateStack.length !== 0) {
         this.current = this.stateStack.pop();
         this.ctx.restore();
         this.pendingClip = null;
         this._cachedGetSinglePixelWidth = null;
       }
     },
     transform: function CanvasGraphics_transform(a, b, c, d, e, f) {
       this.ctx.transform(a, b, c, d, e, f);
       this._cachedGetSinglePixelWidth = null;
     },
     constructPath: function CanvasGraphics_constructPath(ops, args) {
       var ctx = this.ctx;
       var current = this.current;
       var x = current.x,
           y = current.y;
+
       for (var i = 0, j = 0, ii = ops.length; i < ii; i++) {
         switch (ops[i] | 0) {
           case _util.OPS.rectangle:
             x = args[j++];
             y = args[j++];
             var width = args[j++];
             var height = args[j++];
+
             if (width === 0) {
               width = this.getSinglePixelWidth();
             }
+
             if (height === 0) {
               height = this.getSinglePixelWidth();
             }
+
             var xw = x + width;
             var yh = y + height;
             this.ctx.moveTo(x, y);
             this.ctx.lineTo(xw, y);
             this.ctx.lineTo(xw, yh);
             this.ctx.lineTo(x, yh);
             this.ctx.lineTo(x, y);
             this.ctx.closePath();
             break;
+
           case _util.OPS.moveTo:
             x = args[j++];
             y = args[j++];
             ctx.moveTo(x, y);
             break;
+
           case _util.OPS.lineTo:
             x = args[j++];
             y = args[j++];
             ctx.lineTo(x, y);
             break;
+
           case _util.OPS.curveTo:
             x = args[j + 4];
             y = args[j + 5];
             ctx.bezierCurveTo(args[j], args[j + 1], args[j + 2], args[j + 3], x, y);
             j += 6;
             break;
+
           case _util.OPS.curveTo2:
             ctx.bezierCurveTo(x, y, args[j], args[j + 1], args[j + 2], 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];
             ctx.bezierCurveTo(args[j], args[j + 1], x, y, x, y);
             j += 4;
             break;
+
           case _util.OPS.closePath:
             ctx.closePath();
             break;
         }
       }
+
       current.setCurrentPoint(x, y);
     },
     closePath: function CanvasGraphics_closePath() {
       this.ctx.closePath();
     },
     stroke: function CanvasGraphics_stroke(consumePath) {
       consumePath = typeof consumePath !== 'undefined' ? consumePath : true;
       var ctx = this.ctx;
       var strokeColor = this.current.strokeColor;
       ctx.lineWidth = Math.max(this.getSinglePixelWidth() * MIN_WIDTH_FACTOR, this.current.lineWidth);
       ctx.globalAlpha = this.current.strokeAlpha;
+
       if (strokeColor && strokeColor.hasOwnProperty('type') && strokeColor.type === 'Pattern') {
         ctx.save();
         ctx.strokeStyle = strokeColor.getPattern(ctx, this);
         ctx.stroke();
         ctx.restore();
       } else {
         ctx.stroke();
       }
+
       if (consumePath) {
         this.consumePath();
       }
+
       ctx.globalAlpha = this.current.fillAlpha;
     },
     closeStroke: function CanvasGraphics_closeStroke() {
       this.closePath();
       this.stroke();
     },
     fill: function CanvasGraphics_fill(consumePath) {
       consumePath = typeof consumePath !== 'undefined' ? consumePath : true;
       var ctx = this.ctx;
       var fillColor = this.current.fillColor;
       var isPatternFill = this.current.patternFill;
       var needRestore = false;
+
       if (isPatternFill) {
         ctx.save();
+
         if (this.baseTransform) {
           ctx.setTransform.apply(ctx, this.baseTransform);
         }
+
         ctx.fillStyle = fillColor.getPattern(ctx, this);
         needRestore = true;
       }
+
       if (this.pendingEOFill) {
         ctx.fill('evenodd');
         this.pendingEOFill = false;
       } else {
         ctx.fill();
       }
+
       if (needRestore) {
         ctx.restore();
       }
+
       if (consumePath) {
         this.consumePath();
       }
     },
     eoFill: function CanvasGraphics_eoFill() {
       this.pendingEOFill = true;
       this.fill();
     },
@@ -7054,28 +8703,32 @@ var CanvasGraphics = function CanvasGrap
       this.current.textMatrix = _util.IDENTITY_MATRIX;
       this.current.textMatrixScale = 1;
       this.current.x = this.current.lineX = 0;
       this.current.y = this.current.lineY = 0;
     },
     endText: function CanvasGraphics_endText() {
       var paths = this.pendingTextPaths;
       var ctx = this.ctx;
+
       if (paths === undefined) {
         ctx.beginPath();
         return;
       }
+
       ctx.save();
       ctx.beginPath();
+
       for (var i = 0; i < paths.length; i++) {
         var path = paths[i];
         ctx.setTransform.apply(ctx, path.transform);
         ctx.translate(path.x, path.y);
         path.addToPath(ctx, path.fontSize);
       }
+
       ctx.restore();
       ctx.clip();
       ctx.beginPath();
       delete this.pendingTextPaths;
     },
     setCharSpacing: function CanvasGraphics_setCharSpacing(spacing) {
       this.current.charSpacing = spacing;
     },
@@ -7086,34 +8739,41 @@ var CanvasGraphics = function CanvasGrap
       this.current.textHScale = scale / 100;
     },
     setLeading: function CanvasGraphics_setLeading(leading) {
       this.current.leading = -leading;
     },
     setFont: function CanvasGraphics_setFont(fontRefName, size) {
       var fontObj = this.commonObjs.get(fontRefName);
       var current = this.current;
+
       if (!fontObj) {
         throw new Error(`Can't find font for ${fontRefName}`);
       }
+
       current.fontMatrix = fontObj.fontMatrix ? fontObj.fontMatrix : _util.FONT_IDENTITY_MATRIX;
+
       if (current.fontMatrix[0] === 0 || current.fontMatrix[3] === 0) {
         (0, _util.warn)('Invalid font matrix for font ' + fontRefName);
       }
+
       if (size < 0) {
         size = -size;
         current.fontDirection = -1;
       } else {
         current.fontDirection = 1;
       }
+
       this.current.font = fontObj;
       this.current.fontSize = size;
+
       if (fontObj.isType3Font) {
         return;
       }
+
       var name = fontObj.loadedName || 'sans-serif';
       var bold = fontObj.black ? '900' : fontObj.bold ? 'bold' : 'normal';
       var italic = fontObj.italic ? 'italic' : 'normal';
       var typeface = '"' + name + '", ' + fontObj.fallbackName;
       var browserFontSize = size < MIN_FONT_SIZE ? MIN_FONT_SIZE : size > MAX_FONT_SIZE ? MAX_FONT_SIZE : size;
       this.current.fontSizeScale = size / browserFontSize;
       var rule = italic + ' ' + bold + ' ' + browserFontSize + 'px ' + typeface;
       this.ctx.font = rule;
@@ -7136,376 +8796,450 @@ var CanvasGraphics = function CanvasGrap
       this.current.textMatrix = [a, b, c, d, e, f];
       this.current.textMatrixScale = Math.sqrt(a * a + b * b);
       this.current.x = this.current.lineX = 0;
       this.current.y = this.current.lineY = 0;
     },
     nextLine: function CanvasGraphics_nextLine() {
       this.moveText(0, this.current.leading);
     },
+
     paintChar(character, x, y, patternTransform) {
       var ctx = this.ctx;
       var current = this.current;
       var font = current.font;
       var textRenderingMode = current.textRenderingMode;
       var fontSize = current.fontSize / current.fontSizeScale;
       var fillStrokeMode = textRenderingMode & _util.TextRenderingMode.FILL_STROKE_MASK;
       var isAddToPathSet = !!(textRenderingMode & _util.TextRenderingMode.ADD_TO_PATH_FLAG);
       let patternFill = current.patternFill && font.data;
       var addToPath;
+
       if (font.disableFontFace || isAddToPathSet || patternFill) {
         addToPath = font.getPathGenerator(this.commonObjs, character);
       }
+
       if (font.disableFontFace || patternFill) {
         ctx.save();
         ctx.translate(x, y);
         ctx.beginPath();
         addToPath(ctx, fontSize);
+
         if (patternTransform) {
           ctx.setTransform.apply(ctx, patternTransform);
         }
+
         if (fillStrokeMode === _util.TextRenderingMode.FILL || fillStrokeMode === _util.TextRenderingMode.FILL_STROKE) {
           ctx.fill();
         }
+
         if (fillStrokeMode === _util.TextRenderingMode.STROKE || fillStrokeMode === _util.TextRenderingMode.FILL_STROKE) {
           ctx.stroke();
         }
+
         ctx.restore();
       } else {
         if (fillStrokeMode === _util.TextRenderingMode.FILL || fillStrokeMode === _util.TextRenderingMode.FILL_STROKE) {
           ctx.fillText(character, x, y);
         }
+
         if (fillStrokeMode === _util.TextRenderingMode.STROKE || fillStrokeMode === _util.TextRenderingMode.FILL_STROKE) {
           ctx.strokeText(character, x, y);
         }
       }
+
       if (isAddToPathSet) {
         var paths = this.pendingTextPaths || (this.pendingTextPaths = []);
         paths.push({
           transform: ctx.mozCurrentTransform,
           x,
           y,
           fontSize,
           addToPath
         });
       }
     },
+
     get isFontSubpixelAAEnabled() {
       var ctx = this.canvasFactory.create(10, 10).context;
       ctx.scale(1.5, 1);
       ctx.fillText('I', 0, 10);
       var data = ctx.getImageData(0, 0, 10, 10).data;
       var enabled = false;
+
       for (var i = 3; i < data.length; i += 4) {
         if (data[i] > 0 && data[i] < 255) {
           enabled = true;
           break;
         }
       }
+
       return (0, _util.shadow)(this, 'isFontSubpixelAAEnabled', enabled);
     },
+
     showText: function CanvasGraphics_showText(glyphs) {
       var current = this.current;
       var font = current.font;
+
       if (font.isType3Font) {
         return this.showType3Text(glyphs);
       }
+
       var fontSize = current.fontSize;
+
       if (fontSize === 0) {
         return;
       }
+
       var ctx = this.ctx;
       var fontSizeScale = current.fontSizeScale;
       var charSpacing = current.charSpacing;
       var wordSpacing = current.wordSpacing;
       var fontDirection = current.fontDirection;
       var textHScale = current.textHScale * fontDirection;
       var glyphsLength = glyphs.length;
       var vertical = font.vertical;
       var spacingDir = vertical ? 1 : -1;
       var defaultVMetrics = font.defaultVMetrics;
       var widthAdvanceScale = fontSize * current.fontMatrix[0];
       var simpleFillText = current.textRenderingMode === _util.TextRenderingMode.FILL && !font.disableFontFace && !current.patternFill;
       ctx.save();
       let patternTransform;
+
       if (current.patternFill) {
         ctx.save();
         let pattern = current.fillColor.getPattern(ctx, this);
         patternTransform = ctx.mozCurrentTransform;
         ctx.restore();
         ctx.fillStyle = pattern;
       }
+
       ctx.transform.apply(ctx, current.textMatrix);
       ctx.translate(current.x, current.y + current.textRise);
+
       if (fontDirection > 0) {
         ctx.scale(textHScale, -1);
       } else {
         ctx.scale(textHScale, 1);
       }
+
       var lineWidth = current.lineWidth;
       var scale = current.textMatrixScale;
+
       if (scale === 0 || lineWidth === 0) {
         var fillStrokeMode = current.textRenderingMode & _util.TextRenderingMode.FILL_STROKE_MASK;
+
         if (fillStrokeMode === _util.TextRenderingMode.STROKE || fillStrokeMode === _util.TextRenderingMode.FILL_STROKE) {
           this._cachedGetSinglePixelWidth = null;
           lineWidth = this.getSinglePixelWidth() * MIN_WIDTH_FACTOR;
         }
       } else {
         lineWidth /= scale;
       }
+
       if (fontSizeScale !== 1.0) {
         ctx.scale(fontSizeScale, fontSizeScale);
         lineWidth /= fontSizeScale;
       }
+
       ctx.lineWidth = lineWidth;
       var x = 0,
           i;
+
       for (i = 0; i < glyphsLength; ++i) {
         var glyph = glyphs[i];
+
         if ((0, _util.isNum)(glyph)) {
           x += spacingDir * glyph * fontSize / 1000;
           continue;
         }
+
         var restoreNeeded = false;
         var spacing = (glyph.isSpace ? wordSpacing : 0) + charSpacing;
         var character = glyph.fontChar;
         var accent = glyph.accent;
         var scaledX, scaledY, scaledAccentX, scaledAccentY;
         var width = glyph.width;
+
         if (vertical) {
           var vmetric, vx, vy;
           vmetric = glyph.vmetric || defaultVMetrics;
           vx = glyph.vmetric ? vmetric[1] : width * 0.5;
           vx = -vx * widthAdvanceScale;
           vy = vmetric[2] * widthAdvanceScale;
           width = vmetric ? -vmetric[0] : width;
           scaledX = vx / fontSizeScale;
           scaledY = (x + vy) / fontSizeScale;
         } else {
           scaledX = x / fontSizeScale;
           scaledY = 0;
         }
+
         if (font.remeasure && width > 0) {
           var measuredWidth = ctx.measureText(character).width * 1000 / fontSize * fontSizeScale;
+
           if (width < measuredWidth && this.isFontSubpixelAAEnabled) {
             var characterScaleX = width / measuredWidth;
             restoreNeeded = true;
             ctx.save();
             ctx.scale(characterScaleX, 1);
             scaledX /= characterScaleX;
           } else if (width !== measuredWidth) {
             scaledX += (width - measuredWidth) / 2000 * fontSize / fontSizeScale;
           }
         }
+
         if (glyph.isInFont || font.missingFile) {
           if (simpleFillText && !accent) {
             ctx.fillText(character, scaledX, scaledY);
           } else {
             this.paintChar(character, scaledX, scaledY, patternTransform);
+
             if (accent) {
               scaledAccentX = scaledX + accent.offset.x / fontSizeScale;
               scaledAccentY = scaledY - accent.offset.y / fontSizeScale;
               this.paintChar(accent.fontChar, scaledAccentX, scaledAccentY, patternTransform);
             }
           }
         }
+
         var charWidth = width * widthAdvanceScale + spacing * fontDirection;
         x += charWidth;
+
         if (restoreNeeded) {
           ctx.restore();
         }
       }
+
       if (vertical) {
         current.y -= x * textHScale;
       } else {
         current.x += x * textHScale;
       }
+
       ctx.restore();
     },
     showType3Text: function CanvasGraphics_showType3Text(glyphs) {
       var ctx = this.ctx;
       var current = this.current;
       var font = current.font;
       var fontSize = current.fontSize;
       var fontDirection = current.fontDirection;
       var spacingDir = font.vertical ? 1 : -1;
       var charSpacing = current.charSpacing;
       var wordSpacing = current.wordSpacing;
       var textHScale = current.textHScale * fontDirection;
       var fontMatrix = current.fontMatrix || _util.FONT_IDENTITY_MATRIX;
       var glyphsLength = glyphs.length;
       var isTextInvisible = current.textRenderingMode === _util.TextRenderingMode.INVISIBLE;
       var i, glyph, width, spacingLength;
+
       if (isTextInvisible || fontSize === 0) {
         return;
       }
+
       this._cachedGetSinglePixelWidth = null;
       ctx.save();
       ctx.transform.apply(ctx, current.textMatrix);
       ctx.translate(current.x, current.y);
       ctx.scale(textHScale, fontDirection);
+
       for (i = 0; i < glyphsLength; ++i) {
         glyph = glyphs[i];
+
         if ((0, _util.isNum)(glyph)) {
           spacingLength = spacingDir * glyph * fontSize / 1000;
           this.ctx.translate(spacingLength, 0);
           current.x += spacingLength * textHScale;
           continue;
         }
+
         var spacing = (glyph.isSpace ? wordSpacing : 0) + charSpacing;
         var operatorList = font.charProcOperatorList[glyph.operatorListId];
+
         if (!operatorList) {
           (0, _util.warn)(`Type3 character "${glyph.operatorListId}" is not available.`);
           continue;
         }
+
         this.processingType3 = glyph;
         this.save();
         ctx.scale(fontSize, fontSize);
         ctx.transform.apply(ctx, fontMatrix);
         this.executeOperatorList(operatorList);
         this.restore();
+
         var transformed = _util.Util.applyTransform([glyph.width, 0], fontMatrix);
+
         width = transformed[0] * fontSize + spacing;
         ctx.translate(width, 0);
         current.x += width * textHScale;
       }
+
       ctx.restore();
       this.processingType3 = null;
     },
     setCharWidth: function CanvasGraphics_setCharWidth(xWidth, yWidth) {},
     setCharWidthAndBounds: function CanvasGraphics_setCharWidthAndBounds(xWidth, yWidth, llx, lly, urx, ury) {
       this.ctx.rect(llx, lly, urx - llx, ury - lly);
       this.clip();
       this.endPath();
     },
     getColorN_Pattern: function CanvasGraphics_getColorN_Pattern(IR) {
       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);
           }
         };
         pattern = new _pattern_helper.TilingPattern(IR, color, this.ctx, canvasGraphicsFactory, baseTransform);
       } else {
         pattern = (0, _pattern_helper.getShadingPatternFromIR)(IR);
       }
+
       return pattern;
     },
     setStrokeColorN: function CanvasGraphics_setStrokeColorN() {
       this.current.strokeColor = this.getColorN_Pattern(arguments);
     },
     setFillColorN: function CanvasGraphics_setFillColorN() {
       this.current.fillColor = this.getColorN_Pattern(arguments);
       this.current.patternFill = true;
     },
     setStrokeRGBColor: function CanvasGraphics_setStrokeRGBColor(r, g, b) {
       var color = _util.Util.makeCssRgb(r, g, b);
+
       this.ctx.strokeStyle = color;
       this.current.strokeColor = color;
     },
     setFillRGBColor: function CanvasGraphics_setFillRGBColor(r, g, b) {
       var color = _util.Util.makeCssRgb(r, g, b);
+
       this.ctx.fillStyle = color;
       this.current.fillColor = color;
       this.current.patternFill = false;
     },
     shadingFill: function CanvasGraphics_shadingFill(patternIR) {
       var ctx = this.ctx;
       this.save();
       var pattern = (0, _pattern_helper.getShadingPatternFromIR)(patternIR);
       ctx.fillStyle = pattern.getPattern(ctx, this, true);
       var inv = ctx.mozCurrentTransformInverse;
+
       if (inv) {
         var canvas = ctx.canvas;
         var width = canvas.width;
         var height = canvas.height;
+
         var bl = _util.Util.applyTransform([0, 0], inv);
+
         var br = _util.Util.applyTransform([0, height], inv);
+
         var ul = _util.Util.applyTransform([width, 0], inv);
+
         var ur = _util.Util.applyTransform([width, height], inv);
+
         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]);
         this.ctx.fillRect(x0, y0, x1 - x0, y1 - y0);
       } else {
         this.ctx.fillRect(-1e10, -1e10, 2e10, 2e10);
       }
+
       this.restore();
     },
     beginInlineImage: function CanvasGraphics_beginInlineImage() {
       (0, _util.unreachable)('Should not call beginInlineImage');
     },
     beginImageData: function CanvasGraphics_beginImageData() {
       (0, _util.unreachable)('Should not call beginImageData');
     },
     paintFormXObjectBegin: function CanvasGraphics_paintFormXObjectBegin(matrix, bbox) {
       this.save();
       this.baseTransformStack.push(this.baseTransform);
+
       if (Array.isArray(matrix) && matrix.length === 6) {
         this.transform.apply(this, matrix);
       }
+
       this.baseTransform = this.ctx.mozCurrentTransform;
+
       if (bbox) {
         var width = bbox[2] - bbox[0];
         var height = bbox[3] - bbox[1];
         this.ctx.rect(bbox[0], bbox[1], width, height);
         this.clip();
         this.endPath();
       }
     },
     paintFormXObjectEnd: function CanvasGraphics_paintFormXObjectEnd() {
       this.restore();
       this.baseTransform = this.baseTransformStack.pop();
     },
     beginGroup: function CanvasGraphics_beginGroup(group) {
       this.save();
       var currentCtx = this.ctx;
+
       if (!group.isolated) {
         (0, _util.info)('TODO: Support non-isolated groups.');
       }
+
       if (group.knockout) {
         (0, _util.warn)('Knockout groups not supported.');
       }
+
       var currentTransform = currentCtx.mozCurrentTransform;
+
       if (group.matrix) {
         currentCtx.transform.apply(currentCtx, group.matrix);
       }
+
       if (!group.bbox) {
         throw new Error('Bounding box is required.');
       }
+
       var bounds = _util.Util.getAxialAlignedBoundingBox(group.bbox, currentCtx.mozCurrentTransform);
+
       var canvasBounds = [0, 0, currentCtx.canvas.width, currentCtx.canvas.height];
       bounds = _util.Util.intersect(bounds, canvasBounds) || [0, 0, 0, 0];
       var offsetX = Math.floor(bounds[0]);
       var offsetY = Math.floor(bounds[1]);
       var drawnWidth = Math.max(Math.ceil(bounds[2]) - offsetX, 1);
       var drawnHeight = Math.max(Math.ceil(bounds[3]) - offsetY, 1);
       var scaleX = 1,
           scaleY = 1;
+
       if (drawnWidth > MAX_GROUP_SIZE) {
         scaleX = drawnWidth / MAX_GROUP_SIZE;
         drawnWidth = MAX_GROUP_SIZE;
       }
+
       if (drawnHeight > MAX_GROUP_SIZE) {
         scaleY = drawnHeight / MAX_GROUP_SIZE;
         drawnHeight = MAX_GROUP_SIZE;
       }
+
       var cacheId = 'groupAt' + this.groupLevel;
+
       if (group.smask) {
         cacheId += '_smask_' + this.smaskCounter++ % 2;
       }
+
       var scratchCanvas = this.cachedCanvases.getCanvas(cacheId, drawnWidth, drawnHeight, true);
       var groupCtx = scratchCanvas.context;
       groupCtx.scale(1 / scaleX, 1 / scaleY);
       groupCtx.translate(-offsetX, -offsetY);
       groupCtx.transform.apply(groupCtx, currentTransform);
+
       if (group.smask) {
         this.smaskStack.push({
           canvas: scratchCanvas.canvas,
           context: groupCtx,
           offsetX,
           offsetY,
           scaleX,
           scaleY,
@@ -7514,110 +9248,124 @@ var CanvasGraphics = function CanvasGrap
           transferMap: group.smask.transferMap || null,
           startTransformInverse: null
         });
       } else {
         currentCtx.setTransform(1, 0, 0, 1, 0, 0);
         currentCtx.translate(offsetX, offsetY);
         currentCtx.scale(scaleX, scaleY);
       }
+
       copyCtxState(currentCtx, groupCtx);
       this.ctx = groupCtx;
       this.setGState([['BM', 'source-over'], ['ca', 1], ['CA', 1]]);
       this.groupStack.push(currentCtx);
       this.groupLevel++;
       this.current.activeSMask = null;
     },
     endGroup: function CanvasGraphics_endGroup(group) {
       this.groupLevel--;
       var groupCtx = this.ctx;
       this.ctx = this.groupStack.pop();
+
       if (this.ctx.imageSmoothingEnabled !== undefined) {
         this.ctx.imageSmoothingEnabled = false;
       } else {
         this.ctx.mozImageSmoothingEnabled = false;
       }
+
       if (group.smask) {
         this.tempSMask = this.smaskStack.pop();
       } else {
         this.ctx.drawImage(groupCtx.canvas, 0, 0);
       }
+
       this.restore();
     },
     beginAnnotations: function CanvasGraphics_beginAnnotations() {
       this.save();
+
       if (this.baseTransform) {
         this.ctx.setTransform.apply(this.ctx, this.baseTransform);
       }
     },
     endAnnotations: function CanvasGraphics_endAnnotations() {
       this.restore();
     },
     beginAnnotation: function CanvasGraphics_beginAnnotation(rect, transform, matrix) {
       this.save();
       resetCtxToDefault(this.ctx);
       this.current = new CanvasExtraState();
+
       if (Array.isArray(rect) && rect.length === 4) {
         var width = rect[2] - rect[0];
         var height = rect[3] - rect[1];
         this.ctx.rect(rect[0], rect[1], width, height);
         this.clip();
         this.endPath();
       }
+
       this.transform.apply(this, transform);
       this.transform.apply(this, matrix);
     },
     endAnnotation: function CanvasGraphics_endAnnotation() {
       this.restore();
     },
     paintJpegXObject: function CanvasGraphics_paintJpegXObject(objId, w, h) {
       var domImage = this.objs.get(objId);
+
       if (!domImage) {
         (0, _util.warn)('Dependent image isn\'t ready yet');
         return;
       }
+
       this.save();
       var ctx = this.ctx;
       ctx.scale(1 / w, -1 / h);
       ctx.drawImage(domImage, 0, 0, domImage.width, domImage.height, 0, -h, w, h);
+
       if (this.imageLayer) {
         var currentTransform = ctx.mozCurrentTransformInverse;
         var position = this.getCanvasPosition(0, 0);
         this.imageLayer.appendImage({
           objId,
           left: position[0],
           top: position[1],
           width: w / currentTransform[0],
           height: h / currentTransform[3]
         });
       }
+
       this.restore();
     },
     paintImageMaskXObject: function CanvasGraphics_paintImageMaskXObject(img) {
       var ctx = this.ctx;
       var width = img.width,
           height = img.height;
       var fillColor = this.current.fillColor;
       var isPatternFill = this.current.patternFill;
       var glyph = this.processingType3;
+
       if (COMPILE_TYPE3_GLYPHS && glyph && glyph.compiled === undefined) {
         if (width <= MAX_SIZE_TO_COMPILE && height <= MAX_SIZE_TO_COMPILE) {
           glyph.compiled = compileType3Glyph({
             data: img.data,
             width,
             height
           });
         } else {
           glyph.compiled = null;
         }
       }
+
       if (glyph && glyph.compiled) {
         glyph.compiled(ctx);
         return;
       }
+
       var maskCanvas = this.cachedCanvases.getCanvas('maskCanvas', width, height);
       var maskCtx = maskCanvas.context;
       maskCtx.save();
       putBinaryImageMask(maskCtx, img);
       maskCtx.globalCompositeOperation = 'source-in';
       maskCtx.fillStyle = isPatternFill ? fillColor.getPattern(maskCtx, this) : fillColor;
       maskCtx.fillRect(0, 0, width, height);
       maskCtx.restore();
@@ -7632,28 +9380,30 @@ var CanvasGraphics = function CanvasGrap
       var maskCtx = maskCanvas.context;
       maskCtx.save();
       putBinaryImageMask(maskCtx, imgData);
       maskCtx.globalCompositeOperation = 'source-in';
       maskCtx.fillStyle = isPatternFill ? fillColor.getPattern(maskCtx, this) : fillColor;
       maskCtx.fillRect(0, 0, width, height);
       maskCtx.restore();
       var ctx = this.ctx;
+
       for (var i = 0, ii = positions.length; i < ii; i += 2) {
         ctx.save();
         ctx.transform(scaleX, 0, 0, scaleY, positions[i], positions[i + 1]);
         ctx.scale(1, -1);
         ctx.drawImage(maskCanvas.canvas, 0, 0, width, height, 0, -1, 1, 1);
         ctx.restore();
       }
     },
     paintImageMaskXObjectGroup: function CanvasGraphics_paintImageMaskXObjectGroup(images) {
       var ctx = this.ctx;
       var fillColor = this.current.fillColor;
       var isPatternFill = this.current.patternFill;
+
       for (var i = 0, ii = images.length; i < ii; i++) {
         var image = images[i];
         var width = image.width,
             height = image.height;
         var maskCanvas = this.cachedCanvases.getCanvas('maskCanvas', width, height);
         var maskCtx = maskCanvas.context;
         maskCtx.save();
         putBinaryImageMask(maskCtx, image);
@@ -7665,123 +9415,141 @@ var CanvasGraphics = function CanvasGrap
         ctx.transform.apply(ctx, image.transform);
         ctx.scale(1, -1);
         ctx.drawImage(maskCanvas.canvas, 0, 0, width, height, 0, -1, 1, 1);
         ctx.restore();
       }
     },
     paintImageXObject: function CanvasGraphics_paintImageXObject(objId) {
       var imgData = this.objs.get(objId);
+
       if (!imgData) {
         (0, _util.warn)('Dependent image isn\'t ready yet');
         return;
       }
+
       this.paintInlineImageXObject(imgData);
     },
     paintImageXObjectRepeat: function CanvasGraphics_paintImageXObjectRepeat(objId, scaleX, scaleY, positions) {
       var imgData = this.objs.get(objId);
+
       if (!imgData) {
         (0, _util.warn)('Dependent image isn\'t ready yet');
         return;
       }
+
       var width = imgData.width;
       var height = imgData.height;
       var map = [];
+
       for (var i = 0, ii = positions.length; i < ii; i += 2) {
         map.push({
           transform: [scaleX, 0, 0, scaleY, positions[i], positions[i + 1]],
           x: 0,
           y: 0,
           w: width,
           h: height
         });
       }
+
       this.paintInlineImageXObjectGroup(imgData, map);
     },
     paintInlineImageXObject: function CanvasGraphics_paintInlineImageXObject(imgData) {
       var width = imgData.width;
       var height = imgData.height;
       var ctx = this.ctx;
       this.save();
       ctx.scale(1 / width, -1 / height);
       var currentTransform = ctx.mozCurrentTransformInverse;
       var a = currentTransform[0],
           b = currentTransform[1];
       var widthScale = Math.max(Math.sqrt(a * a + b * b), 1);
       var c = currentTransform[2],
           d = currentTransform[3];
       var heightScale = Math.max(Math.sqrt(c * c + d * d), 1);
       var imgToPaint, tmpCanvas;
+
       if (typeof HTMLElement === 'function' && imgData instanceof HTMLElement || !imgData.data) {
         imgToPaint = imgData;
       } else {
         tmpCanvas = this.cachedCanvases.getCanvas('inlineImage', width, height);
         var tmpCtx = tmpCanvas.context;
         putBinaryImageData(tmpCtx, imgData);
         imgToPaint = tmpCanvas.canvas;
       }
+
       var paintWidth = width,
           paintHeight = height;
       var tmpCanvasId = 'prescale1';
+
       while (widthScale > 2 && paintWidth > 1 || heightScale > 2 && paintHeight > 1) {
         var newWidth = paintWidth,
             newHeight = paintHeight;
+
         if (widthScale > 2 && paintWidth > 1) {
           newWidth = Math.ceil(paintWidth / 2);
           widthScale /= paintWidth / newWidth;
         }
+
         if (heightScale > 2 && paintHeight > 1) {
           newHeight = Math.ceil(paintHeight / 2);
           heightScale /= paintHeight / newHeight;
         }
+
         tmpCanvas = this.cachedCanvases.getCanvas(tmpCanvasId, newWidth, newHeight);
         tmpCtx = tmpCanvas.context;
         tmpCtx.clearRect(0, 0, newWidth, newHeight);
         tmpCtx.drawImage(imgToPaint, 0, 0, paintWidth, paintHeight, 0, 0, newWidth, newHeight);
         imgToPaint = tmpCanvas.canvas;
         paintWidth = newWidth;
         paintHeight = newHeight;
         tmpCanvasId = tmpCanvasId === 'prescale1' ? 'prescale2' : 'prescale1';
       }
+
       ctx.drawImage(imgToPaint, 0, 0, paintWidth, paintHeight, 0, -height, width, height);
+
       if (this.imageLayer) {
         var position = this.getCanvasPosition(0, -height);
         this.imageLayer.appendImage({
           imgData,
           left: position[0],
           top: position[1],
           width: width / currentTransform[0],
           height: height / currentTransform[3]
         });
       }
+
       this.restore();
     },
     paintInlineImageXObjectGroup: function CanvasGraphics_paintInlineImageXObjectGroup(imgData, map) {
       var ctx = this.ctx;
       var w = imgData.width;
       var h = imgData.height;
       var tmpCanvas = this.cachedCanvases.getCanvas('inlineImage', w, h);
       var tmpCtx = tmpCanvas.context;
       putBinaryImageData(tmpCtx, imgData);
+
       for (var i = 0, ii = map.length; i < ii; i++) {
         var entry = map[i];
         ctx.save();
         ctx.transform.apply(ctx, entry.transform);
         ctx.scale(1, -1);
         ctx.drawImage(tmpCanvas.canvas, entry.x, entry.y, entry.w, entry.h, 0, -1, 1, 1);
+
         if (this.imageLayer) {
           var position = this.getCanvasPosition(entry.x, entry.y);
           this.imageLayer.appendImage({
             imgData,
             left: position[0],
             top: position[1],
             width: w,
             height: h
           });
         }
+
         ctx.restore();
       }
     },
     paintSolidColorImageMask: function CanvasGraphics_paintSolidColorImageMask() {
       this.ctx.fillRect(0, 0, 1, 1);
     },
     paintXObject: function CanvasGraphics_paintXObject() {
       (0, _util.warn)('Unsupported \'paintXObject\' command.');
@@ -7790,198 +9558,230 @@ var CanvasGraphics = function CanvasGrap
     markPointProps: function CanvasGraphics_markPointProps(tag, properties) {},
     beginMarkedContent: function CanvasGraphics_beginMarkedContent(tag) {},
     beginMarkedContentProps: function CanvasGraphics_beginMarkedContentProps(tag, properties) {},
     endMarkedContent: function CanvasGraphics_endMarkedContent() {},
     beginCompat: function CanvasGraphics_beginCompat() {},
     endCompat: function CanvasGraphics_endCompat() {},
     consumePath: function CanvasGraphics_consumePath() {
       var ctx = this.ctx;
+
       if (this.pendingClip) {
         if (this.pendingClip === EO_CLIP) {
           ctx.clip('evenodd');
         } else {
           ctx.clip();
         }
+
         this.pendingClip = null;
       }
+
       ctx.beginPath();
     },
+
     getSinglePixelWidth(scale) {
       if (this._cachedGetSinglePixelWidth === null) {
         const 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]];
     }
   };
+
   for (var op in _util.OPS) {
     CanvasGraphics.prototype[_util.OPS[op]] = CanvasGraphics.prototype[op];
   }
+
   return CanvasGraphics;
 }();
+
 exports.CanvasGraphics = CanvasGraphics;
 
 /***/ }),
 /* 12 */
 /***/ (function(module, exports, __w_pdfjs_require__) {
 
 "use strict";
 
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.TilingPattern = exports.getShadingPatternFromIR = undefined;
+exports.getShadingPatternFromIR = getShadingPatternFromIR;
+exports.TilingPattern = void 0;
 
 var _util = __w_pdfjs_require__(1);
 
 var ShadingIRs = {};
 ShadingIRs.RadialAxial = {
   fromIR: function RadialAxial_fromIR(raw) {
     var type = raw[1];
     var colorStops = raw[2];
     var p0 = raw[3];
     var p1 = raw[4];
     var r0 = raw[5];
     var r1 = raw[6];
     return {
       type: 'Pattern',
       getPattern: function RadialAxial_getPattern(ctx) {
         var grad;
+
         if (type === 'axial') {
           grad = ctx.createLinearGradient(p0[0], p0[1], p1[0], p1[1]);
         } else if (type === 'radial') {
           grad = ctx.createRadialGradient(p0[0], p0[1], r0, p1[0], p1[1], r1);
         }
+
         for (var i = 0, ii = colorStops.length; i < ii; ++i) {
           var c = colorStops[i];
           grad.addColorStop(c[0], c[1]);
         }
+
         return grad;
       }
     };
   }
 };
+
 var createMeshCanvas = function createMeshCanvasClosure() {
   function drawTriangle(data, context, p1, p2, p3, c1, c2, c3) {
     var coords = context.coords,
         colors = context.colors;
     var bytes = data.data,
         rowSize = data.width * 4;
     var tmp;
+
     if (coords[p1 + 1] > coords[p2 + 1]) {
       tmp = p1;
       p1 = p2;
       p2 = tmp;
       tmp = c1;
       c1 = c2;
       c2 = tmp;
     }
+
     if (coords[p2 + 1] > coords[p3 + 1]) {
       tmp = p2;
       p2 = p3;
       p3 = tmp;
       tmp = c2;
       c2 = c3;
       c3 = tmp;
     }
+
     if (coords[p1 + 1] > coords[p2 + 1]) {
       tmp = p1;
       p1 = p2;
       p2 = tmp;
       tmp = c1;
       c1 = c2;
       c2 = tmp;
     }
+
     var x1 = (coords[p1] + context.offsetX) * context.scaleX;
     var y1 = (coords[p1 + 1] + context.offsetY) * context.scaleY;
     var x2 = (coords[p2] + context.offsetX) * context.scaleX;
     var y2 = (coords[p2 + 1] + context.offsetY) * context.scaleY;
     var x3 = (coords[p3] + context.offsetX) * context.scaleX;
     var y3 = (coords[p3 + 1] + context.offsetY) * context.scaleY;
+
     if (y1 >= y3) {
       return;
     }
+
     var c1r = colors[c1],
         c1g = colors[c1 + 1],
         c1b = colors[c1 + 2];
     var c2r = colors[c2],
         c2g = colors[c2 + 1],
         c2b = colors[c2 + 2];
     var c3r = colors[c3],
         c3g = colors[c3 + 1],
         c3b = colors[c3 + 2];
     var minY = Math.round(y1),
         maxY = Math.round(y3);
     var xa, car, cag, cab;
     var xb, cbr, cbg, cbb;
     var k;
+
     for (var y = minY; y <= maxY; y++) {
       if (y < y2) {
         k = y < y1 ? 0 : y1 === y2 ? 1 : (y1 - y) / (y1 - y2);
         xa = x1 - (x1 - x2) * k;
         car = c1r - (c1r - c2r) * k;
         cag = c1g - (c1g - c2g) * k;
         cab = c1b - (c1b - c2b) * k;
       } else {
         k = y > y3 ? 1 : y2 === y3 ? 0 : (y2 - y) / (y2 - y3);
         xa = x2 - (x2 - x3) * k;
         car = c2r - (c2r - c3r) * k;
         cag = c2g - (c2g - c3g) * k;
         cab = c2b - (c2b - c3b) * k;
       }
+
       k = y < y1 ? 0 : y > y3 ? 1 : (y1 - y) / (y1 - y3);
       xb = x1 - (x1 - x3) * k;
       cbr = c1r - (c1r - c3r) * k;
       cbg = c1g - (c1g - c3g) * k;
       cbb = c1b - (c1b - c3b) * k;
       var x1_ = Math.round(Math.min(xa, xb));
       var x2_ = Math.round(Math.max(xa, xb));
       var j = rowSize * y + x1_ * 4;
+
       for (var x = x1_; x <= x2_; x++) {
         k = (xa - x) / (xa - xb);
         k = k < 0 ? 0 : k > 1 ? 1 : k;
         bytes[j++] = car - (car - cbr) * k | 0;
         bytes[j++] = cag - (cag - cbg) * k | 0;
         bytes[j++] = cab - (cab - cbb) * k | 0;
         bytes[j++] = 255;
       }
     }
   }
+
   function drawFigure(data, figure, context) {
     var ps = figure.coords;
     var cs = figure.colors;
     var i, ii;
+
     switch (figure.type) {
       case 'lattice':
         var verticesPerRow = figure.verticesPerRow;
         var rows = Math.floor(ps.length / verticesPerRow) - 1;
         var cols = verticesPerRow - 1;
+
         for (i = 0; i < rows; i++) {
           var q = i * verticesPerRow;
+
           for (var j = 0; j < cols; j++, q++) {
             drawTriangle(data, context, ps[q], ps[q + 1], ps[q + verticesPerRow], cs[q], cs[q + 1], cs[q + verticesPerRow]);
             drawTriangle(data, context, ps[q + verticesPerRow + 1], ps[q + 1], ps[q + verticesPerRow], cs[q + verticesPerRow + 1], cs[q + 1], cs[q + verticesPerRow]);
           }
         }
+
         break;
+
       case 'triangles':
         for (i = 0, ii = ps.length; i < ii; i += 3) {
           drawTriangle(data, context, ps[i], ps[i + 1], ps[i + 2], cs[i], cs[i + 1], cs[i + 2]);
         }
+
         break;
+
       default:
         throw new Error('illegal figure');
     }
   }
+
   function createMeshCanvas(bounds, combinesScale, coords, colors, figures, backgroundColor, cachedCanvases, webGLContext) {
     var EXPECTED_SCALE = 1.1;
     var MAX_PATTERN_SIZE = 3000;
     var BORDER_SIZE = 2;
     var offsetX = Math.floor(bounds[0]);
     var offsetY = Math.floor(bounds[1]);
     var boundsWidth = Math.ceil(bounds[2]) - offsetX;
     var boundsHeight = Math.ceil(bounds[3]) - offsetY;
@@ -7995,84 +9795,99 @@ var createMeshCanvas = function createMe
       offsetX: -offsetX,
       offsetY: -offsetY,
       scaleX: 1 / scaleX,
       scaleY: 1 / scaleY
     };
     var paddedWidth = width + BORDER_SIZE * 2;
     var paddedHeight = height + BORDER_SIZE * 2;
     var canvas, tmpCanvas, i, ii;
+
     if (webGLContext.isEnabled) {
       canvas = webGLContext.drawFigures({
         width,
         height,
         backgroundColor,
         figures,
         context
       });
       tmpCanvas = cachedCanvases.getCanvas('mesh', paddedWidth, paddedHeight, false);
       tmpCanvas.context.drawImage(canvas, BORDER_SIZE, BORDER_SIZE);
       canvas = tmpCanvas.canvas;
     } else {
       tmpCanvas = cachedCanvases.getCanvas('mesh', paddedWidth, paddedHeight, false);
       var tmpCtx = tmpCanvas.context;
       var data = tmpCtx.createImageData(width, height);
+
       if (backgroundColor) {
         var bytes = data.data;
+
         for (i = 0, ii = bytes.length; i < ii; i += 4) {
           bytes[i] = backgroundColor[0];
           bytes[i + 1] = backgroundColor[1];
           bytes[i + 2] = backgroundColor[2];
           bytes[i + 3] = 255;
         }
       }
+
       for (i = 0; i < figures.length; i++) {
         drawFigure(data, figures[i], context);
       }
+
       tmpCtx.putImageData(data, BORDER_SIZE, BORDER_SIZE);
       canvas = tmpCanvas.canvas;
     }
+
     return {
       canvas,
       offsetX: offsetX - BORDER_SIZE * scaleX,
       offsetY: offsetY - BORDER_SIZE * scaleY,
       scaleX,
       scaleY
     };
   }
+
   return createMeshCanvas;
 }();
+
 ShadingIRs.Mesh = {
   fromIR: function Mesh_fromIR(raw) {
     var coords = raw[2];
     var colors = raw[3];
     var figures = raw[4];
     var bounds = raw[5];
     var matrix = raw[6];
     var background = raw[8];
     return {
       type: 'Pattern',
       getPattern: function Mesh_getPattern(ctx, owner, shadingFill) {
         var scale;
+
         if (shadingFill) {
           scale = _util.Util.singularValueDecompose2dScale(ctx.mozCurrentTransform);
         } else {
           scale = _util.Util.singularValueDecompose2dScale(owner.baseTransform);
+
           if (matrix) {
             var matrixScale = _util.Util.singularValueDecompose2dScale(matrix);
+
             scale = [scale[0] * matrixScale[0], scale[1] * matrixScale[1]];
           }
         }
+
         var temporaryPatternCanvas = createMeshCanvas(bounds, scale, coords, colors, figures, shadingFill ? null : background, owner.cachedCanvases, owner.webGLContext);
+
         if (!shadingFill) {
           ctx.setTransform.apply(ctx, owner.baseTransform);
+
           if (matrix) {
             ctx.transform.apply(ctx, matrix);
           }
         }
+
         ctx.translate(temporaryPatternCanvas.offsetX, temporaryPatternCanvas.offsetY);
         ctx.scale(temporaryPatternCanvas.scaleX, temporaryPatternCanvas.scaleY);
         return ctx.createPattern(temporaryPatternCanvas.canvas, 'no-repeat');
       }
     };
   }
 };
 ShadingIRs.Dummy = {
@@ -8080,43 +9895,49 @@ ShadingIRs.Dummy = {
     return {
       type: 'Pattern',
       getPattern: function Dummy_fromIR_getPattern() {
         return 'hotpink';
       }
     };
   }
 };
+
 function getShadingPatternFromIR(raw) {
   var shadingIR = ShadingIRs[raw[0]];
+
   if (!shadingIR) {
     throw new Error(`Unknown IR type: ${raw[0]}`);
   }
+
   return shadingIR.fromIR(raw);
 }
+
 var TilingPattern = function TilingPatternClosure() {
   var PaintType = {
     COLORED: 1,
     UNCOLORED: 2
   };
   var MAX_PATTERN_SIZE = 3000;
+
   function TilingPattern(IR, color, ctx, canvasGraphicsFactory, baseTransform) {
     this.operatorList = IR[2];
     this.matrix = IR[3] || [1, 0, 0, 1, 0, 0];
     this.bbox = IR[4];
     this.xstep = IR[5];
     this.ystep = IR[6];
     this.paintType = IR[7];
     this.tilingType = IR[8];
     this.color = color;
     this.canvasGraphicsFactory = canvasGraphicsFactory;
     this.baseTransform = baseTransform;
     this.type = 'Pattern';
     this.ctx = ctx;
   }
+
   TilingPattern.prototype = {
     createPatternCanvas: function TilinPattern_createPatternCanvas(owner) {
       var operatorList = this.operatorList;
       var bbox = this.bbox;
       var xstep = this.xstep;
       var ystep = this.ystep;
       var paintType = this.paintType;
       var tilingType = this.tilingType;
@@ -8126,18 +9947,21 @@ var TilingPattern = function TilingPatte
       var x0 = bbox[0],
           y0 = bbox[1],
           x1 = bbox[2],
           y1 = bbox[3];
       var topLeft = [x0, y0];
       var botRight = [x0 + xstep, y0 + ystep];
       var width = botRight[0] - topLeft[0];
       var height = botRight[1] - topLeft[1];
+
       var matrixScale = _util.Util.singularValueDecompose2dScale(this.matrix);
+
       var curMatrixScale = _util.Util.singularValueDecompose2dScale(this.baseTransform);
+
       var combinedScale = [matrixScale[0] * curMatrixScale[0], matrixScale[1] * curMatrixScale[1]];
       width = Math.min(Math.ceil(Math.abs(width * combinedScale[0])), MAX_PATTERN_SIZE);
       height = Math.min(Math.ceil(Math.abs(height * combinedScale[1])), MAX_PATTERN_SIZE);
       var tmpCanvas = owner.cachedCanvases.getCanvas('pattern', width, height, true);
       var tmpCtx = tmpCanvas.context;
       var graphics = canvasGraphicsFactory.createCanvasGraphics(tmpCtx);
       graphics.groupLevel = owner.groupLevel;
       this.setFillAndStrokeStyleToContext(graphics, paintType, color);
@@ -8168,148 +9992,170 @@ var TilingPattern = function TilingPatte
         graphics.ctx.rect(x0, y0, bboxWidth, bboxHeight);
         graphics.clip();
         graphics.endPath();
       }
     },
     setFillAndStrokeStyleToContext: function setFillAndStrokeStyleToContext(graphics, paintType, color) {
       let context = graphics.ctx,
           current = graphics.current;
+
       switch (paintType) {
         case PaintType.COLORED:
           var ctx = this.ctx;
           context.fillStyle = ctx.fillStyle;
           context.strokeStyle = ctx.strokeStyle;
           current.fillColor = ctx.fillStyle;
           current.strokeColor = ctx.strokeStyle;
           break;
+
         case PaintType.UNCOLORED:
           var cssColor = _util.Util.makeCssRgb(color[0], color[1], color[2]);
+
           context.fillStyle = cssColor;
           context.strokeStyle = cssColor;
           current.fillColor = cssColor;
           current.strokeColor = cssColor;
           break;
+
         default:
           throw new _util.FormatError(`Unsupported paint type: ${paintType}`);
       }
     },
     getPattern: function TilingPattern_getPattern(ctx, owner) {
       var temporaryPatternCanvas = this.createPatternCanvas(owner);
       ctx = this.ctx;
       ctx.setTransform.apply(ctx, this.baseTransform);
       ctx.transform.apply(ctx, this.matrix);
       this.scaleToContext();
       return ctx.createPattern(temporaryPatternCanvas, 'repeat');
     }
   };
   return TilingPattern;
 }();
-exports.getShadingPatternFromIR = getShadingPatternFromIR;
+
 exports.TilingPattern = TilingPattern;
 
 /***/ }),
 /* 13 */
 /***/ (function(module, exports, __w_pdfjs_require__) {
 
 "use strict";
 
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.GlobalWorkerOptions = void 0;
 const GlobalWorkerOptions = Object.create(null);
+exports.GlobalWorkerOptions = GlobalWorkerOptions;
 GlobalWorkerOptions.workerPort = GlobalWorkerOptions.workerPort === undefined ? null : GlobalWorkerOptions.workerPort;
 GlobalWorkerOptions.workerSrc = GlobalWorkerOptions.workerSrc === undefined ? '' : GlobalWorkerOptions.workerSrc;
-exports.GlobalWorkerOptions = GlobalWorkerOptions;
 
 /***/ }),
 /* 14 */
 /***/ (function(module, exports, __w_pdfjs_require__) {
 
 "use strict";
 
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.MessageHandler = undefined;
+exports.MessageHandler = MessageHandler;
 
 var _util = __w_pdfjs_require__(1);
 
 async function resolveCall(fn, args, thisArg = null) {
   if (!fn) {
     return;
   }
+
   return fn.apply(thisArg, args);
 }
+
 function wrapReason(reason) {
   if (typeof reason !== 'object') {
     return reason;
   }
+
   switch (reason.name) {
     case 'AbortException':
       return new _util.AbortException(reason.message);
+
     case 'MissingPDFException':
       return new _util.MissingPDFException(reason.message);
+
     case 'UnexpectedResponseException':
       return new _util.UnexpectedResponseException(reason.message, reason.status);
+
     default:
       return new _util.UnknownErrorException(reason.message, reason.details);
   }
 }
+
 function makeReasonSerializable(reason) {
   if (!(reason instanceof Error) || reason instanceof _util.AbortException || reason instanceof _util.MissingPDFException || reason instanceof _util.UnexpectedResponseException || reason instanceof _util.UnknownErrorException) {
     return reason;
   }
+
   return new _util.UnknownErrorException(reason.message, reason.toString());
 }
+
 function resolveOrReject(capability, success, reason) {
   if (success) {
     capability.resolve();
   } else {
     capability.reject(reason);
   }
 }
+
 function finalize(promise) {
   return Promise.resolve(promise).catch(() => {});
 }
+
 function MessageHandler(sourceName, targetName, comObj) {
   this.sourceName = sourceName;
   this.targetName = targetName;
   this.comObj = comObj;
   this.callbackId = 1;
   this.streamId = 1;
   this.postMessageTransfers = true;
   this.streamSinks = Object.create(null);
   this.streamControllers = Object.create(null);
   let callbacksCapabilities = this.callbacksCapabilities = Object.create(null);
   let ah = this.actionHandler = Object.create(null);
+
   this._onComObjOnMessage = event => {
     let data = event.data;
+
     if (data.targetName !== this.sourceName) {
       return;
     }
+
     if (data.stream) {
       this._processStreamMessage(data);
     } else if (data.isReply) {
       let callbackId = data.callbackId;
+
       if (data.callbackId in callbacksCapabilities) {
         let callback = callbacksCapabilities[callbackId];
         delete callbacksCapabilities[callbackId];
+
         if ('error' in data) {
           callback.reject(wrapReason(data.error));
         } else {
           callback.resolve(data.data);
         }
       } else {
         throw new Error(`Cannot resolve callback ${callbackId}`);
       }
     } else if (data.action in ah) {
       let action = ah[data.action];
+
       if (data.callbackId) {
         let sourceName = this.sourceName;
         let targetName = data.sourceName;
         Promise.resolve().then(function () {
           return action[0].call(action[1], data.data);
         }).then(result => {
           comObj.postMessage({
             sourceName,
@@ -8331,53 +10177,62 @@ function MessageHandler(sourceName, targ
         this._createStreamSink(data);
       } else {
         action[0].call(action[1], data.data);
       }
     } else {
       throw new Error(`Unknown action from worker: ${data.action}`);
     }
   };
+
   comObj.addEventListener('message', this._onComObjOnMessage);
 }
+
 MessageHandler.prototype = {
   on(actionName, handler, scope) {
     var ah = this.actionHandler;
+
     if (ah[actionName]) {
       throw new Error(`There is already an actionName called "${actionName}"`);
     }
+
     ah[actionName] = [handler, scope];
   },
+
   send(actionName, data, transfers) {
     var message = {
       sourceName: this.sourceName,
       targetName: this.targetName,
       action: actionName,
       data
     };
     this.postMessage(message, transfers);
   },
+
   sendWithPromise(actionName, data, transfers) {
     var callbackId = this.callbackId++;
     var message = {
       sourceName: this.sourceName,
       targetName: this.targetName,
       action: actionName,
       data,
       callbackId
     };
     var capability = (0, _util.createPromiseCapability)();
     this.callbacksCapabilities[callbackId] = capability;
+
     try {
       this.postMessage(message, transfers);
     } catch (e) {
       capability.reject(e);
     }
+
     return capability.promise;
   },
+
   sendWithStream(actionName, data, queueingStrategy, transfers) {
     let streamId = this.streamId++;
     let sourceName = this.sourceName;
     let targetName = this.targetName;
     return new _util.ReadableStream({
       start: controller => {
         let startCapability = (0, _util.createPromiseCapability)();
         this.streamControllers[streamId] = {
@@ -8417,70 +10272,89 @@ MessageHandler.prototype = {
           stream: 'cancel',
           reason,
           streamId
         });
         return cancelCapability.promise;
       }
     }, queueingStrategy);
   },
+
   _createStreamSink(data) {
     let self = this;
     let action = this.actionHandler[data.action];
     let streamId = data.streamId;
     let desiredSize = data.desiredSize;
     let sourceName = this.sourceName;
     let targetName = data.sourceName;
     let capability = (0, _util.createPromiseCapability)();
-    let sendStreamRequest = ({ stream, chunk, transfers, success, reason }) => {
+
+    let sendStreamRequest = ({
+      stream,
+      chunk,
+      transfers,
+      success,
+      reason
+    }) => {
       this.postMessage({
         sourceName,
         targetName,
         stream,
         streamId,
         chunk,
         success,
         reason
       }, transfers);
     };
+
     let streamSink = {
       enqueue(chunk, size = 1, transfers) {
         if (this.isCancelled) {
           return;
         }
+
         let lastDesiredSize = this.desiredSize;
         this.desiredSize -= size;
+
         if (lastDesiredSize > 0 && this.desiredSize <= 0) {
           this.sinkCapability = (0, _util.createPromiseCapability)();
           this.ready = this.sinkCapability.promise;
         }
+
         sendStreamRequest({
           stream: 'enqueue',
           chunk,
           transfers
         });
       },
+
       close() {
         if (this.isCancelled) {
           return;
         }
+
         this.isCancelled = true;
-        sendStreamRequest({ stream: 'close' });
+        sendStreamRequest({
+          stream: 'close'
+        });
         delete self.streamSinks[streamId];
       },
+
       error(reason) {
         if (this.isCancelled) {
           return;
         }
+
         this.isCancelled = true;
         sendStreamRequest({
           stream: 'error',
           reason
         });
       },
+
       sinkCapability: capability,
       onPull: null,
       onCancel: null,
       isCancelled: false,
       desiredSize,
       ready: null
     };
     streamSink.sinkCapability.resolve();
@@ -8494,885 +10368,1134 @@ MessageHandler.prototype = {
     }, reason => {
       sendStreamRequest({
         stream: 'start_complete',
         success: false,
         reason
       });
     });
   },
+
   _processStreamMessage(data) {
     let sourceName = this.sourceName;
     let targetName = data.sourceName;
     let streamId = data.streamId;
-    let sendStreamResponse = ({ stream, success, reason }) => {
+
+    let sendStreamResponse = ({
+      stream,
+      success,
+      reason
+    }) => {
       this.comObj.postMessage({
         sourceName,
         targetName,
         stream,
         success,
         streamId,
         reason
       });
     };
+
     let deleteStreamController = () => {
       Promise.all([this.streamControllers[data.streamId].startCall, this.streamControllers[data.streamId].pullCall, this.streamControllers[data.streamId].cancelCall].map(function (capability) {
         return capability && finalize(capability.promise);
       })).then(() => {
         delete this.streamControllers[data.streamId];
       });
     };
+
     switch (data.stream) {
       case 'start_complete':
         resolveOrReject(this.streamControllers[data.streamId].startCall, data.success, wrapReason(data.reason));
         break;
+
       case 'pull_complete':
         resolveOrReject(this.streamControllers[data.streamId].pullCall, data.success, wrapReason(data.reason));
         break;
+
       case 'pull':
         if (!this.streamSinks[data.streamId]) {
           sendStreamResponse({
             stream: 'pull_complete',
             success: true
           });
           break;
         }
+
         if (this.streamSinks[data.streamId].desiredSize <= 0 && data.desiredSize > 0) {
           this.streamSinks[data.streamId].sinkCapability.resolve();
         }
+
         this.streamSinks[data.streamId].desiredSize = data.desiredSize;
         resolveCall(this.streamSinks[data.streamId].onPull).then(() => {
           sendStreamResponse({
             stream: 'pull_complete',
             success: true
           });
         }, reason => {
           sendStreamResponse({
             stream: 'pull_complete',
             success: false,
             reason
           });
         });
         break;
+
       case 'enqueue':
         (0, _util.assert)(this.streamControllers[data.streamId], 'enqueue should have stream controller');
+
         if (!this.streamControllers[data.streamId].isClosed) {
           this.streamControllers[data.streamId].controller.enqueue(data.chunk);
         }
+
         break;
+
       case 'close':
         (0, _util.assert)(this.streamControllers[data.streamId], 'close should have stream controller');
+
         if (this.streamControllers[data.streamId].isClosed) {
           break;
         }
+
         this.streamControllers[data.streamId].isClosed = true;
         this.streamControllers[data.streamId].controller.close();
         deleteStreamController();
         break;
+
       case 'error':
         (0, _util.assert)(this.streamControllers[data.streamId], 'error should have stream controller');
         this.streamControllers[data.streamId].controller.error(wrapReason(data.reason));
         deleteStreamController();
         break;
+
       case 'cancel_complete':
         resolveOrReject(this.streamControllers[data.streamId].cancelCall, data.success, wrapReason(data.reason));
         deleteStreamController();
         break;
+
       case 'cancel':
         if (!this.streamSinks[data.streamId]) {
           break;
         }
+
         resolveCall(this.streamSinks[data.streamId].onCancel, [wrapReason(data.reason)]).then(() => {
           sendStreamResponse({
             stream: 'cancel_complete',
             success: true
           });
         }, reason => {
           sendStreamResponse({
             stream: 'cancel_complete',
             success: false,
             reason
           });
         });
         this.streamSinks[data.streamId].sinkCapability.reject(wrapReason(data.reason));
         this.streamSinks[data.streamId].isCancelled = true;
         delete this.streamSinks[data.streamId];
         break;
+
       default:
         throw new Error('Unexpected stream case');
     }
   },
+
   postMessage(message, transfers) {
     if (transfers && this.postMessageTransfers) {
       this.comObj.postMessage(message, transfers);
     } else {
       this.comObj.postMessage(message);
     }
   },
+
   destroy() {
     this.comObj.removeEventListener('message', this._onComObjOnMessage);
   }
+
 };
-exports.MessageHandler = MessageHandler;
 
 /***/ }),
 /* 15 */
 /***/ (function(module, exports, __w_pdfjs_require__) {
 
 "use strict";
 
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.Metadata = undefined;
+exports.Metadata = void 0;
 
 var _util = __w_pdfjs_require__(1);
 
 var _xml_parser = __w_pdfjs_require__(16);
 
 class Metadata {
   constructor(data) {
     (0, _util.assert)(typeof data === 'string', 'Metadata: input is not a string');
     data = this._repair(data);
     let parser = new _xml_parser.SimpleXMLParser();
     const xmlDocument = parser.parseFromString(data);
     this._metadata = Object.create(null);
+
     if (xmlDocument) {
       this._parse(xmlDocument);
     }
   }
+
   _repair(data) {
     return data.replace(/>\\376\\377([^<]+)/g, function (all, codes) {
       let 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 'gt':
             return '>';
+
           case 'lt':
             return '<';
+
           case 'quot':
             return '\"';
         }
+
         throw new Error(`_repair: ${name} isn't defined.`);
       });
       let chars = '';
+
       for (let i = 0, ii = bytes.length; i < ii; i += 2) {
         let 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) + ';';
         }
       }
+
       return '>' + chars;
     });
   }
+
   _parse(xmlDocument) {
     let rdf = xmlDocument.documentElement;
+
     if (rdf.nodeName.toLowerCase() !== 'rdf:rdf') {
       rdf = rdf.firstChild;
+
       while (rdf && rdf.nodeName.toLowerCase() !== 'rdf:rdf') {
         rdf = rdf.nextSibling;
       }
     }
+
     let nodeName = rdf ? rdf.nodeName.toLowerCase() : null;
+
     if (!rdf || nodeName !== 'rdf:rdf' || !rdf.hasChildNodes()) {
       return;
     }
+
     let children = rdf.childNodes;
+
     for (let i = 0, ii = children.length; i < ii; i++) {
       let desc = children[i];
+
       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') {
           let entry = desc.childNodes[j];
           let name = entry.nodeName.toLowerCase();
           this._metadata[name] = entry.textContent.trim();
         }
       }
     }
   }
+
   get(name) {
     return this._metadata[name] || null;
   }
+
   getAll() {
     return this._metadata;
   }
+
   has(name) {
     return typeof this._metadata[name] !== 'undefined';
   }
-}
+
+}
+
 exports.Metadata = Metadata;
 
 /***/ }),
 /* 16 */
 /***/ (function(module, exports, __w_pdfjs_require__) {
 
 "use strict";
 
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.SimpleXMLParser = void 0;
 const XMLParserErrorCode = {
   NoError: 0,
   EndOfDocument: -1,
   UnterminatedCdat: -2,
   UnterminatedXmlDeclaration: -3,
   UnterminatedDoctypeDeclaration: -4,
   UnterminatedComment: -5,
   MalformedElement: -6,
   OutOfMemory: -7,
   UnterminatedAttributeValue: -8,
   UnterminatedElement: -9,
   ElementNeverBegun: -10
 };
+
 function isWhitespace(s, index) {
   const ch = s[index];
   return ch === ' ' || ch === '\n' || ch === '\r' || ch === '\t';
 }
+
 function isWhitespaceString(s) {
   for (let i = 0, ii = s.length; i < ii; i++) {
     if (!isWhitespace(s, i)) {
       return false;
     }
   }
+
   return true;
 }
+
 class XMLParserBase {
   _resolveEntities(s) {
     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));
       }
+
       switch (entity) {
         case 'lt':
           return '<';
+
         case 'gt':
           return '>';
+
         case 'amp':
           return '&';
+
         case 'quot':
           return '\"';
       }
+
       return this.onResolveEntity(entity);
     });
   }
+
   _parseContent(s, start) {
     let pos = start,
         name,
         attributes = [];
+
     function skipWs() {
       while (pos < s.length && isWhitespace(s, pos)) {
         ++pos;
       }
     }
+
     while (pos < s.length && !isWhitespace(s, pos) && s[pos] !== '>' && s[pos] !== '/') {
       ++pos;
     }
+
     name = s.substring(start, pos);
     skipWs();
+
     while (pos < s.length && s[pos] !== '>' && s[pos] !== '/' && s[pos] !== '?') {
       skipWs();
       let attrName = '',
           attrValue = '';
+
       while (pos < s.length && !isWhitespace(s, pos) && s[pos] !== '=') {
         attrName += s[pos];
         ++pos;
       }
+
       skipWs();
+
       if (s[pos] !== '=') {
         return null;
       }
+
       ++pos;
       skipWs();
       const attrEndChar = s[pos];
+
       if (attrEndChar !== '\"' && attrEndChar !== '\'') {
         return null;
       }
+
       const attrEndIndex = s.indexOf(attrEndChar, ++pos);
+
       if (attrEndIndex < 0) {
         return null;
       }
+
       attrValue = s.substring(pos, attrEndIndex);
       attributes.push({
         name: attrName,
         value: this._resolveEntities(attrValue)
       });
       pos = attrEndIndex + 1;
       skipWs();
     }
+
     return {
       name,
       attributes,
       parsed: pos - start
     };
   }
+
   _parseProcessingInstruction(s, start) {
     let pos = start,
         name,
         value;
+
     function skipWs() {
       while (pos < s.length && isWhitespace(s, pos)) {
         ++pos;
       }
     }
+
     while (pos < s.length && !isWhitespace(s, pos) && s[pos] !== '>' && s[pos] !== '/') {
       ++pos;
     }
+
     name = s.substring(start, pos);
     skipWs();
     const attrStart = pos;
+
     while (pos < s.length && (s[pos] !== '?' || s[pos + 1] !== '>')) {
       ++pos;
     }
+
     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);
+
             if (q < 0) {
               this.onError(XMLParserErrorCode.UnterminatedElement);
               return;
             }
+
             this.onEndElement(s.substring(j, q));
             j = q + 1;
             break;
+
           case '?':
             ++j;
+
             const pi = this._parseProcessingInstruction(s, j);
+
             if (s.substring(j + pi.parsed, j + pi.parsed + 2) !== '?>') {
               this.onError(XMLParserErrorCode.UnterminatedXmlDeclaration);
               return;
             }
+
             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.UnterminatedComment);
                 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);
+
               if (q < 0) {
                 this.onError(XMLParserErrorCode.UnterminatedCdat);
                 return;
               }
+
               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);
+
               if (q < 0) {
                 this.onError(XMLParserErrorCode.UnterminatedDoctypeDeclaration);
                 return;
               }
+
               if (q2 > 0 && q > q2) {
                 q = s.indexOf(']>', j + 8);
+
                 if (q < 0) {
                   this.onError(XMLParserErrorCode.UnterminatedDoctypeDeclaration);
                   return;
                 }
+
                 complexDoctype = true;
               }
+
               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;
             }
+
             let isClosed = false;
+
             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;
             }
+
             this.onBeginElement(content.name, content.attributes, isClosed);
             j += content.parsed + (isClosed ? 2 : 1);
             break;
         }
       } else {
         while (j < s.length && s[j] !== '<') {
           j++;
         }
+
         const text = s.substring(i, j);
         this.onText(this._resolveEntities(text));
       }
+
       i = j;
     }
   }
+
   onResolveEntity(name) {
     return `&${name};`;
   }
+
   onPi(name, value) {}
+
   onComment(text) {}
+
   onCdata(text) {}
+
   onDoctype(doctypeContent) {}
+
   onText(text) {}
+
   onBeginElement(name, attributes, isEmpty) {}
+
   onEndElement(name) {}
+
   onError(code) {}
-}
+
+}
+
 class SimpleDOMNode {
   constructor(nodeName, nodeValue) {
     this.nodeName = nodeName;
     this.nodeValue = nodeValue;
     Object.defineProperty(this, 'parentNode', {
       value: null,
       writable: true
     });
   }
+
   get firstChild() {
     return this.childNodes[0];
   }
+
   get nextSibling() {
     let index = this.parentNode.childNodes.indexOf(this);
     return this.parentNode.childNodes[index + 1];
   }
+
   get textContent() {
     if (!this.childNodes) {
       return this.nodeValue || '';
     }
+
     return this.childNodes.map(function (child) {
       return child.textContent;
     }).join('');
   }
+
   hasChildNodes() {
     return this.childNodes && this.childNodes.length > 0;
   }
-}
+
+}
+
 class SimpleXMLParser extends XMLParserBase {
   constructor() {
     super();
     this._currentFragment = null;
     this._stack = null;
     this._errorCode = XMLParserErrorCode.NoError;
   }
+
   parseFromString(data) {
     this._currentFragment = [];
     this._stack = [];
     this._errorCode = XMLParserErrorCode.NoError;
     this.parseXml(data);
+
     if (this._errorCode !== XMLParserErrorCode.NoError) {
       return undefined;
     }
+
     const [documentElement] = this._currentFragment;
+
     if (!documentElement) {
       return undefined;
     }
-    return { documentElement };
-  }
+
+    return {
+      documentElement
+    };
+  }
+
   onResolveEntity(name) {
     switch (name) {
       case 'apos':
         return '\'';
     }
+
     return super.onResolveEntity(name);
   }
+
   onText(text) {
     if (isWhitespaceString(text)) {
       return;
     }
+
     const node = new SimpleDOMNode('#text', text);
+
     this._currentFragment.push(node);
   }
+
   onCdata(text) {
     const node = new SimpleDOMNode('#text', text);
+
     this._currentFragment.push(node);
   }
+
   onBeginElement(name, attributes, isEmpty) {
     const node = new SimpleDOMNode(name);
     node.childNodes = [];
+
     this._currentFragment.push(node);
+
     if (isEmpty) {
       return;
     }
+
     this._stack.push(this._currentFragment);
+
     this._currentFragment = node.childNodes;
   }
+
   onEndElement(name) {
     this._currentFragment = this._stack.pop();
     const lastElement = this._currentFragment[this._currentFragment.length - 1];
+
     for (let i = 0, ii = lastElement.childNodes.length; i < ii; i++) {
       lastElement.childNodes[i].parentNode = lastElement;
     }
   }
+
   onError(code) {
     this._errorCode = code;
   }
-}
+
+}
+
 exports.SimpleXMLParser = SimpleXMLParser;
 
 /***/ }),
 /* 17 */
 /***/ (function(module, exports, __w_pdfjs_require__) {
 
 "use strict";
 
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.PDFDataTransportStream = undefined;
+exports.PDFDataTransportStream = void 0;
 
 var _util = __w_pdfjs_require__(1);
 
 var PDFDataTransportStream = function PDFDataTransportStreamClosure() {
   function PDFDataTransportStream(params, pdfDataRangeTransport) {
     (0, _util.assert)(pdfDataRangeTransport);
     this._queuedChunks = [];
     var initialData = params.initialData;
+
     if (initialData && initialData.length > 0) {
       let buffer = new Uint8Array(initialData).buffer;
+
       this._queuedChunks.push(buffer);
     }
+
     this._pdfDataRangeTransport = pdfDataRangeTransport;
     this._isStreamingSupported = !params.disableStream;
     this._isRangeSupported = !params.disableRange;
     this._contentLength = params.length;
     this._fullRequestReader = null;
     this._rangeReaders = [];
+
     this._pdfDataRangeTransport.addRangeListener((begin, chunk) => {
       this._onReceiveData({
         begin,
         chunk
       });
     });
+
     this._pdfDataRangeTransport.addProgressListener(loaded => {
-      this._onProgress({ loaded });
+      this._onProgress({
+        loaded
+      });
     });
+
     this._pdfDataRangeTransport.addProgressiveReadListener(chunk => {
-      this._onReceiveData({ chunk });
+      this._onReceiveData({
+        chunk
+      });
     });
+
     this._pdfDataRangeTransport.transportReady();
   }
+
   PDFDataTransportStream.prototype = {
     _onReceiveData: function PDFDataTransportStream_onReceiveData(args) {
       let buffer = new Uint8Array(args.chunk).buffer;
+
       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);
+
           return true;
         });
+
         (0, _util.assert)(found);
       }
     },
     _onProgress: function PDFDataTransportStream_onDataProgress(evt) {
       if (this._rangeReaders.length > 0) {
         var firstReader = this._rangeReaders[0];
+
         if (firstReader.onProgress) {
-          firstReader.onProgress({ loaded: evt.loaded });
+          firstReader.onProgress({
+            loaded: evt.loaded
+          });
         }
       }
     },
     _removeRangeReader: function PDFDataTransportStream_removeRangeReader(reader) {
       var i = this._rangeReaders.indexOf(reader);
+
       if (i >= 0) {
         this._rangeReaders.splice(i, 1);
       }
     },
     getFullReader: function PDFDataTransportStream_getFullReader() {
       (0, _util.assert)(!this._fullRequestReader);
       var queuedChunks = this._queuedChunks;
       this._queuedChunks = null;
       return new PDFDataTransportStreamReader(this, queuedChunks);
     },
     getRangeReader: function PDFDataTransportStream_getRangeReader(begin, end) {
       var reader = new PDFDataTransportStreamRangeReader(this, begin, end);
+
       this._pdfDataRangeTransport.requestDataRange(begin, end);
+
       this._rangeReaders.push(reader);
+
       return reader;
     },
     cancelAllRequests: function PDFDataTransportStream_cancelAllRequests(reason) {
       if (this._fullRequestReader) {
         this._fullRequestReader.cancel(reason);
       }
+
       var readers = this._rangeReaders.slice(0);
+
       readers.forEach(function (rangeReader) {
         rangeReader.cancel(reason);
       });
+
       this._pdfDataRangeTransport.abort();
     }
   };
+
   function PDFDataTransportStreamReader(stream, queuedChunks) {
     this._stream = stream;
     this._done = false;
     this._filename = null;
     this._queuedChunks = queuedChunks || [];
     this._requests = [];
     this._headersReady = Promise.resolve();
     stream._fullRequestReader = this;
     this.onProgress = null;
   }
+
   PDFDataTransportStreamReader.prototype = {
     _enqueue: function PDFDataTransportStreamReader_enqueue(chunk) {
       if (this._done) {
         return;
       }
+
       if (this._requests.length > 0) {
         var requestCapability = this._requests.shift();
+
         requestCapability.resolve({
           value: chunk,
           done: false
         });
         return;
       }
+
       this._queuedChunks.push(chunk);
     },
+
     get headersReady() {
       return this._headersReady;
     },
+
     get filename() {
       return this._filename;
     },
+
     get isRangeSupported() {
       return this._stream._isRangeSupported;
     },
+
     get isStreamingSupported() {
       return this._stream._isStreamingSupported;
     },
+
     get contentLength() {
       return this._stream._contentLength;
     },
+
     async read() {
       if (this._queuedChunks.length > 0) {
         var chunk = this._queuedChunks.shift();
+
         return {
           value: chunk,
           done: false
         };
       }
+
       if (this._done) {
         return {
           value: undefined,
           done: true
         };
       }
+
       var requestCapability = (0, _util.createPromiseCapability)();
+
       this._requests.push(requestCapability);
+
       return requestCapability.promise;
     },
+
     cancel: function PDFDataTransportStreamReader_cancel(reason) {
       this._done = true;
+
       this._requests.forEach(function (requestCapability) {
         requestCapability.resolve({
           value: undefined,
           done: true
         });
       });
+
       this._requests = [];
     }
   };
+
   function PDFDataTransportStreamRangeReader(stream, begin, end) {
     this._stream = stream;
     this._begin = begin;
     this._end = end;
     this._queuedChunk = null;
     this._requests = [];
     this._done = false;
     this.onProgress = null;
   }
+
   PDFDataTransportStreamRangeReader.prototype = {
     _enqueue: function PDFDataTransportStreamRangeReader_enqueue(chunk) {
       if (this._done) {
         return;
       }
+
       if (this._requests.length === 0) {
         this._queuedChunk = chunk;
       } else {
         var requestsCapability = this._requests.shift();
+
         requestsCapability.resolve({
           value: chunk,
           done: false
         });
+
         this._requests.forEach(function (requestCapability) {
           requestCapability.resolve({
             value: undefined,
             done: true
           });
         });
+
         this._requests = [];
       }
+
       this._done = true;
+
       this._stream._removeRangeReader(this);
     },
+
     get isStreamingSupported() {
       return false;
     },
+
     async read() {
       if (this._queuedChunk) {
         let chunk = this._queuedChunk;
         this._queuedChunk = null;
         return {
           value: chunk,
           done: false
         };
       }
+
       if (this._done) {
         return {
           value: undefined,
           done: true
         };
       }
+
       var requestCapability = (0, _util.createPromiseCapability)();
+
       this._requests.push(requestCapability);
+
       return requestCapability.promise;
     },
+
     cancel: function PDFDataTransportStreamRangeReader_cancel(reason) {
       this._done = true;
+
       this._requests.forEach(function (requestCapability) {
         requestCapability.resolve({
           value: undefined,
           done: true
         });
       });
+
       this._requests = [];
+
       this._stream._removeRangeReader(this);
     }
   };
   return PDFDataTransportStream;
 }();
+
 exports.PDFDataTransportStream = PDFDataTransportStream;
 
 /***/ }),
 /* 18 */
 /***/ (function(module, exports, __w_pdfjs_require__) {
 
 "use strict";
 
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.WebGLContext = undefined;
+exports.WebGLContext = void 0;
 
 var _util = __w_pdfjs_require__(1);
 
 class WebGLContext {
   constructor({
     enable = false
   }) {
     this._enabled = enable === true;
   }
+
   get isEnabled() {
     let enabled = this._enabled;
+
     if (enabled) {
       enabled = WebGLUtils.tryInitGL();
     }
+
     return (0, _util.shadow)(this, 'isEnabled', enabled);
   }
-  composeSMask({ layer, mask, properties }) {
+
+  composeSMask({
+    layer,
+    mask,
+    properties
+  }) {
     return WebGLUtils.composeSMask(layer, mask, properties);
   }
-  drawFigures({ width, height, backgroundColor, figures, context }) {
+
+  drawFigures({
+    width,
+    height,
+    backgroundColor,
+    figures,
+    context
+  }) {
     return WebGLUtils.drawFigures(width, height, backgroundColor, figures, context);
   }
+
   clear() {
     WebGLUtils.cleanup();
   }
-}
+
+}
+
+exports.WebGLContext = WebGLContext;
+
 var WebGLUtils = function WebGLUtilsClosure() {
   function loadShader(gl, code, shaderType) {
     var shader = gl.createShader(shaderType);
     gl.shaderSource(shader, code);
     gl.compileShader(shader);
     var compiled = gl.getShaderParameter(shader, gl.COMPILE_STATUS);
+
     if (!compiled) {
       var errorMsg = gl.getShaderInfoLog(shader);
       throw new Error('Error during shader compilation: ' + errorMsg);
     }
+
     return shader;
   }
+
   function createVertexShader(gl, code) {
     return loadShader(gl, code, gl.VERTEX_SHADER);
   }
+
   function createFragmentShader(gl, code) {
     return loadShader(gl, code, gl.FRAGMENT_SHADER);
   }
+
   function createProgram(gl, shaders) {
     var program = gl.createProgram();
+
     for (var i = 0, ii = shaders.length; i < ii; ++i) {
       gl.attachShader(program, shaders[i]);
     }
+
     gl.linkProgram(program);
     var linked = gl.getProgramParameter(program, gl.LINK_STATUS);
+
     if (!linked) {
       var errorMsg = gl.getProgramInfoLog(program);
       throw new Error('Error during program linking: ' + errorMsg);
     }
+
     return program;
   }
+
   function createTexture(gl, image, textureId) {
     gl.activeTexture(textureId);
     var texture = gl.createTexture();
     gl.bindTexture(gl.TEXTURE_2D, texture);
     gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
     gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
     gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
     gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
     gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, image);
     return texture;
   }
+
   var currentGL, currentCanvas;
+
   function generateGL() {
     if (currentGL) {
       return;
     }
+
     currentCanvas = document.createElement('canvas');
-    currentGL = currentCanvas.getContext('webgl', { premultipliedalpha: false });
-  }
+    currentGL = currentCanvas.getContext('webgl', {
+      premultipliedalpha: false
+    });
+  }
+
   var smaskVertexShaderCode = '\
   attribute vec2 a_position;                                    \
   attribute vec2 a_texCoord;                                    \
                                                                 \
   uniform vec2 u_resolution;                                    \
                                                                 \
   varying vec2 v_texCoord;                                      \
                                                                 \
@@ -9406,16 +11529,17 @@ var WebGLUtils = function WebGLUtilsClos
       lum = maskColor.r * 0.3 + maskColor.g * 0.59 +            \
             maskColor.b * 0.11;                                 \
     }                                                           \
     imageColor.a *= lum;                                        \
     imageColor.rgb *= imageColor.a;                             \
     gl_FragColor = imageColor;                                  \
   }                                                             ';
   var smaskCache = null;
+
   function initSmaskGL() {
     var canvas, gl;
     generateGL();
     canvas = currentCanvas;
     currentCanvas = null;
     gl = currentGL;
     currentGL = null;
     var vertexShader = createVertexShader(gl, smaskVertexShaderCode);
@@ -9436,34 +11560,39 @@ var WebGLUtils = function WebGLUtilsClos
     gl.bindBuffer(gl.ARRAY_BUFFER, texCoordBuffer);
     gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 1.0, 1.0]), gl.STATIC_DRAW);
     gl.enableVertexAttribArray(texCoordLocation);
     gl.vertexAttribPointer(texCoordLocation, 2, gl.FLOAT, false, 0, 0);
     gl.uniform1i(texLayerLocation, 0);
     gl.uniform1i(texMaskLocation, 1);
     smaskCache = cache;
   }
+
   function composeSMask(layer, mask, properties) {
     var width = layer.width,
         height = layer.height;
+
     if (!smaskCache) {
       initSmaskGL();
     }
+
     var cache = smaskCache,
         canvas = cache.canvas,
         gl = cache.gl;
     canvas.width = width;
     canvas.height = height;
     gl.viewport(0, 0, gl.drawingBufferWidth, gl.drawingBufferHeight);
     gl.uniform2f(cache.resolutionLocation, width, height);
+
     if (properties.backdrop) {
       gl.uniform4f(cache.resolutionLocation, properties.backdrop[0], properties.backdrop[1], properties.backdrop[2], 1);
     } else {
       gl.uniform4f(cache.resolutionLocation, 0, 0, 0, 0);
     }
+
     gl.uniform1i(cache.subtypeLocation, properties.subtype === 'Luminosity' ? 1 : 0);
     var texture = createTexture(gl, layer, gl.TEXTURE0);
     var maskTexture = createTexture(gl, mask, gl.TEXTURE1);
     var buffer = gl.createBuffer();
     gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
     gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([0, 0, width, 0, 0, height, 0, height, width, 0, width, height]), gl.STATIC_DRAW);
     gl.enableVertexAttribArray(cache.positionLocation);
     gl.vertexAttribPointer(cache.positionLocation, 2, gl.FLOAT, false, 0, 0);
@@ -9473,16 +11602,17 @@ var WebGLUtils = function WebGLUtilsClos
     gl.clear(gl.COLOR_BUFFER_BIT);
     gl.drawArrays(gl.TRIANGLES, 0, 6);
     gl.flush();
     gl.deleteTexture(texture);
     gl.deleteTexture(maskTexture);
     gl.deleteBuffer(buffer);
     return canvas;
   }
+
   var figuresVertexShaderCode = '\
   attribute vec2 a_position;                                    \
   attribute vec3 a_color;                                       \
                                                                 \
   uniform vec2 u_resolution;                                    \
   uniform vec2 u_scale;                                         \
   uniform vec2 u_offset;                                        \
                                                                 \
@@ -9499,16 +11629,17 @@ var WebGLUtils = function WebGLUtilsClos
   precision mediump float;                                      \
                                                                 \
   varying vec4 v_color;                                         \
                                                                 \
   void main() {                                                 \
     gl_FragColor = v_color;                                     \
   }                                                             ';
   var figuresCache = null;
+
   function initFiguresGL() {
     var canvas, gl;
     generateGL();
     canvas = currentCanvas;
     currentCanvas = null;
     gl = currentGL;
     currentGL = null;
     var vertexShader = createVertexShader(gl, figuresVertexShaderCode);
@@ -9520,56 +11651,65 @@ var WebGLUtils = function WebGLUtilsClos
     cache.canvas = canvas;
     cache.resolutionLocation = gl.getUniformLocation(program, 'u_resolution');
     cache.scaleLocation = gl.getUniformLocation(program, 'u_scale');
     cache.offsetLocation = gl.getUniformLocation(program, 'u_offset');
     cache.positionLocation = gl.getAttribLocation(program, 'a_position');
     cache.colorLocation = gl.getAttribLocation(program, 'a_color');
     figuresCache = cache;
   }
+
   function drawFigures(width, height, backgroundColor, figures, context) {
     if (!figuresCache) {
       initFiguresGL();
     }
+
     var cache = figuresCache,
         canvas = cache.canvas,
         gl = cache.gl;
     canvas.width = width;
     canvas.height = height;
     gl.viewport(0, 0, gl.drawingBufferWidth, gl.drawingBufferHeight);
     gl.uniform2f(cache.resolutionLocation, width, height);
     var count = 0;
     var i, ii, rows;
+
     for (i = 0, ii = figures.length; i < ii; i++) {
       switch (figures[i].type) {
         case 'lattice':
           rows = figures[i].coords.length / figures[i].verticesPerRow | 0;
           count += (rows - 1) * (figures[i].verticesPerRow - 1) * 6;
           break;
+
         case 'triangles':
           count += figures[i].coords.length;
           break;
       }
     }
+
     var coords = new Float32Array(count * 2);
     var colors = new Uint8Array(count * 3);
     var coordsMap = context.coords,
         colorsMap = context.colors;
     var pIndex = 0,
         cIndex = 0;
+
     for (i = 0, ii = figures.length; i < ii; i++) {
       var figure = figures[i],
           ps = figure.coords,
           cs = figure.colors;
+
       switch (figure.type) {
         case 'lattice':
           var cols = figure.verticesPerRow;
           rows = ps.length / cols | 0;
+
           for (var row = 1; row < rows; row++) {
             var offset = row * cols + 1;
+
             for (var col = 1; col < cols; col++, offset++) {
               coords[pIndex] = coordsMap[ps[offset - cols - 1]];
               coords[pIndex + 1] = coordsMap[ps[offset - cols - 1] + 1];
               coords[pIndex + 2] = coordsMap[ps[offset - cols]];
               coords[pIndex + 3] = coordsMap[ps[offset - cols] + 1];
               coords[pIndex + 4] = coordsMap[ps[offset - 1]];
               coords[pIndex + 5] = coordsMap[ps[offset - 1] + 1];
               colors[cIndex] = colorsMap[cs[offset - cols - 1]];
@@ -9595,35 +11735,40 @@ var WebGLUtils = function WebGLUtilsClos
               colors[cIndex + 14] = colors[cIndex + 8];
               colors[cIndex + 15] = colorsMap[cs[offset]];
               colors[cIndex + 16] = colorsMap[cs[offset] + 1];
               colors[cIndex + 17] = colorsMap[cs[offset] + 2];
               pIndex += 12;
               cIndex += 18;
             }
           }
+
           break;
+
         case 'triangles':
           for (var j = 0, jj = ps.length; j < jj; j++) {
             coords[pIndex] = coordsMap[ps[j]];
             coords[pIndex + 1] = coordsMap[ps[j] + 1];
             colors[cIndex] = colorsMap[cs[j]];
             colors[cIndex + 1] = colorsMap[cs[j] + 1];
             colors[cIndex + 2] = colorsMap[cs[j] + 2];
             pIndex += 2;
             cIndex += 3;
           }
+
           break;
       }
     }
+
     if (backgroundColor) {
       gl.clearColor(backgroundColor[0] / 255, backgroundColor[1] / 255, backgroundColor[2] / 255, 1.0);
     } else {
       gl.clearColor(0, 0, 0, 0);
     }
+
     gl.clear(gl.COLOR_BUFFER_BIT);
     var coordsBuffer = gl.createBuffer();
     gl.bindBuffer(gl.ARRAY_BUFFER, coordsBuffer);
     gl.bufferData(gl.ARRAY_BUFFER, coords, gl.STATIC_DRAW);
     gl.enableVertexAttribArray(cache.positionLocation);
     gl.vertexAttribPointer(cache.positionLocation, 2, gl.FLOAT, false, 0, 0);
     var colorsBuffer = gl.createBuffer();
     gl.bindBuffer(gl.ARRAY_BUFFER, colorsBuffer);
@@ -9633,206 +11778,248 @@ var WebGLUtils = function WebGLUtilsClos
     gl.uniform2f(cache.scaleLocation, context.scaleX, context.scaleY);
     gl.uniform2f(cache.offsetLocation, context.offsetX, context.offsetY);
     gl.drawArrays(gl.TRIANGLES, 0, count);
     gl.flush();
     gl.deleteBuffer(coordsBuffer);
     gl.deleteBuffer(colorsBuffer);
     return canvas;
   }
+
   return {
     tryInitGL() {
       try {
         generateGL();
         return !!currentGL;
       } catch (ex) {}
+
       return false;
     },
+
     composeSMask,
     drawFigures,
+
     cleanup() {
       if (smaskCache && smaskCache.canvas) {
         smaskCache.canvas.width = 0;
         smaskCache.canvas.height = 0;
       }
+
       if (figuresCache && figuresCache.canvas) {
         figuresCache.canvas.width = 0;
         figuresCache.canvas.height = 0;
       }
+
       smaskCache = null;
       figuresCache = null;
     }
+
   };
 }();
-exports.WebGLContext = WebGLContext;
 
 /***/ }),
 /* 19 */
 /***/ (function(module, exports, __w_pdfjs_require__) {
 
 "use strict";
 
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.renderTextLayer = undefined;
+exports.renderTextLayer = void 0;
 
 var _util = __w_pdfjs_require__(1);
 
-var _global_scope = __w_pdfjs_require__(3);
-
-var _global_scope2 = _interopRequireDefault(_global_scope);
+var _global_scope = _interopRequireDefault(__w_pdfjs_require__(3));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 var renderTextLayer = function renderTextLayerClosure() {
   var MAX_TEXT_DIVS_TO_RENDER = 100000;
   var NonWhitespaceRegexp = /\S/;
+
   function isAllWhitespace(str) {
     return !NonWhitespaceRegexp.test(str);
   }
+
   var styleBuf = ['left: ', 0, 'px; top: ', 0, 'px; font-size: ', 0, 'px; font-family: ', '', ';'];
+
   function appendText(task, geom, styles) {
     var textDiv = document.createElement('span');
     var textDivProperties = {
       style: null,
       angle: 0,
       canvasWidth: 0,
       isWhitespace: false,
       originalTransform: null,
       paddingBottom: 0,
       paddingLeft: 0,
       paddingRight: 0,
       paddingTop: 0,
       scale: 1
     };
+
     task._textDivs.push(textDiv);
+
     if (isAllWhitespace(geom.str)) {
       textDivProperties.isWhitespace = true;
+
       task._textDivProperties.set(textDiv, textDivProperties);
+
       return;
     }
+
     var tx = _util.Util.transform(task._viewport.transform, geom.transform);
+
     var angle = Math.atan2(tx[1], tx[0]);
     var style = styles[geom.fontName];
+
     if (style.vertical) {
       angle += Math.PI / 2;
     }
+
     var fontHeight = Math.sqrt(tx[2] * tx[2] + tx[3] * tx[3]);
     var fontAscent = fontHeight;
+
     if (style.ascent) {
       fontAscent = style.ascent * fontAscent;
     } else if (style.descent) {
       fontAscent = (1 + style.descent) * fontAscent;
     }
+
     var left;
     var top;
+
     if (angle === 0) {
       left = tx[4];
       top = tx[5] - fontAscent;
     } else {
       left = tx[4] + fontAscent * Math.sin(angle);
       top = tx[5] - fontAscent * Math.cos(angle);
     }
+
     styleBuf[1] = left;
     styleBuf[3] = top;
     styleBuf[5] = fontHeight;
     styleBuf[7] = style.fontFamily;
     textDivProperties.style = styleBuf.join('');
     textDiv.setAttribute('style', textDivProperties.style);
     textDiv.textContent = geom.str;
+
     if (task._fontInspectorEnabled) {
       textDiv.dataset.fontName = geom.fontName;
     }
+
     if (angle !== 0) {
       textDivProperties.angle = angle * (180 / Math.PI);
     }
+
     if (geom.str.length > 1) {
       if (style.vertical) {
         textDivProperties.canvasWidth = geom.height * task._viewport.scale;
       } else {
         textDivProperties.canvasWidth = geom.width * task._viewport.scale;
       }
     }
+
     task._textDivProperties.set(textDiv, textDivProperties);
+
     if (task._textContentStream) {
       task._layoutText(textDiv);
     }
+
     if (task._enhanceTextSelection) {
       var angleCos = 1,
           angleSin = 0;
+
       if (angle !== 0) {
         angleCos = Math.cos(angle);
         angleSin = Math.sin(angle);
       }
+
       var divWidth = (style.vertical ? geom.height : geom.width) * task._viewport.scale;
       var divHeight = fontHeight;
       var m, b;
+
       if (angle !== 0) {
         m = [angleCos, angleSin, -angleSin, angleCos, left, top];
         b = _util.Util.getAxialAlignedBoundingBox([0, 0, divWidth, divHeight], m);
       } else {
         b = [left, top, left + divWidth, top + divHeight];
       }
+
       task._bounds.push({
         left: b[0],
         top: b[1],
         right: b[2],
         bottom: b[3],
         div: textDiv,
         size: [divWidth, divHeight],
         m
       });
     }
   }
+
   function render(task) {
     if (task._canceled) {
       return;
     }
+
     var textDivs = task._textDivs;
     var capability = task._capability;
     var textDivsLength = textDivs.length;
+
     if (textDivsLength > MAX_TEXT_DIVS_TO_RENDER) {
       task._renderingDone = true;
       capability.resolve();
       return;
     }
+
     if (!task._textContentStream) {
       for (var i = 0; i < textDivsLength; i++) {
         task._layoutText(textDivs[i]);
       }
     }
+
     task._renderingDone = true;
     capability.resolve();
   }
+
   function expand(task) {
     var bounds = task._bounds;
     var viewport = task._viewport;
     var expanded = expandBounds(viewport.width, viewport.height, bounds);
+
     for (var i = 0; i < expanded.length; i++) {
       var div = bounds[i].div;
+
       var divProperties = task._textDivProperties.get(div);
+
       if (divProperties.angle === 0) {
         divProperties.paddingLeft = bounds[i].left - expanded[i].left;
         divProperties.paddingTop = bounds[i].top - expanded[i].top;
         divProperties.paddingRight = expanded[i].right - bounds[i].right;
         divProperties.paddingBottom = expanded[i].bottom - bounds[i].bottom;
+
         task._textDivProperties.set(div, divProperties);
+
         continue;
       }
+
       var e = expanded[i],
           b = bounds[i];
       var m = b.m,
           c = m[0],
           s = m[1];
       var points = [[0, 0], [0, b.size[1]], [b.size[0], 0], b.size];
       var ts = new Float64Array(64);
       points.forEach(function (p, i) {
         var t = _util.Util.applyTransform(p, m);
+
         ts[i + 0] = c && (e.left - t[0]) / c;
         ts[i + 4] = s && (e.top - t[1]) / s;
         ts[i + 8] = c && (e.right - t[0]) / c;
         ts[i + 12] = s && (e.bottom - t[1]) / s;
         ts[i + 16] = s && (e.left - t[0]) / -s;
         ts[i + 20] = c && (e.top - t[1]) / c;
         ts[i + 24] = s && (e.right - t[0]) / -s;
         ts[i + 28] = c && (e.bottom - t[1]) / c;
@@ -9840,34 +12027,41 @@ var renderTextLayer = function renderTex
         ts[i + 36] = s && (e.top - t[1]) / -s;
         ts[i + 40] = c && (e.right - t[0]) / -c;
         ts[i + 44] = s && (e.bottom - t[1]) / -s;
         ts[i + 48] = s && (e.left - t[0]) / s;
         ts[i + 52] = c && (e.top - t[1]) / -c;
         ts[i + 56] = s && (e.right - t[0]) / s;
         ts[i + 60] = c && (e.bottom - t[1]) / -c;
       });
+
       var findPositiveMin = function (ts, offset, count) {
         var result = 0;
+
         for (var i = 0; i < count; i++) {
           var t = ts[offset++];
+
           if (t > 0) {
             result = result ? Math.min(t, result) : t;
           }
         }
+
         return result;
       };
+
       var boxScale = 1 + Math.min(Math.abs(c), Math.abs(s));
       divProperties.paddingLeft = findPositiveMin(ts, 32, 16) / boxScale;
       divProperties.paddingTop = findPositiveMin(ts, 48, 16) / boxScale;
       divProperties.paddingRight = findPositiveMin(ts, 0, 16) / boxScale;
       divProperties.paddingBottom = findPositiveMin(ts, 16, 16) / boxScale;
+
       task._textDivProperties.set(div, divProperties);
     }
   }
+
   function expandBounds(width, height, boxes) {
     var bounds = boxes.map(function (box, i) {
       return {
         x1: box.left,
         y1: box.top,
         x2: box.right,
         y2: box.bottom,
         index: i,
@@ -9900,16 +12094,17 @@ var renderTextLayer = function renderTex
     expandBoundsLTR(height, bounds);
     bounds.forEach(function (b) {
       var i = b.index;
       expanded[i].top = b.x1New;
       expanded[i].bottom = b.x2New;
     });
     return expanded;
   }
+
   function expandBoundsLTR(width, bounds) {
     bounds.sort(function (a, b) {
       return a.x1 - b.x1 || a.index - b.index;
     });
     var fakeBoundary = {
       x1: -Infinity,
       y1: -Infinity,
       x2: 0,
@@ -9920,795 +12115,1013 @@ var renderTextLayer = function renderTex
     };
     var horizon = [{
       start: -Infinity,
       end: Infinity,
       boundary: fakeBoundary
     }];
     bounds.forEach(function (boundary) {
       var i = 0;
+
       while (i < horizon.length && horizon[i].end <= boundary.y1) {
         i++;
       }
+
       var j = horizon.length - 1;
+
       while (j >= 0 && horizon[j].start >= boundary.y2) {
         j--;
       }
+
       var horizonPart, affectedBoundary;
       var q,
           k,
           maxXNew = -Infinity;
+
       for (q = i; q <= j; q++) {
         horizonPart = horizon[q];
         affectedBoundary = horizonPart.boundary;
         var xNew;
+
         if (affectedBoundary.x2 > boundary.x1) {
           xNew = affectedBoundary.index > boundary.index ? affectedBoundary.x1New : boundary.x1;
         } else if (affectedBoundary.x2New === undefined) {
           xNew = (affectedBoundary.x2 + boundary.x1) / 2;
         } else {
           xNew = affectedBoundary.x2New;
         }
+
         if (xNew > maxXNew) {
           maxXNew = xNew;
         }
       }
+
       boundary.x1New = maxXNew;
+
       for (q = i; q <= j; q++) {
         horizonPart = horizon[q];
         affectedBoundary = horizonPart.boundary;
+
         if (affectedBoundary.x2New === undefined) {
           if (affectedBoundary.x2 > boundary.x1) {
             if (affectedBoundary.index > boundary.index) {
               affectedBoundary.x2New = affectedBoundary.x2;
             }
           } else {
             affectedBoundary.x2New = maxXNew;
           }
         } else if (affectedBoundary.x2New > maxXNew) {
           affectedBoundary.x2New = Math.max(maxXNew, affectedBoundary.x2);
         }
       }
+
       var changedHorizon = [],
           lastBoundary = null;
+
       for (q = i; q <= j; q++) {
         horizonPart = horizon[q];
         affectedBoundary = horizonPart.boundary;
         var useBoundary = affectedBoundary.x2 > boundary.x2 ? affectedBoundary : boundary;
+
         if (lastBoundary === useBoundary) {
           changedHorizon[changedHorizon.length - 1].end = horizonPart.end;
         } else {
           changedHorizon.push({
             start: horizonPart.start,
             end: horizonPart.end,
             boundary: useBoundary
           });
           lastBoundary = useBoundary;
         }
       }
+
       if (horizon[i].start < boundary.y1) {
         changedHorizon[0].start = boundary.y1;
         changedHorizon.unshift({
           start: horizon[i].start,
           end: boundary.y1,
           boundary: horizon[i].boundary
         });
       }
+
       if (boundary.y2 < horizon[j].end) {
         changedHorizon[changedHorizon.length - 1].end = boundary.y2;
         changedHorizon.push({
           start: boundary.y2,
           end: horizon[j].end,
           boundary: horizon[j].boundary
         });
       }
+
       for (q = i; q <= j; q++) {
         horizonPart = horizon[q];
         affectedBoundary = horizonPart.boundary;
+
         if (affectedBoundary.x2New !== undefined) {
           continue;
         }
+
         var used = false;
+
         for (k = i - 1; !used && k >= 0 && horizon[k].start >= affectedBoundary.y1; k--) {
           used = horizon[k].boundary === affectedBoundary;
         }
+
         for (k = j + 1; !used && k < horizon.length && horizon[k].end <= affectedBoundary.y2; k++) {
           used = horizon[k].boundary === affectedBoundary;
         }
+
         for (k = 0; !used && k < changedHorizon.length; k++) {
           used = changedHorizon[k].boundary === affectedBoundary;
         }
+
         if (!used) {
           affectedBoundary.x2New = maxXNew;
         }
       }
+
       Array.prototype.splice.apply(horizon, [i, j - i + 1].concat(changedHorizon));
     });
     horizon.forEach(function (horizonPart) {
       var affectedBoundary = horizonPart.boundary;
+
       if (affectedBoundary.x2New === undefined) {
         affectedBoundary.x2New = Math.max(width, affectedBoundary.x2);
       }
     });
   }
-  function TextLayerRenderTask({ textContent, textContentStream, container, viewport, textDivs, textContentItemsStr, enhanceTextSelection }) {
+
+  function TextLayerRenderTask({
+    textContent,
+    textContentStream,
+    container,
+    viewport,
+    textDivs,
+    textContentItemsStr,
+    enhanceTextSelection
+  }) {
     this._textContent = textContent;
     this._textContentStream = textContentStream;
     this._container = container;
     this._viewport = viewport;
     this._textDivs = textDivs || [];
     this._textContentItemsStr = textContentItemsStr || [];
     this._enhanceTextSelection = !!enhanceTextSelection;
-    this._fontInspectorEnabled = !!(_global_scope2.default.FontInspector && _global_scope2.default.FontInspector.enabled);
+    this._fontInspectorEnabled = !!(_global_scope.default.FontInspector && _global_scope.default.FontInspector.enabled);
     this._reader = null;
     this._layoutTextLastFontSize = null;
     this._layoutTextLastFontFamily = null;
     this._layoutTextCtx = null;
     this._textDivProperties = new WeakMap();
     this._renderingDone = false;
     this._canceled = false;
     this._capability = (0, _util.createPromiseCapability)();
     this._renderTimer = null;
     this._bounds = [];
   }
+
   TextLayerRenderTask.prototype = {
     get promise() {
       return this._capability.promise;
     },
+
     cancel: function TextLayer_cancel() {
       if (this._reader) {
         this._reader.cancel(new _util.AbortException('text layer task cancelled'));
+
         this._reader = null;
       }
+
       this._canceled = true;
+
       if (this._renderTimer !== null) {
         clearTimeout(this._renderTimer);
         this._renderTimer = null;
       }
+
       this._capability.reject('canceled');
     },
+
     _processItems(items, styleCache) {
       for (let i = 0, len = items.length; i < len; i++) {
         this._textContentItemsStr.push(items[i].str);
+
         appendText(this, items[i], styleCache);
       }
     },
+
     _layoutText(textDiv) {
       let textLayerFrag = this._container;
+
       let textDivProperties = this._textDivProperties.get(textDiv);
+
       if (textDivProperties.isWhitespace) {
         return;
       }
+
       let fontSize = textDiv.style.fontSize;
       let fontFamily = textDiv.style.fontFamily;
+
       if (fontSize !== this._layoutTextLastFontSize || fontFamily !== this._layoutTextLastFontFamily) {
         this._layoutTextCtx.font = fontSize + ' ' + fontFamily;
         this._layoutTextLastFontSize = fontSize;
         this._layoutTextLastFontFamily = fontFamily;
       }
+
       let width = this._layoutTextCtx.measureText(textDiv.textContent).width;
+
       let transform = '';
+
       if (textDivProperties.canvasWidth !== 0 && width > 0) {
         textDivProperties.scale = textDivProperties.canvasWidth / width;
         transform = 'scaleX(' + textDivProperties.scale + ')';
       }
+
       if (textDivProperties.angle !== 0) {
         transform = 'rotate(' + textDivProperties.angle + 'deg) ' + transform;
       }
+
       if (transform !== '') {
         textDivProperties.originalTransform = transform;
         textDiv.style.transform = transform;
       }
+
       this._textDivProperties.set(textDiv, textDivProperties);
+
       textLayerFrag.appendChild(textDiv);
     },
+
     _render: function TextLayer_render(timeout) {
       let capability = (0, _util.createPromiseCapability)();
       let styleCache = Object.create(null);
       let canvas = document.createElement('canvas');
       canvas.mozOpaque = true;
-      this._layoutTextCtx = canvas.getContext('2d', { alpha: false });
+      this._layoutTextCtx = canvas.getContext('2d', {
+        alpha: false
+      });
+
       if (this._textContent) {
         let textItems = this._textContent.items;
         let textStyles = this._textContent.styles;
+
         this._processItems(textItems, textStyles);
+
         capability.resolve();
       } else if (this._textContentStream) {
         let pump = () => {
-          this._reader.read().then(({ value, done }) => {
+          this._reader.read().then(({
+            value,
+            done
+          }) => {
             if (done) {
               capability.resolve();
               return;
             }
+
             Object.assign(styleCache, value.styles);
+
             this._processItems(value.items, styleCache);
+
             pump();
           }, capability.reject);
         };
+
         this._reader = this._textContentStream.getReader();
         pump();
       } else {
         throw new Error('Neither "textContent" nor "textContentStream"' + ' parameters specified.');
       }
+
       capability.promise.then(() => {
         styleCache = null;
+
         if (!timeout) {
           render(this);
         } else {
           this._renderTimer = setTimeout(() => {
             render(this);
             this._renderTimer = null;
           }, timeout);
         }
       }, this._capability.reject);
     },
     expandTextDivs: function TextLayer_expandTextDivs(expandDivs) {
       if (!this._enhanceTextSelection || !this._renderingDone) {
         return;
       }
+
       if (this._bounds !== null) {
         expand(this);
         this._bounds = null;
       }
+
       for (var i = 0, ii = this._textDivs.length; i < ii; i++) {
         var div = this._textDivs[i];
+
         var divProperties = this._textDivProperties.get(div);
+
         if (divProperties.isWhitespace) {
           continue;
         }
+
         if (expandDivs) {
           var transform = '',
               padding = '';
+
           if (divProperties.scale !== 1) {
             transform = 'scaleX(' + divProperties.scale + ')';
           }
+
           if (divProperties.angle !== 0) {
             transform = 'rotate(' + divProperties.angle + 'deg) ' + transform;
           }
+
           if (divProperties.paddingLeft !== 0) {
             padding += ' padding-left: ' + divProperties.paddingLeft / divProperties.scale + 'px;';
             transform += ' translateX(' + -divProperties.paddingLeft / divProperties.scale + 'px)';
           }
+
           if (divProperties.paddingTop !== 0) {
             padding += ' padding-top: ' + divProperties.paddingTop + 'px;';
             transform += ' translateY(' + -divProperties.paddingTop + 'px)';
           }
+
           if (divProperties.paddingRight !== 0) {
             padding += ' padding-right: ' + divProperties.paddingRight / divProperties.scale + 'px;';
           }
+
           if (divProperties.paddingBottom !== 0) {
             padding += ' padding-bottom: ' + divProperties.paddingBottom + 'px;';
           }
+
           if (padding !== '') {
             div.setAttribute('style', divProperties.style + padding);
           }
+
           if (transform !== '') {
             div.style.transform = transform;
           }
         } else {
           div.style.padding = 0;
           div.style.transform = divProperties.originalTransform || '';
         }
       }
     }
   };
+
   function renderTextLayer(renderParameters) {
     var task = new TextLayerRenderTask({
       textContent: renderParameters.textContent,
       textContentStream: renderParameters.textContentStream,
       container: renderParameters.container,
       viewport: renderParameters.viewport,
       textDivs: renderParameters.textDivs,
       textContentItemsStr: renderParameters.textContentItemsStr,
       enhanceTextSelection: renderParameters.enhanceTextSelection
     });
+
     task._render(renderParameters.timeout);
+
     return task;
   }
+
   return renderTextLayer;
 }();
+
 exports.renderTextLayer = renderTextLayer;
 
 /***/ }),
 /* 20 */
 /***/ (function(module, exports, __w_pdfjs_require__) {
 
 "use strict";
 
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.AnnotationLayer = undefined;
+exports.AnnotationLayer = void 0;
 
 var _dom_utils = __w_pdfjs_require__(8);
 
 var _util = __w_pdfjs_require__(1);
 
 class AnnotationElementFactory {
   static create(parameters) {
     let subtype = parameters.data.annotationType;
+
     switch (subtype) {
       case _util.AnnotationType.LINK:
         return new LinkAnnotationElement(parameters);
+
       case _util.AnnotationType.TEXT:
         return new TextAnnotationElement(parameters);
+
       case _util.AnnotationType.WIDGET:
         let fieldType = parameters.data.fieldType;
+
         switch (fieldType) {
           case 'Tx':
             return new TextWidgetAnnotationElement(parameters);
+
           case 'Btn':
             if (parameters.data.radioButton) {
               return new RadioButtonWidgetAnnotationElement(parameters);
             } else if (parameters.data.checkBox) {
               return new CheckboxWidgetAnnotationElement(parameters);
             }
+
             return new PushButtonWidgetAnnotationElement(parameters);
+
           case 'Ch':
             return new ChoiceWidgetAnnotationElement(parameters);
         }
+
         return new WidgetAnnotationElement(parameters);
+
       case _util.AnnotationType.POPUP:
         return new PopupAnnotationElement(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.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);
     }
   }
-}
+
+}
+
 class AnnotationElement {
   constructor(parameters, isRenderable = false, ignoreBorder = false) {
     this.isRenderable = isRenderable;
     this.data = parameters.data;
     this.layer = parameters.layer;
     this.page = parameters.page;
     this.viewport = parameters.viewport;
     this.linkService = parameters.linkService;
     this.downloadManager = parameters.downloadManager;
     this.imageResourcesPath = parameters.imageResourcesPath;
     this.renderInteractiveForms = parameters.renderInteractiveForms;
     this.svgFactory = parameters.svgFactory;
+
     if (isRenderable) {
       this.container = this._createContainer(ignoreBorder);
     }
   }
+
   _createContainer(ignoreBorder = false) {
     let data = this.data,
         page = this.page,
         viewport = this.viewport;
     let 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);
+
     let 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';
+
     if (!ignoreBorder && data.borderStyle.width > 0) {
       container.style.borderWidth = data.borderStyle.width + 'px';
+
       if (data.borderStyle.style !== _util.AnnotationBorderStyleType.UNDERLINE) {
         width = width - 2 * data.borderStyle.width;
         height = height - 2 * data.borderStyle.width;