Merge mozilla-central to autoland a=merge on a CLOSED TREE
authorCoroiu Cristina <ccoroiu@mozilla.com>
Tue, 27 Nov 2018 01:03:16 +0200
changeset 504575 9dcdb35839c5b2ea345118d2c109682ee1fb0831
parent 504574 a6eccac5baa2fce29837003e8de53e9f243a7df0 (current diff)
parent 504461 a60b595747ade6cdad6b51906bc9a880f6276f19 (diff)
child 504576 eaa26fe663cb2b4ab2a6c6da22b50f8595742092
push id10290
push userffxbld-merge
push dateMon, 03 Dec 2018 16:23:23 +0000
treeherdermozilla-beta@700bed2445e6 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersmerge
milestone65.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Merge mozilla-central to autoland a=merge on a CLOSED TREE
old-configure.in
--- 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;
       }
+
       let horizontalRadius = data.borderStyle.horizontalCornerRadius;
       let verticalRadius = data.borderStyle.verticalCornerRadius;
+
       if (horizontalRadius > 0 || verticalRadius > 0) {
         let radius = horizontalRadius + 'px / ' + verticalRadius + 'px';
         container.style.borderRadius = radius;
       }
+
       switch (data.borderStyle.style) {
         case _util.AnnotationBorderStyleType.SOLID:
           container.style.borderStyle = 'solid';
           break;
+
         case _util.AnnotationBorderStyleType.DASHED:
           container.style.borderStyle = 'dashed';
           break;
+
         case _util.AnnotationBorderStyleType.BEVELED:
           (0, _util.warn)('Unimplemented border style: beveled');
           break;
+
         case _util.AnnotationBorderStyleType.INSET:
           (0, _util.warn)('Unimplemented border style: inset');
           break;
+
         case _util.AnnotationBorderStyleType.UNDERLINE:
           container.style.borderBottomStyle = 'solid';
           break;
+
         default:
           break;
       }