{"version":3,"sources":["webpack://pdfjs-dist/image_decoders/pdf.image_decoders/webpack/universalModuleDefinition","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/webpack/bootstrap","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/src/pdf.image_decoders.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/src/shared/util.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/src/shared/compatibility.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/src/shared/global_scope.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/src/shared/is_node.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/fn/string/includes.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/es6.string.includes.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_export.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_global.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_core.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_hide.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_object-dp.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_an-object.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_is-object.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_ie8-dom-define.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_descriptors.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_fails.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_dom-create.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_to-primitive.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_property-desc.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_redefine.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_has.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_uid.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_ctx.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_a-function.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_string-context.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_is-regexp.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_cof.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_wks.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_shared.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_library.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_defined.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_fails-is-regexp.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/fn/array/includes.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/es7.array.includes.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_array-includes.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_to-iobject.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_iobject.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_to-length.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_to-integer.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_to-absolute-index.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_add-to-unscopables.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/fn/object/assign.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/es6.object.assign.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_object-assign.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_object-keys.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_object-keys-internal.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_shared-key.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_enum-bug-keys.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_object-gops.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_object-pie.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_to-object.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/fn/math/log2.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/es6.math.log2.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/fn/number/is-nan.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/es6.number.is-nan.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/fn/number/is-integer.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/es6.number.is-integer.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_is-integer.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/fn/weak-map.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/es6.object.to-string.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_classof.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/web.dom.iterable.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/es6.array.iterator.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_iter-step.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_iterators.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_iter-define.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_iter-create.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_object-create.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_object-dps.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_html.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_set-to-string-tag.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_object-gpo.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/es6.weak-map.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_array-methods.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_array-species-create.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_array-species-constructor.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_is-array.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_meta.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_collection-weak.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_redefine-all.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_an-instance.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_for-of.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_iter-call.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_is-array-iter.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/core.get-iterator-method.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_validate-collection.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_collection.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_iter-detect.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_inherit-if-required.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_set-proto.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_object-gopd.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/es7.weak-map.of.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_set-collection-of.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/es7.weak-map.from.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_set-collection-from.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/fn/string/code-point-at.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/es6.string.code-point-at.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_string-at.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/fn/string/from-code-point.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/es6.string.from-code-point.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/es6/symbol.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/es6.symbol.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_wks-ext.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_wks-define.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_enum-keys.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_object-gopn-ext.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_object-gopn.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/fn/object/values.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/es7.object.values.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/node_modules/core-js/modules/_object-to-array.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/src/shared/streams_polyfill.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/src/shared/url_polyfill.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/src/core/jbig2.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/src/core/arithmetic_decoder.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/src/core/ccitt.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/src/core/jpg.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/src/core/jpx.js"],"names":["pdfjsVersion","pdfjsBuild","IDENTITY_MATRIX","FONT_IDENTITY_MATRIX","NativeImageDecoding","NONE","DECODE","DISPLAY","PermissionFlag","PRINT","MODIFY_CONTENTS","COPY","MODIFY_ANNOTATIONS","FILL_INTERACTIVE_FORMS","COPY_FOR_ACCESSIBILITY","ASSEMBLE","PRINT_HIGH_QUALITY","TextRenderingMode","FILL","STROKE","FILL_STROKE","INVISIBLE","FILL_ADD_TO_PATH","STROKE_ADD_TO_PATH","FILL_STROKE_ADD_TO_PATH","ADD_TO_PATH","FILL_STROKE_MASK","ADD_TO_PATH_FLAG","ImageKind","GRAYSCALE_1BPP","RGB_24BPP","RGBA_32BPP","AnnotationType","TEXT","LINK","FREETEXT","LINE","SQUARE","CIRCLE","POLYGON","POLYLINE","HIGHLIGHT","UNDERLINE","SQUIGGLY","STRIKEOUT","STAMP","CARET","INK","POPUP","FILEATTACHMENT","SOUND","MOVIE","WIDGET","SCREEN","PRINTERMARK","TRAPNET","WATERMARK","THREED","REDACT","AnnotationFlag","HIDDEN","NOZOOM","NOROTATE","NOVIEW","READONLY","LOCKED","TOGGLENOVIEW","LOCKEDCONTENTS","AnnotationFieldFlag","REQUIRED","NOEXPORT","MULTILINE","PASSWORD","NOTOGGLETOOFF","RADIO","PUSHBUTTON","COMBO","EDIT","SORT","FILESELECT","MULTISELECT","DONOTSPELLCHECK","DONOTSCROLL","COMB","RICHTEXT","RADIOSINUNISON","COMMITONSELCHANGE","AnnotationBorderStyleType","SOLID","DASHED","BEVELED","INSET","StreamType","UNKNOWN","FLATE","LZW","DCT","JPX","JBIG","A85","AHX","CCF","RL","FontType","TYPE1","TYPE1C","CIDFONTTYPE0","CIDFONTTYPE0C","TRUETYPE","CIDFONTTYPE2","TYPE3","OPENTYPE","TYPE0","MMTYPE1","VerbosityLevel","ERRORS","WARNINGS","INFOS","CMapCompressionType","BINARY","STREAM","OPS","dependency","setLineWidth","setLineCap","setLineJoin","setMiterLimit","setDash","setRenderingIntent","setFlatness","setGState","save","restore","transform","moveTo","lineTo","curveTo","curveTo2","curveTo3","closePath","rectangle","stroke","closeStroke","fill","eoFill","fillStroke","eoFillStroke","closeFillStroke","closeEOFillStroke","endPath","clip","eoClip","beginText","endText","setCharSpacing","setWordSpacing","setHScale","setLeading","setFont","setTextRenderingMode","setTextRise","moveText","setLeadingMoveText","setTextMatrix","nextLine","showText","showSpacedText","nextLineShowText","nextLineSetSpacingShowText","setCharWidth","setCharWidthAndBounds","setStrokeColorSpace","setFillColorSpace","setStrokeColor","setStrokeColorN","setFillColor","setFillColorN","setStrokeGray","setFillGray","setStrokeRGBColor","setFillRGBColor","setStrokeCMYKColor","setFillCMYKColor","shadingFill","beginInlineImage","beginImageData","endInlineImage","paintXObject","markPoint","markPointProps","beginMarkedContent","beginMarkedContentProps","endMarkedContent","beginCompat","endCompat","paintFormXObjectBegin","paintFormXObjectEnd","beginGroup","endGroup","beginAnnotations","endAnnotations","beginAnnotation","endAnnotation","paintJpegXObject","paintImageMaskXObject","paintImageMaskXObjectGroup","paintImageXObject","paintInlineImageXObject","paintInlineImageXObjectGroup","paintImageXObjectRepeat","paintImageMaskXObjectRepeat","paintSolidColorImageMask","constructPath","UNSUPPORTED_FEATURES","unknown","forms","javaScript","smask","shadingPattern","font","PasswordResponses","NEED_PASSWORD","INCORRECT_PASSWORD","verbosity","Number","console","unreachable","base","other","url","absoluteUrl","baseUrl","_isValidProtocol","Object","enumerable","configurable","writable","lookup","initializer","PasswordException","UnknownErrorException","InvalidPDFException","MissingPDFException","UnexpectedResponseException","MissingDataException","XRefParseException","FormatError","AbortException","NullCharactersRegExp","warn","str","assert","bytes","length","MAX_ARGUMENT_COUNT","String","strBuf","i","chunkEnd","Math","chunk","arr","resultLength","ii","item","itemLength","arrayByteLength","pos","data","stringToBytes","value","x","offset","buffer8","view32","getArray","stopWhenFound","LOOP_LIMIT","loopCount","dict","values","Util","rgbBuf","m1","m2","xt","p","m","yt","d","p1","p2","r","p3","p4","v","transpose","a","b","c","first","second","sx","sy","rect","orderedX","rect1","rect2","orderedY","result","ROMAN_NUMBER_MAP","lowerCase","number","romanBuf","romanStr","PDFStringTranslateTable","n","code","decodeURIComponent","escape","unescape","encodeURIComponent","ch","capability","createObjectURL","digits","forceDataSchema","URL","blob","type","buffer","b1","b2","b3","d1","d2","d3","d4","globalScope","require","isNodeJS","hasDOM","Buffer","get","scripts","document","Element","div","originalDOMTokenListToggle","DOMTokenList","arguments","force","Array","module","window","global","self","process","$export","context","INCLUDES","includes","core","hide","redefine","ctx","PROTOTYPE","IS_FORCED","IS_GLOBAL","IS_STATIC","IS_PROTO","IS_BIND","target","exports","expProto","source","own","out","exp","Function","__g","version","__e","dP","createDesc","object","anObject","IE8_DOM_DEFINE","toPrimitive","P","TypeError","O","Attributes","isObject","it","is","S","val","fn","has","SRC","TO_STRING","$toString","TPL","isFunction","hasOwnProperty","id","px","key","aFunction","that","isRegExp","defined","cof","MATCH","toString","store","uid","Symbol","USE_SYMBOL","$exports","SHARED","mode","copyright","re","$includes","toIObject","toLength","toAbsoluteIndex","index","IS_INCLUDES","el","IObject","toInteger","min","ceil","floor","isNaN","max","UNSCOPABLES","ArrayProto","assign","getKeys","gOPS","pIE","toObject","$assign","A","B","K","T","aLen","getSymbols","isEnum","keys","j","$keys","enumBugKeys","arrayIndexOf","IE_PROTO","names","shared","log2","isInteger","isFinite","classof","test","TAG","ARG","tryGet","$iterators","Iterators","wks","ITERATOR","TO_STRING_TAG","ArrayValues","DOMIterables","CSSRuleList","CSSStyleDeclaration","CSSValueList","ClientRectList","DOMRectList","DOMStringList","DataTransferItemList","FileList","HTMLAllCollection","HTMLCollection","HTMLFormElement","HTMLSelectElement","MediaList","MimeTypeArray","NamedNodeMap","NodeList","PaintRequestList","Plugin","PluginArray","SVGLengthList","SVGNumberList","SVGPathSegList","SVGPointList","SVGStringList","SVGTransformList","SourceBufferList","StyleSheetList","TextTrackCueList","TextTrackList","TouchList","collections","NAME","explicit","Collection","proto","addToUnscopables","step","kind","done","LIBRARY","$iterCreate","setToStringTag","getPrototypeOf","BUGGY","FF_ITERATOR","KEYS","VALUES","returnThis","getMethod","DEF_VALUES","DEFAULT","VALUES_BUG","Base","$native","$default","$entries","$anyNative","IteratorPrototype","methods","IS_SET","entries","create","descriptor","Constructor","next","dPs","Empty","createDict","iframe","lt","gt","iframeDocument","Properties","def","stat","ObjectProto","each","meta","weak","fails","validate","WEAK_MAP","getWeak","isExtensible","uncaughtFrozenStore","tmp","wrapper","set","$WeakMap","InternalMap","method","asc","IS_MAP","TYPE","IS_FILTER","IS_SOME","IS_EVERY","IS_FIND_INDEX","NO_HOLES","$create","f","res","speciesConstructor","isArray","SPECIES","C","original","META","setDesc","FREEZE","setMeta","w","fastKey","onFreeze","KEY","NEED","redefineAll","anInstance","forOf","createArrayMethod","$has","arrayFind","arrayFindIndex","UncaughtFrozenStore","findUncaughtFrozen","entry","getConstructor","iterable","ufstore","src","forbiddenField","name","call","isArrayIter","getIterFn","BREAK","RETURN","iterFn","iterator","ret","$iterDetect","inheritIfRequired","ADDER","fixMethod","IS_WEAK","common","instance","HASNT_CHAINING","THROWS_ON_PRIMITIVES","ACCEPT_ITERABLES","BUGGY_ZERO","$instance","SAFE_CLOSING","riter","safe","iter","exec","setPrototypeOf","check","buggy","gOPD","of","from","mapFn","mapping","cb","$at","codePointAt","s","l","fromCharCode","$fromCodePoint","fromCodePoint","RangeError","DESCRIPTORS","$fails","wksExt","wksDefine","enumKeys","_create","gOPNExt","$GOPD","$DP","gOPN","$Symbol","$JSON","_stringify","TO_PRIMITIVE","SymbolRegistry","AllSymbols","OPSymbols","USE_NATIVE","QObject","setter","setSymbolDesc","protoDesc","wrap","sym","isSymbol","$defineProperty","D","$defineProperties","$propertyIsEnumerable","E","$getOwnPropertyDescriptor","$getOwnPropertyNames","$getOwnPropertySymbols","IS_OP","tag","$set","es6Symbols","wellKnownSymbols","k","keyFor","useSetter","useSimple","defineProperty","defineProperties","getOwnPropertyDescriptor","getOwnPropertyNames","getOwnPropertySymbols","stringify","args","$replacer","replacer","symbols","windowNames","getWindowNames","hiddenKeys","$values","isReadableStreamSupported","start","controller","constructor","isURLSupported","u","Jbig2Error","Jbig2Image","ContextCache","getContexts","DecodingContext","decoder","shadow","cache","contexts","contextCache","prev","bit","sign","readBits","codeLength","SegmentTypes","CodingTemplates","y","RefinementTemplates","coding","reference","ReusedContexts","RefinementReusedContexts","decodingContext","bitmap","OLD_PIXEL_MASK","row","row1","row2","contextLabel","pixel","input","decodeMMRBitmap","templateIndex","at","decodeBitmapTemplate0","useskip","template","templateLength","templateX","templateY","changingTemplateEntries","reuseMask","minX","maxX","minY","changingEntriesLength","changingTemplateX","changingTemplateY","changingTemplateBit","sbb_left","sbb_top","sbb_right","width","pseudoPixelContext","ltp","sltp","skip","i0","j0","shift","codingTemplate","codingTemplateLength","codingTemplateX","codingTemplateY","referenceTemplate","referenceTemplateLength","referenceTemplateX","referenceTemplateY","referenceWidth","referenceBitmap","referenceHeight","huffman","newSymbols","currentHeight","symbolCodeLength","tableB1","getStandardTable","symbolWidths","deltaHeight","huffmanTables","decodeInteger","currentWidth","totalWidth","firstSymbol","deltaWidth","numberOfInstances","decodeTextRegion","symbolId","decodeIAID","rdx","rdy","symbol","decodeRefinement","decodeBitmap","bitmapSize","huffmanInput","collectiveBitmap","readUncompressedBitmap","originalEnd","bitmapEnd","numberOfSymbolsDecoded","xMin","bitmapWidth","xMax","symbolBitmap","exportedSymbols","flags","currentFlag","totalSymbolsLength","runLength","stripT","firstS","deltaT","deltaFirstS","currentS","currentT","stripSize","t","applyRefinement","refinement","inputSymbols","symbolWidth","symbolHeight","rdw","rdh","offsetT","referenceCorner","offsetS","s2","symbolRow","maxWidth","t2","deltaS","collectiveWidth","patterns","patternBitmap","patternWidth","combinationOperator","regionBitmap","numberOfPatterns","pattern0","patternHeight","bitsPerValue","grayScaleBitPlanes","mmrInput","mg","ng","patternIndex","gridOffsetX","gridOffsetY","regionRow","patternRow","regionY","regionX","segmentHeader","readUint32","segmentType","pageAssociationFieldSize","referredFlags","referredToCount","retainBits","position","referredToSegmentNumberSize","referredTo","readUint16","genericRegionInfo","readRegionSegmentInformation","genericRegionSegmentFlags","genericRegionMmr","searchPatternLength","searchPattern","segments","readSegmentHeader","segment","header","height","RegionSegmentInformationFieldLength","end","dictionary","dictionaryFlags","atLength","readInt8","textRegion","textRegionSegmentFlags","textRegionHuffmanFlags","patternDictionary","patternDictionaryFlags","halftoneRegion","halftoneRegionFlags","genericRegion","pageInfo","resolutionX","resolutionY","pageSegmentFlags","callbackName","visitor","processSegment","chunks","readSegments","processSegments","bitPacked","imgData","q","mask","SimpleSegmentVisitor","onPageInformation","rowSize","info","drawBitmap","regionInfo","mask0","offset0","onImmediateGenericRegion","region","onImmediateLosslessGenericRegion","onSymbolDictionary","getSymbolDictionaryHuffmanTables","referredSegments","referredSymbols","decodeSymbolDictionary","onImmediateTextRegion","getTextRegionHuffmanTables","onImmediateLosslessTextRegion","onPatternDictionary","decodePatternDictionary","onImmediateHalftoneRegion","decodeHalftoneRegion","onImmediateLosslessHalftoneRegion","onTables","customTables","decodeTablesSegment","lineData","line","HuffmanTreeNode","buildTree","node","decodeNode","htOffset","reader","lines","HuffmanTable","decode","assignPrefixCodes","linesLength","prefixLengthMax","histogram","currentLength","firstCode","currentCode","currentTemp","lowestValue","highestValue","prefixSizeBits","rangeSizeBits","currentRangeLow","prefixLength","rangeLength","standardTablesCache","table","Reader","readBit","numBits","byteAlign","currentIndex","codes","runCodesTable","numberOfRepeats","repeatedLength","symbolIDTable","customIndex","tableFirstS","getCustomHuffmanTable","tableDeltaS","tableDeltaT","tableDeltaHeight","tableDeltaWidth","tableBitmapSize","tableAggregateInstances","params","Columns","Rows","BlackIs1","EndOfBlock","eof","currentByte","endOfBlock","lookForEOFLimit","parseChunks","parseJbig2Chunks","parse","parseJbig2","ArithmeticDecoder","QeTable","qe","nmps","nlps","switchFlag","byteIn","bp","cx_index","cx_mps","qeTableIcx","qeIcx","CCITTFaxDecoder","ccittEOL","ccittEOF","twoDimPass","twoDimHoriz","twoDimVert0","twoDimVertR1","twoDimVertL1","twoDimVertR2","twoDimVertL2","twoDimVertR3","twoDimVertL3","twoDimTable","whiteTable1","whiteTable2","blackTable1","blackTable2","blackTable3","options","eoblock","code1","readNextChar","refLine","codingLine","columns","refPos","blackPixels","code2","code3","gotEOL","bits","_addPixels","codingPos","a1","_addPixelsNeg","_findTableCode","limitValue","limit","_getTwoDimCode","_getWhiteCode","_getBlackCode","_lookBits","_eatBits","JpegError","DNLMarkerError","EOIMarkerError","JpegImage","dctZigZag","dctCos1","dctSin1","dctCos3","dctSin3","dctCos6","dctSin6","dctSqrt2","dctSqrt1d2","decodeTransform","colorTransform","codeLengths","children","parseDNLMarker","mcusPerLine","frame","progressive","startOffset","bitsData","bitsCount","nextByte","scanLines","receive","decodeHuffman","component","diff","receiveAndExtend","rs","z","eobrun","e","successiveACState","offsetZ","successiveACNextValue","mcuRow","mcu","mcuCol","blockRow","blockCol","getBlockBufferOffset","componentsLength","components","spectralStart","decodeFn","successivePrev","mcuExpected","mcuToRead","resetInterval","decodeBlock","h","decodeMcu","fileMarker","findNextFileMarker","marker","qt","blockData","p0","blockBufferOffset","p5","p6","p7","v0","v1","v2","v3","v4","v7","v5","v6","col","blocksPerLine","blocksPerColumn","computationBuffer","quantizeAndInverse","startPos","maxPos","newPos","currentPos","currentMarker","peekUint16","invalid","newMarker","dnlScanLines","endOffset","array","mcusPerColumn","blocksPerLineForMcu","blocksPerColumnForMcu","blocksBufferSize","jfif","adobe","numSOSMarkers","quantizationTables","huffmanTablesAC","huffmanTablesDC","appData","major","minor","densityUnits","xDensity","yDensity","thumbWidth","thumbHeight","thumbData","flags0","flags1","transformCode","quantizationTablesLength","quantizationTablesEnd","quantizationTableSpec","tableData","sofScanLines","componentsCount","maxH","maxV","componentId","qId","quantizationId","quantizationTable","prepareComponents","huffmanLength","huffmanTableSpec","codeLengthSum","huffmanValues","buildHuffmanTable","selectorsCount","componentIndex","tableSpec","spectralEnd","successiveApproximation","processed","decodeScan","ex","nextFileMarker","output","buildComponentData","scaleX","scaleY","_getLinearizedBlockData","isSourcePDF","numComponents","dataLength","xScaleBlockOffset","mask3LSB","componentScaleX","componentScaleY","blocksPerScanline","_convertYccToRgb","Y","Cb","Cr","_convertYcckToRgb","_convertYcckToCmyk","_convertCmykToRgb","scale","getData","forceRGB","rgbData","grayColor","JpxError","JpxImage","SubbandsGainLog2","head","headerSize","lbox","tbox","jumpDataLength","colorspace","headerType","parseImageProperties","newByte","stream","oldByte","Xsiz","Ysiz","XOsiz","YOsiz","Csiz","parseCodestream","doNotRecover","siz","precision","isSigned","XRsiz","YRsiz","calculateComponentDimensions","calculateTileGrids","qcd","sqcd","spqcdSize","scalarExpounded","spqcds","spqcd","qcc","cqcc","cod","scod","blockStyle","precinctsSizes","precinctsSize","PPx","PPy","unsupported","tile","initializeTile","buildPackets","parseTilePackets","transformComponents","tiles","numXtiles","numYtiles","jj","tileComponent","codOrCoc","precinctWidth","dimensions","precinctHeight","isZeroRes","resolution","precinctWidthInSubband","precinctHeightInSubband","numprecinctswide","numprecinctshigh","numprecincts","xcb_","ycb_","codeblockWidth","codeblockHeight","cbx0","subband","cby0","cbx1","cby1","precinctParameters","codeblocks","precincts","codeblock","cbx","cby","tbx0","tby0","tbx1","tby1","pi","pj","precinctNumber","precinct","cbxMin","cbyMin","cbxMax","cbyMax","numcodeblockwide","numcodeblockhigh","precinctCodeblocks","subbands","tileIndex","layersCount","maxDecompositionLevelsCount","packet","createPacket","maxNumPrecinctsInLevel","maxNumPrecincts","resolutions","getPrecinctSizesInImageScale","precinctsIterationSizes","py","decompositionLevelsCount","sizeInImageScale","getPrecinctIndexIfExist","posX","pxIndex","precinctIterationSizes","posY","pyIndex","startPrecinctRowIndex","minWidth","minHeight","maxNumWide","maxNumHigh","sizePerComponent","sizePerResolution","minWidthCurrentComponent","minHeightCurrentComponent","maxNumWideCurrentComponent","maxNumHighCurrentComponent","widthCurrentResolution","heightCurrentResolution","blocksDimensions","getBlocksDimensions","buildPrecincts","buildCodeblocks","bscale","resolutionSubbands","progressionOrder","bufferSize","skipNextBit","skipBytes","sopMarkerUsed","ephMarkerUsed","packetsIterator","skipMarkerIfEqual","layerNumber","queue","codeblockColumn","codeblockRow","codeblockIncluded","firstTimeInclusion","inclusionTree","zeroBitPlanesTree","valueReady","codingpasses","codingpassesLog2","codedDataLength","packetItem","x0","y0","right","bottom","blockWidth","blockHeight","bitModel","currentCodingpassType","totalLength","dataItem","encodedData","magnitude","bitsDecoded","magnitudeCorrection","reversible","interleave","levelOffset","nb","coefficients","mb","codingStyleParameters","quantizationParameters","guardBits","segmentationSymbolUsed","subbandCoefficients","mu","epsilon","gainLog2","delta","copyCoefficients","items","left","top","resultImages","transformedTiles","transformTile","tile0","fourComponents","y0items","y1items","y2items","y3items","component0","alpha01","y1","y2","g","qcdOrQcc","TagTree","levelsLength","level","reset","currentLevel","incrementValue","nextLevel","InclusionTree","stopValue","propagateValues","levelIndex","currentValue","BitModel","UNIFORM_CONTEXT","RUNLENGTH_CONTEXT","LLAndLHContextsLabel","HLContextLabel","HHContextLabel","coefficientCount","zeroBitPlanes","setDecoder","setNeighborsSignificance","neighborsSignificance","column","runSignificancePropagationPass","coefficentsMagnitude","coefficentsSign","processingFlags","labels","processedInverseMask","processedMask","firstMagnitudeBitMask","i1","decision","decodeSignBit","significance1","sign1","sign0","contribution","horizontalContribution","decoded","runMagnitudeRefinementPass","width4","index0","indexNext","significance","runCleanupPass","oneRowDown","twoRowsDown","threeRowsDown","iNext","indexBase","checkAllEmpty","allEmpty","hasSignificantCoefficent","i2","checkSegmentationSymbol","Transform","ll","j1","j2","llWidth","llHeight","llItems","hl_lh_hh","bufferPadding","rowBuffer","numBuffers","colBuffers","currentBuffer","IrreversibleTransform","len","alpha","beta","gamma","K_","current","ReversibleTransform"],"mappings":"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","file":"pdf.image_decoders.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine(\"pdfjs-dist/image_decoders/pdf.image_decoders\", [], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"pdfjs-dist/image_decoders/pdf.image_decoders\"] = factory();\n\telse\n\t\troot[\"pdfjs-dist/image_decoders/pdf.image_decoders\"] = factory();\n})(this, function() {\nreturn "," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __w_pdfjs_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __w_pdfjs_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__w_pdfjs_require__.m = modules;\n\n \t// expose the module cache\n \t__w_pdfjs_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__w_pdfjs_require__.d = function(exports, name, getter) {\n \t\tif(!__w_pdfjs_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__w_pdfjs_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__w_pdfjs_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __w_pdfjs_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__w_pdfjs_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __w_pdfjs_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__w_pdfjs_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__w_pdfjs_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__w_pdfjs_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__w_pdfjs_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __w_pdfjs_require__(__w_pdfjs_require__.s = 0);\n","/* Copyright 2018 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/* eslint-disable no-unused-vars */\n\nimport { getVerbosityLevel, setVerbosityLevel } from './shared/util';\nimport { Jbig2mage } from './core/jbig2';\nimport { JpegImage } from './core/jpg';\nimport { JpxImage } from './core/jpx';\n\n// To ensure that the standalone PDF.js image decoders have the same\n// browser/environment compatibility as the regular PDF.js library,\n// the standard set of polyfills are thus included in this build as well.\n//\n// Given that the (current) image decoders don't use all of the features\n// of the complete PDF.js library, e.g. they are completely synchronous,\n// some of the larger polyfills are thus unnecessary.\n//\n// In an attempt to reduce the size of the standalone PDF.js image decoders,\n// the following polyfills are currently being excluded:\n//  - ReadableStream\n//  - Promise\n//  - URL\n\nconst pdfjsVersion = PDFJSDev.eval('BUNDLE_VERSION');\nconst pdfjsBuild = PDFJSDev.eval('BUNDLE_BUILD');\n\nexport {\n  Jbig2mage,\n  JpegImage,\n  JpxImage,\n  getVerbosityLevel,\n  setVerbosityLevel,\n};\n","/* Copyright 2012 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport './compatibility';\nimport { ReadableStream } from './streams_polyfill';\nimport { URL } from './url_polyfill';\n\nconst IDENTITY_MATRIX = [1, 0, 0, 1, 0, 0];\nconst FONT_IDENTITY_MATRIX = [0.001, 0, 0, 0.001, 0, 0];\n\nconst NativeImageDecoding = {\n  NONE: 'none',\n  DECODE: 'decode',\n  DISPLAY: 'display',\n};\n\n// Permission flags from Table 22, Section 7.6.3.2 of the PDF specification.\nconst PermissionFlag = {\n  PRINT: 0x04,\n  MODIFY_CONTENTS: 0x08,\n  COPY: 0x10,\n  MODIFY_ANNOTATIONS: 0x20,\n  FILL_INTERACTIVE_FORMS: 0x100,\n  COPY_FOR_ACCESSIBILITY: 0x200,\n  ASSEMBLE: 0x400,\n  PRINT_HIGH_QUALITY: 0x800,\n};\n\nconst TextRenderingMode = {\n  FILL: 0,\n  STROKE: 1,\n  FILL_STROKE: 2,\n  INVISIBLE: 3,\n  FILL_ADD_TO_PATH: 4,\n  STROKE_ADD_TO_PATH: 5,\n  FILL_STROKE_ADD_TO_PATH: 6,\n  ADD_TO_PATH: 7,\n  FILL_STROKE_MASK: 3,\n  ADD_TO_PATH_FLAG: 4,\n};\n\nconst ImageKind = {\n  GRAYSCALE_1BPP: 1,\n  RGB_24BPP: 2,\n  RGBA_32BPP: 3,\n};\n\nconst AnnotationType = {\n  TEXT: 1,\n  LINK: 2,\n  FREETEXT: 3,\n  LINE: 4,\n  SQUARE: 5,\n  CIRCLE: 6,\n  POLYGON: 7,\n  POLYLINE: 8,\n  HIGHLIGHT: 9,\n  UNDERLINE: 10,\n  SQUIGGLY: 11,\n  STRIKEOUT: 12,\n  STAMP: 13,\n  CARET: 14,\n  INK: 15,\n  POPUP: 16,\n  FILEATTACHMENT: 17,\n  SOUND: 18,\n  MOVIE: 19,\n  WIDGET: 20,\n  SCREEN: 21,\n  PRINTERMARK: 22,\n  TRAPNET: 23,\n  WATERMARK: 24,\n  THREED: 25,\n  REDACT: 26,\n};\n\nconst AnnotationFlag = {\n  INVISIBLE: 0x01,\n  HIDDEN: 0x02,\n  PRINT: 0x04,\n  NOZOOM: 0x08,\n  NOROTATE: 0x10,\n  NOVIEW: 0x20,\n  READONLY: 0x40,\n  LOCKED: 0x80,\n  TOGGLENOVIEW: 0x100,\n  LOCKEDCONTENTS: 0x200,\n};\n\nconst AnnotationFieldFlag = {\n  READONLY: 0x0000001,\n  REQUIRED: 0x0000002,\n  NOEXPORT: 0x0000004,\n  MULTILINE: 0x0001000,\n  PASSWORD: 0x0002000,\n  NOTOGGLETOOFF: 0x0004000,\n  RADIO: 0x0008000,\n  PUSHBUTTON: 0x0010000,\n  COMBO: 0x0020000,\n  EDIT: 0x0040000,\n  SORT: 0x0080000,\n  FILESELECT: 0x0100000,\n  MULTISELECT: 0x0200000,\n  DONOTSPELLCHECK: 0x0400000,\n  DONOTSCROLL: 0x0800000,\n  COMB: 0x1000000,\n  RICHTEXT: 0x2000000,\n  RADIOSINUNISON: 0x2000000,\n  COMMITONSELCHANGE: 0x4000000,\n};\n\nconst AnnotationBorderStyleType = {\n  SOLID: 1,\n  DASHED: 2,\n  BEVELED: 3,\n  INSET: 4,\n  UNDERLINE: 5,\n};\n\nconst StreamType = {\n  UNKNOWN: 0,\n  FLATE: 1,\n  LZW: 2,\n  DCT: 3,\n  JPX: 4,\n  JBIG: 5,\n  A85: 6,\n  AHX: 7,\n  CCF: 8,\n  RL: 9,\n};\n\nconst FontType = {\n  UNKNOWN: 0,\n  TYPE1: 1,\n  TYPE1C: 2,\n  CIDFONTTYPE0: 3,\n  CIDFONTTYPE0C: 4,\n  TRUETYPE: 5,\n  CIDFONTTYPE2: 6,\n  TYPE3: 7,\n  OPENTYPE: 8,\n  TYPE0: 9,\n  MMTYPE1: 10,\n};\n\nconst VerbosityLevel = {\n  ERRORS: 0,\n  WARNINGS: 1,\n  INFOS: 5,\n};\n\nconst CMapCompressionType = {\n  NONE: 0,\n  BINARY: 1,\n  STREAM: 2,\n};\n\n// All the possible operations for an operator list.\nconst OPS = {\n  // Intentionally start from 1 so it is easy to spot bad operators that will be\n  // 0's.\n  dependency: 1,\n  setLineWidth: 2,\n  setLineCap: 3,\n  setLineJoin: 4,\n  setMiterLimit: 5,\n  setDash: 6,\n  setRenderingIntent: 7,\n  setFlatness: 8,\n  setGState: 9,\n  save: 10,\n  restore: 11,\n  transform: 12,\n  moveTo: 13,\n  lineTo: 14,\n  curveTo: 15,\n  curveTo2: 16,\n  curveTo3: 17,\n  closePath: 18,\n  rectangle: 19,\n  stroke: 20,\n  closeStroke: 21,\n  fill: 22,\n  eoFill: 23,\n  fillStroke: 24,\n  eoFillStroke: 25,\n  closeFillStroke: 26,\n  closeEOFillStroke: 27,\n  endPath: 28,\n  clip: 29,\n  eoClip: 30,\n  beginText: 31,\n  endText: 32,\n  setCharSpacing: 33,\n  setWordSpacing: 34,\n  setHScale: 35,\n  setLeading: 36,\n  setFont: 37,\n  setTextRenderingMode: 38,\n  setTextRise: 39,\n  moveText: 40,\n  setLeadingMoveText: 41,\n  setTextMatrix: 42,\n  nextLine: 43,\n  showText: 44,\n  showSpacedText: 45,\n  nextLineShowText: 46,\n  nextLineSetSpacingShowText: 47,\n  setCharWidth: 48,\n  setCharWidthAndBounds: 49,\n  setStrokeColorSpace: 50,\n  setFillColorSpace: 51,\n  setStrokeColor: 52,\n  setStrokeColorN: 53,\n  setFillColor: 54,\n  setFillColorN: 55,\n  setStrokeGray: 56,\n  setFillGray: 57,\n  setStrokeRGBColor: 58,\n  setFillRGBColor: 59,\n  setStrokeCMYKColor: 60,\n  setFillCMYKColor: 61,\n  shadingFill: 62,\n  beginInlineImage: 63,\n  beginImageData: 64,\n  endInlineImage: 65,\n  paintXObject: 66,\n  markPoint: 67,\n  markPointProps: 68,\n  beginMarkedContent: 69,\n  beginMarkedContentProps: 70,\n  endMarkedContent: 71,\n  beginCompat: 72,\n  endCompat: 73,\n  paintFormXObjectBegin: 74,\n  paintFormXObjectEnd: 75,\n  beginGroup: 76,\n  endGroup: 77,\n  beginAnnotations: 78,\n  endAnnotations: 79,\n  beginAnnotation: 80,\n  endAnnotation: 81,\n  paintJpegXObject: 82,\n  paintImageMaskXObject: 83,\n  paintImageMaskXObjectGroup: 84,\n  paintImageXObject: 85,\n  paintInlineImageXObject: 86,\n  paintInlineImageXObjectGroup: 87,\n  paintImageXObjectRepeat: 88,\n  paintImageMaskXObjectRepeat: 89,\n  paintSolidColorImageMask: 90,\n  constructPath: 91,\n};\n\nconst UNSUPPORTED_FEATURES = {\n  unknown: 'unknown',\n  forms: 'forms',\n  javaScript: 'javaScript',\n  smask: 'smask',\n  shadingPattern: 'shadingPattern',\n  font: 'font',\n};\n\nconst PasswordResponses = {\n  NEED_PASSWORD: 1,\n  INCORRECT_PASSWORD: 2,\n};\n\nlet verbosity = VerbosityLevel.WARNINGS;\n\nfunction setVerbosityLevel(level) {\n  if (Number.isInteger(level)) {\n    verbosity = level;\n  }\n}\n\nfunction getVerbosityLevel() {\n  return verbosity;\n}\n\n// A notice for devs. These are good for things that are helpful to devs, such\n// as warning that Workers were disabled, which is important to devs but not\n// end users.\nfunction info(msg) {\n  if (verbosity >= VerbosityLevel.INFOS) {\n    console.log('Info: ' + msg);\n  }\n}\n\n// Non-fatal warnings.\nfunction warn(msg) {\n  if (verbosity >= VerbosityLevel.WARNINGS) {\n    console.log('Warning: ' + msg);\n  }\n}\n\n// Deprecated API function -- display regardless of the `verbosity` setting.\nfunction deprecated(details) {\n  console.log('Deprecated API usage: ' + details);\n}\n\nfunction unreachable(msg) {\n  throw new Error(msg);\n}\n\nfunction assert(cond, msg) {\n  if (!cond) {\n    unreachable(msg);\n  }\n}\n\n// Checks if URLs have the same origin. For non-HTTP based URLs, returns false.\nfunction isSameOrigin(baseUrl, otherUrl) {\n  try {\n    var base = new URL(baseUrl);\n    if (!base.origin || base.origin === 'null') {\n      return false; // non-HTTP url\n    }\n  } catch (e) {\n    return false;\n  }\n\n  var other = new URL(otherUrl, base);\n  return base.origin === other.origin;\n}\n\n// Checks if URLs use one of the whitelisted protocols, e.g. to avoid XSS.\nfunction _isValidProtocol(url) {\n  if (!url) {\n    return false;\n  }\n  switch (url.protocol) {\n    case 'http:':\n    case 'https:':\n    case 'ftp:':\n    case 'mailto:':\n    case 'tel:':\n      return true;\n    default:\n      return false;\n  }\n}\n\n/**\n * Attempts to create a valid absolute URL.\n *\n * @param {URL|string} url - An absolute, or relative, URL.\n * @param {URL|string} baseUrl - An absolute URL.\n * @returns Either a valid {URL}, or `null` otherwise.\n */\nfunction createValidAbsoluteUrl(url, baseUrl) {\n  if (!url) {\n    return null;\n  }\n  try {\n    var absoluteUrl = baseUrl ? new URL(url, baseUrl) : new URL(url);\n    if (_isValidProtocol(absoluteUrl)) {\n      return absoluteUrl;\n    }\n  } catch (ex) { /* `new URL()` will throw on incorrect data. */ }\n  return null;\n}\n\nfunction shadow(obj, prop, value) {\n  Object.defineProperty(obj, prop, { value,\n                                     enumerable: true,\n                                     configurable: true,\n                                     writable: false, });\n  return value;\n}\n\nfunction getLookupTableFactory(initializer) {\n  var lookup;\n  return function () {\n    if (initializer) {\n      lookup = Object.create(null);\n      initializer(lookup);\n      initializer = null;\n    }\n    return lookup;\n  };\n}\n\nvar PasswordException = (function PasswordExceptionClosure() {\n  function PasswordException(msg, code) {\n    this.name = 'PasswordException';\n    this.message = msg;\n    this.code = code;\n  }\n\n  PasswordException.prototype = new Error();\n  PasswordException.constructor = PasswordException;\n\n  return PasswordException;\n})();\n\nvar UnknownErrorException = (function UnknownErrorExceptionClosure() {\n  function UnknownErrorException(msg, details) {\n    this.name = 'UnknownErrorException';\n    this.message = msg;\n    this.details = details;\n  }\n\n  UnknownErrorException.prototype = new Error();\n  UnknownErrorException.constructor = UnknownErrorException;\n\n  return UnknownErrorException;\n})();\n\nvar InvalidPDFException = (function InvalidPDFExceptionClosure() {\n  function InvalidPDFException(msg) {\n    this.name = 'InvalidPDFException';\n    this.message = msg;\n  }\n\n  InvalidPDFException.prototype = new Error();\n  InvalidPDFException.constructor = InvalidPDFException;\n\n  return InvalidPDFException;\n})();\n\nvar MissingPDFException = (function MissingPDFExceptionClosure() {\n  function MissingPDFException(msg) {\n    this.name = 'MissingPDFException';\n    this.message = msg;\n  }\n\n  MissingPDFException.prototype = new Error();\n  MissingPDFException.constructor = MissingPDFException;\n\n  return MissingPDFException;\n})();\n\nvar UnexpectedResponseException =\n    (function UnexpectedResponseExceptionClosure() {\n  function UnexpectedResponseException(msg, status) {\n    this.name = 'UnexpectedResponseException';\n    this.message = msg;\n    this.status = status;\n  }\n\n  UnexpectedResponseException.prototype = new Error();\n  UnexpectedResponseException.constructor = UnexpectedResponseException;\n\n  return UnexpectedResponseException;\n})();\n\nvar MissingDataException = (function MissingDataExceptionClosure() {\n  function MissingDataException(begin, end) {\n    this.begin = begin;\n    this.end = end;\n    this.message = 'Missing data [' + begin + ', ' + end + ')';\n  }\n\n  MissingDataException.prototype = new Error();\n  MissingDataException.prototype.name = 'MissingDataException';\n  MissingDataException.constructor = MissingDataException;\n\n  return MissingDataException;\n})();\n\nvar XRefParseException = (function XRefParseExceptionClosure() {\n  function XRefParseException(msg) {\n    this.message = msg;\n  }\n\n  XRefParseException.prototype = new Error();\n  XRefParseException.prototype.name = 'XRefParseException';\n  XRefParseException.constructor = XRefParseException;\n\n  return XRefParseException;\n})();\n\n/**\n * Error caused during parsing PDF data.\n */\nlet FormatError = (function FormatErrorClosure() {\n  function FormatError(msg) {\n    this.message = msg;\n  }\n\n  FormatError.prototype = new Error();\n  FormatError.prototype.name = 'FormatError';\n  FormatError.constructor = FormatError;\n\n  return FormatError;\n})();\n\n/**\n * Error used to indicate task cancellation.\n */\nlet AbortException = (function AbortExceptionClosure() {\n  function AbortException(msg) {\n    this.name = 'AbortException';\n    this.message = msg;\n  }\n\n  AbortException.prototype = new Error();\n  AbortException.constructor = AbortException;\n\n  return AbortException;\n})();\n\nvar NullCharactersRegExp = /\\x00/g;\n\nfunction removeNullCharacters(str) {\n  if (typeof str !== 'string') {\n    warn('The argument for removeNullCharacters must be a string.');\n    return str;\n  }\n  return str.replace(NullCharactersRegExp, '');\n}\n\nfunction bytesToString(bytes) {\n  assert(bytes !== null && typeof bytes === 'object' &&\n         bytes.length !== undefined, 'Invalid argument for bytesToString');\n  var length = bytes.length;\n  var MAX_ARGUMENT_COUNT = 8192;\n  if (length < MAX_ARGUMENT_COUNT) {\n    return String.fromCharCode.apply(null, bytes);\n  }\n  var strBuf = [];\n  for (var i = 0; i < length; i += MAX_ARGUMENT_COUNT) {\n    var chunkEnd = Math.min(i + MAX_ARGUMENT_COUNT, length);\n    var chunk = bytes.subarray(i, chunkEnd);\n    strBuf.push(String.fromCharCode.apply(null, chunk));\n  }\n  return strBuf.join('');\n}\n\nfunction stringToBytes(str) {\n  assert(typeof str === 'string', 'Invalid argument for stringToBytes');\n  var length = str.length;\n  var bytes = new Uint8Array(length);\n  for (var i = 0; i < length; ++i) {\n    bytes[i] = str.charCodeAt(i) & 0xFF;\n  }\n  return bytes;\n}\n\n/**\n * Gets length of the array (Array, Uint8Array, or string) in bytes.\n * @param {Array|Uint8Array|string} arr\n * @returns {number}\n */\nfunction arrayByteLength(arr) {\n  if (arr.length !== undefined) {\n    return arr.length;\n  }\n  assert(arr.byteLength !== undefined);\n  return arr.byteLength;\n}\n\n/**\n * Combines array items (arrays) into single Uint8Array object.\n * @param {Array} arr - the array of the arrays (Array, Uint8Array, or string).\n * @returns {Uint8Array}\n */\nfunction arraysToBytes(arr) {\n  // Shortcut: if first and only item is Uint8Array, return it.\n  if (arr.length === 1 && (arr[0] instanceof Uint8Array)) {\n    return arr[0];\n  }\n  var resultLength = 0;\n  var i, ii = arr.length;\n  var item, itemLength;\n  for (i = 0; i < ii; i++) {\n    item = arr[i];\n    itemLength = arrayByteLength(item);\n    resultLength += itemLength;\n  }\n  var pos = 0;\n  var data = new Uint8Array(resultLength);\n  for (i = 0; i < ii; i++) {\n    item = arr[i];\n    if (!(item instanceof Uint8Array)) {\n      if (typeof item === 'string') {\n        item = stringToBytes(item);\n      } else {\n        item = new Uint8Array(item);\n      }\n    }\n    itemLength = item.byteLength;\n    data.set(item, pos);\n    pos += itemLength;\n  }\n  return data;\n}\n\nfunction string32(value) {\n  return String.fromCharCode((value >> 24) & 0xff, (value >> 16) & 0xff,\n                             (value >> 8) & 0xff, value & 0xff);\n}\n\n// Calculate the base 2 logarithm of the number `x`. This differs from the\n// native function in the sense that it returns the ceiling value and that it\n// returns 0 instead of `Infinity`/`NaN` for `x` values smaller than/equal to 0.\nfunction log2(x) {\n  if (x <= 0) {\n    return 0;\n  }\n  return Math.ceil(Math.log2(x));\n}\n\nfunction readInt8(data, start) {\n  return (data[start] << 24) >> 24;\n}\n\nfunction readUint16(data, offset) {\n  return (data[offset] << 8) | data[offset + 1];\n}\n\nfunction readUint32(data, offset) {\n  return ((data[offset] << 24) | (data[offset + 1] << 16) |\n         (data[offset + 2] << 8) | data[offset + 3]) >>> 0;\n}\n\n// Lazy test the endianness of the platform\n// NOTE: This will be 'true' for simulated TypedArrays\nfunction isLittleEndian() {\n  var buffer8 = new Uint8Array(4);\n  buffer8[0] = 1;\n  var view32 = new Uint32Array(buffer8.buffer, 0, 1);\n  return (view32[0] === 1);\n}\n\n// Checks if it's possible to eval JS expressions.\nfunction isEvalSupported() {\n  try {\n    new Function(''); // eslint-disable-line no-new, no-new-func\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Get the value of an inheritable property.\n *\n * If the PDF specification explicitly lists a property in a dictionary as\n * inheritable, then the value of the property may be present in the dictionary\n * itself or in one or more parents of the dictionary.\n *\n * If the key is not found in the tree, `undefined` is returned. Otherwise,\n * the value for the key is returned or, if `stopWhenFound` is `false`, a list\n * of values is returned. To avoid infinite loops, the traversal is stopped when\n * the loop limit is reached.\n *\n * @param {Dict} dict - Dictionary from where to start the traversal.\n * @param {string} key - The key of the property to find the value for.\n * @param {boolean} getArray - Whether or not the value should be fetched as an\n *   array. The default value is `false`.\n * @param {boolean} stopWhenFound - Whether or not to stop the traversal when\n *   the key is found. If set to `false`, we always walk up the entire parent\n *   chain, for example to be able to find `\\Resources` placed on multiple\n *   levels of the tree. The default value is `true`.\n */\nfunction getInheritableProperty({ dict, key, getArray = false,\n                                  stopWhenFound = true, }) {\n  const LOOP_LIMIT = 100;\n  let loopCount = 0;\n  let values;\n\n  while (dict) {\n    const value = getArray ? dict.getArray(key) : dict.get(key);\n    if (value !== undefined) {\n      if (stopWhenFound) {\n        return value;\n      }\n      if (!values) {\n        values = [];\n      }\n      values.push(value);\n    }\n    if (++loopCount > LOOP_LIMIT) {\n      warn(`getInheritableProperty: maximum loop count exceeded for \"${key}\"`);\n      break;\n    }\n    dict = dict.get('Parent');\n  }\n  return values;\n}\n\nvar Util = (function UtilClosure() {\n  function Util() {}\n\n  var rgbBuf = ['rgb(', 0, ',', 0, ',', 0, ')'];\n\n  // makeCssRgb() can be called thousands of times. Using |rgbBuf| avoids\n  // creating many intermediate strings.\n  Util.makeCssRgb = function Util_makeCssRgb(r, g, b) {\n    rgbBuf[1] = r;\n    rgbBuf[3] = g;\n    rgbBuf[5] = b;\n    return rgbBuf.join('');\n  };\n\n  // Concatenates two transformation matrices together and returns the result.\n  Util.transform = function Util_transform(m1, m2) {\n    return [\n      m1[0] * m2[0] + m1[2] * m2[1],\n      m1[1] * m2[0] + m1[3] * m2[1],\n      m1[0] * m2[2] + m1[2] * m2[3],\n      m1[1] * m2[2] + m1[3] * m2[3],\n      m1[0] * m2[4] + m1[2] * m2[5] + m1[4],\n      m1[1] * m2[4] + m1[3] * m2[5] + m1[5]\n    ];\n  };\n\n  // For 2d affine transforms\n  Util.applyTransform = function Util_applyTransform(p, m) {\n    var xt = p[0] * m[0] + p[1] * m[2] + m[4];\n    var yt = p[0] * m[1] + p[1] * m[3] + m[5];\n    return [xt, yt];\n  };\n\n  Util.applyInverseTransform = function Util_applyInverseTransform(p, m) {\n    var d = m[0] * m[3] - m[1] * m[2];\n    var xt = (p[0] * m[3] - p[1] * m[2] + m[2] * m[5] - m[4] * m[3]) / d;\n    var yt = (-p[0] * m[1] + p[1] * m[0] + m[4] * m[1] - m[5] * m[0]) / d;\n    return [xt, yt];\n  };\n\n  // Applies the transform to the rectangle and finds the minimum axially\n  // aligned bounding box.\n  Util.getAxialAlignedBoundingBox =\n    function Util_getAxialAlignedBoundingBox(r, m) {\n\n    var p1 = Util.applyTransform(r, m);\n    var p2 = Util.applyTransform(r.slice(2, 4), m);\n    var p3 = Util.applyTransform([r[0], r[3]], m);\n    var p4 = Util.applyTransform([r[2], r[1]], m);\n    return [\n      Math.min(p1[0], p2[0], p3[0], p4[0]),\n      Math.min(p1[1], p2[1], p3[1], p4[1]),\n      Math.max(p1[0], p2[0], p3[0], p4[0]),\n      Math.max(p1[1], p2[1], p3[1], p4[1])\n    ];\n  };\n\n  Util.inverseTransform = function Util_inverseTransform(m) {\n    var d = m[0] * m[3] - m[1] * m[2];\n    return [m[3] / d, -m[1] / d, -m[2] / d, m[0] / d,\n      (m[2] * m[5] - m[4] * m[3]) / d, (m[4] * m[1] - m[5] * m[0]) / d];\n  };\n\n  // Apply a generic 3d matrix M on a 3-vector v:\n  //   | a b c |   | X |\n  //   | d e f | x | Y |\n  //   | g h i |   | Z |\n  // M is assumed to be serialized as [a,b,c,d,e,f,g,h,i],\n  // with v as [X,Y,Z]\n  Util.apply3dTransform = function Util_apply3dTransform(m, v) {\n    return [\n      m[0] * v[0] + m[1] * v[1] + m[2] * v[2],\n      m[3] * v[0] + m[4] * v[1] + m[5] * v[2],\n      m[6] * v[0] + m[7] * v[1] + m[8] * v[2]\n    ];\n  };\n\n  // This calculation uses Singular Value Decomposition.\n  // The SVD can be represented with formula A = USV. We are interested in the\n  // matrix S here because it represents the scale values.\n  Util.singularValueDecompose2dScale =\n    function Util_singularValueDecompose2dScale(m) {\n\n    var transpose = [m[0], m[2], m[1], m[3]];\n\n    // Multiply matrix m with its transpose.\n    var a = m[0] * transpose[0] + m[1] * transpose[2];\n    var b = m[0] * transpose[1] + m[1] * transpose[3];\n    var c = m[2] * transpose[0] + m[3] * transpose[2];\n    var d = m[2] * transpose[1] + m[3] * transpose[3];\n\n    // Solve the second degree polynomial to get roots.\n    var first = (a + d) / 2;\n    var second = Math.sqrt((a + d) * (a + d) - 4 * (a * d - c * b)) / 2;\n    var sx = first + second || 1;\n    var sy = first - second || 1;\n\n    // Scale values are the square roots of the eigenvalues.\n    return [Math.sqrt(sx), Math.sqrt(sy)];\n  };\n\n  // Normalize rectangle rect=[x1, y1, x2, y2] so that (x1,y1) < (x2,y2)\n  // For coordinate systems whose origin lies in the bottom-left, this\n  // means normalization to (BL,TR) ordering. For systems with origin in the\n  // top-left, this means (TL,BR) ordering.\n  Util.normalizeRect = function Util_normalizeRect(rect) {\n    var r = rect.slice(0); // clone rect\n    if (rect[0] > rect[2]) {\n      r[0] = rect[2];\n      r[2] = rect[0];\n    }\n    if (rect[1] > rect[3]) {\n      r[1] = rect[3];\n      r[3] = rect[1];\n    }\n    return r;\n  };\n\n  // Returns a rectangle [x1, y1, x2, y2] corresponding to the\n  // intersection of rect1 and rect2. If no intersection, returns 'false'\n  // The rectangle coordinates of rect1, rect2 should be [x1, y1, x2, y2]\n  Util.intersect = function Util_intersect(rect1, rect2) {\n    function compare(a, b) {\n      return a - b;\n    }\n\n    // Order points along the axes\n    var orderedX = [rect1[0], rect1[2], rect2[0], rect2[2]].sort(compare),\n        orderedY = [rect1[1], rect1[3], rect2[1], rect2[3]].sort(compare),\n        result = [];\n\n    rect1 = Util.normalizeRect(rect1);\n    rect2 = Util.normalizeRect(rect2);\n\n    // X: first and second points belong to different rectangles?\n    if ((orderedX[0] === rect1[0] && orderedX[1] === rect2[0]) ||\n        (orderedX[0] === rect2[0] && orderedX[1] === rect1[0])) {\n      // Intersection must be between second and third points\n      result[0] = orderedX[1];\n      result[2] = orderedX[2];\n    } else {\n      return false;\n    }\n\n    // Y: first and second points belong to different rectangles?\n    if ((orderedY[0] === rect1[1] && orderedY[1] === rect2[1]) ||\n        (orderedY[0] === rect2[1] && orderedY[1] === rect1[1])) {\n      // Intersection must be between second and third points\n      result[1] = orderedY[1];\n      result[3] = orderedY[2];\n    } else {\n      return false;\n    }\n\n    return result;\n  };\n\n  return Util;\n})();\n\nconst ROMAN_NUMBER_MAP = [\n  '', 'C', 'CC', 'CCC', 'CD', 'D', 'DC', 'DCC', 'DCCC', 'CM',\n  '', 'X', 'XX', 'XXX', 'XL', 'L', 'LX', 'LXX', 'LXXX', 'XC',\n  '', 'I', 'II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX'\n];\n\n/**\n * Converts positive integers to (upper case) Roman numerals.\n * @param {integer} number - The number that should be converted.\n * @param {boolean} lowerCase - Indicates if the result should be converted\n *   to lower case letters. The default value is `false`.\n * @return {string} The resulting Roman number.\n */\nfunction toRomanNumerals(number, lowerCase = false) {\n  assert(Number.isInteger(number) && number > 0,\n         'The number should be a positive integer.');\n  let pos, romanBuf = [];\n  // Thousands\n  while (number >= 1000) {\n    number -= 1000;\n    romanBuf.push('M');\n  }\n  // Hundreds\n  pos = (number / 100) | 0;\n  number %= 100;\n  romanBuf.push(ROMAN_NUMBER_MAP[pos]);\n  // Tens\n  pos = (number / 10) | 0;\n  number %= 10;\n  romanBuf.push(ROMAN_NUMBER_MAP[10 + pos]);\n  // Ones\n  romanBuf.push(ROMAN_NUMBER_MAP[20 + number]);\n\n  const romanStr = romanBuf.join('');\n  return (lowerCase ? romanStr.toLowerCase() : romanStr);\n}\n\nconst PDFStringTranslateTable = [\n  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n  0x2D8, 0x2C7, 0x2C6, 0x2D9, 0x2DD, 0x2DB, 0x2DA, 0x2DC, 0, 0, 0, 0, 0, 0, 0,\n  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x2022, 0x2020, 0x2021, 0x2026, 0x2014,\n  0x2013, 0x192, 0x2044, 0x2039, 0x203A, 0x2212, 0x2030, 0x201E, 0x201C,\n  0x201D, 0x2018, 0x2019, 0x201A, 0x2122, 0xFB01, 0xFB02, 0x141, 0x152, 0x160,\n  0x178, 0x17D, 0x131, 0x142, 0x153, 0x161, 0x17E, 0, 0x20AC\n];\n\nfunction stringToPDFString(str) {\n  var i, n = str.length, strBuf = [];\n  if (str[0] === '\\xFE' && str[1] === '\\xFF') {\n    // UTF16BE BOM\n    for (i = 2; i < n; i += 2) {\n      strBuf.push(String.fromCharCode(\n        (str.charCodeAt(i) << 8) | str.charCodeAt(i + 1)));\n    }\n  } else {\n    for (i = 0; i < n; ++i) {\n      var code = PDFStringTranslateTable[str.charCodeAt(i)];\n      strBuf.push(code ? String.fromCharCode(code) : str.charAt(i));\n    }\n  }\n  return strBuf.join('');\n}\n\nfunction stringToUTF8String(str) {\n  return decodeURIComponent(escape(str));\n}\n\nfunction utf8StringToString(str) {\n  return unescape(encodeURIComponent(str));\n}\n\nfunction isEmptyObj(obj) {\n  for (var key in obj) {\n    return false;\n  }\n  return true;\n}\n\nfunction isBool(v) {\n  return typeof v === 'boolean';\n}\n\nfunction isNum(v) {\n  return typeof v === 'number';\n}\n\nfunction isString(v) {\n  return typeof v === 'string';\n}\n\nfunction isArrayBuffer(v) {\n  return typeof v === 'object' && v !== null && v.byteLength !== undefined;\n}\n\n// Checks if ch is one of the following characters: SPACE, TAB, CR or LF.\nfunction isSpace(ch) {\n  return (ch === 0x20 || ch === 0x09 || ch === 0x0D || ch === 0x0A);\n}\n\n/**\n * Promise Capability object.\n *\n * @typedef {Object} PromiseCapability\n * @property {Promise} promise - A promise object.\n * @property {function} resolve - Fulfills the promise.\n * @property {function} reject - Rejects the promise.\n */\n\n/**\n * Creates a promise capability object.\n * @alias createPromiseCapability\n *\n * @return {PromiseCapability} A capability object contains:\n * - a Promise, resolve and reject methods.\n */\nfunction createPromiseCapability() {\n  var capability = {};\n  capability.promise = new Promise(function (resolve, reject) {\n    capability.resolve = resolve;\n    capability.reject = reject;\n  });\n  return capability;\n}\n\nvar createObjectURL = (function createObjectURLClosure() {\n  // Blob/createObjectURL is not available, falling back to data schema.\n  var digits =\n    'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';\n\n  return function createObjectURL(data, contentType, forceDataSchema = false) {\n    if (!forceDataSchema && URL.createObjectURL) {\n      const blob = new Blob([data], { type: contentType, });\n      return URL.createObjectURL(blob);\n    }\n\n    var buffer = 'data:' + contentType + ';base64,';\n    for (var i = 0, ii = data.length; i < ii; i += 3) {\n      var b1 = data[i] & 0xFF;\n      var b2 = data[i + 1] & 0xFF;\n      var b3 = data[i + 2] & 0xFF;\n      var d1 = b1 >> 2, d2 = ((b1 & 3) << 4) | (b2 >> 4);\n      var d3 = i + 1 < ii ? ((b2 & 0xF) << 2) | (b3 >> 6) : 64;\n      var d4 = i + 2 < ii ? (b3 & 0x3F) : 64;\n      buffer += digits[d1] + digits[d2] + digits[d3] + digits[d4];\n    }\n    return buffer;\n  };\n})();\n\nexport {\n  FONT_IDENTITY_MATRIX,\n  IDENTITY_MATRIX,\n  OPS,\n  VerbosityLevel,\n  UNSUPPORTED_FEATURES,\n  AnnotationBorderStyleType,\n  AnnotationFieldFlag,\n  AnnotationFlag,\n  AnnotationType,\n  FontType,\n  ImageKind,\n  CMapCompressionType,\n  AbortException,\n  InvalidPDFException,\n  MissingDataException,\n  MissingPDFException,\n  NativeImageDecoding,\n  PasswordException,\n  PasswordResponses,\n  PermissionFlag,\n  StreamType,\n  TextRenderingMode,\n  UnexpectedResponseException,\n  UnknownErrorException,\n  Util,\n  toRomanNumerals,\n  XRefParseException,\n  FormatError,\n  arrayByteLength,\n  arraysToBytes,\n  assert,\n  bytesToString,\n  createPromiseCapability,\n  createObjectURL,\n  deprecated,\n  getInheritableProperty,\n  getLookupTableFactory,\n  getVerbosityLevel,\n  info,\n  isArrayBuffer,\n  isBool,\n  isEmptyObj,\n  isNum,\n  isString,\n  isSpace,\n  isSameOrigin,\n  createValidAbsoluteUrl,\n  isLittleEndian,\n  isEvalSupported,\n  log2,\n  readInt8,\n  readUint16,\n  readUint32,\n  removeNullCharacters,\n  ReadableStream,\n  URL,\n  setVerbosityLevel,\n  shadow,\n  string32,\n  stringToBytes,\n  stringToPDFString,\n  stringToUTF8String,\n  utf8StringToString,\n  warn,\n  unreachable,\n};\n","/* Copyright 2017 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nconst globalScope = require('./global_scope');\n\n// Skip compatibility checks for the extensions and if we already ran\n// this module.\nif ((typeof PDFJSDev === 'undefined' ||\n     !PDFJSDev.test('FIREFOX || MOZCENTRAL')) &&\n    !globalScope._pdfjsCompatibilityChecked) {\n\nglobalScope._pdfjsCompatibilityChecked = true;\n\n// In the Chrome extension, most of the polyfills are unnecessary.\n// We support down to Chrome 49, because it's still commonly used by Windows XP\n// users - https://github.com/mozilla/pdf.js/issues/9397\nif (typeof PDFJSDev === 'undefined' || !PDFJSDev.test('CHROME')) {\n\nconst isNodeJS = require('./is_node');\n\nconst hasDOM = typeof window === 'object' && typeof document === 'object';\n\n// Support: Node.js\n(function checkNodeBtoa() {\n  if (globalScope.btoa || !isNodeJS()) {\n    return;\n  }\n  globalScope.btoa = function(chars) {\n    // eslint-disable-next-line no-undef\n    return Buffer.from(chars, 'binary').toString('base64');\n  };\n})();\n\n// Support: Node.js\n(function checkNodeAtob() {\n  if (globalScope.atob || !isNodeJS()) {\n    return;\n  }\n  globalScope.atob = function(input) {\n    // eslint-disable-next-line no-undef\n    return Buffer.from(input, 'base64').toString('binary');\n  };\n})();\n\n// Provides document.currentScript support\n// Support: IE, Chrome<29.\n(function checkCurrentScript() {\n  if (!hasDOM) {\n    return;\n  }\n  if ('currentScript' in document) {\n    return;\n  }\n  Object.defineProperty(document, 'currentScript', {\n    get() {\n      var scripts = document.getElementsByTagName('script');\n      return scripts[scripts.length - 1];\n    },\n    enumerable: true,\n    configurable: true,\n  });\n})();\n\n// Provides support for ChildNode.remove in legacy browsers.\n// Support: IE.\n(function checkChildNodeRemove() {\n  if (!hasDOM) {\n    return;\n  }\n  if (typeof Element.prototype.remove !== 'undefined') {\n    return;\n  }\n  Element.prototype.remove = function () {\n    if (this.parentNode) {\n      // eslint-disable-next-line mozilla/avoid-removeChild\n      this.parentNode.removeChild(this);\n    }\n  };\n})();\n\n// Provides support for DOMTokenList.prototype.toggle, with the optional\n// \"force\" parameter, in legacy browsers.\n// Support: IE\n(function checkDOMTokenListToggle() {\n  if (!hasDOM || isNodeJS()) {\n    return;\n  }\n  const div = document.createElement('div');\n  if (div.classList.toggle('test', 0) === false) {\n    return;\n  }\n  const originalDOMTokenListToggle = DOMTokenList.prototype.toggle;\n\n  DOMTokenList.prototype.toggle = function(token) {\n    if (arguments.length > 1) {\n      const force = !!arguments[1];\n      return (this[force ? 'add' : 'remove'](token), force);\n    }\n    return originalDOMTokenListToggle(token);\n  };\n})();\n\n// Provides support for String.prototype.includes in legacy browsers.\n// Support: IE, Chrome<41\n(function checkStringIncludes() {\n  if (String.prototype.includes) {\n    return;\n  }\n  require('core-js/fn/string/includes');\n})();\n\n// Provides support for Array.prototype.includes in legacy browsers.\n// Support: IE, Chrome<47\n(function checkArrayIncludes() {\n  if (Array.prototype.includes) {\n    return;\n  }\n  require('core-js/fn/array/includes');\n})();\n\n// Provides support for Object.assign in legacy browsers.\n// Support: IE\n(function checkObjectAssign() {\n  if (Object.assign) {\n    return;\n  }\n  require('core-js/fn/object/assign');\n})();\n\n// Provides support for Math.log2 in legacy browsers.\n// Support: IE, Chrome<38\n(function checkMathLog2() {\n  if (Math.log2) {\n    return;\n  }\n  Math.log2 = require('core-js/fn/math/log2');\n})();\n\n// Provides support for Number.isNaN in legacy browsers.\n// Support: IE.\n(function checkNumberIsNaN() {\n  if (Number.isNaN) {\n    return;\n  }\n  Number.isNaN = require('core-js/fn/number/is-nan');\n})();\n\n// Provides support for Number.isInteger in legacy browsers.\n// Support: IE, Chrome<34\n(function checkNumberIsInteger() {\n  if (Number.isInteger) {\n    return;\n  }\n  Number.isInteger = require('core-js/fn/number/is-integer');\n})();\n\n// Support: IE, Safari<8, Chrome<32\n(function checkPromise() {\n  if (typeof PDFJSDev !== 'undefined' && PDFJSDev.test('IMAGE_DECODERS')) {\n    // The current image decoders are synchronous, hence `Promise` shouldn't\n    // need to be polyfilled for the IMAGE_DECODERS build target.\n    return;\n  }\n  if (globalScope.Promise) {\n    return;\n  }\n  globalScope.Promise = require('core-js/fn/promise');\n})();\n\n// Support: IE<11, Safari<8, Chrome<36\n(function checkWeakMap() {\n  if (globalScope.WeakMap) {\n    return;\n  }\n  globalScope.WeakMap = require('core-js/fn/weak-map');\n})();\n\n// Provides support for String.codePointAt in legacy browsers.\n// Support: IE11.\n(function checkStringCodePointAt() {\n  if (String.codePointAt) {\n    return;\n  }\n  String.codePointAt = require('core-js/fn/string/code-point-at');\n})();\n\n// Provides support for String.fromCodePoint in legacy browsers.\n// Support: IE11.\n(function checkStringFromCodePoint() {\n  if (String.fromCodePoint) {\n    return;\n  }\n  String.fromCodePoint = require('core-js/fn/string/from-code-point');\n})();\n\n// Support: IE\n(function checkSymbol() {\n  if (globalScope.Symbol) {\n    return;\n  }\n  require('core-js/es6/symbol');\n})();\n\n} // End of !PDFJSDev.test('CHROME')\n\n// Provides support for Object.values in legacy browsers.\n// Support: IE, Chrome<54\n(function checkObjectValues() {\n  if (Object.values) {\n    return;\n  }\n  Object.values = require('core-js/fn/object/values');\n})();\n\n}\n","/* Copyright 2017 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/* globals module */\n\nmodule.exports =\n  (typeof window !== 'undefined' && window.Math === Math) ? window :\n  // eslint-disable-next-line no-undef\n  (typeof global !== 'undefined' && global.Math === Math) ? global :\n  (typeof self !== 'undefined' && self.Math === Math) ? self : {};\n","/* Copyright 2018 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/* globals module, process */\n\nmodule.exports = function isNodeJS() {\n  return typeof process === 'object' && process + '' === '[object process]';\n};\n","require('../../modules/es6.string.includes');\nmodule.exports = require('../../modules/_core').String.includes;\n","// 21.1.3.7 String.prototype.includes(searchString, position = 0)\n'use strict';\nvar $export = require('./_export');\nvar context = require('./_string-context');\nvar INCLUDES = 'includes';\n\n$export($export.P + $export.F * require('./_fails-is-regexp')(INCLUDES), 'String', {\n  includes: function includes(searchString /* , position = 0 */) {\n    return !!~context(this, searchString, INCLUDES)\n      .indexOf(searchString, arguments.length > 1 ? arguments[1] : undefined);\n  }\n});\n","var global = require('./_global');\nvar core = require('./_core');\nvar hide = require('./_hide');\nvar redefine = require('./_redefine');\nvar ctx = require('./_ctx');\nvar PROTOTYPE = 'prototype';\n\nvar $export = function (type, name, source) {\n  var IS_FORCED = type & $export.F;\n  var IS_GLOBAL = type & $export.G;\n  var IS_STATIC = type & $export.S;\n  var IS_PROTO = type & $export.P;\n  var IS_BIND = type & $export.B;\n  var target = IS_GLOBAL ? global : IS_STATIC ? global[name] || (global[name] = {}) : (global[name] || {})[PROTOTYPE];\n  var exports = IS_GLOBAL ? core : core[name] || (core[name] = {});\n  var expProto = exports[PROTOTYPE] || (exports[PROTOTYPE] = {});\n  var key, own, out, exp;\n  if (IS_GLOBAL) source = name;\n  for (key in source) {\n    // contains in native\n    own = !IS_FORCED && target && target[key] !== undefined;\n    // export native or passed\n    out = (own ? target : source)[key];\n    // bind timers to global for call from export context\n    exp = IS_BIND && own ? ctx(out, global) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;\n    // extend global\n    if (target) redefine(target, key, out, type & $export.U);\n    // export\n    if (exports[key] != out) hide(exports, key, exp);\n    if (IS_PROTO && expProto[key] != out) expProto[key] = out;\n  }\n};\nglobal.core = core;\n// type bitmap\n$export.F = 1;   // forced\n$export.G = 2;   // global\n$export.S = 4;   // static\n$export.P = 8;   // proto\n$export.B = 16;  // bind\n$export.W = 32;  // wrap\n$export.U = 64;  // safe\n$export.R = 128; // real proto method for `library`\nmodule.exports = $export;\n","// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\nvar global = module.exports = typeof window != 'undefined' && window.Math == Math\n  ? window : typeof self != 'undefined' && self.Math == Math ? self\n  // eslint-disable-next-line no-new-func\n  : Function('return this')();\nif (typeof __g == 'number') __g = global; // eslint-disable-line no-undef\n","var core = module.exports = { version: '2.5.7' };\nif (typeof __e == 'number') __e = core; // eslint-disable-line no-undef\n","var dP = require('./_object-dp');\nvar createDesc = require('./_property-desc');\nmodule.exports = require('./_descriptors') ? function (object, key, value) {\n  return dP.f(object, key, createDesc(1, value));\n} : function (object, key, value) {\n  object[key] = value;\n  return object;\n};\n","var anObject = require('./_an-object');\nvar IE8_DOM_DEFINE = require('./_ie8-dom-define');\nvar toPrimitive = require('./_to-primitive');\nvar dP = Object.defineProperty;\n\nexports.f = require('./_descriptors') ? Object.defineProperty : function defineProperty(O, P, Attributes) {\n  anObject(O);\n  P = toPrimitive(P, true);\n  anObject(Attributes);\n  if (IE8_DOM_DEFINE) try {\n    return dP(O, P, Attributes);\n  } catch (e) { /* empty */ }\n  if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported!');\n  if ('value' in Attributes) O[P] = Attributes.value;\n  return O;\n};\n","var isObject = require('./_is-object');\nmodule.exports = function (it) {\n  if (!isObject(it)) throw TypeError(it + ' is not an object!');\n  return it;\n};\n","module.exports = function (it) {\n  return typeof it === 'object' ? it !== null : typeof it === 'function';\n};\n","module.exports = !require('./_descriptors') && !require('./_fails')(function () {\n  return Object.defineProperty(require('./_dom-create')('div'), 'a', { get: function () { return 7; } }).a != 7;\n});\n","// Thank's IE8 for his funny defineProperty\nmodule.exports = !require('./_fails')(function () {\n  return Object.defineProperty({}, 'a', { get: function () { return 7; } }).a != 7;\n});\n","module.exports = function (exec) {\n  try {\n    return !!exec();\n  } catch (e) {\n    return true;\n  }\n};\n","var isObject = require('./_is-object');\nvar document = require('./_global').document;\n// typeof document.createElement is 'object' in old IE\nvar is = isObject(document) && isObject(document.createElement);\nmodule.exports = function (it) {\n  return is ? document.createElement(it) : {};\n};\n","// 7.1.1 ToPrimitive(input [, PreferredType])\nvar isObject = require('./_is-object');\n// instead of the ES6 spec version, we didn't implement @@toPrimitive case\n// and the second argument - flag - preferred type is a string\nmodule.exports = function (it, S) {\n  if (!isObject(it)) return it;\n  var fn, val;\n  if (S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val;\n  if (typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it))) return val;\n  if (!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val;\n  throw TypeError(\"Can't convert object to primitive value\");\n};\n","module.exports = function (bitmap, value) {\n  return {\n    enumerable: !(bitmap & 1),\n    configurable: !(bitmap & 2),\n    writable: !(bitmap & 4),\n    value: value\n  };\n};\n","var global = require('./_global');\nvar hide = require('./_hide');\nvar has = require('./_has');\nvar SRC = require('./_uid')('src');\nvar TO_STRING = 'toString';\nvar $toString = Function[TO_STRING];\nvar TPL = ('' + $toString).split(TO_STRING);\n\nrequire('./_core').inspectSource = function (it) {\n  return $toString.call(it);\n};\n\n(module.exports = function (O, key, val, safe) {\n  var isFunction = typeof val == 'function';\n  if (isFunction) has(val, 'name') || hide(val, 'name', key);\n  if (O[key] === val) return;\n  if (isFunction) has(val, SRC) || hide(val, SRC, O[key] ? '' + O[key] : TPL.join(String(key)));\n  if (O === global) {\n    O[key] = val;\n  } else if (!safe) {\n    delete O[key];\n    hide(O, key, val);\n  } else if (O[key]) {\n    O[key] = val;\n  } else {\n    hide(O, key, val);\n  }\n// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative\n})(Function.prototype, TO_STRING, function toString() {\n  return typeof this == 'function' && this[SRC] || $toString.call(this);\n});\n","var hasOwnProperty = {}.hasOwnProperty;\nmodule.exports = function (it, key) {\n  return hasOwnProperty.call(it, key);\n};\n","var id = 0;\nvar px = Math.random();\nmodule.exports = function (key) {\n  return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));\n};\n","// optional / simple context binding\nvar aFunction = require('./_a-function');\nmodule.exports = function (fn, that, length) {\n  aFunction(fn);\n  if (that === undefined) return fn;\n  switch (length) {\n    case 1: return function (a) {\n      return fn.call(that, a);\n    };\n    case 2: return function (a, b) {\n      return fn.call(that, a, b);\n    };\n    case 3: return function (a, b, c) {\n      return fn.call(that, a, b, c);\n    };\n  }\n  return function (/* ...args */) {\n    return fn.apply(that, arguments);\n  };\n};\n","module.exports = function (it) {\n  if (typeof it != 'function') throw TypeError(it + ' is not a function!');\n  return it;\n};\n","// helper for String#{startsWith, endsWith, includes}\nvar isRegExp = require('./_is-regexp');\nvar defined = require('./_defined');\n\nmodule.exports = function (that, searchString, NAME) {\n  if (isRegExp(searchString)) throw TypeError('String#' + NAME + \" doesn't accept regex!\");\n  return String(defined(that));\n};\n","// 7.2.8 IsRegExp(argument)\nvar isObject = require('./_is-object');\nvar cof = require('./_cof');\nvar MATCH = require('./_wks')('match');\nmodule.exports = function (it) {\n  var isRegExp;\n  return isObject(it) && ((isRegExp = it[MATCH]) !== undefined ? !!isRegExp : cof(it) == 'RegExp');\n};\n","var toString = {}.toString;\n\nmodule.exports = function (it) {\n  return toString.call(it).slice(8, -1);\n};\n","var store = require('./_shared')('wks');\nvar uid = require('./_uid');\nvar Symbol = require('./_global').Symbol;\nvar USE_SYMBOL = typeof Symbol == 'function';\n\nvar $exports = module.exports = function (name) {\n  return store[name] || (store[name] =\n    USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)('Symbol.' + name));\n};\n\n$exports.store = store;\n","var core = require('./_core');\nvar global = require('./_global');\nvar SHARED = '__core-js_shared__';\nvar store = global[SHARED] || (global[SHARED] = {});\n\n(module.exports = function (key, value) {\n  return store[key] || (store[key] = value !== undefined ? value : {});\n})('versions', []).push({\n  version: core.version,\n  mode: require('./_library') ? 'pure' : 'global',\n  copyright: '© 2018 Denis Pushkarev (zloirock.ru)'\n});\n","module.exports = false;\n","// 7.2.1 RequireObjectCoercible(argument)\nmodule.exports = function (it) {\n  if (it == undefined) throw TypeError(\"Can't call method on  \" + it);\n  return it;\n};\n","var MATCH = require('./_wks')('match');\nmodule.exports = function (KEY) {\n  var re = /./;\n  try {\n    '/./'[KEY](re);\n  } catch (e) {\n    try {\n      re[MATCH] = false;\n      return !'/./'[KEY](re);\n    } catch (f) { /* empty */ }\n  } return true;\n};\n","require('../../modules/es7.array.includes');\nmodule.exports = require('../../modules/_core').Array.includes;\n","'use strict';\n// https://github.com/tc39/Array.prototype.includes\nvar $export = require('./_export');\nvar $includes = require('./_array-includes')(true);\n\n$export($export.P, 'Array', {\n  includes: function includes(el /* , fromIndex = 0 */) {\n    return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined);\n  }\n});\n\nrequire('./_add-to-unscopables')('includes');\n","// false -> Array#indexOf\n// true  -> Array#includes\nvar toIObject = require('./_to-iobject');\nvar toLength = require('./_to-length');\nvar toAbsoluteIndex = require('./_to-absolute-index');\nmodule.exports = function (IS_INCLUDES) {\n  return function ($this, el, fromIndex) {\n    var O = toIObject($this);\n    var length = toLength(O.length);\n    var index = toAbsoluteIndex(fromIndex, length);\n    var value;\n    // Array#includes uses SameValueZero equality algorithm\n    // eslint-disable-next-line no-self-compare\n    if (IS_INCLUDES && el != el) while (length > index) {\n      value = O[index++];\n      // eslint-disable-next-line no-self-compare\n      if (value != value) return true;\n    // Array#indexOf ignores holes, Array#includes - not\n    } else for (;length > index; index++) if (IS_INCLUDES || index in O) {\n      if (O[index] === el) return IS_INCLUDES || index || 0;\n    } return !IS_INCLUDES && -1;\n  };\n};\n","// to indexed object, toObject with fallback for non-array-like ES3 strings\nvar IObject = require('./_iobject');\nvar defined = require('./_defined');\nmodule.exports = function (it) {\n  return IObject(defined(it));\n};\n","// fallback for non-array-like ES3 and non-enumerable old V8 strings\nvar cof = require('./_cof');\n// eslint-disable-next-line no-prototype-builtins\nmodule.exports = Object('z').propertyIsEnumerable(0) ? Object : function (it) {\n  return cof(it) == 'String' ? it.split('') : Object(it);\n};\n","// 7.1.15 ToLength\nvar toInteger = require('./_to-integer');\nvar min = Math.min;\nmodule.exports = function (it) {\n  return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991\n};\n","// 7.1.4 ToInteger\nvar ceil = Math.ceil;\nvar floor = Math.floor;\nmodule.exports = function (it) {\n  return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);\n};\n","var toInteger = require('./_to-integer');\nvar max = Math.max;\nvar min = Math.min;\nmodule.exports = function (index, length) {\n  index = toInteger(index);\n  return index < 0 ? max(index + length, 0) : min(index, length);\n};\n","// 22.1.3.31 Array.prototype[@@unscopables]\nvar UNSCOPABLES = require('./_wks')('unscopables');\nvar ArrayProto = Array.prototype;\nif (ArrayProto[UNSCOPABLES] == undefined) require('./_hide')(ArrayProto, UNSCOPABLES, {});\nmodule.exports = function (key) {\n  ArrayProto[UNSCOPABLES][key] = true;\n};\n","require('../../modules/es6.object.assign');\nmodule.exports = require('../../modules/_core').Object.assign;\n","// 19.1.3.1 Object.assign(target, source)\nvar $export = require('./_export');\n\n$export($export.S + $export.F, 'Object', { assign: require('./_object-assign') });\n","'use strict';\n// 19.1.2.1 Object.assign(target, source, ...)\nvar getKeys = require('./_object-keys');\nvar gOPS = require('./_object-gops');\nvar pIE = require('./_object-pie');\nvar toObject = require('./_to-object');\nvar IObject = require('./_iobject');\nvar $assign = Object.assign;\n\n// should work with symbols and should have deterministic property order (V8 bug)\nmodule.exports = !$assign || require('./_fails')(function () {\n  var A = {};\n  var B = {};\n  // eslint-disable-next-line no-undef\n  var S = Symbol();\n  var K = 'abcdefghijklmnopqrst';\n  A[S] = 7;\n  K.split('').forEach(function (k) { B[k] = k; });\n  return $assign({}, A)[S] != 7 || Object.keys($assign({}, B)).join('') != K;\n}) ? function assign(target, source) { // eslint-disable-line no-unused-vars\n  var T = toObject(target);\n  var aLen = arguments.length;\n  var index = 1;\n  var getSymbols = gOPS.f;\n  var isEnum = pIE.f;\n  while (aLen > index) {\n    var S = IObject(arguments[index++]);\n    var keys = getSymbols ? getKeys(S).concat(getSymbols(S)) : getKeys(S);\n    var length = keys.length;\n    var j = 0;\n    var key;\n    while (length > j) if (isEnum.call(S, key = keys[j++])) T[key] = S[key];\n  } return T;\n} : $assign;\n","// 19.1.2.14 / 15.2.3.14 Object.keys(O)\nvar $keys = require('./_object-keys-internal');\nvar enumBugKeys = require('./_enum-bug-keys');\n\nmodule.exports = Object.keys || function keys(O) {\n  return $keys(O, enumBugKeys);\n};\n","var has = require('./_has');\nvar toIObject = require('./_to-iobject');\nvar arrayIndexOf = require('./_array-includes')(false);\nvar IE_PROTO = require('./_shared-key')('IE_PROTO');\n\nmodule.exports = function (object, names) {\n  var O = toIObject(object);\n  var i = 0;\n  var result = [];\n  var key;\n  for (key in O) if (key != IE_PROTO) has(O, key) && result.push(key);\n  // Don't enum bug & hidden keys\n  while (names.length > i) if (has(O, key = names[i++])) {\n    ~arrayIndexOf(result, key) || result.push(key);\n  }\n  return result;\n};\n","var shared = require('./_shared')('keys');\nvar uid = require('./_uid');\nmodule.exports = function (key) {\n  return shared[key] || (shared[key] = uid(key));\n};\n","// IE 8- don't enum bug keys\nmodule.exports = (\n  'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'\n).split(',');\n","exports.f = Object.getOwnPropertySymbols;\n","exports.f = {}.propertyIsEnumerable;\n","// 7.1.13 ToObject(argument)\nvar defined = require('./_defined');\nmodule.exports = function (it) {\n  return Object(defined(it));\n};\n","require('../../modules/es6.math.log2');\nmodule.exports = require('../../modules/_core').Math.log2;\n","// 20.2.2.22 Math.log2(x)\nvar $export = require('./_export');\n\n$export($export.S, 'Math', {\n  log2: function log2(x) {\n    return Math.log(x) / Math.LN2;\n  }\n});\n","require('../../modules/es6.number.is-nan');\nmodule.exports = require('../../modules/_core').Number.isNaN;\n","// 20.1.2.4 Number.isNaN(number)\nvar $export = require('./_export');\n\n$export($export.S, 'Number', {\n  isNaN: function isNaN(number) {\n    // eslint-disable-next-line no-self-compare\n    return number != number;\n  }\n});\n","require('../../modules/es6.number.is-integer');\nmodule.exports = require('../../modules/_core').Number.isInteger;\n","// 20.1.2.3 Number.isInteger(number)\nvar $export = require('./_export');\n\n$export($export.S, 'Number', { isInteger: require('./_is-integer') });\n","// 20.1.2.3 Number.isInteger(number)\nvar isObject = require('./_is-object');\nvar floor = Math.floor;\nmodule.exports = function isInteger(it) {\n  return !isObject(it) && isFinite(it) && floor(it) === it;\n};\n","require('../modules/es6.object.to-string');\nrequire('../modules/web.dom.iterable');\nrequire('../modules/es6.weak-map');\nrequire('../modules/es7.weak-map.of');\nrequire('../modules/es7.weak-map.from');\nmodule.exports = require('../modules/_core').WeakMap;\n","'use strict';\n// 19.1.3.6 Object.prototype.toString()\nvar classof = require('./_classof');\nvar test = {};\ntest[require('./_wks')('toStringTag')] = 'z';\nif (test + '' != '[object z]') {\n  require('./_redefine')(Object.prototype, 'toString', function toString() {\n    return '[object ' + classof(this) + ']';\n  }, true);\n}\n","// getting tag from 19.1.3.6 Object.prototype.toString()\nvar cof = require('./_cof');\nvar TAG = require('./_wks')('toStringTag');\n// ES3 wrong here\nvar ARG = cof(function () { return arguments; }()) == 'Arguments';\n\n// fallback for IE11 Script Access Denied error\nvar tryGet = function (it, key) {\n  try {\n    return it[key];\n  } catch (e) { /* empty */ }\n};\n\nmodule.exports = function (it) {\n  var O, T, B;\n  return it === undefined ? 'Undefined' : it === null ? 'Null'\n    // @@toStringTag case\n    : typeof (T = tryGet(O = Object(it), TAG)) == 'string' ? T\n    // builtinTag case\n    : ARG ? cof(O)\n    // ES3 arguments fallback\n    : (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B;\n};\n","var $iterators = require('./es6.array.iterator');\nvar getKeys = require('./_object-keys');\nvar redefine = require('./_redefine');\nvar global = require('./_global');\nvar hide = require('./_hide');\nvar Iterators = require('./_iterators');\nvar wks = require('./_wks');\nvar ITERATOR = wks('iterator');\nvar TO_STRING_TAG = wks('toStringTag');\nvar ArrayValues = Iterators.Array;\n\nvar DOMIterables = {\n  CSSRuleList: true, // TODO: Not spec compliant, should be false.\n  CSSStyleDeclaration: false,\n  CSSValueList: false,\n  ClientRectList: false,\n  DOMRectList: false,\n  DOMStringList: false,\n  DOMTokenList: true,\n  DataTransferItemList: false,\n  FileList: false,\n  HTMLAllCollection: false,\n  HTMLCollection: false,\n  HTMLFormElement: false,\n  HTMLSelectElement: false,\n  MediaList: true, // TODO: Not spec compliant, should be false.\n  MimeTypeArray: false,\n  NamedNodeMap: false,\n  NodeList: true,\n  PaintRequestList: false,\n  Plugin: false,\n  PluginArray: false,\n  SVGLengthList: false,\n  SVGNumberList: false,\n  SVGPathSegList: false,\n  SVGPointList: false,\n  SVGStringList: false,\n  SVGTransformList: false,\n  SourceBufferList: false,\n  StyleSheetList: true, // TODO: Not spec compliant, should be false.\n  TextTrackCueList: false,\n  TextTrackList: false,\n  TouchList: false\n};\n\nfor (var collections = getKeys(DOMIterables), i = 0; i < collections.length; i++) {\n  var NAME = collections[i];\n  var explicit = DOMIterables[NAME];\n  var Collection = global[NAME];\n  var proto = Collection && Collection.prototype;\n  var key;\n  if (proto) {\n    if (!proto[ITERATOR]) hide(proto, ITERATOR, ArrayValues);\n    if (!proto[TO_STRING_TAG]) hide(proto, TO_STRING_TAG, NAME);\n    Iterators[NAME] = ArrayValues;\n    if (explicit) for (key in $iterators) if (!proto[key]) redefine(proto, key, $iterators[key], true);\n  }\n}\n","'use strict';\nvar addToUnscopables = require('./_add-to-unscopables');\nvar step = require('./_iter-step');\nvar Iterators = require('./_iterators');\nvar toIObject = require('./_to-iobject');\n\n// 22.1.3.4 Array.prototype.entries()\n// 22.1.3.13 Array.prototype.keys()\n// 22.1.3.29 Array.prototype.values()\n// 22.1.3.30 Array.prototype[@@iterator]()\nmodule.exports = require('./_iter-define')(Array, 'Array', function (iterated, kind) {\n  this._t = toIObject(iterated); // target\n  this._i = 0;                   // next index\n  this._k = kind;                // kind\n// 22.1.5.2.1 %ArrayIteratorPrototype%.next()\n}, function () {\n  var O = this._t;\n  var kind = this._k;\n  var index = this._i++;\n  if (!O || index >= O.length) {\n    this._t = undefined;\n    return step(1);\n  }\n  if (kind == 'keys') return step(0, index);\n  if (kind == 'values') return step(0, O[index]);\n  return step(0, [index, O[index]]);\n}, 'values');\n\n// argumentsList[@@iterator] is %ArrayProto_values% (9.4.4.6, 9.4.4.7)\nIterators.Arguments = Iterators.Array;\n\naddToUnscopables('keys');\naddToUnscopables('values');\naddToUnscopables('entries');\n","module.exports = function (done, value) {\n  return { value: value, done: !!done };\n};\n","module.exports = {};\n","'use strict';\nvar LIBRARY = require('./_library');\nvar $export = require('./_export');\nvar redefine = require('./_redefine');\nvar hide = require('./_hide');\nvar Iterators = require('./_iterators');\nvar $iterCreate = require('./_iter-create');\nvar setToStringTag = require('./_set-to-string-tag');\nvar getPrototypeOf = require('./_object-gpo');\nvar ITERATOR = require('./_wks')('iterator');\nvar BUGGY = !([].keys && 'next' in [].keys()); // Safari has buggy iterators w/o `next`\nvar FF_ITERATOR = '@@iterator';\nvar KEYS = 'keys';\nvar VALUES = 'values';\n\nvar returnThis = function () { return this; };\n\nmodule.exports = function (Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED) {\n  $iterCreate(Constructor, NAME, next);\n  var getMethod = function (kind) {\n    if (!BUGGY && kind in proto) return proto[kind];\n    switch (kind) {\n      case KEYS: return function keys() { return new Constructor(this, kind); };\n      case VALUES: return function values() { return new Constructor(this, kind); };\n    } return function entries() { return new Constructor(this, kind); };\n  };\n  var TAG = NAME + ' Iterator';\n  var DEF_VALUES = DEFAULT == VALUES;\n  var VALUES_BUG = false;\n  var proto = Base.prototype;\n  var $native = proto[ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT];\n  var $default = $native || getMethod(DEFAULT);\n  var $entries = DEFAULT ? !DEF_VALUES ? $default : getMethod('entries') : undefined;\n  var $anyNative = NAME == 'Array' ? proto.entries || $native : $native;\n  var methods, key, IteratorPrototype;\n  // Fix native\n  if ($anyNative) {\n    IteratorPrototype = getPrototypeOf($anyNative.call(new Base()));\n    if (IteratorPrototype !== Object.prototype && IteratorPrototype.next) {\n      // Set @@toStringTag to native iterators\n      setToStringTag(IteratorPrototype, TAG, true);\n      // fix for some old engines\n      if (!LIBRARY && typeof IteratorPrototype[ITERATOR] != 'function') hide(IteratorPrototype, ITERATOR, returnThis);\n    }\n  }\n  // fix Array#{values, @@iterator}.name in V8 / FF\n  if (DEF_VALUES && $native && $native.name !== VALUES) {\n    VALUES_BUG = true;\n    $default = function values() { return $native.call(this); };\n  }\n  // Define iterator\n  if ((!LIBRARY || FORCED) && (BUGGY || VALUES_BUG || !proto[ITERATOR])) {\n    hide(proto, ITERATOR, $default);\n  }\n  // Plug for library\n  Iterators[NAME] = $default;\n  Iterators[TAG] = returnThis;\n  if (DEFAULT) {\n    methods = {\n      values: DEF_VALUES ? $default : getMethod(VALUES),\n      keys: IS_SET ? $default : getMethod(KEYS),\n      entries: $entries\n    };\n    if (FORCED) for (key in methods) {\n      if (!(key in proto)) redefine(proto, key, methods[key]);\n    } else $export($export.P + $export.F * (BUGGY || VALUES_BUG), NAME, methods);\n  }\n  return methods;\n};\n","'use strict';\nvar create = require('./_object-create');\nvar descriptor = require('./_property-desc');\nvar setToStringTag = require('./_set-to-string-tag');\nvar IteratorPrototype = {};\n\n// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()\nrequire('./_hide')(IteratorPrototype, require('./_wks')('iterator'), function () { return this; });\n\nmodule.exports = function (Constructor, NAME, next) {\n  Constructor.prototype = create(IteratorPrototype, { next: descriptor(1, next) });\n  setToStringTag(Constructor, NAME + ' Iterator');\n};\n","// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])\nvar anObject = require('./_an-object');\nvar dPs = require('./_object-dps');\nvar enumBugKeys = require('./_enum-bug-keys');\nvar IE_PROTO = require('./_shared-key')('IE_PROTO');\nvar Empty = function () { /* empty */ };\nvar PROTOTYPE = 'prototype';\n\n// Create object with fake `null` prototype: use iframe Object with cleared prototype\nvar createDict = function () {\n  // Thrash, waste and sodomy: IE GC bug\n  var iframe = require('./_dom-create')('iframe');\n  var i = enumBugKeys.length;\n  var lt = '<';\n  var gt = '>';\n  var iframeDocument;\n  iframe.style.display = 'none';\n  require('./_html').appendChild(iframe);\n  iframe.src = 'javascript:'; // eslint-disable-line no-script-url\n  // createDict = iframe.contentWindow.Object;\n  // html.removeChild(iframe);\n  iframeDocument = iframe.contentWindow.document;\n  iframeDocument.open();\n  iframeDocument.write(lt + 'script' + gt + 'document.F=Object' + lt + '/script' + gt);\n  iframeDocument.close();\n  createDict = iframeDocument.F;\n  while (i--) delete createDict[PROTOTYPE][enumBugKeys[i]];\n  return createDict();\n};\n\nmodule.exports = Object.create || function create(O, Properties) {\n  var result;\n  if (O !== null) {\n    Empty[PROTOTYPE] = anObject(O);\n    result = new Empty();\n    Empty[PROTOTYPE] = null;\n    // add \"__proto__\" for Object.getPrototypeOf polyfill\n    result[IE_PROTO] = O;\n  } else result = createDict();\n  return Properties === undefined ? result : dPs(result, Properties);\n};\n","var dP = require('./_object-dp');\nvar anObject = require('./_an-object');\nvar getKeys = require('./_object-keys');\n\nmodule.exports = require('./_descriptors') ? Object.defineProperties : function defineProperties(O, Properties) {\n  anObject(O);\n  var keys = getKeys(Properties);\n  var length = keys.length;\n  var i = 0;\n  var P;\n  while (length > i) dP.f(O, P = keys[i++], Properties[P]);\n  return O;\n};\n","var document = require('./_global').document;\nmodule.exports = document && document.documentElement;\n","var def = require('./_object-dp').f;\nvar has = require('./_has');\nvar TAG = require('./_wks')('toStringTag');\n\nmodule.exports = function (it, tag, stat) {\n  if (it && !has(it = stat ? it : it.prototype, TAG)) def(it, TAG, { configurable: true, value: tag });\n};\n","// 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)\nvar has = require('./_has');\nvar toObject = require('./_to-object');\nvar IE_PROTO = require('./_shared-key')('IE_PROTO');\nvar ObjectProto = Object.prototype;\n\nmodule.exports = Object.getPrototypeOf || function (O) {\n  O = toObject(O);\n  if (has(O, IE_PROTO)) return O[IE_PROTO];\n  if (typeof O.constructor == 'function' && O instanceof O.constructor) {\n    return O.constructor.prototype;\n  } return O instanceof Object ? ObjectProto : null;\n};\n","'use strict';\nvar each = require('./_array-methods')(0);\nvar redefine = require('./_redefine');\nvar meta = require('./_meta');\nvar assign = require('./_object-assign');\nvar weak = require('./_collection-weak');\nvar isObject = require('./_is-object');\nvar fails = require('./_fails');\nvar validate = require('./_validate-collection');\nvar WEAK_MAP = 'WeakMap';\nvar getWeak = meta.getWeak;\nvar isExtensible = Object.isExtensible;\nvar uncaughtFrozenStore = weak.ufstore;\nvar tmp = {};\nvar InternalMap;\n\nvar wrapper = function (get) {\n  return function WeakMap() {\n    return get(this, arguments.length > 0 ? arguments[0] : undefined);\n  };\n};\n\nvar methods = {\n  // 23.3.3.3 WeakMap.prototype.get(key)\n  get: function get(key) {\n    if (isObject(key)) {\n      var data = getWeak(key);\n      if (data === true) return uncaughtFrozenStore(validate(this, WEAK_MAP)).get(key);\n      return data ? data[this._i] : undefined;\n    }\n  },\n  // 23.3.3.5 WeakMap.prototype.set(key, value)\n  set: function set(key, value) {\n    return weak.def(validate(this, WEAK_MAP), key, value);\n  }\n};\n\n// 23.3 WeakMap Objects\nvar $WeakMap = module.exports = require('./_collection')(WEAK_MAP, wrapper, methods, weak, true, true);\n\n// IE11 WeakMap frozen keys fix\nif (fails(function () { return new $WeakMap().set((Object.freeze || Object)(tmp), 7).get(tmp) != 7; })) {\n  InternalMap = weak.getConstructor(wrapper, WEAK_MAP);\n  assign(InternalMap.prototype, methods);\n  meta.NEED = true;\n  each(['delete', 'has', 'get', 'set'], function (key) {\n    var proto = $WeakMap.prototype;\n    var method = proto[key];\n    redefine(proto, key, function (a, b) {\n      // store frozen objects on internal weakmap shim\n      if (isObject(a) && !isExtensible(a)) {\n        if (!this._f) this._f = new InternalMap();\n        var result = this._f[key](a, b);\n        return key == 'set' ? this : result;\n      // store all the rest on native weakmap\n      } return method.call(this, a, b);\n    });\n  });\n}\n","// 0 -> Array#forEach\n// 1 -> Array#map\n// 2 -> Array#filter\n// 3 -> Array#some\n// 4 -> Array#every\n// 5 -> Array#find\n// 6 -> Array#findIndex\nvar ctx = require('./_ctx');\nvar IObject = require('./_iobject');\nvar toObject = require('./_to-object');\nvar toLength = require('./_to-length');\nvar asc = require('./_array-species-create');\nmodule.exports = function (TYPE, $create) {\n  var IS_MAP = TYPE == 1;\n  var IS_FILTER = TYPE == 2;\n  var IS_SOME = TYPE == 3;\n  var IS_EVERY = TYPE == 4;\n  var IS_FIND_INDEX = TYPE == 6;\n  var NO_HOLES = TYPE == 5 || IS_FIND_INDEX;\n  var create = $create || asc;\n  return function ($this, callbackfn, that) {\n    var O = toObject($this);\n    var self = IObject(O);\n    var f = ctx(callbackfn, that, 3);\n    var length = toLength(self.length);\n    var index = 0;\n    var result = IS_MAP ? create($this, length) : IS_FILTER ? create($this, 0) : undefined;\n    var val, res;\n    for (;length > index; index++) if (NO_HOLES || index in self) {\n      val = self[index];\n      res = f(val, index, O);\n      if (TYPE) {\n        if (IS_MAP) result[index] = res;   // map\n        else if (res) switch (TYPE) {\n          case 3: return true;             // some\n          case 5: return val;              // find\n          case 6: return index;            // findIndex\n          case 2: result.push(val);        // filter\n        } else if (IS_EVERY) return false; // every\n      }\n    }\n    return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : result;\n  };\n};\n","// 9.4.2.3 ArraySpeciesCreate(originalArray, length)\nvar speciesConstructor = require('./_array-species-constructor');\n\nmodule.exports = function (original, length) {\n  return new (speciesConstructor(original))(length);\n};\n","var isObject = require('./_is-object');\nvar isArray = require('./_is-array');\nvar SPECIES = require('./_wks')('species');\n\nmodule.exports = function (original) {\n  var C;\n  if (isArray(original)) {\n    C = original.constructor;\n    // cross-realm fallback\n    if (typeof C == 'function' && (C === Array || isArray(C.prototype))) C = undefined;\n    if (isObject(C)) {\n      C = C[SPECIES];\n      if (C === null) C = undefined;\n    }\n  } return C === undefined ? Array : C;\n};\n","// 7.2.2 IsArray(argument)\nvar cof = require('./_cof');\nmodule.exports = Array.isArray || function isArray(arg) {\n  return cof(arg) == 'Array';\n};\n","var META = require('./_uid')('meta');\nvar isObject = require('./_is-object');\nvar has = require('./_has');\nvar setDesc = require('./_object-dp').f;\nvar id = 0;\nvar isExtensible = Object.isExtensible || function () {\n  return true;\n};\nvar FREEZE = !require('./_fails')(function () {\n  return isExtensible(Object.preventExtensions({}));\n});\nvar setMeta = function (it) {\n  setDesc(it, META, { value: {\n    i: 'O' + ++id, // object ID\n    w: {}          // weak collections IDs\n  } });\n};\nvar fastKey = function (it, create) {\n  // return primitive with prefix\n  if (!isObject(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;\n  if (!has(it, META)) {\n    // can't set metadata to uncaught frozen object\n    if (!isExtensible(it)) return 'F';\n    // not necessary to add metadata\n    if (!create) return 'E';\n    // add missing metadata\n    setMeta(it);\n  // return object ID\n  } return it[META].i;\n};\nvar getWeak = function (it, create) {\n  if (!has(it, META)) {\n    // can't set metadata to uncaught frozen object\n    if (!isExtensible(it)) return true;\n    // not necessary to add metadata\n    if (!create) return false;\n    // add missing metadata\n    setMeta(it);\n  // return hash weak collections IDs\n  } return it[META].w;\n};\n// add metadata on freeze-family methods calling\nvar onFreeze = function (it) {\n  if (FREEZE && meta.NEED && isExtensible(it) && !has(it, META)) setMeta(it);\n  return it;\n};\nvar meta = module.exports = {\n  KEY: META,\n  NEED: false,\n  fastKey: fastKey,\n  getWeak: getWeak,\n  onFreeze: onFreeze\n};\n","'use strict';\nvar redefineAll = require('./_redefine-all');\nvar getWeak = require('./_meta').getWeak;\nvar anObject = require('./_an-object');\nvar isObject = require('./_is-object');\nvar anInstance = require('./_an-instance');\nvar forOf = require('./_for-of');\nvar createArrayMethod = require('./_array-methods');\nvar $has = require('./_has');\nvar validate = require('./_validate-collection');\nvar arrayFind = createArrayMethod(5);\nvar arrayFindIndex = createArrayMethod(6);\nvar id = 0;\n\n// fallback for uncaught frozen keys\nvar uncaughtFrozenStore = function (that) {\n  return that._l || (that._l = new UncaughtFrozenStore());\n};\nvar UncaughtFrozenStore = function () {\n  this.a = [];\n};\nvar findUncaughtFrozen = function (store, key) {\n  return arrayFind(store.a, function (it) {\n    return it[0] === key;\n  });\n};\nUncaughtFrozenStore.prototype = {\n  get: function (key) {\n    var entry = findUncaughtFrozen(this, key);\n    if (entry) return entry[1];\n  },\n  has: function (key) {\n    return !!findUncaughtFrozen(this, key);\n  },\n  set: function (key, value) {\n    var entry = findUncaughtFrozen(this, key);\n    if (entry) entry[1] = value;\n    else this.a.push([key, value]);\n  },\n  'delete': function (key) {\n    var index = arrayFindIndex(this.a, function (it) {\n      return it[0] === key;\n    });\n    if (~index) this.a.splice(index, 1);\n    return !!~index;\n  }\n};\n\nmodule.exports = {\n  getConstructor: function (wrapper, NAME, IS_MAP, ADDER) {\n    var C = wrapper(function (that, iterable) {\n      anInstance(that, C, NAME, '_i');\n      that._t = NAME;      // collection type\n      that._i = id++;      // collection id\n      that._l = undefined; // leak store for uncaught frozen objects\n      if (iterable != undefined) forOf(iterable, IS_MAP, that[ADDER], that);\n    });\n    redefineAll(C.prototype, {\n      // 23.3.3.2 WeakMap.prototype.delete(key)\n      // 23.4.3.3 WeakSet.prototype.delete(value)\n      'delete': function (key) {\n        if (!isObject(key)) return false;\n        var data = getWeak(key);\n        if (data === true) return uncaughtFrozenStore(validate(this, NAME))['delete'](key);\n        return data && $has(data, this._i) && delete data[this._i];\n      },\n      // 23.3.3.4 WeakMap.prototype.has(key)\n      // 23.4.3.4 WeakSet.prototype.has(value)\n      has: function has(key) {\n        if (!isObject(key)) return false;\n        var data = getWeak(key);\n        if (data === true) return uncaughtFrozenStore(validate(this, NAME)).has(key);\n        return data && $has(data, this._i);\n      }\n    });\n    return C;\n  },\n  def: function (that, key, value) {\n    var data = getWeak(anObject(key), true);\n    if (data === true) uncaughtFrozenStore(that).set(key, value);\n    else data[that._i] = value;\n    return that;\n  },\n  ufstore: uncaughtFrozenStore\n};\n","var redefine = require('./_redefine');\nmodule.exports = function (target, src, safe) {\n  for (var key in src) redefine(target, key, src[key], safe);\n  return target;\n};\n","module.exports = function (it, Constructor, name, forbiddenField) {\n  if (!(it instanceof Constructor) || (forbiddenField !== undefined && forbiddenField in it)) {\n    throw TypeError(name + ': incorrect invocation!');\n  } return it;\n};\n","var ctx = require('./_ctx');\nvar call = require('./_iter-call');\nvar isArrayIter = require('./_is-array-iter');\nvar anObject = require('./_an-object');\nvar toLength = require('./_to-length');\nvar getIterFn = require('./core.get-iterator-method');\nvar BREAK = {};\nvar RETURN = {};\nvar exports = module.exports = function (iterable, entries, fn, that, ITERATOR) {\n  var iterFn = ITERATOR ? function () { return iterable; } : getIterFn(iterable);\n  var f = ctx(fn, that, entries ? 2 : 1);\n  var index = 0;\n  var length, step, iterator, result;\n  if (typeof iterFn != 'function') throw TypeError(iterable + ' is not iterable!');\n  // fast case for arrays with default iterator\n  if (isArrayIter(iterFn)) for (length = toLength(iterable.length); length > index; index++) {\n    result = entries ? f(anObject(step = iterable[index])[0], step[1]) : f(iterable[index]);\n    if (result === BREAK || result === RETURN) return result;\n  } else for (iterator = iterFn.call(iterable); !(step = iterator.next()).done;) {\n    result = call(iterator, f, step.value, entries);\n    if (result === BREAK || result === RETURN) return result;\n  }\n};\nexports.BREAK = BREAK;\nexports.RETURN = RETURN;\n","// call something on iterator step with safe closing on error\nvar anObject = require('./_an-object');\nmodule.exports = function (iterator, fn, value, entries) {\n  try {\n    return entries ? fn(anObject(value)[0], value[1]) : fn(value);\n  // 7.4.6 IteratorClose(iterator, completion)\n  } catch (e) {\n    var ret = iterator['return'];\n    if (ret !== undefined) anObject(ret.call(iterator));\n    throw e;\n  }\n};\n","// check on default Array iterator\nvar Iterators = require('./_iterators');\nvar ITERATOR = require('./_wks')('iterator');\nvar ArrayProto = Array.prototype;\n\nmodule.exports = function (it) {\n  return it !== undefined && (Iterators.Array === it || ArrayProto[ITERATOR] === it);\n};\n","var classof = require('./_classof');\nvar ITERATOR = require('./_wks')('iterator');\nvar Iterators = require('./_iterators');\nmodule.exports = require('./_core').getIteratorMethod = function (it) {\n  if (it != undefined) return it[ITERATOR]\n    || it['@@iterator']\n    || Iterators[classof(it)];\n};\n","var isObject = require('./_is-object');\nmodule.exports = function (it, TYPE) {\n  if (!isObject(it) || it._t !== TYPE) throw TypeError('Incompatible receiver, ' + TYPE + ' required!');\n  return it;\n};\n","'use strict';\nvar global = require('./_global');\nvar $export = require('./_export');\nvar redefine = require('./_redefine');\nvar redefineAll = require('./_redefine-all');\nvar meta = require('./_meta');\nvar forOf = require('./_for-of');\nvar anInstance = require('./_an-instance');\nvar isObject = require('./_is-object');\nvar fails = require('./_fails');\nvar $iterDetect = require('./_iter-detect');\nvar setToStringTag = require('./_set-to-string-tag');\nvar inheritIfRequired = require('./_inherit-if-required');\n\nmodule.exports = function (NAME, wrapper, methods, common, IS_MAP, IS_WEAK) {\n  var Base = global[NAME];\n  var C = Base;\n  var ADDER = IS_MAP ? 'set' : 'add';\n  var proto = C && C.prototype;\n  var O = {};\n  var fixMethod = function (KEY) {\n    var fn = proto[KEY];\n    redefine(proto, KEY,\n      KEY == 'delete' ? function (a) {\n        return IS_WEAK && !isObject(a) ? false : fn.call(this, a === 0 ? 0 : a);\n      } : KEY == 'has' ? function has(a) {\n        return IS_WEAK && !isObject(a) ? false : fn.call(this, a === 0 ? 0 : a);\n      } : KEY == 'get' ? function get(a) {\n        return IS_WEAK && !isObject(a) ? undefined : fn.call(this, a === 0 ? 0 : a);\n      } : KEY == 'add' ? function add(a) { fn.call(this, a === 0 ? 0 : a); return this; }\n        : function set(a, b) { fn.call(this, a === 0 ? 0 : a, b); return this; }\n    );\n  };\n  if (typeof C != 'function' || !(IS_WEAK || proto.forEach && !fails(function () {\n    new C().entries().next();\n  }))) {\n    // create collection constructor\n    C = common.getConstructor(wrapper, NAME, IS_MAP, ADDER);\n    redefineAll(C.prototype, methods);\n    meta.NEED = true;\n  } else {\n    var instance = new C();\n    // early implementations not supports chaining\n    var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) != instance;\n    // V8 ~  Chromium 40- weak-collections throws on primitives, but should return false\n    var THROWS_ON_PRIMITIVES = fails(function () { instance.has(1); });\n    // most early implementations doesn't supports iterables, most modern - not close it correctly\n    var ACCEPT_ITERABLES = $iterDetect(function (iter) { new C(iter); }); // eslint-disable-line no-new\n    // for early implementations -0 and +0 not the same\n    var BUGGY_ZERO = !IS_WEAK && fails(function () {\n      // V8 ~ Chromium 42- fails only with 5+ elements\n      var $instance = new C();\n      var index = 5;\n      while (index--) $instance[ADDER](index, index);\n      return !$instance.has(-0);\n    });\n    if (!ACCEPT_ITERABLES) {\n      C = wrapper(function (target, iterable) {\n        anInstance(target, C, NAME);\n        var that = inheritIfRequired(new Base(), target, C);\n        if (iterable != undefined) forOf(iterable, IS_MAP, that[ADDER], that);\n        return that;\n      });\n      C.prototype = proto;\n      proto.constructor = C;\n    }\n    if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) {\n      fixMethod('delete');\n      fixMethod('has');\n      IS_MAP && fixMethod('get');\n    }\n    if (BUGGY_ZERO || HASNT_CHAINING) fixMethod(ADDER);\n    // weak collections should not contains .clear method\n    if (IS_WEAK && proto.clear) delete proto.clear;\n  }\n\n  setToStringTag(C, NAME);\n\n  O[NAME] = C;\n  $export($export.G + $export.W + $export.F * (C != Base), O);\n\n  if (!IS_WEAK) common.setStrong(C, NAME, IS_MAP);\n\n  return C;\n};\n","var ITERATOR = require('./_wks')('iterator');\nvar SAFE_CLOSING = false;\n\ntry {\n  var riter = [7][ITERATOR]();\n  riter['return'] = function () { SAFE_CLOSING = true; };\n  // eslint-disable-next-line no-throw-literal\n  Array.from(riter, function () { throw 2; });\n} catch (e) { /* empty */ }\n\nmodule.exports = function (exec, skipClosing) {\n  if (!skipClosing && !SAFE_CLOSING) return false;\n  var safe = false;\n  try {\n    var arr = [7];\n    var iter = arr[ITERATOR]();\n    iter.next = function () { return { done: safe = true }; };\n    arr[ITERATOR] = function () { return iter; };\n    exec(arr);\n  } catch (e) { /* empty */ }\n  return safe;\n};\n","var isObject = require('./_is-object');\nvar setPrototypeOf = require('./_set-proto').set;\nmodule.exports = function (that, target, C) {\n  var S = target.constructor;\n  var P;\n  if (S !== C && typeof S == 'function' && (P = S.prototype) !== C.prototype && isObject(P) && setPrototypeOf) {\n    setPrototypeOf(that, P);\n  } return that;\n};\n","// Works with __proto__ only. Old v8 can't work with null proto objects.\n/* eslint-disable no-proto */\nvar isObject = require('./_is-object');\nvar anObject = require('./_an-object');\nvar check = function (O, proto) {\n  anObject(O);\n  if (!isObject(proto) && proto !== null) throw TypeError(proto + \": can't set as prototype!\");\n};\nmodule.exports = {\n  set: Object.setPrototypeOf || ('__proto__' in {} ? // eslint-disable-line\n    function (test, buggy, set) {\n      try {\n        set = require('./_ctx')(Function.call, require('./_object-gopd').f(Object.prototype, '__proto__').set, 2);\n        set(test, []);\n        buggy = !(test instanceof Array);\n      } catch (e) { buggy = true; }\n      return function setPrototypeOf(O, proto) {\n        check(O, proto);\n        if (buggy) O.__proto__ = proto;\n        else set(O, proto);\n        return O;\n      };\n    }({}, false) : undefined),\n  check: check\n};\n","var pIE = require('./_object-pie');\nvar createDesc = require('./_property-desc');\nvar toIObject = require('./_to-iobject');\nvar toPrimitive = require('./_to-primitive');\nvar has = require('./_has');\nvar IE8_DOM_DEFINE = require('./_ie8-dom-define');\nvar gOPD = Object.getOwnPropertyDescriptor;\n\nexports.f = require('./_descriptors') ? gOPD : function getOwnPropertyDescriptor(O, P) {\n  O = toIObject(O);\n  P = toPrimitive(P, true);\n  if (IE8_DOM_DEFINE) try {\n    return gOPD(O, P);\n  } catch (e) { /* empty */ }\n  if (has(O, P)) return createDesc(!pIE.f.call(O, P), O[P]);\n};\n","// https://tc39.github.io/proposal-setmap-offrom/#sec-weakmap.of\nrequire('./_set-collection-of')('WeakMap');\n","'use strict';\n// https://tc39.github.io/proposal-setmap-offrom/\nvar $export = require('./_export');\n\nmodule.exports = function (COLLECTION) {\n  $export($export.S, COLLECTION, { of: function of() {\n    var length = arguments.length;\n    var A = new Array(length);\n    while (length--) A[length] = arguments[length];\n    return new this(A);\n  } });\n};\n","// https://tc39.github.io/proposal-setmap-offrom/#sec-weakmap.from\nrequire('./_set-collection-from')('WeakMap');\n","'use strict';\n// https://tc39.github.io/proposal-setmap-offrom/\nvar $export = require('./_export');\nvar aFunction = require('./_a-function');\nvar ctx = require('./_ctx');\nvar forOf = require('./_for-of');\n\nmodule.exports = function (COLLECTION) {\n  $export($export.S, COLLECTION, { from: function from(source /* , mapFn, thisArg */) {\n    var mapFn = arguments[1];\n    var mapping, A, n, cb;\n    aFunction(this);\n    mapping = mapFn !== undefined;\n    if (mapping) aFunction(mapFn);\n    if (source == undefined) return new this();\n    A = [];\n    if (mapping) {\n      n = 0;\n      cb = ctx(mapFn, arguments[2], 2);\n      forOf(source, false, function (nextItem) {\n        A.push(cb(nextItem, n++));\n      });\n    } else {\n      forOf(source, false, A.push, A);\n    }\n    return new this(A);\n  } });\n};\n","require('../../modules/es6.string.code-point-at');\nmodule.exports = require('../../modules/_core').String.codePointAt;\n","'use strict';\nvar $export = require('./_export');\nvar $at = require('./_string-at')(false);\n$export($export.P, 'String', {\n  // 21.1.3.3 String.prototype.codePointAt(pos)\n  codePointAt: function codePointAt(pos) {\n    return $at(this, pos);\n  }\n});\n","var toInteger = require('./_to-integer');\nvar defined = require('./_defined');\n// true  -> String#at\n// false -> String#codePointAt\nmodule.exports = function (TO_STRING) {\n  return function (that, pos) {\n    var s = String(defined(that));\n    var i = toInteger(pos);\n    var l = s.length;\n    var a, b;\n    if (i < 0 || i >= l) return TO_STRING ? '' : undefined;\n    a = s.charCodeAt(i);\n    return a < 0xd800 || a > 0xdbff || i + 1 === l || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff\n      ? TO_STRING ? s.charAt(i) : a\n      : TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000;\n  };\n};\n","require('../../modules/es6.string.from-code-point');\nmodule.exports = require('../../modules/_core').String.fromCodePoint;\n","var $export = require('./_export');\nvar toAbsoluteIndex = require('./_to-absolute-index');\nvar fromCharCode = String.fromCharCode;\nvar $fromCodePoint = String.fromCodePoint;\n\n// length should be 1, old FF problem\n$export($export.S + $export.F * (!!$fromCodePoint && $fromCodePoint.length != 1), 'String', {\n  // 21.1.2.2 String.fromCodePoint(...codePoints)\n  fromCodePoint: function fromCodePoint(x) { // eslint-disable-line no-unused-vars\n    var res = [];\n    var aLen = arguments.length;\n    var i = 0;\n    var code;\n    while (aLen > i) {\n      code = +arguments[i++];\n      if (toAbsoluteIndex(code, 0x10ffff) !== code) throw RangeError(code + ' is not a valid code point');\n      res.push(code < 0x10000\n        ? fromCharCode(code)\n        : fromCharCode(((code -= 0x10000) >> 10) + 0xd800, code % 0x400 + 0xdc00)\n      );\n    } return res.join('');\n  }\n});\n","require('../modules/es6.symbol');\nrequire('../modules/es6.object.to-string');\nmodule.exports = require('../modules/_core').Symbol;\n","'use strict';\n// ECMAScript 6 symbols shim\nvar global = require('./_global');\nvar has = require('./_has');\nvar DESCRIPTORS = require('./_descriptors');\nvar $export = require('./_export');\nvar redefine = require('./_redefine');\nvar META = require('./_meta').KEY;\nvar $fails = require('./_fails');\nvar shared = require('./_shared');\nvar setToStringTag = require('./_set-to-string-tag');\nvar uid = require('./_uid');\nvar wks = require('./_wks');\nvar wksExt = require('./_wks-ext');\nvar wksDefine = require('./_wks-define');\nvar enumKeys = require('./_enum-keys');\nvar isArray = require('./_is-array');\nvar anObject = require('./_an-object');\nvar isObject = require('./_is-object');\nvar toIObject = require('./_to-iobject');\nvar toPrimitive = require('./_to-primitive');\nvar createDesc = require('./_property-desc');\nvar _create = require('./_object-create');\nvar gOPNExt = require('./_object-gopn-ext');\nvar $GOPD = require('./_object-gopd');\nvar $DP = require('./_object-dp');\nvar $keys = require('./_object-keys');\nvar gOPD = $GOPD.f;\nvar dP = $DP.f;\nvar gOPN = gOPNExt.f;\nvar $Symbol = global.Symbol;\nvar $JSON = global.JSON;\nvar _stringify = $JSON && $JSON.stringify;\nvar PROTOTYPE = 'prototype';\nvar HIDDEN = wks('_hidden');\nvar TO_PRIMITIVE = wks('toPrimitive');\nvar isEnum = {}.propertyIsEnumerable;\nvar SymbolRegistry = shared('symbol-registry');\nvar AllSymbols = shared('symbols');\nvar OPSymbols = shared('op-symbols');\nvar ObjectProto = Object[PROTOTYPE];\nvar USE_NATIVE = typeof $Symbol == 'function';\nvar QObject = global.QObject;\n// Don't use setters in Qt Script, https://github.com/zloirock/core-js/issues/173\nvar setter = !QObject || !QObject[PROTOTYPE] || !QObject[PROTOTYPE].findChild;\n\n// fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687\nvar setSymbolDesc = DESCRIPTORS && $fails(function () {\n  return _create(dP({}, 'a', {\n    get: function () { return dP(this, 'a', { value: 7 }).a; }\n  })).a != 7;\n}) ? function (it, key, D) {\n  var protoDesc = gOPD(ObjectProto, key);\n  if (protoDesc) delete ObjectProto[key];\n  dP(it, key, D);\n  if (protoDesc && it !== ObjectProto) dP(ObjectProto, key, protoDesc);\n} : dP;\n\nvar wrap = function (tag) {\n  var sym = AllSymbols[tag] = _create($Symbol[PROTOTYPE]);\n  sym._k = tag;\n  return sym;\n};\n\nvar isSymbol = USE_NATIVE && typeof $Symbol.iterator == 'symbol' ? function (it) {\n  return typeof it == 'symbol';\n} : function (it) {\n  return it instanceof $Symbol;\n};\n\nvar $defineProperty = function defineProperty(it, key, D) {\n  if (it === ObjectProto) $defineProperty(OPSymbols, key, D);\n  anObject(it);\n  key = toPrimitive(key, true);\n  anObject(D);\n  if (has(AllSymbols, key)) {\n    if (!D.enumerable) {\n      if (!has(it, HIDDEN)) dP(it, HIDDEN, createDesc(1, {}));\n      it[HIDDEN][key] = true;\n    } else {\n      if (has(it, HIDDEN) && it[HIDDEN][key]) it[HIDDEN][key] = false;\n      D = _create(D, { enumerable: createDesc(0, false) });\n    } return setSymbolDesc(it, key, D);\n  } return dP(it, key, D);\n};\nvar $defineProperties = function defineProperties(it, P) {\n  anObject(it);\n  var keys = enumKeys(P = toIObject(P));\n  var i = 0;\n  var l = keys.length;\n  var key;\n  while (l > i) $defineProperty(it, key = keys[i++], P[key]);\n  return it;\n};\nvar $create = function create(it, P) {\n  return P === undefined ? _create(it) : $defineProperties(_create(it), P);\n};\nvar $propertyIsEnumerable = function propertyIsEnumerable(key) {\n  var E = isEnum.call(this, key = toPrimitive(key, true));\n  if (this === ObjectProto && has(AllSymbols, key) && !has(OPSymbols, key)) return false;\n  return E || !has(this, key) || !has(AllSymbols, key) || has(this, HIDDEN) && this[HIDDEN][key] ? E : true;\n};\nvar $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(it, key) {\n  it = toIObject(it);\n  key = toPrimitive(key, true);\n  if (it === ObjectProto && has(AllSymbols, key) && !has(OPSymbols, key)) return;\n  var D = gOPD(it, key);\n  if (D && has(AllSymbols, key) && !(has(it, HIDDEN) && it[HIDDEN][key])) D.enumerable = true;\n  return D;\n};\nvar $getOwnPropertyNames = function getOwnPropertyNames(it) {\n  var names = gOPN(toIObject(it));\n  var result = [];\n  var i = 0;\n  var key;\n  while (names.length > i) {\n    if (!has(AllSymbols, key = names[i++]) && key != HIDDEN && key != META) result.push(key);\n  } return result;\n};\nvar $getOwnPropertySymbols = function getOwnPropertySymbols(it) {\n  var IS_OP = it === ObjectProto;\n  var names = gOPN(IS_OP ? OPSymbols : toIObject(it));\n  var result = [];\n  var i = 0;\n  var key;\n  while (names.length > i) {\n    if (has(AllSymbols, key = names[i++]) && (IS_OP ? has(ObjectProto, key) : true)) result.push(AllSymbols[key]);\n  } return result;\n};\n\n// 19.4.1.1 Symbol([description])\nif (!USE_NATIVE) {\n  $Symbol = function Symbol() {\n    if (this instanceof $Symbol) throw TypeError('Symbol is not a constructor!');\n    var tag = uid(arguments.length > 0 ? arguments[0] : undefined);\n    var $set = function (value) {\n      if (this === ObjectProto) $set.call(OPSymbols, value);\n      if (has(this, HIDDEN) && has(this[HIDDEN], tag)) this[HIDDEN][tag] = false;\n      setSymbolDesc(this, tag, createDesc(1, value));\n    };\n    if (DESCRIPTORS && setter) setSymbolDesc(ObjectProto, tag, { configurable: true, set: $set });\n    return wrap(tag);\n  };\n  redefine($Symbol[PROTOTYPE], 'toString', function toString() {\n    return this._k;\n  });\n\n  $GOPD.f = $getOwnPropertyDescriptor;\n  $DP.f = $defineProperty;\n  require('./_object-gopn').f = gOPNExt.f = $getOwnPropertyNames;\n  require('./_object-pie').f = $propertyIsEnumerable;\n  require('./_object-gops').f = $getOwnPropertySymbols;\n\n  if (DESCRIPTORS && !require('./_library')) {\n    redefine(ObjectProto, 'propertyIsEnumerable', $propertyIsEnumerable, true);\n  }\n\n  wksExt.f = function (name) {\n    return wrap(wks(name));\n  };\n}\n\n$export($export.G + $export.W + $export.F * !USE_NATIVE, { Symbol: $Symbol });\n\nfor (var es6Symbols = (\n  // 19.4.2.2, 19.4.2.3, 19.4.2.4, 19.4.2.6, 19.4.2.8, 19.4.2.9, 19.4.2.10, 19.4.2.11, 19.4.2.12, 19.4.2.13, 19.4.2.14\n  'hasInstance,isConcatSpreadable,iterator,match,replace,search,species,split,toPrimitive,toStringTag,unscopables'\n).split(','), j = 0; es6Symbols.length > j;)wks(es6Symbols[j++]);\n\nfor (var wellKnownSymbols = $keys(wks.store), k = 0; wellKnownSymbols.length > k;) wksDefine(wellKnownSymbols[k++]);\n\n$export($export.S + $export.F * !USE_NATIVE, 'Symbol', {\n  // 19.4.2.1 Symbol.for(key)\n  'for': function (key) {\n    return has(SymbolRegistry, key += '')\n      ? SymbolRegistry[key]\n      : SymbolRegistry[key] = $Symbol(key);\n  },\n  // 19.4.2.5 Symbol.keyFor(sym)\n  keyFor: function keyFor(sym) {\n    if (!isSymbol(sym)) throw TypeError(sym + ' is not a symbol!');\n    for (var key in SymbolRegistry) if (SymbolRegistry[key] === sym) return key;\n  },\n  useSetter: function () { setter = true; },\n  useSimple: function () { setter = false; }\n});\n\n$export($export.S + $export.F * !USE_NATIVE, 'Object', {\n  // 19.1.2.2 Object.create(O [, Properties])\n  create: $create,\n  // 19.1.2.4 Object.defineProperty(O, P, Attributes)\n  defineProperty: $defineProperty,\n  // 19.1.2.3 Object.defineProperties(O, Properties)\n  defineProperties: $defineProperties,\n  // 19.1.2.6 Object.getOwnPropertyDescriptor(O, P)\n  getOwnPropertyDescriptor: $getOwnPropertyDescriptor,\n  // 19.1.2.7 Object.getOwnPropertyNames(O)\n  getOwnPropertyNames: $getOwnPropertyNames,\n  // 19.1.2.8 Object.getOwnPropertySymbols(O)\n  getOwnPropertySymbols: $getOwnPropertySymbols\n});\n\n// 24.3.2 JSON.stringify(value [, replacer [, space]])\n$JSON && $export($export.S + $export.F * (!USE_NATIVE || $fails(function () {\n  var S = $Symbol();\n  // MS Edge converts symbol values to JSON as {}\n  // WebKit converts symbol values to JSON as null\n  // V8 throws on boxed symbols\n  return _stringify([S]) != '[null]' || _stringify({ a: S }) != '{}' || _stringify(Object(S)) != '{}';\n})), 'JSON', {\n  stringify: function stringify(it) {\n    var args = [it];\n    var i = 1;\n    var replacer, $replacer;\n    while (arguments.length > i) args.push(arguments[i++]);\n    $replacer = replacer = args[1];\n    if (!isObject(replacer) && it === undefined || isSymbol(it)) return; // IE8 returns string on undefined\n    if (!isArray(replacer)) replacer = function (key, value) {\n      if (typeof $replacer == 'function') value = $replacer.call(this, key, value);\n      if (!isSymbol(value)) return value;\n    };\n    args[1] = replacer;\n    return _stringify.apply($JSON, args);\n  }\n});\n\n// 19.4.3.4 Symbol.prototype[@@toPrimitive](hint)\n$Symbol[PROTOTYPE][TO_PRIMITIVE] || require('./_hide')($Symbol[PROTOTYPE], TO_PRIMITIVE, $Symbol[PROTOTYPE].valueOf);\n// 19.4.3.5 Symbol.prototype[@@toStringTag]\nsetToStringTag($Symbol, 'Symbol');\n// 20.2.1.9 Math[@@toStringTag]\nsetToStringTag(Math, 'Math', true);\n// 24.3.3 JSON[@@toStringTag]\nsetToStringTag(global.JSON, 'JSON', true);\n","exports.f = require('./_wks');\n","var global = require('./_global');\nvar core = require('./_core');\nvar LIBRARY = require('./_library');\nvar wksExt = require('./_wks-ext');\nvar defineProperty = require('./_object-dp').f;\nmodule.exports = function (name) {\n  var $Symbol = core.Symbol || (core.Symbol = LIBRARY ? {} : global.Symbol || {});\n  if (name.charAt(0) != '_' && !(name in $Symbol)) defineProperty($Symbol, name, { value: wksExt.f(name) });\n};\n","// all enumerable object keys, includes symbols\nvar getKeys = require('./_object-keys');\nvar gOPS = require('./_object-gops');\nvar pIE = require('./_object-pie');\nmodule.exports = function (it) {\n  var result = getKeys(it);\n  var getSymbols = gOPS.f;\n  if (getSymbols) {\n    var symbols = getSymbols(it);\n    var isEnum = pIE.f;\n    var i = 0;\n    var key;\n    while (symbols.length > i) if (isEnum.call(it, key = symbols[i++])) result.push(key);\n  } return result;\n};\n","// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window\nvar toIObject = require('./_to-iobject');\nvar gOPN = require('./_object-gopn').f;\nvar toString = {}.toString;\n\nvar windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames\n  ? Object.getOwnPropertyNames(window) : [];\n\nvar getWindowNames = function (it) {\n  try {\n    return gOPN(it);\n  } catch (e) {\n    return windowNames.slice();\n  }\n};\n\nmodule.exports.f = function getOwnPropertyNames(it) {\n  return windowNames && toString.call(it) == '[object Window]' ? getWindowNames(it) : gOPN(toIObject(it));\n};\n","// 19.1.2.7 / 15.2.3.4 Object.getOwnPropertyNames(O)\nvar $keys = require('./_object-keys-internal');\nvar hiddenKeys = require('./_enum-bug-keys').concat('length', 'prototype');\n\nexports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {\n  return $keys(O, hiddenKeys);\n};\n","require('../../modules/es7.object.values');\nmodule.exports = require('../../modules/_core').Object.values;\n","// https://github.com/tc39/proposal-object-values-entries\nvar $export = require('./_export');\nvar $values = require('./_object-to-array')(false);\n\n$export($export.S, 'Object', {\n  values: function values(it) {\n    return $values(it);\n  }\n});\n","var getKeys = require('./_object-keys');\nvar toIObject = require('./_to-iobject');\nvar isEnum = require('./_object-pie').f;\nmodule.exports = function (isEntries) {\n  return function (it) {\n    var O = toIObject(it);\n    var keys = getKeys(O);\n    var length = keys.length;\n    var i = 0;\n    var result = [];\n    var key;\n    while (length > i) if (isEnum.call(O, key = keys[i++])) {\n      result.push(isEntries ? [key, O[key]] : O[key]);\n    } return result;\n  };\n};\n","/* Copyright 2017 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/* eslint-disable no-restricted-globals */\n\nlet isReadableStreamSupported = false;\nif (typeof ReadableStream !== 'undefined') {\n  // MS Edge may say it has ReadableStream but they are not up to spec yet.\n  try {\n    // eslint-disable-next-line no-new\n    new ReadableStream({\n      start(controller) {\n        controller.close();\n      },\n    });\n    isReadableStreamSupported = true;\n  } catch (e) {\n    // The ReadableStream constructor cannot be used.\n  }\n}\nif (isReadableStreamSupported) {\n  exports.ReadableStream = ReadableStream;\n} else {\n  if (typeof PDFJSDev !== 'undefined' && PDFJSDev.test('IMAGE_DECODERS')) {\n    class DummyReadableStream {\n      constructor() {\n        throw new Error('The current image decoders are synchronous, ' +\n                        'hence `ReadableStream` shouldn\\'t need to be ' +\n                        'polyfilled for the IMAGE_DECODERS build target.');\n      }\n    }\n    exports.ReadableStream = DummyReadableStream;\n  } else {\n    exports.ReadableStream =\n      require('../../external/streams/streams-lib').ReadableStream;\n  }\n}\n","/* Copyright 2018 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/* eslint-disable no-restricted-globals */\n\nif (typeof PDFJSDev !== 'undefined' && !PDFJSDev.test('GENERIC')) {\n  // The `URL` constructor is assumed to be available in the extension builds.\n  exports.URL = URL;\n} else {\n  let isURLSupported = false;\n  try {\n    if (typeof URL === 'function' && typeof URL.prototype === 'object' &&\n        ('origin' in URL.prototype)) {\n      const u = new URL('b', 'http://a');\n      u.pathname = 'c%20d';\n      isURLSupported = (u.href === 'http://a/c%20d');\n    }\n  } catch (ex) {\n    // The `URL` constructor cannot be used.\n  }\n\n  if (isURLSupported) {\n    exports.URL = URL;\n  } else {\n    if (typeof PDFJSDev !== 'undefined' && PDFJSDev.test('IMAGE_DECODERS')) {\n      class DummyURL {\n        constructor() {\n          throw new Error('The current image decoders doesn\\'t utilize the ' +\n                          '`URL` constructor, hence it shouldn\\'t need to be ' +\n                          'polyfilled for the IMAGE_DECODERS build target.');\n        }\n      }\n      exports.URL = DummyURL;\n    } else {\n      const PolyfillURL = require('../../external/url/url-lib').URL;\n\n      // Attempt to copy over the static methods.\n      const OriginalURL = require('./global_scope').URL;\n      if (OriginalURL) {\n        PolyfillURL.createObjectURL = function(blob) {\n          // IE extension allows a second optional options argument, see\n          // http://msdn.microsoft.com/en-us/library/ie/hh772302(v=vs.85).aspx\n          return OriginalURL.createObjectURL.apply(OriginalURL, arguments);\n        };\n        PolyfillURL.revokeObjectURL = function(url) {\n          OriginalURL.revokeObjectURL(url);\n        };\n      }\n      exports.URL = PolyfillURL;\n    }\n  }\n}\n","/* Copyright 2012 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { log2, readInt8, readUint16, readUint32, shadow } from '../shared/util';\nimport { ArithmeticDecoder } from './arithmetic_decoder';\nimport { CCITTFaxDecoder } from './ccitt';\n\nlet Jbig2Error = (function Jbig2ErrorClosure() {\n  function Jbig2Error(msg) {\n    this.message = 'JBIG2 error: ' + msg;\n  }\n\n  Jbig2Error.prototype = new Error();\n  Jbig2Error.prototype.name = 'Jbig2Error';\n  Jbig2Error.constructor = Jbig2Error;\n\n  return Jbig2Error;\n})();\n\nvar Jbig2Image = (function Jbig2ImageClosure() {\n  // Utility data structures\n  function ContextCache() {}\n\n  ContextCache.prototype = {\n    getContexts(id) {\n      if (id in this) {\n        return this[id];\n      }\n      return (this[id] = new Int8Array(1 << 16));\n    },\n  };\n\n  function DecodingContext(data, start, end) {\n    this.data = data;\n    this.start = start;\n    this.end = end;\n  }\n\n  DecodingContext.prototype = {\n    get decoder() {\n      var decoder = new ArithmeticDecoder(this.data, this.start, this.end);\n      return shadow(this, 'decoder', decoder);\n    },\n    get contextCache() {\n      var cache = new ContextCache();\n      return shadow(this, 'contextCache', cache);\n    },\n  };\n\n  // Annex A. Arithmetic Integer Decoding Procedure\n  // A.2 Procedure for decoding values\n  function decodeInteger(contextCache, procedure, decoder) {\n    var contexts = contextCache.getContexts(procedure);\n    var prev = 1;\n\n    function readBits(length) {\n      var v = 0;\n      for (var i = 0; i < length; i++) {\n        var bit = decoder.readBit(contexts, prev);\n        prev = (prev < 256 ? (prev << 1) | bit :\n                (((prev << 1) | bit) & 511) | 256);\n        v = (v << 1) | bit;\n      }\n      return v >>> 0;\n    }\n\n    var sign = readBits(1);\n    var value = readBits(1) ?\n                  (readBits(1) ?\n                    (readBits(1) ?\n                      (readBits(1) ?\n                        (readBits(1) ?\n                          (readBits(32) + 4436) :\n                        readBits(12) + 340) :\n                      readBits(8) + 84) :\n                    readBits(6) + 20) :\n                  readBits(4) + 4) :\n                readBits(2);\n    return (sign === 0 ? value : (value > 0 ? -value : null));\n  }\n\n  // A.3 The IAID decoding procedure\n  function decodeIAID(contextCache, decoder, codeLength) {\n    var contexts = contextCache.getContexts('IAID');\n\n    var prev = 1;\n    for (var i = 0; i < codeLength; i++) {\n      var bit = decoder.readBit(contexts, prev);\n      prev = (prev << 1) | bit;\n    }\n    if (codeLength < 31) {\n      return prev & ((1 << codeLength) - 1);\n    }\n    return prev & 0x7FFFFFFF;\n  }\n\n  // 7.3 Segment types\n  var SegmentTypes = [\n    'SymbolDictionary', null, null, null, 'IntermediateTextRegion', null,\n    'ImmediateTextRegion', 'ImmediateLosslessTextRegion', null, null, null,\n    null, null, null, null, null, 'PatternDictionary', null, null, null,\n    'IntermediateHalftoneRegion', null, 'ImmediateHalftoneRegion',\n    'ImmediateLosslessHalftoneRegion', null, null, null, null, null, null, null,\n    null, null, null, null, null, 'IntermediateGenericRegion', null,\n    'ImmediateGenericRegion', 'ImmediateLosslessGenericRegion',\n    'IntermediateGenericRefinementRegion', null,\n    'ImmediateGenericRefinementRegion',\n    'ImmediateLosslessGenericRefinementRegion', null, null, null, null,\n    'PageInformation', 'EndOfPage', 'EndOfStripe', 'EndOfFile', 'Profiles',\n    'Tables', null, null, null, null, null, null, null, null,\n    'Extension'\n  ];\n\n  var CodingTemplates = [\n    [{ x: -1, y: -2, }, { x: 0, y: -2, }, { x: 1, y: -2, }, { x: -2, y: -1, },\n     { x: -1, y: -1, }, { x: 0, y: -1, }, { x: 1, y: -1, }, { x: 2, y: -1, },\n     { x: -4, y: 0, }, { x: -3, y: 0, }, { x: -2, y: 0, }, { x: -1, y: 0, }],\n    [{ x: -1, y: -2, }, { x: 0, y: -2, }, { x: 1, y: -2, }, { x: 2, y: -2, },\n     { x: -2, y: -1, }, { x: -1, y: -1, }, { x: 0, y: -1, }, { x: 1, y: -1, },\n     { x: 2, y: -1, }, { x: -3, y: 0, }, { x: -2, y: 0, }, { x: -1, y: 0, }],\n    [{ x: -1, y: -2, }, { x: 0, y: -2, }, { x: 1, y: -2, }, { x: -2, y: -1, },\n     { x: -1, y: -1, }, { x: 0, y: -1, }, { x: 1, y: -1, }, { x: -2, y: 0, },\n     { x: -1, y: 0, }],\n    [{ x: -3, y: -1, }, { x: -2, y: -1, }, { x: -1, y: -1, }, { x: 0, y: -1, },\n     { x: 1, y: -1, }, { x: -4, y: 0, }, { x: -3, y: 0, }, { x: -2, y: 0, },\n     { x: -1, y: 0, }]\n  ];\n\n  var RefinementTemplates = [\n    {\n      coding: [{ x: 0, y: -1, }, { x: 1, y: -1, }, { x: -1, y: 0, }],\n      reference: [{ x: 0, y: -1, }, { x: 1, y: -1, }, { x: -1, y: 0, },\n                  { x: 0, y: 0, }, { x: 1, y: 0, }, { x: -1, y: 1, },\n                  { x: 0, y: 1, }, { x: 1, y: 1, }],\n    },\n    {\n      coding: [{ x: -1, y: -1, }, { x: 0, y: -1, }, { x: 1, y: -1, },\n               { x: -1, y: 0, }],\n      reference: [{ x: 0, y: -1, }, { x: -1, y: 0, }, { x: 0, y: 0, },\n                  { x: 1, y: 0, }, { x: 0, y: 1, }, { x: 1, y: 1, }],\n    }\n  ];\n\n  // See 6.2.5.7 Decoding the bitmap.\n  var ReusedContexts = [\n    0x9B25, // 10011 0110010 0101\n    0x0795, // 0011 110010 101\n    0x00E5, // 001 11001 01\n    0x0195  // 011001 0101\n  ];\n\n  var RefinementReusedContexts = [\n    0x0020, // '000' + '0' (coding) + '00010000' + '0' (reference)\n    0x0008  // '0000' + '001000'\n  ];\n\n  function decodeBitmapTemplate0(width, height, decodingContext) {\n    var decoder = decodingContext.decoder;\n    var contexts = decodingContext.contextCache.getContexts('GB');\n    var contextLabel, i, j, pixel, row, row1, row2, bitmap = [];\n\n    // ...ooooo....\n    // ..ooooooo... Context template for current pixel (X)\n    // .ooooX...... (concatenate values of 'o'-pixels to get contextLabel)\n    var OLD_PIXEL_MASK = 0x7BF7; // 01111 0111111 0111\n\n    for (i = 0; i < height; i++) {\n      row = bitmap[i] = new Uint8Array(width);\n      row1 = (i < 1) ? row : bitmap[i - 1];\n      row2 = (i < 2) ? row : bitmap[i - 2];\n\n      // At the beginning of each row:\n      // Fill contextLabel with pixels that are above/right of (X)\n      contextLabel = (row2[0] << 13) | (row2[1] << 12) | (row2[2] << 11) |\n                     (row1[0] << 7) | (row1[1] << 6) | (row1[2] << 5) |\n                     (row1[3] << 4);\n\n      for (j = 0; j < width; j++) {\n        row[j] = pixel = decoder.readBit(contexts, contextLabel);\n\n        // At each pixel: Clear contextLabel pixels that are shifted\n        // out of the context, then add new ones.\n        contextLabel = ((contextLabel & OLD_PIXEL_MASK) << 1) |\n                       (j + 3 < width ? row2[j + 3] << 11 : 0) |\n                       (j + 4 < width ? row1[j + 4] << 4 : 0) | pixel;\n      }\n    }\n\n    return bitmap;\n  }\n\n  // 6.2 Generic Region Decoding Procedure\n  function decodeBitmap(mmr, width, height, templateIndex, prediction, skip, at,\n                        decodingContext) {\n    if (mmr) {\n      let input = new Reader(decodingContext.data, decodingContext.start,\n        decodingContext.end);\n      return decodeMMRBitmap(input, width, height, false);\n    }\n\n    // Use optimized version for the most common case\n    if (templateIndex === 0 && !skip && !prediction && at.length === 4 &&\n        at[0].x === 3 && at[0].y === -1 && at[1].x === -3 && at[1].y === -1 &&\n        at[2].x === 2 && at[2].y === -2 && at[3].x === -2 && at[3].y === -2) {\n      return decodeBitmapTemplate0(width, height, decodingContext);\n    }\n\n    var useskip = !!skip;\n    var template = CodingTemplates[templateIndex].concat(at);\n\n    // Sorting is non-standard, and it is not required. But sorting increases\n    // the number of template bits that can be reused from the previous\n    // contextLabel in the main loop.\n    template.sort(function (a, b) {\n      return (a.y - b.y) || (a.x - b.x);\n    });\n\n    var templateLength = template.length;\n    var templateX = new Int8Array(templateLength);\n    var templateY = new Int8Array(templateLength);\n    var changingTemplateEntries = [];\n    var reuseMask = 0, minX = 0, maxX = 0, minY = 0;\n    var c, k;\n\n    for (k = 0; k < templateLength; k++) {\n      templateX[k] = template[k].x;\n      templateY[k] = template[k].y;\n      minX = Math.min(minX, template[k].x);\n      maxX = Math.max(maxX, template[k].x);\n      minY = Math.min(minY, template[k].y);\n      // Check if the template pixel appears in two consecutive context labels,\n      // so it can be reused. Otherwise, we add it to the list of changing\n      // template entries.\n      if (k < templateLength - 1 &&\n          template[k].y === template[k + 1].y &&\n          template[k].x === template[k + 1].x - 1) {\n        reuseMask |= 1 << (templateLength - 1 - k);\n      } else {\n        changingTemplateEntries.push(k);\n      }\n    }\n    var changingEntriesLength = changingTemplateEntries.length;\n\n    var changingTemplateX = new Int8Array(changingEntriesLength);\n    var changingTemplateY = new Int8Array(changingEntriesLength);\n    var changingTemplateBit = new Uint16Array(changingEntriesLength);\n    for (c = 0; c < changingEntriesLength; c++) {\n      k = changingTemplateEntries[c];\n      changingTemplateX[c] = template[k].x;\n      changingTemplateY[c] = template[k].y;\n      changingTemplateBit[c] = 1 << (templateLength - 1 - k);\n    }\n\n    // Get the safe bounding box edges from the width, height, minX, maxX, minY\n    var sbb_left = -minX;\n    var sbb_top = -minY;\n    var sbb_right = width - maxX;\n\n    var pseudoPixelContext = ReusedContexts[templateIndex];\n    var row = new Uint8Array(width);\n    var bitmap = [];\n\n    var decoder = decodingContext.decoder;\n    var contexts = decodingContext.contextCache.getContexts('GB');\n\n    var ltp = 0, j, i0, j0, contextLabel = 0, bit, shift;\n    for (var i = 0; i < height; i++) {\n      if (prediction) {\n        var sltp = decoder.readBit(contexts, pseudoPixelContext);\n        ltp ^= sltp;\n        if (ltp) {\n          bitmap.push(row); // duplicate previous row\n          continue;\n        }\n      }\n      row = new Uint8Array(row);\n      bitmap.push(row);\n      for (j = 0; j < width; j++) {\n        if (useskip && skip[i][j]) {\n          row[j] = 0;\n          continue;\n        }\n        // Are we in the middle of a scanline, so we can reuse contextLabel\n        // bits?\n        if (j >= sbb_left && j < sbb_right && i >= sbb_top) {\n          // If yes, we can just shift the bits that are reusable and only\n          // fetch the remaining ones.\n          contextLabel = (contextLabel << 1) & reuseMask;\n          for (k = 0; k < changingEntriesLength; k++) {\n            i0 = i + changingTemplateY[k];\n            j0 = j + changingTemplateX[k];\n            bit = bitmap[i0][j0];\n            if (bit) {\n              bit = changingTemplateBit[k];\n              contextLabel |= bit;\n            }\n          }\n        } else {\n          // compute the contextLabel from scratch\n          contextLabel = 0;\n          shift = templateLength - 1;\n          for (k = 0; k < templateLength; k++, shift--) {\n            j0 = j + templateX[k];\n            if (j0 >= 0 && j0 < width) {\n              i0 = i + templateY[k];\n              if (i0 >= 0) {\n                bit = bitmap[i0][j0];\n                if (bit) {\n                  contextLabel |= bit << shift;\n                }\n              }\n            }\n          }\n        }\n        var pixel = decoder.readBit(contexts, contextLabel);\n        row[j] = pixel;\n      }\n    }\n    return bitmap;\n  }\n\n  // 6.3.2 Generic Refinement Region Decoding Procedure\n  function decodeRefinement(width, height, templateIndex, referenceBitmap,\n                            offsetX, offsetY, prediction, at,\n                            decodingContext) {\n    var codingTemplate = RefinementTemplates[templateIndex].coding;\n    if (templateIndex === 0) {\n      codingTemplate = codingTemplate.concat([at[0]]);\n    }\n    var codingTemplateLength = codingTemplate.length;\n    var codingTemplateX = new Int32Array(codingTemplateLength);\n    var codingTemplateY = new Int32Array(codingTemplateLength);\n    var k;\n    for (k = 0; k < codingTemplateLength; k++) {\n      codingTemplateX[k] = codingTemplate[k].x;\n      codingTemplateY[k] = codingTemplate[k].y;\n    }\n\n    var referenceTemplate = RefinementTemplates[templateIndex].reference;\n    if (templateIndex === 0) {\n      referenceTemplate = referenceTemplate.concat([at[1]]);\n    }\n    var referenceTemplateLength = referenceTemplate.length;\n    var referenceTemplateX = new Int32Array(referenceTemplateLength);\n    var referenceTemplateY = new Int32Array(referenceTemplateLength);\n    for (k = 0; k < referenceTemplateLength; k++) {\n      referenceTemplateX[k] = referenceTemplate[k].x;\n      referenceTemplateY[k] = referenceTemplate[k].y;\n    }\n    var referenceWidth = referenceBitmap[0].length;\n    var referenceHeight = referenceBitmap.length;\n\n    var pseudoPixelContext = RefinementReusedContexts[templateIndex];\n    var bitmap = [];\n\n    var decoder = decodingContext.decoder;\n    var contexts = decodingContext.contextCache.getContexts('GR');\n\n    var ltp = 0;\n    for (var i = 0; i < height; i++) {\n      if (prediction) {\n        var sltp = decoder.readBit(contexts, pseudoPixelContext);\n        ltp ^= sltp;\n        if (ltp) {\n          throw new Jbig2Error('prediction is not supported');\n        }\n      }\n      var row = new Uint8Array(width);\n      bitmap.push(row);\n      for (var j = 0; j < width; j++) {\n        var i0, j0;\n        var contextLabel = 0;\n        for (k = 0; k < codingTemplateLength; k++) {\n          i0 = i + codingTemplateY[k];\n          j0 = j + codingTemplateX[k];\n          if (i0 < 0 || j0 < 0 || j0 >= width) {\n            contextLabel <<= 1; // out of bound pixel\n          } else {\n            contextLabel = (contextLabel << 1) | bitmap[i0][j0];\n          }\n        }\n        for (k = 0; k < referenceTemplateLength; k++) {\n          i0 = i + referenceTemplateY[k] - offsetY;\n          j0 = j + referenceTemplateX[k] - offsetX;\n          if (i0 < 0 || i0 >= referenceHeight || j0 < 0 ||\n              j0 >= referenceWidth) {\n            contextLabel <<= 1; // out of bound pixel\n          } else {\n            contextLabel = (contextLabel << 1) | referenceBitmap[i0][j0];\n          }\n        }\n        var pixel = decoder.readBit(contexts, contextLabel);\n        row[j] = pixel;\n      }\n    }\n\n    return bitmap;\n  }\n\n  // 6.5.5 Decoding the symbol dictionary\n  function decodeSymbolDictionary(huffman, refinement, symbols,\n                                  numberOfNewSymbols, numberOfExportedSymbols,\n                                  huffmanTables, templateIndex, at,\n                                  refinementTemplateIndex, refinementAt,\n                                  decodingContext, huffmanInput) {\n    if (huffman && refinement) {\n      throw new Jbig2Error('symbol refinement with Huffman is not supported');\n    }\n\n    var newSymbols = [];\n    var currentHeight = 0;\n    var symbolCodeLength = log2(symbols.length + numberOfNewSymbols);\n\n    var decoder = decodingContext.decoder;\n    var contextCache = decodingContext.contextCache;\n    let tableB1, symbolWidths;\n    if (huffman) {\n      tableB1 = getStandardTable(1); // standard table B.1\n      symbolWidths = [];\n      symbolCodeLength = Math.max(symbolCodeLength, 1); // 6.5.8.2.3\n    }\n\n    while (newSymbols.length < numberOfNewSymbols) {\n      var deltaHeight = huffman ?\n        huffmanTables.tableDeltaHeight.decode(huffmanInput) :\n        decodeInteger(contextCache, 'IADH', decoder); // 6.5.6\n      currentHeight += deltaHeight;\n      let currentWidth = 0, totalWidth = 0;\n      let firstSymbol = huffman ? symbolWidths.length : 0;\n      while (true) {\n        var deltaWidth = huffman ?\n          huffmanTables.tableDeltaWidth.decode(huffmanInput) :\n          decodeInteger(contextCache, 'IADW', decoder); // 6.5.7\n        if (deltaWidth === null) {\n          break; // OOB\n        }\n        currentWidth += deltaWidth;\n        totalWidth += currentWidth;\n        var bitmap;\n        if (refinement) {\n          // 6.5.8.2 Refinement/aggregate-coded symbol bitmap\n          var numberOfInstances = decodeInteger(contextCache, 'IAAI', decoder);\n          if (numberOfInstances > 1) {\n            bitmap = decodeTextRegion(huffman, refinement,\n                                      currentWidth, currentHeight, 0,\n                                      numberOfInstances, 1, // strip size\n                                      symbols.concat(newSymbols),\n                                      symbolCodeLength,\n                                      0, // transposed\n                                      0, // ds offset\n                                      1, // top left 7.4.3.1.1\n                                      0, // OR operator\n                                      huffmanTables,\n                                      refinementTemplateIndex, refinementAt,\n                                      decodingContext, 0, huffmanInput);\n          } else {\n            var symbolId = decodeIAID(contextCache, decoder, symbolCodeLength);\n            var rdx = decodeInteger(contextCache, 'IARDX', decoder); // 6.4.11.3\n            var rdy = decodeInteger(contextCache, 'IARDY', decoder); // 6.4.11.4\n            var symbol = (symbolId < symbols.length ? symbols[symbolId] :\n                          newSymbols[symbolId - symbols.length]);\n            bitmap = decodeRefinement(currentWidth, currentHeight,\n            refinementTemplateIndex, symbol, rdx, rdy, false, refinementAt,\n            decodingContext);\n          }\n          newSymbols.push(bitmap);\n        } else if (huffman) {\n          // Store only symbol width and decode a collective bitmap when the\n          // height class is done.\n          symbolWidths.push(currentWidth);\n        } else {\n          // 6.5.8.1 Direct-coded symbol bitmap\n          bitmap = decodeBitmap(false, currentWidth, currentHeight,\n            templateIndex, false, null, at, decodingContext);\n          newSymbols.push(bitmap);\n        }\n      }\n      if (huffman && !refinement) {\n        // 6.5.9 Height class collective bitmap\n        let bitmapSize = huffmanTables.tableBitmapSize.decode(huffmanInput);\n        huffmanInput.byteAlign();\n        let collectiveBitmap;\n        if (bitmapSize === 0) {\n          // Uncompressed collective bitmap\n          collectiveBitmap = readUncompressedBitmap(huffmanInput, totalWidth,\n            currentHeight);\n        } else {\n          // MMR collective bitmap\n          let originalEnd = huffmanInput.end;\n          let bitmapEnd = huffmanInput.position + bitmapSize;\n          huffmanInput.end = bitmapEnd;\n          collectiveBitmap = decodeMMRBitmap(huffmanInput, totalWidth,\n            currentHeight, false);\n          huffmanInput.end = originalEnd;\n          huffmanInput.position = bitmapEnd;\n        }\n        let numberOfSymbolsDecoded = symbolWidths.length;\n        if (firstSymbol === numberOfSymbolsDecoded - 1) {\n          // collectiveBitmap is a single symbol.\n          newSymbols.push(collectiveBitmap);\n        } else {\n          // Divide collectiveBitmap into symbols.\n          let i, y, xMin = 0, xMax, bitmapWidth, symbolBitmap;\n          for (i = firstSymbol; i < numberOfSymbolsDecoded; i++) {\n            bitmapWidth = symbolWidths[i];\n            xMax = xMin + bitmapWidth;\n            symbolBitmap = [];\n            for (y = 0; y < currentHeight; y++) {\n              symbolBitmap.push(collectiveBitmap[y].subarray(xMin, xMax));\n            }\n            newSymbols.push(symbolBitmap);\n            xMin = xMax;\n          }\n        }\n      }\n    }\n\n    // 6.5.10 Exported symbols\n    var exportedSymbols = [];\n    var flags = [], currentFlag = false;\n    var totalSymbolsLength = symbols.length + numberOfNewSymbols;\n    while (flags.length < totalSymbolsLength) {\n      var runLength = huffman ? tableB1.decode(huffmanInput) :\n        decodeInteger(contextCache, 'IAEX', decoder);\n      while (runLength--) {\n        flags.push(currentFlag);\n      }\n      currentFlag = !currentFlag;\n    }\n    for (var i = 0, ii = symbols.length; i < ii; i++) {\n      if (flags[i]) {\n        exportedSymbols.push(symbols[i]);\n      }\n    }\n    for (var j = 0; j < numberOfNewSymbols; i++, j++) {\n      if (flags[i]) {\n        exportedSymbols.push(newSymbols[j]);\n      }\n    }\n    return exportedSymbols;\n  }\n\n  function decodeTextRegion(huffman, refinement, width, height,\n                            defaultPixelValue, numberOfSymbolInstances,\n                            stripSize, inputSymbols, symbolCodeLength,\n                            transposed, dsOffset, referenceCorner,\n                            combinationOperator, huffmanTables,\n                            refinementTemplateIndex, refinementAt,\n                            decodingContext, logStripSize, huffmanInput) {\n    if (huffman && refinement) {\n      throw new Jbig2Error('refinement with Huffman is not supported');\n    }\n\n    // Prepare bitmap\n    var bitmap = [];\n    var i, row;\n    for (i = 0; i < height; i++) {\n      row = new Uint8Array(width);\n      if (defaultPixelValue) {\n        for (var j = 0; j < width; j++) {\n          row[j] = defaultPixelValue;\n        }\n      }\n      bitmap.push(row);\n    }\n\n    var decoder = decodingContext.decoder;\n    var contextCache = decodingContext.contextCache;\n\n    var stripT = huffman ? -huffmanTables.tableDeltaT.decode(huffmanInput) :\n      -decodeInteger(contextCache, 'IADT', decoder); // 6.4.6\n    var firstS = 0;\n    i = 0;\n    while (i < numberOfSymbolInstances) {\n      var deltaT = huffman ? huffmanTables.tableDeltaT.decode(huffmanInput) :\n        decodeInteger(contextCache, 'IADT', decoder); // 6.4.6\n      stripT += deltaT;\n\n      var deltaFirstS = huffman ?\n        huffmanTables.tableFirstS.decode(huffmanInput) :\n        decodeInteger(contextCache, 'IAFS', decoder); // 6.4.7\n      firstS += deltaFirstS;\n      var currentS = firstS;\n      do {\n        let currentT = 0; // 6.4.9\n        if (stripSize > 1) {\n          currentT = huffman ? huffmanInput.readBits(logStripSize) :\n            decodeInteger(contextCache, 'IAIT', decoder);\n        }\n        var t = stripSize * stripT + currentT;\n        var symbolId = huffman ?\n          huffmanTables.symbolIDTable.decode(huffmanInput) :\n          decodeIAID(contextCache, decoder, symbolCodeLength);\n        var applyRefinement = (refinement && (huffman ? huffmanInput.readBit() :\n          decodeInteger(contextCache, 'IARI', decoder)));\n        var symbolBitmap = inputSymbols[symbolId];\n        var symbolWidth = symbolBitmap[0].length;\n        var symbolHeight = symbolBitmap.length;\n        if (applyRefinement) {\n          var rdw = decodeInteger(contextCache, 'IARDW', decoder); // 6.4.11.1\n          var rdh = decodeInteger(contextCache, 'IARDH', decoder); // 6.4.11.2\n          var rdx = decodeInteger(contextCache, 'IARDX', decoder); // 6.4.11.3\n          var rdy = decodeInteger(contextCache, 'IARDY', decoder); // 6.4.11.4\n          symbolWidth += rdw;\n          symbolHeight += rdh;\n          symbolBitmap = decodeRefinement(symbolWidth, symbolHeight,\n            refinementTemplateIndex, symbolBitmap, (rdw >> 1) + rdx,\n            (rdh >> 1) + rdy, false, refinementAt,\n            decodingContext);\n        }\n        var offsetT = t - ((referenceCorner & 1) ? 0 : (symbolHeight - 1));\n        var offsetS = currentS -\n          ((referenceCorner & 2) ? (symbolWidth - 1) : 0);\n        var s2, t2, symbolRow;\n        if (transposed) {\n          // Place Symbol Bitmap from T1,S1\n          for (s2 = 0; s2 < symbolHeight; s2++) {\n            row = bitmap[offsetS + s2];\n            if (!row) {\n              continue;\n            }\n            symbolRow = symbolBitmap[s2];\n            // To ignore Parts of Symbol bitmap which goes\n            // outside bitmap region\n            var maxWidth = Math.min(width - offsetT, symbolWidth);\n            switch (combinationOperator) {\n              case 0: // OR\n                for (t2 = 0; t2 < maxWidth; t2++) {\n                  row[offsetT + t2] |= symbolRow[t2];\n                }\n                break;\n              case 2: // XOR\n                for (t2 = 0; t2 < maxWidth; t2++) {\n                  row[offsetT + t2] ^= symbolRow[t2];\n                }\n                break;\n              default:\n                throw new Jbig2Error(\n                  `operator ${combinationOperator} is not supported`);\n            }\n          }\n          currentS += symbolHeight - 1;\n        } else {\n          for (t2 = 0; t2 < symbolHeight; t2++) {\n            row = bitmap[offsetT + t2];\n            if (!row) {\n              continue;\n            }\n            symbolRow = symbolBitmap[t2];\n            switch (combinationOperator) {\n              case 0: // OR\n                for (s2 = 0; s2 < symbolWidth; s2++) {\n                  row[offsetS + s2] |= symbolRow[s2];\n                }\n                break;\n              case 2: // XOR\n                for (s2 = 0; s2 < symbolWidth; s2++) {\n                  row[offsetS + s2] ^= symbolRow[s2];\n                }\n                break;\n              default:\n                throw new Jbig2Error(\n                  `operator ${combinationOperator} is not supported`);\n            }\n          }\n          currentS += symbolWidth - 1;\n        }\n        i++;\n        var deltaS = huffman ? huffmanTables.tableDeltaS.decode(huffmanInput) :\n          decodeInteger(contextCache, 'IADS', decoder); // 6.4.8\n        if (deltaS === null) {\n          break; // OOB\n        }\n        currentS += deltaS + dsOffset;\n      } while (true);\n    }\n    return bitmap;\n  }\n\n  function decodePatternDictionary(mmr, patternWidth, patternHeight,\n                                   maxPatternIndex, template, decodingContext) {\n    let at = [];\n    if (!mmr) {\n      at.push({\n        x: -patternWidth,\n        y: 0,\n      });\n      if (template === 0) {\n        at.push({\n          x: -3,\n          y: -1,\n        });\n        at.push({\n          x: 2,\n          y: -2,\n        });\n        at.push({\n          x: -2,\n          y: -2,\n        });\n      }\n    }\n    let collectiveWidth = (maxPatternIndex + 1) * patternWidth;\n    let collectiveBitmap = decodeBitmap(mmr, collectiveWidth, patternHeight,\n                                        template, false, null, at,\n                                        decodingContext);\n    // Divide collective bitmap into patterns.\n    let patterns = [], i = 0, patternBitmap, xMin, xMax, y;\n    while (i <= maxPatternIndex) {\n      patternBitmap = [];\n      xMin = patternWidth * i;\n      xMax = xMin + patternWidth;\n      for (y = 0; y < patternHeight; y++) {\n        patternBitmap.push(collectiveBitmap[y].subarray(xMin, xMax));\n      }\n      patterns.push(patternBitmap);\n      i++;\n    }\n    return patterns;\n  }\n\n  function decodeHalftoneRegion(mmr, patterns, template, regionWidth,\n                                regionHeight, defaultPixelValue, enableSkip,\n                                combinationOperator, gridWidth, gridHeight,\n                                gridOffsetX, gridOffsetY, gridVectorX,\n                                gridVectorY, decodingContext) {\n    let skip = null;\n    if (enableSkip) {\n      throw new Jbig2Error('skip is not supported');\n    }\n    if (combinationOperator !== 0) {\n      throw new Jbig2Error('operator ' + combinationOperator +\n        ' is not supported in halftone region');\n    }\n\n    // Prepare bitmap.\n    let regionBitmap = [];\n    let i, j, row;\n    for (i = 0; i < regionHeight; i++) {\n      row = new Uint8Array(regionWidth);\n      if (defaultPixelValue) {\n        for (j = 0; j < regionWidth; j++) {\n          row[j] = defaultPixelValue;\n        }\n      }\n      regionBitmap.push(row);\n    }\n\n    let numberOfPatterns = patterns.length;\n    let pattern0 = patterns[0];\n    let patternWidth = pattern0[0].length, patternHeight = pattern0.length;\n    let bitsPerValue = log2(numberOfPatterns);\n    let at = [];\n    if (!mmr) {\n      at.push({\n        x: (template <= 1) ? 3 : 2,\n        y: -1,\n      });\n      if (template === 0) {\n        at.push({\n          x: -3,\n          y: -1,\n        });\n        at.push({\n          x: 2,\n          y: -2,\n        });\n        at.push({\n          x: -2,\n          y: -2,\n        });\n      }\n    }\n    // Annex C. Gray-scale Image Decoding Procedure.\n    let grayScaleBitPlanes = [], mmrInput, bitmap;\n    if (mmr) {\n      // MMR bit planes are in one continuous stream. Only EOFB codes indicate\n      // the end of each bitmap, so EOFBs must be decoded.\n      mmrInput = new Reader(decodingContext.data, decodingContext.start,\n        decodingContext.end);\n    }\n    for (i = bitsPerValue - 1; i >= 0; i--) {\n      if (mmr) {\n        bitmap = decodeMMRBitmap(mmrInput, gridWidth, gridHeight, true);\n      } else {\n        bitmap = decodeBitmap(false, gridWidth, gridHeight, template, false,\n          skip, at, decodingContext);\n      }\n      grayScaleBitPlanes[i] = bitmap;\n    }\n    // 6.6.5.2 Rendering the patterns.\n    let mg, ng, bit, patternIndex, patternBitmap, x, y, patternRow, regionRow;\n    for (mg = 0; mg < gridHeight; mg++) {\n      for (ng = 0; ng < gridWidth; ng++) {\n        bit = 0;\n        patternIndex = 0;\n        for (j = bitsPerValue - 1; j >= 0; j--) {\n          bit = grayScaleBitPlanes[j][mg][ng] ^ bit; // Gray decoding\n          patternIndex |= bit << j;\n        }\n        patternBitmap = patterns[patternIndex];\n        x = (gridOffsetX + mg * gridVectorY + ng * gridVectorX) >> 8;\n        y = (gridOffsetY + mg * gridVectorX - ng * gridVectorY) >> 8;\n        // Draw patternBitmap at (x, y).\n        if (x >= 0 && x + patternWidth <= regionWidth && y >= 0 &&\n            y + patternHeight <= regionHeight) {\n          for (i = 0; i < patternHeight; i++) {\n            regionRow = regionBitmap[y + i];\n            patternRow = patternBitmap[i];\n            for (j = 0; j < patternWidth; j++) {\n              regionRow[x + j] |= patternRow[j];\n            }\n          }\n        } else {\n          let regionX, regionY;\n          for (i = 0; i < patternHeight; i++) {\n            regionY = y + i;\n            if (regionY < 0 || regionY >= regionHeight) {\n              continue;\n            }\n            regionRow = regionBitmap[regionY];\n            patternRow = patternBitmap[i];\n            for (j = 0; j < patternWidth; j++) {\n              regionX = x + j;\n              if (regionX >= 0 && regionX < regionWidth) {\n                regionRow[regionX] |= patternRow[j];\n              }\n            }\n          }\n        }\n      }\n    }\n    return regionBitmap;\n  }\n\n  function readSegmentHeader(data, start) {\n    var segmentHeader = {};\n    segmentHeader.number = readUint32(data, start);\n    var flags = data[start + 4];\n    var segmentType = flags & 0x3F;\n    if (!SegmentTypes[segmentType]) {\n      throw new Jbig2Error('invalid segment type: ' + segmentType);\n    }\n    segmentHeader.type = segmentType;\n    segmentHeader.typeName = SegmentTypes[segmentType];\n    segmentHeader.deferredNonRetain = !!(flags & 0x80);\n\n    var pageAssociationFieldSize = !!(flags & 0x40);\n    var referredFlags = data[start + 5];\n    var referredToCount = (referredFlags >> 5) & 7;\n    var retainBits = [referredFlags & 31];\n    var position = start + 6;\n    if (referredFlags === 7) {\n      referredToCount = readUint32(data, position - 1) & 0x1FFFFFFF;\n      position += 3;\n      var bytes = (referredToCount + 7) >> 3;\n      retainBits[0] = data[position++];\n      while (--bytes > 0) {\n        retainBits.push(data[position++]);\n      }\n    } else if (referredFlags === 5 || referredFlags === 6) {\n      throw new Jbig2Error('invalid referred-to flags');\n    }\n\n    segmentHeader.retainBits = retainBits;\n    var referredToSegmentNumberSize = (segmentHeader.number <= 256 ? 1 :\n      (segmentHeader.number <= 65536 ? 2 : 4));\n    var referredTo = [];\n    var i, ii;\n    for (i = 0; i < referredToCount; i++) {\n      var number = (referredToSegmentNumberSize === 1 ? data[position] :\n        (referredToSegmentNumberSize === 2 ? readUint16(data, position) :\n        readUint32(data, position)));\n      referredTo.push(number);\n      position += referredToSegmentNumberSize;\n    }\n    segmentHeader.referredTo = referredTo;\n    if (!pageAssociationFieldSize) {\n      segmentHeader.pageAssociation = data[position++];\n    } else {\n      segmentHeader.pageAssociation = readUint32(data, position);\n      position += 4;\n    }\n    segmentHeader.length = readUint32(data, position);\n    position += 4;\n\n    if (segmentHeader.length === 0xFFFFFFFF) {\n      // 7.2.7 Segment data length, unknown segment length\n      if (segmentType === 38) { // ImmediateGenericRegion\n        var genericRegionInfo = readRegionSegmentInformation(data, position);\n        var genericRegionSegmentFlags = data[position +\n          RegionSegmentInformationFieldLength];\n        var genericRegionMmr = !!(genericRegionSegmentFlags & 1);\n        // searching for the segment end\n        var searchPatternLength = 6;\n        var searchPattern = new Uint8Array(searchPatternLength);\n        if (!genericRegionMmr) {\n          searchPattern[0] = 0xFF;\n          searchPattern[1] = 0xAC;\n        }\n        searchPattern[2] = (genericRegionInfo.height >>> 24) & 0xFF;\n        searchPattern[3] = (genericRegionInfo.height >> 16) & 0xFF;\n        searchPattern[4] = (genericRegionInfo.height >> 8) & 0xFF;\n        searchPattern[5] = genericRegionInfo.height & 0xFF;\n        for (i = position, ii = data.length; i < ii; i++) {\n          var j = 0;\n          while (j < searchPatternLength && searchPattern[j] === data[i + j]) {\n            j++;\n          }\n          if (j === searchPatternLength) {\n            segmentHeader.length = i + searchPatternLength;\n            break;\n          }\n        }\n        if (segmentHeader.length === 0xFFFFFFFF) {\n          throw new Jbig2Error('segment end was not found');\n        }\n      } else {\n        throw new Jbig2Error('invalid unknown segment length');\n      }\n    }\n    segmentHeader.headerEnd = position;\n    return segmentHeader;\n  }\n\n  function readSegments(header, data, start, end) {\n    var segments = [];\n    var position = start;\n    while (position < end) {\n      var segmentHeader = readSegmentHeader(data, position);\n      position = segmentHeader.headerEnd;\n      var segment = {\n        header: segmentHeader,\n        data,\n      };\n      if (!header.randomAccess) {\n        segment.start = position;\n        position += segmentHeader.length;\n        segment.end = position;\n      }\n      segments.push(segment);\n      if (segmentHeader.type === 51) {\n        break; // end of file is found\n      }\n    }\n    if (header.randomAccess) {\n      for (var i = 0, ii = segments.length; i < ii; i++) {\n        segments[i].start = position;\n        position += segments[i].header.length;\n        segments[i].end = position;\n      }\n    }\n    return segments;\n  }\n\n  // 7.4.1 Region segment information field\n  function readRegionSegmentInformation(data, start) {\n    return {\n      width: readUint32(data, start),\n      height: readUint32(data, start + 4),\n      x: readUint32(data, start + 8),\n      y: readUint32(data, start + 12),\n      combinationOperator: data[start + 16] & 7,\n    };\n  }\n  var RegionSegmentInformationFieldLength = 17;\n\n  function processSegment(segment, visitor) {\n    var header = segment.header;\n\n    var data = segment.data, position = segment.start, end = segment.end;\n    var args, at, i, atLength;\n    switch (header.type) {\n      case 0: // SymbolDictionary\n        // 7.4.2 Symbol dictionary segment syntax\n        var dictionary = {};\n        var dictionaryFlags = readUint16(data, position); // 7.4.2.1.1\n        dictionary.huffman = !!(dictionaryFlags & 1);\n        dictionary.refinement = !!(dictionaryFlags & 2);\n        dictionary.huffmanDHSelector = (dictionaryFlags >> 2) & 3;\n        dictionary.huffmanDWSelector = (dictionaryFlags >> 4) & 3;\n        dictionary.bitmapSizeSelector = (dictionaryFlags >> 6) & 1;\n        dictionary.aggregationInstancesSelector = (dictionaryFlags >> 7) & 1;\n        dictionary.bitmapCodingContextUsed = !!(dictionaryFlags & 256);\n        dictionary.bitmapCodingContextRetained = !!(dictionaryFlags & 512);\n        dictionary.template = (dictionaryFlags >> 10) & 3;\n        dictionary.refinementTemplate = (dictionaryFlags >> 12) & 1;\n        position += 2;\n        if (!dictionary.huffman) {\n          atLength = dictionary.template === 0 ? 4 : 1;\n          at = [];\n          for (i = 0; i < atLength; i++) {\n            at.push({\n              x: readInt8(data, position),\n              y: readInt8(data, position + 1),\n            });\n            position += 2;\n          }\n          dictionary.at = at;\n        }\n        if (dictionary.refinement && !dictionary.refinementTemplate) {\n          at = [];\n          for (i = 0; i < 2; i++) {\n            at.push({\n              x: readInt8(data, position),\n              y: readInt8(data, position + 1),\n            });\n            position += 2;\n          }\n          dictionary.refinementAt = at;\n        }\n        dictionary.numberOfExportedSymbols = readUint32(data, position);\n        position += 4;\n        dictionary.numberOfNewSymbols = readUint32(data, position);\n        position += 4;\n        args = [dictionary, header.number, header.referredTo,\n                data, position, end];\n        break;\n      case 6: // ImmediateTextRegion\n      case 7: // ImmediateLosslessTextRegion\n        var textRegion = {};\n        textRegion.info = readRegionSegmentInformation(data, position);\n        position += RegionSegmentInformationFieldLength;\n        var textRegionSegmentFlags = readUint16(data, position);\n        position += 2;\n        textRegion.huffman = !!(textRegionSegmentFlags & 1);\n        textRegion.refinement = !!(textRegionSegmentFlags & 2);\n        textRegion.logStripSize = (textRegionSegmentFlags >> 2) & 3;\n        textRegion.stripSize = 1 << textRegion.logStripSize;\n        textRegion.referenceCorner = (textRegionSegmentFlags >> 4) & 3;\n        textRegion.transposed = !!(textRegionSegmentFlags & 64);\n        textRegion.combinationOperator = (textRegionSegmentFlags >> 7) & 3;\n        textRegion.defaultPixelValue = (textRegionSegmentFlags >> 9) & 1;\n        textRegion.dsOffset = (textRegionSegmentFlags << 17) >> 27;\n        textRegion.refinementTemplate = (textRegionSegmentFlags >> 15) & 1;\n        if (textRegion.huffman) {\n          var textRegionHuffmanFlags = readUint16(data, position);\n          position += 2;\n          textRegion.huffmanFS = (textRegionHuffmanFlags) & 3;\n          textRegion.huffmanDS = (textRegionHuffmanFlags >> 2) & 3;\n          textRegion.huffmanDT = (textRegionHuffmanFlags >> 4) & 3;\n          textRegion.huffmanRefinementDW = (textRegionHuffmanFlags >> 6) & 3;\n          textRegion.huffmanRefinementDH = (textRegionHuffmanFlags >> 8) & 3;\n          textRegion.huffmanRefinementDX = (textRegionHuffmanFlags >> 10) & 3;\n          textRegion.huffmanRefinementDY = (textRegionHuffmanFlags >> 12) & 3;\n          textRegion.huffmanRefinementSizeSelector =\n            !!(textRegionHuffmanFlags & 0x4000);\n        }\n        if (textRegion.refinement && !textRegion.refinementTemplate) {\n          at = [];\n          for (i = 0; i < 2; i++) {\n            at.push({\n              x: readInt8(data, position),\n              y: readInt8(data, position + 1),\n            });\n            position += 2;\n          }\n          textRegion.refinementAt = at;\n        }\n        textRegion.numberOfSymbolInstances = readUint32(data, position);\n        position += 4;\n        args = [textRegion, header.referredTo, data, position, end];\n        break;\n      case 16: // PatternDictionary\n        // 7.4.4. Pattern dictionary segment syntax\n        let patternDictionary = {};\n        let patternDictionaryFlags = data[position++];\n        patternDictionary.mmr = !!(patternDictionaryFlags & 1);\n        patternDictionary.template = (patternDictionaryFlags >> 1) & 3;\n        patternDictionary.patternWidth = data[position++];\n        patternDictionary.patternHeight = data[position++];\n        patternDictionary.maxPatternIndex = readUint32(data, position);\n        position += 4;\n        args = [patternDictionary, header.number, data, position, end];\n        break;\n      case 22: // ImmediateHalftoneRegion\n      case 23: // ImmediateLosslessHalftoneRegion\n        // 7.4.5 Halftone region segment syntax\n        let halftoneRegion = {};\n        halftoneRegion.info = readRegionSegmentInformation(data, position);\n        position += RegionSegmentInformationFieldLength;\n        let halftoneRegionFlags = data[position++];\n        halftoneRegion.mmr = !!(halftoneRegionFlags & 1);\n        halftoneRegion.template = (halftoneRegionFlags >> 1) & 3;\n        halftoneRegion.enableSkip = !!(halftoneRegionFlags & 8);\n        halftoneRegion.combinationOperator = (halftoneRegionFlags >> 4) & 7;\n        halftoneRegion.defaultPixelValue = (halftoneRegionFlags >> 7) & 1;\n        halftoneRegion.gridWidth = readUint32(data, position);\n        position += 4;\n        halftoneRegion.gridHeight = readUint32(data, position);\n        position += 4;\n        halftoneRegion.gridOffsetX = readUint32(data, position) & 0xFFFFFFFF;\n        position += 4;\n        halftoneRegion.gridOffsetY = readUint32(data, position) & 0xFFFFFFFF;\n        position += 4;\n        halftoneRegion.gridVectorX = readUint16(data, position);\n        position += 2;\n        halftoneRegion.gridVectorY = readUint16(data, position);\n        position += 2;\n        args = [halftoneRegion, header.referredTo, data, position, end];\n        break;\n      case 38: // ImmediateGenericRegion\n      case 39: // ImmediateLosslessGenericRegion\n        var genericRegion = {};\n        genericRegion.info = readRegionSegmentInformation(data, position);\n        position += RegionSegmentInformationFieldLength;\n        var genericRegionSegmentFlags = data[position++];\n        genericRegion.mmr = !!(genericRegionSegmentFlags & 1);\n        genericRegion.template = (genericRegionSegmentFlags >> 1) & 3;\n        genericRegion.prediction = !!(genericRegionSegmentFlags & 8);\n        if (!genericRegion.mmr) {\n          atLength = genericRegion.template === 0 ? 4 : 1;\n          at = [];\n          for (i = 0; i < atLength; i++) {\n            at.push({\n              x: readInt8(data, position),\n              y: readInt8(data, position + 1),\n            });\n            position += 2;\n          }\n          genericRegion.at = at;\n        }\n        args = [genericRegion, data, position, end];\n        break;\n      case 48: // PageInformation\n        var pageInfo = {\n          width: readUint32(data, position),\n          height: readUint32(data, position + 4),\n          resolutionX: readUint32(data, position + 8),\n          resolutionY: readUint32(data, position + 12),\n        };\n        if (pageInfo.height === 0xFFFFFFFF) {\n          delete pageInfo.height;\n        }\n        var pageSegmentFlags = data[position + 16];\n        readUint16(data, position + 17); // pageStripingInformation\n        pageInfo.lossless = !!(pageSegmentFlags & 1);\n        pageInfo.refinement = !!(pageSegmentFlags & 2);\n        pageInfo.defaultPixelValue = (pageSegmentFlags >> 2) & 1;\n        pageInfo.combinationOperator = (pageSegmentFlags >> 3) & 3;\n        pageInfo.requiresBuffer = !!(pageSegmentFlags & 32);\n        pageInfo.combinationOperatorOverride = !!(pageSegmentFlags & 64);\n        args = [pageInfo];\n        break;\n      case 49: // EndOfPage\n        break;\n      case 50: // EndOfStripe\n        break;\n      case 51: // EndOfFile\n        break;\n      case 53: // Tables\n        args = [header.number, data, position, end];\n        break;\n      case 62: // 7.4.15 defines 2 extension types which\n               // are comments and can be ignored.\n        break;\n      default:\n        throw new Jbig2Error(`segment type ${header.typeName}(${header.type})` +\n                             ' is not implemented');\n    }\n    var callbackName = 'on' + header.typeName;\n    if (callbackName in visitor) {\n      visitor[callbackName].apply(visitor, args);\n    }\n  }\n\n  function processSegments(segments, visitor) {\n    for (var i = 0, ii = segments.length; i < ii; i++) {\n      processSegment(segments[i], visitor);\n    }\n  }\n\n  function parseJbig2Chunks(chunks) {\n    var visitor = new SimpleSegmentVisitor();\n    for (var i = 0, ii = chunks.length; i < ii; i++) {\n      var chunk = chunks[i];\n      var segments = readSegments({}, chunk.data, chunk.start, chunk.end);\n      processSegments(segments, visitor);\n    }\n    return visitor.buffer;\n  }\n\n  function parseJbig2(data) {\n    let position = 0, end = data.length;\n\n    if (data[position] !== 0x97 || data[position + 1] !== 0x4A ||\n        data[position + 2] !== 0x42 || data[position + 3] !== 0x32 ||\n        data[position + 4] !== 0x0D || data[position + 5] !== 0x0A ||\n        data[position + 6] !== 0x1A || data[position + 7] !== 0x0A) {\n      throw new Jbig2Error('parseJbig2 - invalid header.');\n    }\n\n    let header = Object.create(null);\n    position += 8;\n    const flags = data[position++];\n    header.randomAccess = !(flags & 1);\n    if (!(flags & 2)) {\n      header.numberOfPages = readUint32(data, position);\n      position += 4;\n    }\n\n    let segments = readSegments(header, data, position, end);\n    let visitor = new SimpleSegmentVisitor();\n    processSegments(segments, visitor);\n\n    const { width, height, } = visitor.currentPageInfo;\n    const bitPacked = visitor.buffer;\n    let imgData = new Uint8ClampedArray(width * height);\n    let q = 0, k = 0;\n    for (let i = 0; i < height; i++) {\n      let mask = 0, buffer;\n      for (let j = 0; j < width; j++) {\n        if (!mask) {\n          mask = 128; buffer = bitPacked[k++];\n        }\n        imgData[q++] = (buffer & mask) ? 0 : 255;\n        mask >>= 1;\n      }\n    }\n\n    return { imgData, width, height, };\n  }\n\n  function SimpleSegmentVisitor() {}\n\n  SimpleSegmentVisitor.prototype = {\n    onPageInformation: function SimpleSegmentVisitor_onPageInformation(info) {\n      this.currentPageInfo = info;\n      var rowSize = (info.width + 7) >> 3;\n      var buffer = new Uint8ClampedArray(rowSize * info.height);\n      // The contents of ArrayBuffers are initialized to 0.\n      // Fill the buffer with 0xFF only if info.defaultPixelValue is set\n      if (info.defaultPixelValue) {\n        for (var i = 0, ii = buffer.length; i < ii; i++) {\n          buffer[i] = 0xFF;\n        }\n      }\n      this.buffer = buffer;\n    },\n    drawBitmap: function SimpleSegmentVisitor_drawBitmap(regionInfo, bitmap) {\n      var pageInfo = this.currentPageInfo;\n      var width = regionInfo.width, height = regionInfo.height;\n      var rowSize = (pageInfo.width + 7) >> 3;\n      var combinationOperator = pageInfo.combinationOperatorOverride ?\n        regionInfo.combinationOperator : pageInfo.combinationOperator;\n      var buffer = this.buffer;\n      var mask0 = 128 >> (regionInfo.x & 7);\n      var offset0 = regionInfo.y * rowSize + (regionInfo.x >> 3);\n      var i, j, mask, offset;\n      switch (combinationOperator) {\n        case 0: // OR\n          for (i = 0; i < height; i++) {\n            mask = mask0;\n            offset = offset0;\n            for (j = 0; j < width; j++) {\n              if (bitmap[i][j]) {\n                buffer[offset] |= mask;\n              }\n              mask >>= 1;\n              if (!mask) {\n                mask = 128;\n                offset++;\n              }\n            }\n            offset0 += rowSize;\n          }\n        break;\n        case 2: // XOR\n          for (i = 0; i < height; i++) {\n            mask = mask0;\n            offset = offset0;\n            for (j = 0; j < width; j++) {\n              if (bitmap[i][j]) {\n                buffer[offset] ^= mask;\n              }\n              mask >>= 1;\n              if (!mask) {\n                mask = 128;\n                offset++;\n              }\n            }\n            offset0 += rowSize;\n          }\n          break;\n        default:\n          throw new Jbig2Error(\n            `operator ${combinationOperator} is not supported`);\n      }\n    },\n    onImmediateGenericRegion:\n      function SimpleSegmentVisitor_onImmediateGenericRegion(region, data,\n                                                             start, end) {\n      var regionInfo = region.info;\n      var decodingContext = new DecodingContext(data, start, end);\n      var bitmap = decodeBitmap(region.mmr, regionInfo.width, regionInfo.height,\n                                region.template, region.prediction, null,\n                                region.at, decodingContext);\n      this.drawBitmap(regionInfo, bitmap);\n    },\n    onImmediateLosslessGenericRegion:\n      function SimpleSegmentVisitor_onImmediateLosslessGenericRegion() {\n      this.onImmediateGenericRegion.apply(this, arguments);\n    },\n    onSymbolDictionary:\n      function SimpleSegmentVisitor_onSymbolDictionary(dictionary,\n                                                       currentSegment,\n                                                       referredSegments,\n                                                       data, start, end) {\n      let huffmanTables, huffmanInput;\n      if (dictionary.huffman) {\n        huffmanTables = getSymbolDictionaryHuffmanTables(dictionary,\n          referredSegments, this.customTables);\n        huffmanInput = new Reader(data, start, end);\n      }\n\n      // Combines exported symbols from all referred segments\n      var symbols = this.symbols;\n      if (!symbols) {\n        this.symbols = symbols = {};\n      }\n\n      var inputSymbols = [];\n      for (var i = 0, ii = referredSegments.length; i < ii; i++) {\n        let referredSymbols = symbols[referredSegments[i]];\n        // referredSymbols is undefined when we have a reference to a Tables\n        // segment instead of a SymbolDictionary.\n        if (referredSymbols) {\n          inputSymbols = inputSymbols.concat(referredSymbols);\n        }\n      }\n\n      var decodingContext = new DecodingContext(data, start, end);\n      symbols[currentSegment] = decodeSymbolDictionary(dictionary.huffman,\n        dictionary.refinement, inputSymbols, dictionary.numberOfNewSymbols,\n        dictionary.numberOfExportedSymbols, huffmanTables,\n        dictionary.template, dictionary.at,\n        dictionary.refinementTemplate, dictionary.refinementAt,\n        decodingContext, huffmanInput);\n    },\n    onImmediateTextRegion:\n      function SimpleSegmentVisitor_onImmediateTextRegion(region,\n                                                          referredSegments,\n                                                          data, start, end) {\n      var regionInfo = region.info;\n      let huffmanTables, huffmanInput;\n\n      // Combines exported symbols from all referred segments\n      var symbols = this.symbols;\n      var inputSymbols = [];\n      for (var i = 0, ii = referredSegments.length; i < ii; i++) {\n        let referredSymbols = symbols[referredSegments[i]];\n        // referredSymbols is undefined when we have a reference to a Tables\n        // segment instead of a SymbolDictionary.\n        if (referredSymbols) {\n          inputSymbols = inputSymbols.concat(referredSymbols);\n        }\n      }\n      var symbolCodeLength = log2(inputSymbols.length);\n      if (region.huffman) {\n        huffmanInput = new Reader(data, start, end);\n        huffmanTables = getTextRegionHuffmanTables(region, referredSegments,\n          this.customTables, inputSymbols.length, huffmanInput);\n      }\n\n      var decodingContext = new DecodingContext(data, start, end);\n      var bitmap = decodeTextRegion(region.huffman, region.refinement,\n        regionInfo.width, regionInfo.height, region.defaultPixelValue,\n        region.numberOfSymbolInstances, region.stripSize, inputSymbols,\n        symbolCodeLength, region.transposed, region.dsOffset,\n        region.referenceCorner, region.combinationOperator, huffmanTables,\n        region.refinementTemplate, region.refinementAt, decodingContext,\n        region.logStripSize, huffmanInput);\n      this.drawBitmap(regionInfo, bitmap);\n    },\n    onImmediateLosslessTextRegion:\n      function SimpleSegmentVisitor_onImmediateLosslessTextRegion() {\n      this.onImmediateTextRegion.apply(this, arguments);\n    },\n    onPatternDictionary(dictionary, currentSegment, data, start, end) {\n      let patterns = this.patterns;\n      if (!patterns) {\n        this.patterns = patterns = {};\n      }\n      let decodingContext = new DecodingContext(data, start, end);\n      patterns[currentSegment] = decodePatternDictionary(dictionary.mmr,\n        dictionary.patternWidth, dictionary.patternHeight,\n        dictionary.maxPatternIndex, dictionary.template, decodingContext);\n    },\n    onImmediateHalftoneRegion(region, referredSegments, data, start, end) {\n      // HalftoneRegion refers to exactly one PatternDictionary.\n      let patterns = this.patterns[referredSegments[0]];\n      let regionInfo = region.info;\n      let decodingContext = new DecodingContext(data, start, end);\n      let bitmap = decodeHalftoneRegion(region.mmr, patterns,\n        region.template, regionInfo.width, regionInfo.height,\n        region.defaultPixelValue, region.enableSkip, region.combinationOperator,\n        region.gridWidth, region.gridHeight, region.gridOffsetX,\n        region.gridOffsetY, region.gridVectorX, region.gridVectorY,\n        decodingContext);\n      this.drawBitmap(regionInfo, bitmap);\n    },\n    onImmediateLosslessHalftoneRegion() {\n      this.onImmediateHalftoneRegion.apply(this, arguments);\n    },\n    onTables(currentSegment, data, start, end) {\n      let customTables = this.customTables;\n      if (!customTables) {\n        this.customTables = customTables = {};\n      }\n      customTables[currentSegment] = decodeTablesSegment(data, start, end);\n    },\n  };\n\n  function HuffmanLine(lineData) {\n    if (lineData.length === 2) {\n      // OOB line.\n      this.isOOB = true;\n      this.rangeLow = 0;\n      this.prefixLength = lineData[0];\n      this.rangeLength = 0;\n      this.prefixCode = lineData[1];\n      this.isLowerRange = false;\n    } else {\n      // Normal, upper range or lower range line.\n      // Upper range lines are processed like normal lines.\n      this.isOOB = false;\n      this.rangeLow = lineData[0];\n      this.prefixLength = lineData[1];\n      this.rangeLength = lineData[2];\n      this.prefixCode = lineData[3];\n      this.isLowerRange = (lineData[4] === 'lower');\n    }\n  }\n\n  function HuffmanTreeNode(line) {\n    this.children = [];\n    if (line) {\n      // Leaf node\n      this.isLeaf = true;\n      this.rangeLength = line.rangeLength;\n      this.rangeLow = line.rangeLow;\n      this.isLowerRange = line.isLowerRange;\n      this.isOOB = line.isOOB;\n    } else {\n      // Intermediate or root node\n      this.isLeaf = false;\n    }\n  }\n\n  HuffmanTreeNode.prototype = {\n    buildTree(line, shift) {\n      let bit = (line.prefixCode >> shift) & 1;\n      if (shift <= 0) {\n        // Create a leaf node.\n        this.children[bit] = new HuffmanTreeNode(line);\n      } else {\n        // Create an intermediate node and continue recursively.\n        let node = this.children[bit];\n        if (!node) {\n          this.children[bit] = node = new HuffmanTreeNode(null);\n        }\n        node.buildTree(line, shift - 1);\n      }\n    },\n    decodeNode(reader) {\n      if (this.isLeaf) {\n        if (this.isOOB) {\n          return null;\n        }\n        let htOffset = reader.readBits(this.rangeLength);\n        return this.rangeLow + (this.isLowerRange ? -htOffset : htOffset);\n      }\n      let node = this.children[reader.readBit()];\n      if (!node) {\n        throw new Jbig2Error('invalid Huffman data');\n      }\n      return node.decodeNode(reader);\n    },\n  };\n\n  function HuffmanTable(lines, prefixCodesDone) {\n    if (!prefixCodesDone) {\n      this.assignPrefixCodes(lines);\n    }\n    // Create Huffman tree.\n    this.rootNode = new HuffmanTreeNode(null);\n    let i, ii = lines.length, line;\n    for (i = 0; i < ii; i++) {\n      line = lines[i];\n      if (line.prefixLength > 0) {\n        this.rootNode.buildTree(line, line.prefixLength - 1);\n      }\n    }\n  }\n\n  HuffmanTable.prototype = {\n    decode(reader) {\n      return this.rootNode.decodeNode(reader);\n    },\n    assignPrefixCodes(lines) {\n      // Annex B.3 Assigning the prefix codes.\n      let linesLength = lines.length, prefixLengthMax = 0, i;\n      for (i = 0; i < linesLength; i++) {\n        prefixLengthMax = Math.max(prefixLengthMax, lines[i].prefixLength);\n      }\n\n      let histogram = new Uint32Array(prefixLengthMax + 1);\n      for (i = 0; i < linesLength; i++) {\n        histogram[lines[i].prefixLength]++;\n      }\n      let currentLength = 1, firstCode = 0, currentCode, currentTemp, line;\n      histogram[0] = 0;\n\n      while (currentLength <= prefixLengthMax) {\n        firstCode = (firstCode + histogram[currentLength - 1]) << 1;\n        currentCode = firstCode;\n        currentTemp = 0;\n        while (currentTemp < linesLength) {\n          line = lines[currentTemp];\n          if (line.prefixLength === currentLength) {\n            line.prefixCode = currentCode;\n            currentCode++;\n          }\n          currentTemp++;\n        }\n        currentLength++;\n      }\n    },\n  };\n\n  function decodeTablesSegment(data, start, end) {\n    // Decodes a Tables segment, i.e., a custom Huffman table.\n    // Annex B.2 Code table structure.\n    let flags = data[start];\n    let lowestValue = readUint32(data, start + 1) & 0xFFFFFFFF;\n    let highestValue = readUint32(data, start + 5) & 0xFFFFFFFF;\n    let reader = new Reader(data, start + 9, end);\n\n    let prefixSizeBits = ((flags >> 1) & 7) + 1;\n    let rangeSizeBits = ((flags >> 4) & 7) + 1;\n    let lines = [];\n    let prefixLength, rangeLength, currentRangeLow = lowestValue;\n\n    // Normal table lines\n    do {\n      prefixLength = reader.readBits(prefixSizeBits);\n      rangeLength = reader.readBits(rangeSizeBits);\n      lines.push(new HuffmanLine(\n        [currentRangeLow, prefixLength, rangeLength, 0]));\n      currentRangeLow += 1 << rangeLength;\n    } while (currentRangeLow < highestValue);\n\n    // Lower range table line\n    prefixLength = reader.readBits(prefixSizeBits);\n    lines.push(\n      new HuffmanLine([lowestValue - 1, prefixLength, 32, 0, 'lower']));\n\n    // Upper range table line\n    prefixLength = reader.readBits(prefixSizeBits);\n    lines.push(new HuffmanLine([highestValue, prefixLength, 32, 0]));\n\n    if (flags & 1) {\n      // Out-of-band table line\n      prefixLength = reader.readBits(prefixSizeBits);\n      lines.push(new HuffmanLine([prefixLength, 0]));\n    }\n\n    return new HuffmanTable(lines, false);\n  }\n\n  let standardTablesCache = {};\n\n  function getStandardTable(number) {\n    // Annex B.5 Standard Huffman tables.\n    let table = standardTablesCache[number];\n    if (table) {\n      return table;\n    }\n    let lines;\n    switch (number) {\n      case 1:\n        lines = [\n          [0, 1, 4, 0x0],\n          [16, 2, 8, 0x2],\n          [272, 3, 16, 0x6],\n          [65808, 3, 32, 0x7] // upper\n        ];\n        break;\n      case 2:\n        lines = [\n          [0, 1, 0, 0x0],\n          [1, 2, 0, 0x2],\n          [2, 3, 0, 0x6],\n          [3, 4, 3, 0xE],\n          [11, 5, 6, 0x1E],\n          [75, 6, 32, 0x3E], // upper\n          [6, 0x3F] // OOB\n        ];\n        break;\n      case 3:\n        lines = [\n          [-256, 8, 8, 0xFE],\n          [0, 1, 0, 0x0],\n          [1, 2, 0, 0x2],\n          [2, 3, 0, 0x6],\n          [3, 4, 3, 0xE],\n          [11, 5, 6, 0x1E],\n          [-257, 8, 32, 0xFF, 'lower'],\n          [75, 7, 32, 0x7E], // upper\n          [6, 0x3E] // OOB\n        ];\n        break;\n      case 4:\n        lines = [\n          [1, 1, 0, 0x0],\n          [2, 2, 0, 0x2],\n          [3, 3, 0, 0x6],\n          [4, 4, 3, 0xE],\n          [12, 5, 6, 0x1E],\n          [76, 5, 32, 0x1F] // upper\n        ];\n        break;\n      case 5:\n        lines = [\n          [-255, 7, 8, 0x7E],\n          [1, 1, 0, 0x0],\n          [2, 2, 0, 0x2],\n          [3, 3, 0, 0x6],\n          [4, 4, 3, 0xE],\n          [12, 5, 6, 0x1E],\n          [-256, 7, 32, 0x7F, 'lower'],\n          [76, 6, 32, 0x3E] // upper\n        ];\n        break;\n      case 6:\n        lines = [\n          [-2048, 5, 10, 0x1C],\n          [-1024, 4, 9, 0x8],\n          [-512, 4, 8, 0x9],\n          [-256, 4, 7, 0xA],\n          [-128, 5, 6, 0x1D],\n          [-64, 5, 5, 0x1E],\n          [-32, 4, 5, 0xB],\n          [0, 2, 7, 0x0],\n          [128, 3, 7, 0x2],\n          [256, 3, 8, 0x3],\n          [512, 4, 9, 0xC],\n          [1024, 4, 10, 0xD],\n          [-2049, 6, 32, 0x3E, 'lower'],\n          [2048, 6, 32, 0x3F] // upper\n        ];\n        break;\n      case 7:\n        lines = [\n          [-1024, 4, 9, 0x8],\n          [-512, 3, 8, 0x0],\n          [-256, 4, 7, 0x9],\n          [-128, 5, 6, 0x1A],\n          [-64, 5, 5, 0x1B],\n          [-32, 4, 5, 0xA],\n          [0, 4, 5, 0xB],\n          [32, 5, 5, 0x1C],\n          [64, 5, 6, 0x1D],\n          [128, 4, 7, 0xC],\n          [256, 3, 8, 0x1],\n          [512, 3, 9, 0x2],\n          [1024, 3, 10, 0x3],\n          [-1025, 5, 32, 0x1E, 'lower'],\n          [2048, 5, 32, 0x1F] // upper\n        ];\n        break;\n      case 8:\n        lines = [\n          [-15, 8, 3, 0xFC],\n          [-7, 9, 1, 0x1FC],\n          [-5, 8, 1, 0xFD],\n          [-3, 9, 0, 0x1FD],\n          [-2, 7, 0, 0x7C],\n          [-1, 4, 0, 0xA],\n          [0, 2, 1, 0x0],\n          [2, 5, 0, 0x1A],\n          [3, 6, 0, 0x3A],\n          [4, 3, 4, 0x4],\n          [20, 6, 1, 0x3B],\n          [22, 4, 4, 0xB],\n          [38, 4, 5, 0xC],\n          [70, 5, 6, 0x1B],\n          [134, 5, 7, 0x1C],\n          [262, 6, 7, 0x3C],\n          [390, 7, 8, 0x7D],\n          [646, 6, 10, 0x3D],\n          [-16, 9, 32, 0x1FE, 'lower'],\n          [1670, 9, 32, 0x1FF], // upper\n          [2, 0x1] // OOB\n        ];\n        break;\n      case 9:\n        lines = [\n          [-31, 8, 4, 0xFC],\n          [-15, 9, 2, 0x1FC],\n          [-11, 8, 2, 0xFD],\n          [-7, 9, 1, 0x1FD],\n          [-5, 7, 1, 0x7C],\n          [-3, 4, 1, 0xA],\n          [-1, 3, 1, 0x2],\n          [1, 3, 1, 0x3],\n          [3, 5, 1, 0x1A],\n          [5, 6, 1, 0x3A],\n          [7, 3, 5, 0x4],\n          [39, 6, 2, 0x3B],\n          [43, 4, 5, 0xB],\n          [75, 4, 6, 0xC],\n          [139, 5, 7, 0x1B],\n          [267, 5, 8, 0x1C],\n          [523, 6, 8, 0x3C],\n          [779, 7, 9, 0x7D],\n          [1291, 6, 11, 0x3D],\n          [-32, 9, 32, 0x1FE, 'lower'],\n          [3339, 9, 32, 0x1FF], // upper\n          [2, 0x0] // OOB\n        ];\n        break;\n      case 10:\n        lines = [\n          [-21, 7, 4, 0x7A],\n          [-5, 8, 0, 0xFC],\n          [-4, 7, 0, 0x7B],\n          [-3, 5, 0, 0x18],\n          [-2, 2, 2, 0x0],\n          [2, 5, 0, 0x19],\n          [3, 6, 0, 0x36],\n          [4, 7, 0, 0x7C],\n          [5, 8, 0, 0xFD],\n          [6, 2, 6, 0x1],\n          [70, 5, 5, 0x1A],\n          [102, 6, 5, 0x37],\n          [134, 6, 6, 0x38],\n          [198, 6, 7, 0x39],\n          [326, 6, 8, 0x3A],\n          [582, 6, 9, 0x3B],\n          [1094, 6, 10, 0x3C],\n          [2118, 7, 11, 0x7D],\n          [-22, 8, 32, 0xFE, 'lower'],\n          [4166, 8, 32, 0xFF], // upper\n          [2, 0x2] // OOB\n        ];\n        break;\n      case 11:\n        lines = [\n          [1, 1, 0, 0x0],\n          [2, 2, 1, 0x2],\n          [4, 4, 0, 0xC],\n          [5, 4, 1, 0xD],\n          [7, 5, 1, 0x1C],\n          [9, 5, 2, 0x1D],\n          [13, 6, 2, 0x3C],\n          [17, 7, 2, 0x7A],\n          [21, 7, 3, 0x7B],\n          [29, 7, 4, 0x7C],\n          [45, 7, 5, 0x7D],\n          [77, 7, 6, 0x7E],\n          [141, 7, 32, 0x7F] // upper\n        ];\n        break;\n      case 12:\n        lines = [\n          [1, 1, 0, 0x0],\n          [2, 2, 0, 0x2],\n          [3, 3, 1, 0x6],\n          [5, 5, 0, 0x1C],\n          [6, 5, 1, 0x1D],\n          [8, 6, 1, 0x3C],\n          [10, 7, 0, 0x7A],\n          [11, 7, 1, 0x7B],\n          [13, 7, 2, 0x7C],\n          [17, 7, 3, 0x7D],\n          [25, 7, 4, 0x7E],\n          [41, 8, 5, 0xFE],\n          [73, 8, 32, 0xFF] // upper\n        ];\n        break;\n      case 13:\n        lines = [\n          [1, 1, 0, 0x0],\n          [2, 3, 0, 0x4],\n          [3, 4, 0, 0xC],\n          [4, 5, 0, 0x1C],\n          [5, 4, 1, 0xD],\n          [7, 3, 3, 0x5],\n          [15, 6, 1, 0x3A],\n          [17, 6, 2, 0x3B],\n          [21, 6, 3, 0x3C],\n          [29, 6, 4, 0x3D],\n          [45, 6, 5, 0x3E],\n          [77, 7, 6, 0x7E],\n          [141, 7, 32, 0x7F] // upper\n        ];\n        break;\n      case 14:\n        lines = [\n          [-2, 3, 0, 0x4],\n          [-1, 3, 0, 0x5],\n          [0, 1, 0, 0x0],\n          [1, 3, 0, 0x6],\n          [2, 3, 0, 0x7]\n        ];\n        break;\n      case 15:\n        lines = [\n          [-24, 7, 4, 0x7C],\n          [-8, 6, 2, 0x3C],\n          [-4, 5, 1, 0x1C],\n          [-2, 4, 0, 0xC],\n          [-1, 3, 0, 0x4],\n          [0, 1, 0, 0x0],\n          [1, 3, 0, 0x5],\n          [2, 4, 0, 0xD],\n          [3, 5, 1, 0x1D],\n          [5, 6, 2, 0x3D],\n          [9, 7, 4, 0x7D],\n          [-25, 7, 32, 0x7E, 'lower'],\n          [25, 7, 32, 0x7F] // upper\n        ];\n        break;\n      default:\n        throw new Jbig2Error(`standard table B.${number} does not exist`);\n    }\n\n    let length = lines.length, i;\n    for (i = 0; i < length; i++) {\n      lines[i] = new HuffmanLine(lines[i]);\n    }\n    table = new HuffmanTable(lines, true);\n    standardTablesCache[number] = table;\n    return table;\n  }\n\n  function Reader(data, start, end) {\n    this.data = data;\n    this.start = start;\n    this.end = end;\n    this.position = start;\n    this.shift = -1;\n    this.currentByte = 0;\n  }\n\n  Reader.prototype = {\n    readBit() {\n      if (this.shift < 0) {\n        if (this.position >= this.end) {\n          throw new Jbig2Error('end of data while reading bit');\n        }\n        this.currentByte = this.data[this.position++];\n        this.shift = 7;\n      }\n      let bit = (this.currentByte >> this.shift) & 1;\n      this.shift--;\n      return bit;\n    },\n\n    readBits(numBits) {\n      let result = 0, i;\n      for (i = numBits - 1; i >= 0; i--) {\n        result |= this.readBit() << i;\n      }\n      return result;\n    },\n\n    byteAlign() {\n      this.shift = -1;\n    },\n\n    next() {\n      if (this.position >= this.end) {\n        return -1;\n      }\n      return this.data[this.position++];\n    },\n  };\n\n  function getCustomHuffmanTable(index, referredTo, customTables) {\n    // Returns a Tables segment that has been earlier decoded.\n    // See 7.4.2.1.6 (symbol dictionary) or 7.4.3.1.6 (text region).\n    let currentIndex = 0, i, ii = referredTo.length, table;\n    for (i = 0; i < ii; i++) {\n      table = customTables[referredTo[i]];\n      if (table) {\n        if (index === currentIndex) {\n          return table;\n        }\n        currentIndex++;\n      }\n    }\n    throw new Jbig2Error('can\\'t find custom Huffman table');\n  }\n\n  function getTextRegionHuffmanTables(textRegion, referredTo, customTables,\n                                      numberOfSymbols, reader) {\n    // 7.4.3.1.7 Symbol ID Huffman table decoding\n\n    // Read code lengths for RUNCODEs 0...34.\n    let codes = [], i, codeLength;\n    for (i = 0; i <= 34; i++) {\n      codeLength = reader.readBits(4);\n      codes.push(new HuffmanLine([i, codeLength, 0, 0]));\n    }\n    // Assign Huffman codes for RUNCODEs.\n    let runCodesTable = new HuffmanTable(codes, false);\n\n    // Read a Huffman code using the assignment above.\n    // Interpret the RUNCODE codes and the additional bits (if any).\n    codes.length = 0;\n    for (i = 0; i < numberOfSymbols;) {\n      codeLength = runCodesTable.decode(reader);\n      if (codeLength >= 32) {\n        let repeatedLength, numberOfRepeats, j;\n        switch (codeLength) {\n          case 32:\n            if (i === 0) {\n              throw new Jbig2Error('no previous value in symbol ID table');\n            }\n            numberOfRepeats = reader.readBits(2) + 3;\n            repeatedLength = codes[i - 1].prefixLength;\n            break;\n          case 33:\n            numberOfRepeats = reader.readBits(3) + 3;\n            repeatedLength = 0;\n            break;\n          case 34:\n            numberOfRepeats = reader.readBits(7) + 11;\n            repeatedLength = 0;\n            break;\n          default:\n            throw new Jbig2Error('invalid code length in symbol ID table');\n        }\n        for (j = 0; j < numberOfRepeats; j++) {\n          codes.push(new HuffmanLine([i, repeatedLength, 0, 0]));\n          i++;\n        }\n      } else {\n        codes.push(new HuffmanLine([i, codeLength, 0, 0]));\n        i++;\n      }\n    }\n    reader.byteAlign();\n    let symbolIDTable = new HuffmanTable(codes, false);\n\n    // 7.4.3.1.6 Text region segment Huffman table selection\n\n    let customIndex = 0, tableFirstS, tableDeltaS, tableDeltaT;\n\n    switch (textRegion.huffmanFS) {\n      case 0:\n      case 1:\n        tableFirstS = getStandardTable(textRegion.huffmanFS + 6);\n        break;\n      case 3:\n        tableFirstS = getCustomHuffmanTable(customIndex, referredTo,\n          customTables);\n        customIndex++;\n        break;\n      default:\n        throw new Jbig2Error('invalid Huffman FS selector');\n    }\n\n    switch (textRegion.huffmanDS) {\n      case 0:\n      case 1:\n      case 2:\n        tableDeltaS = getStandardTable(textRegion.huffmanDS + 8);\n        break;\n      case 3:\n        tableDeltaS = getCustomHuffmanTable(customIndex, referredTo,\n          customTables);\n        customIndex++;\n        break;\n      default:\n        throw new Jbig2Error('invalid Huffman DS selector');\n    }\n\n    switch (textRegion.huffmanDT) {\n      case 0:\n      case 1:\n      case 2:\n        tableDeltaT = getStandardTable(textRegion.huffmanDT + 11);\n        break;\n      case 3:\n        tableDeltaT = getCustomHuffmanTable(customIndex, referredTo,\n          customTables);\n        customIndex++;\n        break;\n      default:\n        throw new Jbig2Error('invalid Huffman DT selector');\n    }\n\n    if (textRegion.refinement) {\n      // Load tables RDW, RDH, RDX and RDY.\n      throw new Jbig2Error('refinement with Huffman is not supported');\n    }\n\n    return {\n      symbolIDTable,\n      tableFirstS,\n      tableDeltaS,\n      tableDeltaT,\n    };\n  }\n\n  function getSymbolDictionaryHuffmanTables(dictionary, referredTo,\n                                            customTables) {\n    // 7.4.2.1.6 Symbol dictionary segment Huffman table selection\n\n    let customIndex = 0, tableDeltaHeight, tableDeltaWidth;\n    switch (dictionary.huffmanDHSelector) {\n      case 0:\n      case 1:\n        tableDeltaHeight = getStandardTable(dictionary.huffmanDHSelector + 4);\n        break;\n      case 3:\n        tableDeltaHeight = getCustomHuffmanTable(customIndex, referredTo,\n          customTables);\n        customIndex++;\n        break;\n      default:\n        throw new Jbig2Error('invalid Huffman DH selector');\n    }\n\n    switch (dictionary.huffmanDWSelector) {\n      case 0:\n      case 1:\n        tableDeltaWidth = getStandardTable(dictionary.huffmanDWSelector + 2);\n        break;\n      case 3:\n        tableDeltaWidth = getCustomHuffmanTable(customIndex, referredTo,\n          customTables);\n        customIndex++;\n        break;\n      default:\n        throw new Jbig2Error('invalid Huffman DW selector');\n    }\n\n    let tableBitmapSize, tableAggregateInstances;\n    if (dictionary.bitmapSizeSelector) {\n      tableBitmapSize = getCustomHuffmanTable(customIndex, referredTo,\n        customTables);\n      customIndex++;\n    } else {\n      tableBitmapSize = getStandardTable(1);\n    }\n\n    if (dictionary.aggregationInstancesSelector) {\n      tableAggregateInstances = getCustomHuffmanTable(customIndex, referredTo,\n        customTables);\n    } else {\n      tableAggregateInstances = getStandardTable(1);\n    }\n\n    return {\n      tableDeltaHeight,\n      tableDeltaWidth,\n      tableBitmapSize,\n      tableAggregateInstances,\n    };\n  }\n\n  function readUncompressedBitmap(reader, width, height) {\n    let bitmap = [], x, y, row;\n    for (y = 0; y < height; y++) {\n      row = new Uint8Array(width);\n      bitmap.push(row);\n      for (x = 0; x < width; x++) {\n        row[x] = reader.readBit();\n      }\n      reader.byteAlign();\n    }\n    return bitmap;\n  }\n\n  function decodeMMRBitmap(input, width, height, endOfBlock) {\n    // MMR is the same compression algorithm as the PDF filter\n    // CCITTFaxDecode with /K -1.\n    let params = {\n      K: -1,\n      Columns: width,\n      Rows: height,\n      BlackIs1: true,\n      EndOfBlock: endOfBlock,\n    };\n    let decoder = new CCITTFaxDecoder(input, params);\n    let bitmap = [], x, y, row, currentByte, shift, eof = false;\n\n    for (y = 0; y < height; y++) {\n      row = new Uint8Array(width);\n      bitmap.push(row);\n      shift = -1;\n      for (x = 0; x < width; x++) {\n        if (shift < 0) {\n          currentByte = decoder.readNextChar();\n          if (currentByte === -1) {\n            // Set the rest of the bits to zero.\n            currentByte = 0;\n            eof = true;\n          }\n          shift = 7;\n        }\n        row[x] = (currentByte >> shift) & 1;\n        shift--;\n      }\n    }\n\n    if (endOfBlock && !eof) {\n      // Read until EOFB has been consumed.\n      const lookForEOFLimit = 5;\n      for (let i = 0; i < lookForEOFLimit; i++) {\n        if (decoder.readNextChar() === -1) {\n          break;\n        }\n      }\n    }\n\n    return bitmap;\n  }\n\n  function Jbig2Image() {}\n\n  Jbig2Image.prototype = {\n    parseChunks(chunks) {\n      return parseJbig2Chunks(chunks);\n    },\n\n    parse(data) {\n      const { imgData, width, height, } = parseJbig2(data);\n      this.width = width;\n      this.height = height;\n      return imgData;\n    },\n  };\n\n  return Jbig2Image;\n})();\n\nexport {\n  Jbig2Image,\n};\n","/* Copyright 2012 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/* This class implements the QM Coder decoding as defined in\n *   JPEG 2000 Part I Final Committee Draft Version 1.0\n *   Annex C.3 Arithmetic decoding procedure\n * available at http://www.jpeg.org/public/fcd15444-1.pdf\n *\n * The arithmetic decoder is used in conjunction with context models to decode\n * JPEG2000 and JBIG2 streams.\n */\nvar ArithmeticDecoder = (function ArithmeticDecoderClosure() {\n  // Table C-2\n  var QeTable = [\n    { qe: 0x5601, nmps: 1, nlps: 1, switchFlag: 1, },\n    { qe: 0x3401, nmps: 2, nlps: 6, switchFlag: 0, },\n    { qe: 0x1801, nmps: 3, nlps: 9, switchFlag: 0, },\n    { qe: 0x0AC1, nmps: 4, nlps: 12, switchFlag: 0, },\n    { qe: 0x0521, nmps: 5, nlps: 29, switchFlag: 0, },\n    { qe: 0x0221, nmps: 38, nlps: 33, switchFlag: 0, },\n    { qe: 0x5601, nmps: 7, nlps: 6, switchFlag: 1, },\n    { qe: 0x5401, nmps: 8, nlps: 14, switchFlag: 0, },\n    { qe: 0x4801, nmps: 9, nlps: 14, switchFlag: 0, },\n    { qe: 0x3801, nmps: 10, nlps: 14, switchFlag: 0, },\n    { qe: 0x3001, nmps: 11, nlps: 17, switchFlag: 0, },\n    { qe: 0x2401, nmps: 12, nlps: 18, switchFlag: 0, },\n    { qe: 0x1C01, nmps: 13, nlps: 20, switchFlag: 0, },\n    { qe: 0x1601, nmps: 29, nlps: 21, switchFlag: 0, },\n    { qe: 0x5601, nmps: 15, nlps: 14, switchFlag: 1, },\n    { qe: 0x5401, nmps: 16, nlps: 14, switchFlag: 0, },\n    { qe: 0x5101, nmps: 17, nlps: 15, switchFlag: 0, },\n    { qe: 0x4801, nmps: 18, nlps: 16, switchFlag: 0, },\n    { qe: 0x3801, nmps: 19, nlps: 17, switchFlag: 0, },\n    { qe: 0x3401, nmps: 20, nlps: 18, switchFlag: 0, },\n    { qe: 0x3001, nmps: 21, nlps: 19, switchFlag: 0, },\n    { qe: 0x2801, nmps: 22, nlps: 19, switchFlag: 0, },\n    { qe: 0x2401, nmps: 23, nlps: 20, switchFlag: 0, },\n    { qe: 0x2201, nmps: 24, nlps: 21, switchFlag: 0, },\n    { qe: 0x1C01, nmps: 25, nlps: 22, switchFlag: 0, },\n    { qe: 0x1801, nmps: 26, nlps: 23, switchFlag: 0, },\n    { qe: 0x1601, nmps: 27, nlps: 24, switchFlag: 0, },\n    { qe: 0x1401, nmps: 28, nlps: 25, switchFlag: 0, },\n    { qe: 0x1201, nmps: 29, nlps: 26, switchFlag: 0, },\n    { qe: 0x1101, nmps: 30, nlps: 27, switchFlag: 0, },\n    { qe: 0x0AC1, nmps: 31, nlps: 28, switchFlag: 0, },\n    { qe: 0x09C1, nmps: 32, nlps: 29, switchFlag: 0, },\n    { qe: 0x08A1, nmps: 33, nlps: 30, switchFlag: 0, },\n    { qe: 0x0521, nmps: 34, nlps: 31, switchFlag: 0, },\n    { qe: 0x0441, nmps: 35, nlps: 32, switchFlag: 0, },\n    { qe: 0x02A1, nmps: 36, nlps: 33, switchFlag: 0, },\n    { qe: 0x0221, nmps: 37, nlps: 34, switchFlag: 0, },\n    { qe: 0x0141, nmps: 38, nlps: 35, switchFlag: 0, },\n    { qe: 0x0111, nmps: 39, nlps: 36, switchFlag: 0, },\n    { qe: 0x0085, nmps: 40, nlps: 37, switchFlag: 0, },\n    { qe: 0x0049, nmps: 41, nlps: 38, switchFlag: 0, },\n    { qe: 0x0025, nmps: 42, nlps: 39, switchFlag: 0, },\n    { qe: 0x0015, nmps: 43, nlps: 40, switchFlag: 0, },\n    { qe: 0x0009, nmps: 44, nlps: 41, switchFlag: 0, },\n    { qe: 0x0005, nmps: 45, nlps: 42, switchFlag: 0, },\n    { qe: 0x0001, nmps: 45, nlps: 43, switchFlag: 0, },\n    { qe: 0x5601, nmps: 46, nlps: 46, switchFlag: 0, }\n  ];\n\n  // C.3.5 Initialisation of the decoder (INITDEC)\n  function ArithmeticDecoder(data, start, end) {\n    this.data = data;\n    this.bp = start;\n    this.dataEnd = end;\n\n    this.chigh = data[start];\n    this.clow = 0;\n\n    this.byteIn();\n\n    this.chigh = ((this.chigh << 7) & 0xFFFF) | ((this.clow >> 9) & 0x7F);\n    this.clow = (this.clow << 7) & 0xFFFF;\n    this.ct -= 7;\n    this.a = 0x8000;\n  }\n\n  ArithmeticDecoder.prototype = {\n    // C.3.4 Compressed data input (BYTEIN)\n    byteIn: function ArithmeticDecoder_byteIn() {\n      var data = this.data;\n      var bp = this.bp;\n      if (data[bp] === 0xFF) {\n        var b1 = data[bp + 1];\n        if (b1 > 0x8F) {\n          this.clow += 0xFF00;\n          this.ct = 8;\n        } else {\n          bp++;\n          this.clow += (data[bp] << 9);\n          this.ct = 7;\n          this.bp = bp;\n        }\n      } else {\n        bp++;\n        this.clow += bp < this.dataEnd ? (data[bp] << 8) : 0xFF00;\n        this.ct = 8;\n        this.bp = bp;\n      }\n      if (this.clow > 0xFFFF) {\n        this.chigh += (this.clow >> 16);\n        this.clow &= 0xFFFF;\n      }\n    },\n    // C.3.2 Decoding a decision (DECODE)\n    readBit: function ArithmeticDecoder_readBit(contexts, pos) {\n      // contexts are packed into 1 byte:\n      // highest 7 bits carry cx.index, lowest bit carries cx.mps\n      var cx_index = contexts[pos] >> 1, cx_mps = contexts[pos] & 1;\n      var qeTableIcx = QeTable[cx_index];\n      var qeIcx = qeTableIcx.qe;\n      var d;\n      var a = this.a - qeIcx;\n\n      if (this.chigh < qeIcx) {\n        // exchangeLps\n        if (a < qeIcx) {\n          a = qeIcx;\n          d = cx_mps;\n          cx_index = qeTableIcx.nmps;\n        } else {\n          a = qeIcx;\n          d = 1 ^ cx_mps;\n          if (qeTableIcx.switchFlag === 1) {\n            cx_mps = d;\n          }\n          cx_index = qeTableIcx.nlps;\n        }\n      } else {\n        this.chigh -= qeIcx;\n        if ((a & 0x8000) !== 0) {\n          this.a = a;\n          return cx_mps;\n        }\n        // exchangeMps\n        if (a < qeIcx) {\n          d = 1 ^ cx_mps;\n          if (qeTableIcx.switchFlag === 1) {\n            cx_mps = d;\n          }\n          cx_index = qeTableIcx.nlps;\n        } else {\n          d = cx_mps;\n          cx_index = qeTableIcx.nmps;\n        }\n      }\n      // C.3.3 renormD;\n      do {\n        if (this.ct === 0) {\n          this.byteIn();\n        }\n\n        a <<= 1;\n        this.chigh = ((this.chigh << 1) & 0xFFFF) | ((this.clow >> 15) & 1);\n        this.clow = (this.clow << 1) & 0xFFFF;\n        this.ct--;\n      } while ((a & 0x8000) === 0);\n      this.a = a;\n\n      contexts[pos] = cx_index << 1 | cx_mps;\n      return d;\n    },\n  };\n\n  return ArithmeticDecoder;\n})();\n\nexport {\n  ArithmeticDecoder,\n};\n","/* Copyright 2012 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/* Copyright 1996-2003 Glyph & Cog, LLC\n *\n * The CCITT stream implementation contained in this file is a JavaScript port\n * of XPDF's implementation, made available under the Apache 2.0 open source\n * license.\n */\n\n/**\n * @typedef {Object} CCITTFaxDecoderSource\n * @property {function} next - Method that return one byte of data for decoding,\n *   or -1 when EOF is reached.\n */\n\nimport { info } from '../shared/util';\n\nlet CCITTFaxDecoder = (function CCITTFaxDecoder() {\n\n  const ccittEOL = -2;\n  const ccittEOF = -1;\n  const twoDimPass = 0;\n  const twoDimHoriz = 1;\n  const twoDimVert0 = 2;\n  const twoDimVertR1 = 3;\n  const twoDimVertL1 = 4;\n  const twoDimVertR2 = 5;\n  const twoDimVertL2 = 6;\n  const twoDimVertR3 = 7;\n  const twoDimVertL3 = 8;\n\n  const twoDimTable = [\n    [-1, -1], [-1, -1],                   // 000000x\n    [7, twoDimVertL3],                    // 0000010\n    [7, twoDimVertR3],                    // 0000011\n    [6, twoDimVertL2], [6, twoDimVertL2], // 000010x\n    [6, twoDimVertR2], [6, twoDimVertR2], // 000011x\n    [4, twoDimPass], [4, twoDimPass],     // 0001xxx\n    [4, twoDimPass], [4, twoDimPass],\n    [4, twoDimPass], [4, twoDimPass],\n    [4, twoDimPass], [4, twoDimPass],\n    [3, twoDimHoriz], [3, twoDimHoriz],   // 001xxxx\n    [3, twoDimHoriz], [3, twoDimHoriz],\n    [3, twoDimHoriz], [3, twoDimHoriz],\n    [3, twoDimHoriz], [3, twoDimHoriz],\n    [3, twoDimHoriz], [3, twoDimHoriz],\n    [3, twoDimHoriz], [3, twoDimHoriz],\n    [3, twoDimHoriz], [3, twoDimHoriz],\n    [3, twoDimHoriz], [3, twoDimHoriz],\n    [3, twoDimVertL1], [3, twoDimVertL1], // 010xxxx\n    [3, twoDimVertL1], [3, twoDimVertL1],\n    [3, twoDimVertL1], [3, twoDimVertL1],\n    [3, twoDimVertL1], [3, twoDimVertL1],\n    [3, twoDimVertL1], [3, twoDimVertL1],\n    [3, twoDimVertL1], [3, twoDimVertL1],\n    [3, twoDimVertL1], [3, twoDimVertL1],\n    [3, twoDimVertL1], [3, twoDimVertL1],\n    [3, twoDimVertR1], [3, twoDimVertR1], // 011xxxx\n    [3, twoDimVertR1], [3, twoDimVertR1],\n    [3, twoDimVertR1], [3, twoDimVertR1],\n    [3, twoDimVertR1], [3, twoDimVertR1],\n    [3, twoDimVertR1], [3, twoDimVertR1],\n    [3, twoDimVertR1], [3, twoDimVertR1],\n    [3, twoDimVertR1], [3, twoDimVertR1],\n    [3, twoDimVertR1], [3, twoDimVertR1],\n    [1, twoDimVert0], [1, twoDimVert0],   // 1xxxxxx\n    [1, twoDimVert0], [1, twoDimVert0],\n    [1, twoDimVert0], [1, twoDimVert0],\n    [1, twoDimVert0], [1, twoDimVert0],\n    [1, twoDimVert0], [1, twoDimVert0],\n    [1, twoDimVert0], [1, twoDimVert0],\n    [1, twoDimVert0], [1, twoDimVert0],\n    [1, twoDimVert0], [1, twoDimVert0],\n    [1, twoDimVert0], [1, twoDimVert0],\n    [1, twoDimVert0], [1, twoDimVert0],\n    [1, twoDimVert0], [1, twoDimVert0],\n    [1, twoDimVert0], [1, twoDimVert0],\n    [1, twoDimVert0], [1, twoDimVert0],\n    [1, twoDimVert0], [1, twoDimVert0],\n    [1, twoDimVert0], [1, twoDimVert0],\n    [1, twoDimVert0], [1, twoDimVert0],\n    [1, twoDimVert0], [1, twoDimVert0],\n    [1, twoDimVert0], [1, twoDimVert0],\n    [1, twoDimVert0], [1, twoDimVert0],\n    [1, twoDimVert0], [1, twoDimVert0],\n    [1, twoDimVert0], [1, twoDimVert0],\n    [1, twoDimVert0], [1, twoDimVert0],\n    [1, twoDimVert0], [1, twoDimVert0],\n    [1, twoDimVert0], [1, twoDimVert0],\n    [1, twoDimVert0], [1, twoDimVert0],\n    [1, twoDimVert0], [1, twoDimVert0],\n    [1, twoDimVert0], [1, twoDimVert0],\n    [1, twoDimVert0], [1, twoDimVert0],\n    [1, twoDimVert0], [1, twoDimVert0],\n    [1, twoDimVert0], [1, twoDimVert0],\n    [1, twoDimVert0], [1, twoDimVert0],\n    [1, twoDimVert0], [1, twoDimVert0]\n  ];\n\n  const whiteTable1 = [\n    [-1, -1],                               // 00000\n    [12, ccittEOL],                         // 00001\n    [-1, -1], [-1, -1],                     // 0001x\n    [-1, -1], [-1, -1], [-1, -1], [-1, -1], // 001xx\n    [-1, -1], [-1, -1], [-1, -1], [-1, -1], // 010xx\n    [-1, -1], [-1, -1], [-1, -1], [-1, -1], // 011xx\n    [11, 1792], [11, 1792],                 // 1000x\n    [12, 1984],                             // 10010\n    [12, 2048],                             // 10011\n    [12, 2112],                             // 10100\n    [12, 2176],                             // 10101\n    [12, 2240],                             // 10110\n    [12, 2304],                             // 10111\n    [11, 1856], [11, 1856],                 // 1100x\n    [11, 1920], [11, 1920],                 // 1101x\n    [12, 2368],                             // 11100\n    [12, 2432],                             // 11101\n    [12, 2496],                             // 11110\n    [12, 2560]                              // 11111\n  ];\n\n  const whiteTable2 = [\n    [-1, -1], [-1, -1], [-1, -1], [-1, -1],     // 0000000xx\n    [8, 29], [8, 29],                           // 00000010x\n    [8, 30], [8, 30],                           // 00000011x\n    [8, 45], [8, 45],                           // 00000100x\n    [8, 46], [8, 46],                           // 00000101x\n    [7, 22], [7, 22], [7, 22], [7, 22],         // 0000011xx\n    [7, 23], [7, 23], [7, 23], [7, 23],         // 0000100xx\n    [8, 47], [8, 47],                           // 00001010x\n    [8, 48], [8, 48],                           // 00001011x\n    [6, 13], [6, 13], [6, 13], [6, 13],         // 000011xxx\n    [6, 13], [6, 13], [6, 13], [6, 13],\n    [7, 20], [7, 20], [7, 20], [7, 20],         // 0001000xx\n    [8, 33], [8, 33],                           // 00010010x\n    [8, 34], [8, 34],                           // 00010011x\n    [8, 35], [8, 35],                           // 00010100x\n    [8, 36], [8, 36],                           // 00010101x\n    [8, 37], [8, 37],                           // 00010110x\n    [8, 38], [8, 38],                           // 00010111x\n    [7, 19], [7, 19], [7, 19], [7, 19],         // 0001100xx\n    [8, 31], [8, 31],                           // 00011010x\n    [8, 32], [8, 32],                           // 00011011x\n    [6, 1], [6, 1], [6, 1], [6, 1],             // 000111xxx\n    [6, 1], [6, 1], [6, 1], [6, 1],\n    [6, 12], [6, 12], [6, 12], [6, 12],         // 001000xxx\n    [6, 12], [6, 12], [6, 12], [6, 12],\n    [8, 53], [8, 53],                           // 00100100x\n    [8, 54], [8, 54],                           // 00100101x\n    [7, 26], [7, 26], [7, 26], [7, 26],         // 0010011xx\n    [8, 39], [8, 39],                           // 00101000x\n    [8, 40], [8, 40],                           // 00101001x\n    [8, 41], [8, 41],                           // 00101010x\n    [8, 42], [8, 42],                           // 00101011x\n    [8, 43], [8, 43],                           // 00101100x\n    [8, 44], [8, 44],                           // 00101101x\n    [7, 21], [7, 21], [7, 21], [7, 21],         // 0010111xx\n    [7, 28], [7, 28], [7, 28], [7, 28],         // 0011000xx\n    [8, 61], [8, 61],                           // 00110010x\n    [8, 62], [8, 62],                           // 00110011x\n    [8, 63], [8, 63],                           // 00110100x\n    [8, 0], [8, 0],                             // 00110101x\n    [8, 320], [8, 320],                         // 00110110x\n    [8, 384], [8, 384],                         // 00110111x\n    [5, 10], [5, 10], [5, 10], [5, 10],         // 00111xxxx\n    [5, 10], [5, 10], [5, 10], [5, 10],\n    [5, 10], [5, 10], [5, 10], [5, 10],\n    [5, 10], [5, 10], [5, 10], [5, 10],\n    [5, 11], [5, 11], [5, 11], [5, 11],         // 01000xxxx\n    [5, 11], [5, 11], [5, 11], [5, 11],\n    [5, 11], [5, 11], [5, 11], [5, 11],\n    [5, 11], [5, 11], [5, 11], [5, 11],\n    [7, 27], [7, 27], [7, 27], [7, 27],         // 0100100xx\n    [8, 59], [8, 59],                           // 01001010x\n    [8, 60], [8, 60],                           // 01001011x\n    [9, 1472],                                  // 010011000\n    [9, 1536],                                  // 010011001\n    [9, 1600],                                  // 010011010\n    [9, 1728],                                  // 010011011\n    [7, 18], [7, 18], [7, 18], [7, 18],         // 0100111xx\n    [7, 24], [7, 24], [7, 24], [7, 24],         // 0101000xx\n    [8, 49], [8, 49],                           // 01010010x\n    [8, 50], [8, 50],                           // 01010011x\n    [8, 51], [8, 51],                           // 01010100x\n    [8, 52], [8, 52],                           // 01010101x\n    [7, 25], [7, 25], [7, 25], [7, 25],         // 0101011xx\n    [8, 55], [8, 55],                           // 01011000x\n    [8, 56], [8, 56],                           // 01011001x\n    [8, 57], [8, 57],                           // 01011010x\n    [8, 58], [8, 58],                           // 01011011x\n    [6, 192], [6, 192], [6, 192], [6, 192],     // 010111xxx\n    [6, 192], [6, 192], [6, 192], [6, 192],\n    [6, 1664], [6, 1664], [6, 1664], [6, 1664], // 011000xxx\n    [6, 1664], [6, 1664], [6, 1664], [6, 1664],\n    [8, 448], [8, 448],                         // 01100100x\n    [8, 512], [8, 512],                         // 01100101x\n    [9, 704],                                   // 011001100\n    [9, 768],                                   // 011001101\n    [8, 640], [8, 640],                         // 01100111x\n    [8, 576], [8, 576],                         // 01101000x\n    [9, 832],                                   // 011010010\n    [9, 896],                                   // 011010011\n    [9, 960],                                   // 011010100\n    [9, 1024],                                  // 011010101\n    [9, 1088],                                  // 011010110\n    [9, 1152],                                  // 011010111\n    [9, 1216],                                  // 011011000\n    [9, 1280],                                  // 011011001\n    [9, 1344],                                  // 011011010\n    [9, 1408],                                  // 011011011\n    [7, 256], [7, 256], [7, 256], [7, 256],     // 0110111xx\n    [4, 2], [4, 2], [4, 2], [4, 2],             // 0111xxxxx\n    [4, 2], [4, 2], [4, 2], [4, 2],\n    [4, 2], [4, 2], [4, 2], [4, 2],\n    [4, 2], [4, 2], [4, 2], [4, 2],\n    [4, 2], [4, 2], [4, 2], [4, 2],\n    [4, 2], [4, 2], [4, 2], [4, 2],\n    [4, 2], [4, 2], [4, 2], [4, 2],\n    [4, 2], [4, 2], [4, 2], [4, 2],\n    [4, 3], [4, 3], [4, 3], [4, 3],             // 1000xxxxx\n    [4, 3], [4, 3], [4, 3], [4, 3],\n    [4, 3], [4, 3], [4, 3], [4, 3],\n    [4, 3], [4, 3], [4, 3], [4, 3],\n    [4, 3], [4, 3], [4, 3], [4, 3],\n    [4, 3], [4, 3], [4, 3], [4, 3],\n    [4, 3], [4, 3], [4, 3], [4, 3],\n    [4, 3], [4, 3], [4, 3], [4, 3],\n    [5, 128], [5, 128], [5, 128], [5, 128],     // 10010xxxx\n    [5, 128], [5, 128], [5, 128], [5, 128],\n    [5, 128], [5, 128], [5, 128], [5, 128],\n    [5, 128], [5, 128], [5, 128], [5, 128],\n    [5, 8], [5, 8], [5, 8], [5, 8],             // 10011xxxx\n    [5, 8], [5, 8], [5, 8], [5, 8],\n    [5, 8], [5, 8], [5, 8], [5, 8],\n    [5, 8], [5, 8], [5, 8], [5, 8],\n    [5, 9], [5, 9], [5, 9], [5, 9],             // 10100xxxx\n    [5, 9], [5, 9], [5, 9], [5, 9],\n    [5, 9], [5, 9], [5, 9], [5, 9],\n    [5, 9], [5, 9], [5, 9], [5, 9],\n    [6, 16], [6, 16], [6, 16], [6, 16],         // 101010xxx\n    [6, 16], [6, 16], [6, 16], [6, 16],\n    [6, 17], [6, 17], [6, 17], [6, 17],         // 101011xxx\n    [6, 17], [6, 17], [6, 17], [6, 17],\n    [4, 4], [4, 4], [4, 4], [4, 4],             // 1011xxxxx\n    [4, 4], [4, 4], [4, 4], [4, 4],\n    [4, 4], [4, 4], [4, 4], [4, 4],\n    [4, 4], [4, 4], [4, 4], [4, 4],\n    [4, 4], [4, 4], [4, 4], [4, 4],\n    [4, 4], [4, 4], [4, 4], [4, 4],\n    [4, 4], [4, 4], [4, 4], [4, 4],\n    [4, 4], [4, 4], [4, 4], [4, 4],\n    [4, 5], [4, 5], [4, 5], [4, 5],             // 1100xxxxx\n    [4, 5], [4, 5], [4, 5], [4, 5],\n    [4, 5], [4, 5], [4, 5], [4, 5],\n    [4, 5], [4, 5], [4, 5], [4, 5],\n    [4, 5], [4, 5], [4, 5], [4, 5],\n    [4, 5], [4, 5], [4, 5], [4, 5],\n    [4, 5], [4, 5], [4, 5], [4, 5],\n    [4, 5], [4, 5], [4, 5], [4, 5],\n    [6, 14], [6, 14], [6, 14], [6, 14],         // 110100xxx\n    [6, 14], [6, 14], [6, 14], [6, 14],\n    [6, 15], [6, 15], [6, 15], [6, 15],         // 110101xxx\n    [6, 15], [6, 15], [6, 15], [6, 15],\n    [5, 64], [5, 64], [5, 64], [5, 64],         // 11011xxxx\n    [5, 64], [5, 64], [5, 64], [5, 64],\n    [5, 64], [5, 64], [5, 64], [5, 64],\n    [5, 64], [5, 64], [5, 64], [5, 64],\n    [4, 6], [4, 6], [4, 6], [4, 6],             // 1110xxxxx\n    [4, 6], [4, 6], [4, 6], [4, 6],\n    [4, 6], [4, 6], [4, 6], [4, 6],\n    [4, 6], [4, 6], [4, 6], [4, 6],\n    [4, 6], [4, 6], [4, 6], [4, 6],\n    [4, 6], [4, 6], [4, 6], [4, 6],\n    [4, 6], [4, 6], [4, 6], [4, 6],\n    [4, 6], [4, 6], [4, 6], [4, 6],\n    [4, 7], [4, 7], [4, 7], [4, 7],             // 1111xxxxx\n    [4, 7], [4, 7], [4, 7], [4, 7],\n    [4, 7], [4, 7], [4, 7], [4, 7],\n    [4, 7], [4, 7], [4, 7], [4, 7],\n    [4, 7], [4, 7], [4, 7], [4, 7],\n    [4, 7], [4, 7], [4, 7], [4, 7],\n    [4, 7], [4, 7], [4, 7], [4, 7],\n    [4, 7], [4, 7], [4, 7], [4, 7]\n  ];\n\n  const blackTable1 = [\n    [-1, -1], [-1, -1],                             // 000000000000x\n    [12, ccittEOL], [12, ccittEOL],                 // 000000000001x\n    [-1, -1], [-1, -1], [-1, -1], [-1, -1],         // 00000000001xx\n    [-1, -1], [-1, -1], [-1, -1], [-1, -1],         // 00000000010xx\n    [-1, -1], [-1, -1], [-1, -1], [-1, -1],         // 00000000011xx\n    [-1, -1], [-1, -1], [-1, -1], [-1, -1],         // 00000000100xx\n    [-1, -1], [-1, -1], [-1, -1], [-1, -1],         // 00000000101xx\n    [-1, -1], [-1, -1], [-1, -1], [-1, -1],         // 00000000110xx\n    [-1, -1], [-1, -1], [-1, -1], [-1, -1],         // 00000000111xx\n    [11, 1792], [11, 1792], [11, 1792], [11, 1792], // 00000001000xx\n    [12, 1984], [12, 1984],                         // 000000010010x\n    [12, 2048], [12, 2048],                         // 000000010011x\n    [12, 2112], [12, 2112],                         // 000000010100x\n    [12, 2176], [12, 2176],                         // 000000010101x\n    [12, 2240], [12, 2240],                         // 000000010110x\n    [12, 2304], [12, 2304],                         // 000000010111x\n    [11, 1856], [11, 1856], [11, 1856], [11, 1856], // 00000001100xx\n    [11, 1920], [11, 1920], [11, 1920], [11, 1920], // 00000001101xx\n    [12, 2368], [12, 2368],                         // 000000011100x\n    [12, 2432], [12, 2432],                         // 000000011101x\n    [12, 2496], [12, 2496],                         // 000000011110x\n    [12, 2560], [12, 2560],                         // 000000011111x\n    [10, 18], [10, 18], [10, 18], [10, 18],         // 0000001000xxx\n    [10, 18], [10, 18], [10, 18], [10, 18],\n    [12, 52], [12, 52],                             // 000000100100x\n    [13, 640],                                      // 0000001001010\n    [13, 704],                                      // 0000001001011\n    [13, 768],                                      // 0000001001100\n    [13, 832],                                      // 0000001001101\n    [12, 55], [12, 55],                             // 000000100111x\n    [12, 56], [12, 56],                             // 000000101000x\n    [13, 1280],                                     // 0000001010010\n    [13, 1344],                                     // 0000001010011\n    [13, 1408],                                     // 0000001010100\n    [13, 1472],                                     // 0000001010101\n    [12, 59], [12, 59],                             // 000000101011x\n    [12, 60], [12, 60],                             // 000000101100x\n    [13, 1536],                                     // 0000001011010\n    [13, 1600],                                     // 0000001011011\n    [11, 24], [11, 24], [11, 24], [11, 24],         // 00000010111xx\n    [11, 25], [11, 25], [11, 25], [11, 25],         // 00000011000xx\n    [13, 1664],                                     // 0000001100100\n    [13, 1728],                                     // 0000001100101\n    [12, 320], [12, 320],                           // 000000110011x\n    [12, 384], [12, 384],                           // 000000110100x\n    [12, 448], [12, 448],                           // 000000110101x\n    [13, 512],                                      // 0000001101100\n    [13, 576],                                      // 0000001101101\n    [12, 53], [12, 53],                             // 000000110111x\n    [12, 54], [12, 54],                             // 000000111000x\n    [13, 896],                                      // 0000001110010\n    [13, 960],                                      // 0000001110011\n    [13, 1024],                                     // 0000001110100\n    [13, 1088],                                     // 0000001110101\n    [13, 1152],                                     // 0000001110110\n    [13, 1216],                                     // 0000001110111\n    [10, 64], [10, 64], [10, 64], [10, 64],         // 0000001111xxx\n    [10, 64], [10, 64], [10, 64], [10, 64]\n  ];\n\n  const blackTable2 = [\n    [8, 13], [8, 13], [8, 13], [8, 13],     // 00000100xxxx\n    [8, 13], [8, 13], [8, 13], [8, 13],\n    [8, 13], [8, 13], [8, 13], [8, 13],\n    [8, 13], [8, 13], [8, 13], [8, 13],\n    [11, 23], [11, 23],                     // 00000101000x\n    [12, 50],                               // 000001010010\n    [12, 51],                               // 000001010011\n    [12, 44],                               // 000001010100\n    [12, 45],                               // 000001010101\n    [12, 46],                               // 000001010110\n    [12, 47],                               // 000001010111\n    [12, 57],                               // 000001011000\n    [12, 58],                               // 000001011001\n    [12, 61],                               // 000001011010\n    [12, 256],                              // 000001011011\n    [10, 16], [10, 16], [10, 16], [10, 16], // 0000010111xx\n    [10, 17], [10, 17], [10, 17], [10, 17], // 0000011000xx\n    [12, 48],                               // 000001100100\n    [12, 49],                               // 000001100101\n    [12, 62],                               // 000001100110\n    [12, 63],                               // 000001100111\n    [12, 30],                               // 000001101000\n    [12, 31],                               // 000001101001\n    [12, 32],                               // 000001101010\n    [12, 33],                               // 000001101011\n    [12, 40],                               // 000001101100\n    [12, 41],                               // 000001101101\n    [11, 22], [11, 22],                     // 00000110111x\n    [8, 14], [8, 14], [8, 14], [8, 14],     // 00000111xxxx\n    [8, 14], [8, 14], [8, 14], [8, 14],\n    [8, 14], [8, 14], [8, 14], [8, 14],\n    [8, 14], [8, 14], [8, 14], [8, 14],\n    [7, 10], [7, 10], [7, 10], [7, 10],     // 0000100xxxxx\n    [7, 10], [7, 10], [7, 10], [7, 10],\n    [7, 10], [7, 10], [7, 10], [7, 10],\n    [7, 10], [7, 10], [7, 10], [7, 10],\n    [7, 10], [7, 10], [7, 10], [7, 10],\n    [7, 10], [7, 10], [7, 10], [7, 10],\n    [7, 10], [7, 10], [7, 10], [7, 10],\n    [7, 10], [7, 10], [7, 10], [7, 10],\n    [7, 11], [7, 11], [7, 11], [7, 11],     // 0000101xxxxx\n    [7, 11], [7, 11], [7, 11], [7, 11],\n    [7, 11], [7, 11], [7, 11], [7, 11],\n    [7, 11], [7, 11], [7, 11], [7, 11],\n    [7, 11], [7, 11], [7, 11], [7, 11],\n    [7, 11], [7, 11], [7, 11], [7, 11],\n    [7, 11], [7, 11], [7, 11], [7, 11],\n    [7, 11], [7, 11], [7, 11], [7, 11],\n    [9, 15], [9, 15], [9, 15], [9, 15],     // 000011000xxx\n    [9, 15], [9, 15], [9, 15], [9, 15],\n    [12, 128],                              // 000011001000\n    [12, 192],                              // 000011001001\n    [12, 26],                               // 000011001010\n    [12, 27],                               // 000011001011\n    [12, 28],                               // 000011001100\n    [12, 29],                               // 000011001101\n    [11, 19], [11, 19],                     // 00001100111x\n    [11, 20], [11, 20],                     // 00001101000x\n    [12, 34],                               // 000011010010\n    [12, 35],                               // 000011010011\n    [12, 36],                               // 000011010100\n    [12, 37],                               // 000011010101\n    [12, 38],                               // 000011010110\n    [12, 39],                               // 000011010111\n    [11, 21], [11, 21],                     // 00001101100x\n    [12, 42],                               // 000011011010\n    [12, 43],                               // 000011011011\n    [10, 0], [10, 0], [10, 0], [10, 0],     // 0000110111xx\n    [7, 12], [7, 12], [7, 12], [7, 12],     // 0000111xxxxx\n    [7, 12], [7, 12], [7, 12], [7, 12],\n    [7, 12], [7, 12], [7, 12], [7, 12],\n    [7, 12], [7, 12], [7, 12], [7, 12],\n    [7, 12], [7, 12], [7, 12], [7, 12],\n    [7, 12], [7, 12], [7, 12], [7, 12],\n    [7, 12], [7, 12], [7, 12], [7, 12],\n    [7, 12], [7, 12], [7, 12], [7, 12]\n  ];\n\n  const blackTable3 = [\n    [-1, -1], [-1, -1], [-1, -1], [-1, -1], // 0000xx\n    [6, 9],                                 // 000100\n    [6, 8],                                 // 000101\n    [5, 7], [5, 7],                         // 00011x\n    [4, 6], [4, 6], [4, 6], [4, 6],         // 0010xx\n    [4, 5], [4, 5], [4, 5], [4, 5],         // 0011xx\n    [3, 1], [3, 1], [3, 1], [3, 1],         // 010xxx\n    [3, 1], [3, 1], [3, 1], [3, 1],\n    [3, 4], [3, 4], [3, 4], [3, 4],         // 011xxx\n    [3, 4], [3, 4], [3, 4], [3, 4],\n    [2, 3], [2, 3], [2, 3], [2, 3],         // 10xxxx\n    [2, 3], [2, 3], [2, 3], [2, 3],\n    [2, 3], [2, 3], [2, 3], [2, 3],\n    [2, 3], [2, 3], [2, 3], [2, 3],\n    [2, 2], [2, 2], [2, 2], [2, 2],         // 11xxxx\n    [2, 2], [2, 2], [2, 2], [2, 2],\n    [2, 2], [2, 2], [2, 2], [2, 2],\n    [2, 2], [2, 2], [2, 2], [2, 2]\n  ];\n\n  /**\n   * @param {CCITTFaxDecoderSource} source - The data which should be decoded.\n   * @param {Object} options - (optional) Decoding options.\n   */\n  function CCITTFaxDecoder(source, options = {}) {\n    if (!source || typeof source.next !== 'function') {\n      throw new Error('CCITTFaxDecoder - invalid \"source\" parameter.');\n    }\n    this.source = source;\n    this.eof = false;\n\n    this.encoding = options['K'] || 0;\n    this.eoline = options['EndOfLine'] || false;\n    this.byteAlign = options['EncodedByteAlign'] || false;\n    this.columns = options['Columns'] || 1728;\n    this.rows = options['Rows'] || 0;\n    let eoblock = options['EndOfBlock'];\n    if (eoblock === null || eoblock === undefined) {\n      eoblock = true;\n    }\n    this.eoblock = eoblock;\n    this.black = options['BlackIs1'] || false;\n\n    this.codingLine = new Uint32Array(this.columns + 1);\n    this.refLine = new Uint32Array(this.columns + 2);\n\n    this.codingLine[0] = this.columns;\n    this.codingPos = 0;\n\n    this.row = 0;\n    this.nextLine2D = this.encoding < 0;\n    this.inputBits = 0;\n    this.inputBuf = 0;\n    this.outputBits = 0;\n    this.rowsDone = false;\n\n    let code1;\n    while ((code1 = this._lookBits(12)) === 0) {\n      this._eatBits(1);\n    }\n    if (code1 === 1) {\n      this._eatBits(12);\n    }\n    if (this.encoding > 0) {\n      this.nextLine2D = !this._lookBits(1);\n      this._eatBits(1);\n    }\n  }\n\n  CCITTFaxDecoder.prototype = {\n    readNextChar() {\n      if (this.eof) {\n        return -1;\n      }\n      let refLine = this.refLine;\n      let codingLine = this.codingLine;\n      let columns = this.columns;\n\n      let refPos, blackPixels, bits, i;\n\n      if (this.outputBits === 0) {\n        if (this.rowsDone) {\n          this.eof = true;\n        }\n        if (this.eof) {\n          return -1;\n        }\n        this.err = false;\n\n        let code1, code2, code3;\n        if (this.nextLine2D) {\n          for (i = 0; codingLine[i] < columns; ++i) {\n            refLine[i] = codingLine[i];\n          }\n          refLine[i++] = columns;\n          refLine[i] = columns;\n          codingLine[0] = 0;\n          this.codingPos = 0;\n          refPos = 0;\n          blackPixels = 0;\n\n          while (codingLine[this.codingPos] < columns) {\n            code1 = this._getTwoDimCode();\n            switch (code1) {\n              case twoDimPass:\n                this._addPixels(refLine[refPos + 1], blackPixels);\n                if (refLine[refPos + 1] < columns) {\n                  refPos += 2;\n                }\n                break;\n              case twoDimHoriz:\n                code1 = code2 = 0;\n                if (blackPixels) {\n                  do {\n                    code1 += (code3 = this._getBlackCode());\n                  } while (code3 >= 64);\n                  do {\n                    code2 += (code3 = this._getWhiteCode());\n                  } while (code3 >= 64);\n                } else {\n                  do {\n                    code1 += (code3 = this._getWhiteCode());\n                  } while (code3 >= 64);\n                  do {\n                    code2 += (code3 = this._getBlackCode());\n                  } while (code3 >= 64);\n                }\n                this._addPixels(codingLine[this.codingPos] +\n                               code1, blackPixels);\n                if (codingLine[this.codingPos] < columns) {\n                  this._addPixels(codingLine[this.codingPos] + code2,\n                                 blackPixels ^ 1);\n                }\n                while (refLine[refPos] <= codingLine[this.codingPos] &&\n                       refLine[refPos] < columns) {\n                  refPos += 2;\n                }\n                break;\n              case twoDimVertR3:\n                this._addPixels(refLine[refPos] + 3, blackPixels);\n                blackPixels ^= 1;\n                if (codingLine[this.codingPos] < columns) {\n                  ++refPos;\n                  while (refLine[refPos] <= codingLine[this.codingPos] &&\n                         refLine[refPos] < columns) {\n                    refPos += 2;\n                  }\n                }\n                break;\n              case twoDimVertR2:\n                this._addPixels(refLine[refPos] + 2, blackPixels);\n                blackPixels ^= 1;\n                if (codingLine[this.codingPos] < columns) {\n                  ++refPos;\n                  while (refLine[refPos] <= codingLine[this.codingPos] &&\n                         refLine[refPos] < columns) {\n                    refPos += 2;\n                  }\n                }\n                break;\n              case twoDimVertR1:\n                this._addPixels(refLine[refPos] + 1, blackPixels);\n                blackPixels ^= 1;\n                if (codingLine[this.codingPos] < columns) {\n                  ++refPos;\n                  while (refLine[refPos] <= codingLine[this.codingPos] &&\n                         refLine[refPos] < columns) {\n                    refPos += 2;\n                  }\n                }\n                break;\n              case twoDimVert0:\n                this._addPixels(refLine[refPos], blackPixels);\n                blackPixels ^= 1;\n                if (codingLine[this.codingPos] < columns) {\n                  ++refPos;\n                  while (refLine[refPos] <= codingLine[this.codingPos] &&\n                         refLine[refPos] < columns) {\n                    refPos += 2;\n                  }\n                }\n                break;\n              case twoDimVertL3:\n                this._addPixelsNeg(refLine[refPos] - 3, blackPixels);\n                blackPixels ^= 1;\n                if (codingLine[this.codingPos] < columns) {\n                  if (refPos > 0) {\n                    --refPos;\n                  } else {\n                    ++refPos;\n                  }\n                  while (refLine[refPos] <= codingLine[this.codingPos] &&\n                         refLine[refPos] < columns) {\n                    refPos += 2;\n                  }\n                }\n                break;\n              case twoDimVertL2:\n                this._addPixelsNeg(refLine[refPos] - 2, blackPixels);\n                blackPixels ^= 1;\n                if (codingLine[this.codingPos] < columns) {\n                  if (refPos > 0) {\n                    --refPos;\n                  } else {\n                    ++refPos;\n                  }\n                  while (refLine[refPos] <= codingLine[this.codingPos] &&\n                         refLine[refPos] < columns) {\n                    refPos += 2;\n                  }\n                }\n                break;\n              case twoDimVertL1:\n                this._addPixelsNeg(refLine[refPos] - 1, blackPixels);\n                blackPixels ^= 1;\n                if (codingLine[this.codingPos] < columns) {\n                  if (refPos > 0) {\n                    --refPos;\n                  } else {\n                    ++refPos;\n                  }\n                  while (refLine[refPos] <= codingLine[this.codingPos] &&\n                         refLine[refPos] < columns) {\n                    refPos += 2;\n                  }\n                }\n                break;\n              case ccittEOF:\n                this._addPixels(columns, 0);\n                this.eof = true;\n                break;\n              default:\n                info('bad 2d code');\n                this._addPixels(columns, 0);\n                this.err = true;\n            }\n          }\n        } else {\n          codingLine[0] = 0;\n          this.codingPos = 0;\n          blackPixels = 0;\n          while (codingLine[this.codingPos] < columns) {\n            code1 = 0;\n            if (blackPixels) {\n              do {\n                code1 += (code3 = this._getBlackCode());\n              } while (code3 >= 64);\n            } else {\n              do {\n                code1 += (code3 = this._getWhiteCode());\n              } while (code3 >= 64);\n            }\n            this._addPixels(codingLine[this.codingPos] + code1, blackPixels);\n            blackPixels ^= 1;\n          }\n        }\n\n        let gotEOL = false;\n\n        if (this.byteAlign) {\n          this.inputBits &= ~7;\n        }\n\n        if (!this.eoblock && this.row === this.rows - 1) {\n          this.rowsDone = true;\n        } else {\n          code1 = this._lookBits(12);\n          if (this.eoline) {\n            while (code1 !== ccittEOF && code1 !== 1) {\n              this._eatBits(1);\n              code1 = this._lookBits(12);\n            }\n          } else {\n            while (code1 === 0) {\n              this._eatBits(1);\n              code1 = this._lookBits(12);\n            }\n          }\n          if (code1 === 1) {\n            this._eatBits(12);\n            gotEOL = true;\n          } else if (code1 === ccittEOF) {\n            this.eof = true;\n          }\n        }\n\n        if (!this.eof && this.encoding > 0 && !this.rowsDone) {\n          this.nextLine2D = !this._lookBits(1);\n          this._eatBits(1);\n        }\n\n        if (this.eoblock && gotEOL && this.byteAlign) {\n          code1 = this._lookBits(12);\n          if (code1 === 1) {\n            this._eatBits(12);\n            if (this.encoding > 0) {\n              this._lookBits(1);\n              this._eatBits(1);\n            }\n            if (this.encoding >= 0) {\n              for (i = 0; i < 4; ++i) {\n                code1 = this._lookBits(12);\n                if (code1 !== 1) {\n                  info('bad rtc code: ' + code1);\n                }\n                this._eatBits(12);\n                if (this.encoding > 0) {\n                  this._lookBits(1);\n                  this._eatBits(1);\n                }\n              }\n            }\n            this.eof = true;\n          }\n        } else if (this.err && this.eoline) {\n          while (true) {\n            code1 = this._lookBits(13);\n            if (code1 === ccittEOF) {\n              this.eof = true;\n              return -1;\n            }\n            if ((code1 >> 1) === 1) {\n              break;\n            }\n            this._eatBits(1);\n          }\n          this._eatBits(12);\n          if (this.encoding > 0) {\n            this._eatBits(1);\n            this.nextLine2D = !(code1 & 1);\n          }\n        }\n\n        if (codingLine[0] > 0) {\n          this.outputBits = codingLine[this.codingPos = 0];\n        } else {\n          this.outputBits = codingLine[this.codingPos = 1];\n        }\n        this.row++;\n      }\n\n      let c;\n      if (this.outputBits >= 8) {\n        c = (this.codingPos & 1) ? 0 : 0xFF;\n        this.outputBits -= 8;\n        if (this.outputBits === 0 && codingLine[this.codingPos] < columns) {\n          this.codingPos++;\n          this.outputBits = (codingLine[this.codingPos] -\n                             codingLine[this.codingPos - 1]);\n        }\n      } else {\n        bits = 8;\n        c = 0;\n        do {\n          if (this.outputBits > bits) {\n            c <<= bits;\n            if (!(this.codingPos & 1)) {\n              c |= 0xFF >> (8 - bits);\n            }\n            this.outputBits -= bits;\n            bits = 0;\n          } else {\n            c <<= this.outputBits;\n            if (!(this.codingPos & 1)) {\n              c |= 0xFF >> (8 - this.outputBits);\n            }\n            bits -= this.outputBits;\n            this.outputBits = 0;\n            if (codingLine[this.codingPos] < columns) {\n              this.codingPos++;\n              this.outputBits = (codingLine[this.codingPos] -\n                                 codingLine[this.codingPos - 1]);\n            } else if (bits > 0) {\n              c <<= bits;\n              bits = 0;\n            }\n          }\n        } while (bits);\n      }\n      if (this.black) {\n        c ^= 0xFF;\n      }\n      return c;\n    },\n\n    /**\n     * @private\n     */\n    _addPixels(a1, blackPixels) {\n      let codingLine = this.codingLine;\n      let codingPos = this.codingPos;\n\n      if (a1 > codingLine[codingPos]) {\n        if (a1 > this.columns) {\n          info('row is wrong length');\n          this.err = true;\n          a1 = this.columns;\n        }\n        if ((codingPos & 1) ^ blackPixels) {\n          ++codingPos;\n        }\n\n        codingLine[codingPos] = a1;\n      }\n      this.codingPos = codingPos;\n    },\n\n    /**\n     * @private\n     */\n    _addPixelsNeg(a1, blackPixels) {\n      let codingLine = this.codingLine;\n      let codingPos = this.codingPos;\n\n      if (a1 > codingLine[codingPos]) {\n        if (a1 > this.columns) {\n          info('row is wrong length');\n          this.err = true;\n          a1 = this.columns;\n        }\n        if ((codingPos & 1) ^ blackPixels) {\n          ++codingPos;\n        }\n\n        codingLine[codingPos] = a1;\n      } else if (a1 < codingLine[codingPos]) {\n        if (a1 < 0) {\n          info('invalid code');\n          this.err = true;\n          a1 = 0;\n        }\n        while (codingPos > 0 && a1 < codingLine[codingPos - 1]) {\n          --codingPos;\n        }\n        codingLine[codingPos] = a1;\n      }\n\n      this.codingPos = codingPos;\n    },\n\n    /**\n     * This function returns the code found from the table.\n     * The start and end parameters set the boundaries for searching the table.\n     * The limit parameter is optional. Function returns an array with three\n     * values. The first array element indicates whether a valid code is being\n     * returned. The second array element is the actual code. The third array\n     * element indicates whether EOF was reached.\n     * @private\n     */\n    _findTableCode(start, end, table, limit) {\n      let limitValue = limit || 0;\n      for (let i = start; i <= end; ++i) {\n        let code = this._lookBits(i);\n        if (code === ccittEOF) {\n          return [true, 1, false];\n        }\n        if (i < end) {\n          code <<= end - i;\n        }\n        if (!limitValue || code >= limitValue) {\n          let p = table[code - limitValue];\n          if (p[0] === i) {\n            this._eatBits(i);\n            return [true, p[1], true];\n          }\n        }\n      }\n      return [false, 0, false];\n    },\n\n    /**\n     * @private\n     */\n    _getTwoDimCode() {\n      let code = 0;\n      let p;\n      if (this.eoblock) {\n        code = this._lookBits(7);\n        p = twoDimTable[code];\n        if (p && p[0] > 0) {\n          this._eatBits(p[0]);\n          return p[1];\n        }\n      } else {\n        let result = this._findTableCode(1, 7, twoDimTable);\n        if (result[0] && result[2]) {\n          return result[1];\n        }\n      }\n      info('Bad two dim code');\n      return ccittEOF;\n    },\n\n    /**\n     * @private\n     */\n    _getWhiteCode() {\n      let code = 0;\n      let p;\n      if (this.eoblock) {\n        code = this._lookBits(12);\n        if (code === ccittEOF) {\n          return 1;\n        }\n\n        if ((code >> 5) === 0) {\n          p = whiteTable1[code];\n        } else {\n          p = whiteTable2[code >> 3];\n        }\n\n        if (p[0] > 0) {\n          this._eatBits(p[0]);\n          return p[1];\n        }\n      } else {\n        let result = this._findTableCode(1, 9, whiteTable2);\n        if (result[0]) {\n          return result[1];\n        }\n\n        result = this._findTableCode(11, 12, whiteTable1);\n        if (result[0]) {\n          return result[1];\n        }\n      }\n      info('bad white code');\n      this._eatBits(1);\n      return 1;\n    },\n\n    /**\n     * @private\n     */\n    _getBlackCode() {\n      let code, p;\n      if (this.eoblock) {\n        code = this._lookBits(13);\n        if (code === ccittEOF) {\n          return 1;\n        }\n        if ((code >> 7) === 0) {\n          p = blackTable1[code];\n        } else if ((code >> 9) === 0 && (code >> 7) !== 0) {\n          p = blackTable2[(code >> 1) - 64];\n        } else {\n          p = blackTable3[code >> 7];\n        }\n\n        if (p[0] > 0) {\n          this._eatBits(p[0]);\n          return p[1];\n        }\n      } else {\n        let result = this._findTableCode(2, 6, blackTable3);\n        if (result[0]) {\n          return result[1];\n        }\n\n        result = this._findTableCode(7, 12, blackTable2, 64);\n        if (result[0]) {\n          return result[1];\n        }\n\n        result = this._findTableCode(10, 13, blackTable1);\n        if (result[0]) {\n          return result[1];\n        }\n      }\n      info('bad black code');\n      this._eatBits(1);\n      return 1;\n    },\n\n    /**\n     * @private\n     */\n    _lookBits(n) {\n      let c;\n      while (this.inputBits < n) {\n        if ((c = this.source.next()) === -1) {\n          if (this.inputBits === 0) {\n            return ccittEOF;\n          }\n          return ((this.inputBuf << (n - this.inputBits)) &\n                  (0xFFFF >> (16 - n)));\n        }\n        this.inputBuf = (this.inputBuf << 8) | c;\n        this.inputBits += 8;\n      }\n      return (this.inputBuf >> (this.inputBits - n)) & (0xFFFF >> (16 - n));\n    },\n\n    /**\n     * @private\n     */\n    _eatBits(n) {\n      if ((this.inputBits -= n) < 0) {\n        this.inputBits = 0;\n      }\n    },\n  };\n\n  return CCITTFaxDecoder;\n})();\n\nexport {\n  CCITTFaxDecoder,\n};\n","/* Copyright 2014 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the 'License');\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an 'AS IS' BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/* eslint-disable no-multi-spaces */\n\nimport { assert, warn } from '../shared/util';\n\nlet JpegError = (function JpegErrorClosure() {\n  function JpegError(msg) {\n    this.message = 'JPEG error: ' + msg;\n  }\n\n  JpegError.prototype = new Error();\n  JpegError.prototype.name = 'JpegError';\n  JpegError.constructor = JpegError;\n\n  return JpegError;\n})();\n\nlet DNLMarkerError = (function DNLMarkerErrorClosure() {\n  function DNLMarkerError(message, scanLines) {\n    this.message = message;\n    this.scanLines = scanLines;\n  }\n\n  DNLMarkerError.prototype = new Error();\n  DNLMarkerError.prototype.name = 'DNLMarkerError';\n  DNLMarkerError.constructor = DNLMarkerError;\n\n  return DNLMarkerError;\n})();\n\nlet EOIMarkerError = (function EOIMarkerErrorClosure() {\n  function EOIMarkerError(message) {\n    this.message = message;\n  }\n\n  EOIMarkerError.prototype = new Error();\n  EOIMarkerError.prototype.name = 'EOIMarkerError';\n  EOIMarkerError.constructor = EOIMarkerError;\n\n  return EOIMarkerError;\n})();\n\n/**\n * This code was forked from https://github.com/notmasteryet/jpgjs.\n * The original version was created by GitHub user notmasteryet.\n *\n * - The JPEG specification can be found in the ITU CCITT Recommendation T.81\n *   (www.w3.org/Graphics/JPEG/itu-t81.pdf)\n * - The JFIF specification can be found in the JPEG File Interchange Format\n *   (www.w3.org/Graphics/JPEG/jfif3.pdf)\n * - The Adobe Application-Specific JPEG markers in the\n *   Supporting the DCT Filters in PostScript Level 2, Technical Note #5116\n *   (partners.adobe.com/public/developer/en/ps/sdk/5116.DCT_Filter.pdf)\n */\n\nvar JpegImage = (function JpegImageClosure() {\n  var dctZigZag = new Uint8Array([\n     0,\n     1,  8,\n    16,  9,  2,\n     3, 10, 17, 24,\n    32, 25, 18, 11, 4,\n     5, 12, 19, 26, 33, 40,\n    48, 41, 34, 27, 20, 13,  6,\n     7, 14, 21, 28, 35, 42, 49, 56,\n    57, 50, 43, 36, 29, 22, 15,\n    23, 30, 37, 44, 51, 58,\n    59, 52, 45, 38, 31,\n    39, 46, 53, 60,\n    61, 54, 47,\n    55, 62,\n    63\n  ]);\n\n  var dctCos1  =  4017;   // cos(pi/16)\n  var dctSin1  =   799;   // sin(pi/16)\n  var dctCos3  =  3406;   // cos(3*pi/16)\n  var dctSin3  =  2276;   // sin(3*pi/16)\n  var dctCos6  =  1567;   // cos(6*pi/16)\n  var dctSin6  =  3784;   // sin(6*pi/16)\n  var dctSqrt2 =  5793;   // sqrt(2)\n  var dctSqrt1d2 = 2896;  // sqrt(2) / 2\n\n  function JpegImage({ decodeTransform = null, colorTransform = -1, } = {}) {\n    this._decodeTransform = decodeTransform;\n    this._colorTransform = colorTransform;\n  }\n\n  function buildHuffmanTable(codeLengths, values) {\n    var k = 0, code = [], i, j, length = 16;\n    while (length > 0 && !codeLengths[length - 1]) {\n      length--;\n    }\n    code.push({ children: [], index: 0, });\n    var p = code[0], q;\n    for (i = 0; i < length; i++) {\n      for (j = 0; j < codeLengths[i]; j++) {\n        p = code.pop();\n        p.children[p.index] = values[k];\n        while (p.index > 0) {\n          p = code.pop();\n        }\n        p.index++;\n        code.push(p);\n        while (code.length <= i) {\n          code.push(q = { children: [], index: 0, });\n          p.children[p.index] = q.children;\n          p = q;\n        }\n        k++;\n      }\n      if (i + 1 < length) {\n        // p here points to last code\n        code.push(q = { children: [], index: 0, });\n        p.children[p.index] = q.children;\n        p = q;\n      }\n    }\n    return code[0].children;\n  }\n\n  function getBlockBufferOffset(component, row, col) {\n    return 64 * ((component.blocksPerLine + 1) * row + col);\n  }\n\n  function decodeScan(data, offset, frame, components, resetInterval,\n                      spectralStart, spectralEnd, successivePrev, successive,\n                      parseDNLMarker = false) {\n    var mcusPerLine = frame.mcusPerLine;\n    var progressive = frame.progressive;\n\n    var startOffset = offset, bitsData = 0, bitsCount = 0;\n\n    function readBit() {\n      if (bitsCount > 0) {\n        bitsCount--;\n        return (bitsData >> bitsCount) & 1;\n      }\n      bitsData = data[offset++];\n      if (bitsData === 0xFF) {\n        var nextByte = data[offset++];\n        if (nextByte) {\n          if (nextByte === 0xDC && parseDNLMarker) { // DNL == 0xFFDC\n            offset += 2; // Skip data length.\n            const scanLines = (data[offset++] << 8) | data[offset++];\n            if (scanLines > 0 && scanLines !== frame.scanLines) {\n              throw new DNLMarkerError(\n                'Found DNL marker (0xFFDC) while parsing scan data', scanLines);\n            }\n          } else if (nextByte === 0xD9) { // EOI == 0xFFD9\n            throw new EOIMarkerError(\n              'Found EOI marker (0xFFD9) while parsing scan data');\n          }\n          throw new JpegError(\n            `unexpected marker ${((bitsData << 8) | nextByte).toString(16)}`);\n        }\n        // unstuff 0\n      }\n      bitsCount = 7;\n      return bitsData >>> 7;\n    }\n\n    function decodeHuffman(tree) {\n      var node = tree;\n      while (true) {\n        node = node[readBit()];\n        if (typeof node === 'number') {\n          return node;\n        }\n        if (typeof node !== 'object') {\n          throw new JpegError('invalid huffman sequence');\n        }\n      }\n    }\n\n    function receive(length) {\n      var n = 0;\n      while (length > 0) {\n        n = (n << 1) | readBit();\n        length--;\n      }\n      return n;\n    }\n\n    function receiveAndExtend(length) {\n      if (length === 1) {\n        return readBit() === 1 ? 1 : -1;\n      }\n      var n = receive(length);\n      if (n >= 1 << (length - 1)) {\n        return n;\n      }\n      return n + (-1 << length) + 1;\n    }\n\n    function decodeBaseline(component, offset) {\n      var t = decodeHuffman(component.huffmanTableDC);\n      var diff = t === 0 ? 0 : receiveAndExtend(t);\n      component.blockData[offset] = (component.pred += diff);\n      var k = 1;\n      while (k < 64) {\n        var rs = decodeHuffman(component.huffmanTableAC);\n        var s = rs & 15, r = rs >> 4;\n        if (s === 0) {\n          if (r < 15) {\n            break;\n          }\n          k += 16;\n          continue;\n        }\n        k += r;\n        var z = dctZigZag[k];\n        component.blockData[offset + z] = receiveAndExtend(s);\n        k++;\n      }\n    }\n\n    function decodeDCFirst(component, offset) {\n      var t = decodeHuffman(component.huffmanTableDC);\n      var diff = t === 0 ? 0 : (receiveAndExtend(t) << successive);\n      component.blockData[offset] = (component.pred += diff);\n    }\n\n    function decodeDCSuccessive(component, offset) {\n      component.blockData[offset] |= readBit() << successive;\n    }\n\n    var eobrun = 0;\n    function decodeACFirst(component, offset) {\n      if (eobrun > 0) {\n        eobrun--;\n        return;\n      }\n      var k = spectralStart, e = spectralEnd;\n      while (k <= e) {\n        var rs = decodeHuffman(component.huffmanTableAC);\n        var s = rs & 15, r = rs >> 4;\n        if (s === 0) {\n          if (r < 15) {\n            eobrun = receive(r) + (1 << r) - 1;\n            break;\n          }\n          k += 16;\n          continue;\n        }\n        k += r;\n        var z = dctZigZag[k];\n        component.blockData[offset + z] =\n          receiveAndExtend(s) * (1 << successive);\n        k++;\n      }\n    }\n\n    var successiveACState = 0, successiveACNextValue;\n    function decodeACSuccessive(component, offset) {\n      var k = spectralStart;\n      var e = spectralEnd;\n      var r = 0;\n      var s;\n      var rs;\n      while (k <= e) {\n        let offsetZ = offset + dctZigZag[k];\n        let sign = component.blockData[offsetZ] < 0 ? -1 : 1;\n        switch (successiveACState) {\n          case 0: // initial state\n            rs = decodeHuffman(component.huffmanTableAC);\n            s = rs & 15;\n            r = rs >> 4;\n            if (s === 0) {\n              if (r < 15) {\n                eobrun = receive(r) + (1 << r);\n                successiveACState = 4;\n              } else {\n                r = 16;\n                successiveACState = 1;\n              }\n            } else {\n              if (s !== 1) {\n                throw new JpegError('invalid ACn encoding');\n              }\n              successiveACNextValue = receiveAndExtend(s);\n              successiveACState = r ? 2 : 3;\n            }\n            continue;\n          case 1: // skipping r zero items\n          case 2:\n            if (component.blockData[offsetZ]) {\n              component.blockData[offsetZ] += sign * (readBit() << successive);\n            } else {\n              r--;\n              if (r === 0) {\n                successiveACState = successiveACState === 2 ? 3 : 0;\n              }\n            }\n            break;\n          case 3: // set value for a zero item\n            if (component.blockData[offsetZ]) {\n              component.blockData[offsetZ] += sign * (readBit() << successive);\n            } else {\n              component.blockData[offsetZ] =\n                successiveACNextValue << successive;\n              successiveACState = 0;\n            }\n            break;\n          case 4: // eob\n            if (component.blockData[offsetZ]) {\n              component.blockData[offsetZ] += sign * (readBit() << successive);\n            }\n            break;\n        }\n        k++;\n      }\n      if (successiveACState === 4) {\n        eobrun--;\n        if (eobrun === 0) {\n          successiveACState = 0;\n        }\n      }\n    }\n\n    function decodeMcu(component, decode, mcu, row, col) {\n      var mcuRow = (mcu / mcusPerLine) | 0;\n      var mcuCol = mcu % mcusPerLine;\n      var blockRow = mcuRow * component.v + row;\n      var blockCol = mcuCol * component.h + col;\n      var offset = getBlockBufferOffset(component, blockRow, blockCol);\n      decode(component, offset);\n    }\n\n    function decodeBlock(component, decode, mcu) {\n      var blockRow = (mcu / component.blocksPerLine) | 0;\n      var blockCol = mcu % component.blocksPerLine;\n      var offset = getBlockBufferOffset(component, blockRow, blockCol);\n      decode(component, offset);\n    }\n\n    var componentsLength = components.length;\n    var component, i, j, k, n;\n    var decodeFn;\n    if (progressive) {\n      if (spectralStart === 0) {\n        decodeFn = successivePrev === 0 ? decodeDCFirst : decodeDCSuccessive;\n      } else {\n        decodeFn = successivePrev === 0 ? decodeACFirst : decodeACSuccessive;\n      }\n    } else {\n      decodeFn = decodeBaseline;\n    }\n\n    var mcu = 0, fileMarker;\n    var mcuExpected;\n    if (componentsLength === 1) {\n      mcuExpected = components[0].blocksPerLine * components[0].blocksPerColumn;\n    } else {\n      mcuExpected = mcusPerLine * frame.mcusPerColumn;\n    }\n\n    var h, v;\n    while (mcu < mcuExpected) {\n      // reset interval stuff\n      var mcuToRead = resetInterval ?\n        Math.min(mcuExpected - mcu, resetInterval) : mcuExpected;\n      for (i = 0; i < componentsLength; i++) {\n        components[i].pred = 0;\n      }\n      eobrun = 0;\n\n      if (componentsLength === 1) {\n        component = components[0];\n        for (n = 0; n < mcuToRead; n++) {\n          decodeBlock(component, decodeFn, mcu);\n          mcu++;\n        }\n      } else {\n        for (n = 0; n < mcuToRead; n++) {\n          for (i = 0; i < componentsLength; i++) {\n            component = components[i];\n            h = component.h;\n            v = component.v;\n            for (j = 0; j < v; j++) {\n              for (k = 0; k < h; k++) {\n                decodeMcu(component, decodeFn, mcu, j, k);\n              }\n            }\n          }\n          mcu++;\n        }\n      }\n\n      // find marker\n      bitsCount = 0;\n      fileMarker = findNextFileMarker(data, offset);\n      // Some bad images seem to pad Scan blocks with e.g. zero bytes, skip past\n      // those to attempt to find a valid marker (fixes issue4090.pdf).\n      if (fileMarker && fileMarker.invalid) {\n        warn('decodeScan - unexpected MCU data, current marker is: ' +\n             fileMarker.invalid);\n        offset = fileMarker.offset;\n      }\n      var marker = fileMarker && fileMarker.marker;\n      if (!marker || marker <= 0xFF00) {\n        throw new JpegError('marker was not found');\n      }\n\n      if (marker >= 0xFFD0 && marker <= 0xFFD7) { // RSTx\n        offset += 2;\n      } else {\n        break;\n      }\n    }\n\n    fileMarker = findNextFileMarker(data, offset);\n    // Some images include more Scan blocks than expected, skip past those and\n    // attempt to find the next valid marker (fixes issue8182.pdf).\n    if (fileMarker && fileMarker.invalid) {\n      warn('decodeScan - unexpected Scan data, current marker is: ' +\n           fileMarker.invalid);\n      offset = fileMarker.offset;\n    }\n\n    return offset - startOffset;\n  }\n\n  // A port of poppler's IDCT method which in turn is taken from:\n  //   Christoph Loeffler, Adriaan Ligtenberg, George S. Moschytz,\n  //   'Practical Fast 1-D DCT Algorithms with 11 Multiplications',\n  //   IEEE Intl. Conf. on Acoustics, Speech & Signal Processing, 1989,\n  //   988-991.\n  function quantizeAndInverse(component, blockBufferOffset, p) {\n    var qt = component.quantizationTable, blockData = component.blockData;\n    var v0, v1, v2, v3, v4, v5, v6, v7;\n    var p0, p1, p2, p3, p4, p5, p6, p7;\n    var t;\n\n    if (!qt) {\n      throw new JpegError('missing required Quantization Table.');\n    }\n\n    // inverse DCT on rows\n    for (var row = 0; row < 64; row += 8) {\n      // gather block data\n      p0 = blockData[blockBufferOffset + row];\n      p1 = blockData[blockBufferOffset + row + 1];\n      p2 = blockData[blockBufferOffset + row + 2];\n      p3 = blockData[blockBufferOffset + row + 3];\n      p4 = blockData[blockBufferOffset + row + 4];\n      p5 = blockData[blockBufferOffset + row + 5];\n      p6 = blockData[blockBufferOffset + row + 6];\n      p7 = blockData[blockBufferOffset + row + 7];\n\n      // dequant p0\n      p0 *= qt[row];\n\n      // check for all-zero AC coefficients\n      if ((p1 | p2 | p3 | p4 | p5 | p6 | p7) === 0) {\n        t = (dctSqrt2 * p0 + 512) >> 10;\n        p[row] = t;\n        p[row + 1] = t;\n        p[row + 2] = t;\n        p[row + 3] = t;\n        p[row + 4] = t;\n        p[row + 5] = t;\n        p[row + 6] = t;\n        p[row + 7] = t;\n        continue;\n      }\n      // dequant p1 ... p7\n      p1 *= qt[row + 1];\n      p2 *= qt[row + 2];\n      p3 *= qt[row + 3];\n      p4 *= qt[row + 4];\n      p5 *= qt[row + 5];\n      p6 *= qt[row + 6];\n      p7 *= qt[row + 7];\n\n      // stage 4\n      v0 = (dctSqrt2 * p0 + 128) >> 8;\n      v1 = (dctSqrt2 * p4 + 128) >> 8;\n      v2 = p2;\n      v3 = p6;\n      v4 = (dctSqrt1d2 * (p1 - p7) + 128) >> 8;\n      v7 = (dctSqrt1d2 * (p1 + p7) + 128) >> 8;\n      v5 = p3 << 4;\n      v6 = p5 << 4;\n\n      // stage 3\n      v0 = (v0 + v1 + 1) >> 1;\n      v1 = v0 - v1;\n      t  = (v2 * dctSin6 + v3 * dctCos6 + 128) >> 8;\n      v2 = (v2 * dctCos6 - v3 * dctSin6 + 128) >> 8;\n      v3 = t;\n      v4 = (v4 + v6 + 1) >> 1;\n      v6 = v4 - v6;\n      v7 = (v7 + v5 + 1) >> 1;\n      v5 = v7 - v5;\n\n      // stage 2\n      v0 = (v0 + v3 + 1) >> 1;\n      v3 = v0 - v3;\n      v1 = (v1 + v2 + 1) >> 1;\n      v2 = v1 - v2;\n      t  = (v4 * dctSin3 + v7 * dctCos3 + 2048) >> 12;\n      v4 = (v4 * dctCos3 - v7 * dctSin3 + 2048) >> 12;\n      v7 = t;\n      t  = (v5 * dctSin1 + v6 * dctCos1 + 2048) >> 12;\n      v5 = (v5 * dctCos1 - v6 * dctSin1 + 2048) >> 12;\n      v6 = t;\n\n      // stage 1\n      p[row] = v0 + v7;\n      p[row + 7] = v0 - v7;\n      p[row + 1] = v1 + v6;\n      p[row + 6] = v1 - v6;\n      p[row + 2] = v2 + v5;\n      p[row + 5] = v2 - v5;\n      p[row + 3] = v3 + v4;\n      p[row + 4] = v3 - v4;\n    }\n\n    // inverse DCT on columns\n    for (var col = 0; col < 8; ++col) {\n      p0 = p[col];\n      p1 = p[col +  8];\n      p2 = p[col + 16];\n      p3 = p[col + 24];\n      p4 = p[col + 32];\n      p5 = p[col + 40];\n      p6 = p[col + 48];\n      p7 = p[col + 56];\n\n      // check for all-zero AC coefficients\n      if ((p1 | p2 | p3 | p4 | p5 | p6 | p7) === 0) {\n        t = (dctSqrt2 * p0 + 8192) >> 14;\n        // convert to 8 bit\n        t = (t < -2040) ? 0 : (t >= 2024) ? 255 : (t + 2056) >> 4;\n        blockData[blockBufferOffset + col] = t;\n        blockData[blockBufferOffset + col +  8] = t;\n        blockData[blockBufferOffset + col + 16] = t;\n        blockData[blockBufferOffset + col + 24] = t;\n        blockData[blockBufferOffset + col + 32] = t;\n        blockData[blockBufferOffset + col + 40] = t;\n        blockData[blockBufferOffset + col + 48] = t;\n        blockData[blockBufferOffset + col + 56] = t;\n        continue;\n      }\n\n      // stage 4\n      v0 = (dctSqrt2 * p0 + 2048) >> 12;\n      v1 = (dctSqrt2 * p4 + 2048) >> 12;\n      v2 = p2;\n      v3 = p6;\n      v4 = (dctSqrt1d2 * (p1 - p7) + 2048) >> 12;\n      v7 = (dctSqrt1d2 * (p1 + p7) + 2048) >> 12;\n      v5 = p3;\n      v6 = p5;\n\n      // stage 3\n      // Shift v0 by 128.5 << 5 here, so we don't need to shift p0...p7 when\n      // converting to UInt8 range later.\n      v0 = ((v0 + v1 + 1) >> 1) + 4112;\n      v1 = v0 - v1;\n      t  = (v2 * dctSin6 + v3 * dctCos6 + 2048) >> 12;\n      v2 = (v2 * dctCos6 - v3 * dctSin6 + 2048) >> 12;\n      v3 = t;\n      v4 = (v4 + v6 + 1) >> 1;\n      v6 = v4 - v6;\n      v7 = (v7 + v5 + 1) >> 1;\n      v5 = v7 - v5;\n\n      // stage 2\n      v0 = (v0 + v3 + 1) >> 1;\n      v3 = v0 - v3;\n      v1 = (v1 + v2 + 1) >> 1;\n      v2 = v1 - v2;\n      t  = (v4 * dctSin3 + v7 * dctCos3 + 2048) >> 12;\n      v4 = (v4 * dctCos3 - v7 * dctSin3 + 2048) >> 12;\n      v7 = t;\n      t  = (v5 * dctSin1 + v6 * dctCos1 + 2048) >> 12;\n      v5 = (v5 * dctCos1 - v6 * dctSin1 + 2048) >> 12;\n      v6 = t;\n\n      // stage 1\n      p0 = v0 + v7;\n      p7 = v0 - v7;\n      p1 = v1 + v6;\n      p6 = v1 - v6;\n      p2 = v2 + v5;\n      p5 = v2 - v5;\n      p3 = v3 + v4;\n      p4 = v3 - v4;\n\n      // convert to 8-bit integers\n      p0 = (p0 < 16) ? 0 : (p0 >= 4080) ? 255 : p0 >> 4;\n      p1 = (p1 < 16) ? 0 : (p1 >= 4080) ? 255 : p1 >> 4;\n      p2 = (p2 < 16) ? 0 : (p2 >= 4080) ? 255 : p2 >> 4;\n      p3 = (p3 < 16) ? 0 : (p3 >= 4080) ? 255 : p3 >> 4;\n      p4 = (p4 < 16) ? 0 : (p4 >= 4080) ? 255 : p4 >> 4;\n      p5 = (p5 < 16) ? 0 : (p5 >= 4080) ? 255 : p5 >> 4;\n      p6 = (p6 < 16) ? 0 : (p6 >= 4080) ? 255 : p6 >> 4;\n      p7 = (p7 < 16) ? 0 : (p7 >= 4080) ? 255 : p7 >> 4;\n\n      // store block data\n      blockData[blockBufferOffset + col] = p0;\n      blockData[blockBufferOffset + col +  8] = p1;\n      blockData[blockBufferOffset + col + 16] = p2;\n      blockData[blockBufferOffset + col + 24] = p3;\n      blockData[blockBufferOffset + col + 32] = p4;\n      blockData[blockBufferOffset + col + 40] = p5;\n      blockData[blockBufferOffset + col + 48] = p6;\n      blockData[blockBufferOffset + col + 56] = p7;\n    }\n  }\n\n  function buildComponentData(frame, component) {\n    var blocksPerLine = component.blocksPerLine;\n    var blocksPerColumn = component.blocksPerColumn;\n    var computationBuffer = new Int16Array(64);\n\n    for (var blockRow = 0; blockRow < blocksPerColumn; blockRow++) {\n      for (var blockCol = 0; blockCol < blocksPerLine; blockCol++) {\n        var offset = getBlockBufferOffset(component, blockRow, blockCol);\n        quantizeAndInverse(component, offset, computationBuffer);\n      }\n    }\n    return component.blockData;\n  }\n\n  function findNextFileMarker(data, currentPos, startPos = currentPos) {\n    function peekUint16(pos) {\n      return (data[pos] << 8) | data[pos + 1];\n    }\n\n    const maxPos = data.length - 1;\n    var newPos = startPos < currentPos ? startPos : currentPos;\n\n    if (currentPos >= maxPos) {\n      return null; // Don't attempt to read non-existent data and just return.\n    }\n    var currentMarker = peekUint16(currentPos);\n    if (currentMarker >= 0xFFC0 && currentMarker <= 0xFFFE) {\n      return {\n        invalid: null,\n        marker: currentMarker,\n        offset: currentPos,\n      };\n    }\n    var newMarker = peekUint16(newPos);\n    while (!(newMarker >= 0xFFC0 && newMarker <= 0xFFFE)) {\n      if (++newPos >= maxPos) {\n        return null; // Don't attempt to read non-existent data and just return.\n      }\n      newMarker = peekUint16(newPos);\n    }\n    return {\n      invalid: currentMarker.toString(16),\n      marker: newMarker,\n      offset: newPos,\n    };\n  }\n\n  JpegImage.prototype = {\n    parse(data, { dnlScanLines = null, } = {}) {\n\n      function readUint16() {\n        var value = (data[offset] << 8) | data[offset + 1];\n        offset += 2;\n        return value;\n      }\n\n      function readDataBlock() {\n        var length = readUint16();\n        var endOffset = offset + length - 2;\n\n        var fileMarker = findNextFileMarker(data, endOffset, offset);\n        if (fileMarker && fileMarker.invalid) {\n          warn('readDataBlock - incorrect length, current marker is: ' +\n               fileMarker.invalid);\n          endOffset = fileMarker.offset;\n        }\n\n        var array = data.subarray(offset, endOffset);\n        offset += array.length;\n        return array;\n      }\n\n      function prepareComponents(frame) {\n        var mcusPerLine = Math.ceil(frame.samplesPerLine / 8 / frame.maxH);\n        var mcusPerColumn = Math.ceil(frame.scanLines / 8 / frame.maxV);\n        for (var i = 0; i < frame.components.length; i++) {\n          component = frame.components[i];\n          var blocksPerLine = Math.ceil(Math.ceil(frame.samplesPerLine / 8) *\n                                        component.h / frame.maxH);\n          var blocksPerColumn = Math.ceil(Math.ceil(frame.scanLines / 8) *\n                                          component.v / frame.maxV);\n          var blocksPerLineForMcu = mcusPerLine * component.h;\n          var blocksPerColumnForMcu = mcusPerColumn * component.v;\n\n          var blocksBufferSize = 64 * blocksPerColumnForMcu *\n                                      (blocksPerLineForMcu + 1);\n          component.blockData = new Int16Array(blocksBufferSize);\n          component.blocksPerLine = blocksPerLine;\n          component.blocksPerColumn = blocksPerColumn;\n        }\n        frame.mcusPerLine = mcusPerLine;\n        frame.mcusPerColumn = mcusPerColumn;\n      }\n\n      var offset = 0;\n      var jfif = null;\n      var adobe = null;\n      var frame, resetInterval;\n      let numSOSMarkers = 0;\n      var quantizationTables = [];\n      var huffmanTablesAC = [], huffmanTablesDC = [];\n      var fileMarker = readUint16();\n      if (fileMarker !== 0xFFD8) { // SOI (Start of Image)\n        throw new JpegError('SOI not found');\n      }\n\n      fileMarker = readUint16();\n      markerLoop: while (fileMarker !== 0xFFD9) { // EOI (End of image)\n        var i, j, l;\n        switch (fileMarker) {\n          case 0xFFE0: // APP0 (Application Specific)\n          case 0xFFE1: // APP1\n          case 0xFFE2: // APP2\n          case 0xFFE3: // APP3\n          case 0xFFE4: // APP4\n          case 0xFFE5: // APP5\n          case 0xFFE6: // APP6\n          case 0xFFE7: // APP7\n          case 0xFFE8: // APP8\n          case 0xFFE9: // APP9\n          case 0xFFEA: // APP10\n          case 0xFFEB: // APP11\n          case 0xFFEC: // APP12\n          case 0xFFED: // APP13\n          case 0xFFEE: // APP14\n          case 0xFFEF: // APP15\n          case 0xFFFE: // COM (Comment)\n            var appData = readDataBlock();\n\n            if (fileMarker === 0xFFE0) {\n              if (appData[0] === 0x4A && appData[1] === 0x46 &&\n                  appData[2] === 0x49 && appData[3] === 0x46 &&\n                  appData[4] === 0) { // 'JFIF\\x00'\n                jfif = {\n                  version: { major: appData[5], minor: appData[6], },\n                  densityUnits: appData[7],\n                  xDensity: (appData[8] << 8) | appData[9],\n                  yDensity: (appData[10] << 8) | appData[11],\n                  thumbWidth: appData[12],\n                  thumbHeight: appData[13],\n                  thumbData: appData.subarray(14, 14 +\n                                              3 * appData[12] * appData[13]),\n                };\n              }\n            }\n            // TODO APP1 - Exif\n            if (fileMarker === 0xFFEE) {\n              if (appData[0] === 0x41 && appData[1] === 0x64 &&\n                  appData[2] === 0x6F && appData[3] === 0x62 &&\n                  appData[4] === 0x65) { // 'Adobe'\n                adobe = {\n                  version: (appData[5] << 8) | appData[6],\n                  flags0: (appData[7] << 8) | appData[8],\n                  flags1: (appData[9] << 8) | appData[10],\n                  transformCode: appData[11],\n                };\n              }\n            }\n            break;\n\n          case 0xFFDB: // DQT (Define Quantization Tables)\n            var quantizationTablesLength = readUint16();\n            var quantizationTablesEnd = quantizationTablesLength + offset - 2;\n            var z;\n            while (offset < quantizationTablesEnd) {\n              var quantizationTableSpec = data[offset++];\n              var tableData = new Uint16Array(64);\n              if ((quantizationTableSpec >> 4) === 0) { // 8 bit values\n                for (j = 0; j < 64; j++) {\n                  z = dctZigZag[j];\n                  tableData[z] = data[offset++];\n                }\n              } else if ((quantizationTableSpec >> 4) === 1) { // 16 bit values\n                for (j = 0; j < 64; j++) {\n                  z = dctZigZag[j];\n                  tableData[z] = readUint16();\n                }\n              } else {\n                throw new JpegError('DQT - invalid table spec');\n              }\n              quantizationTables[quantizationTableSpec & 15] = tableData;\n            }\n            break;\n\n          case 0xFFC0: // SOF0 (Start of Frame, Baseline DCT)\n          case 0xFFC1: // SOF1 (Start of Frame, Extended DCT)\n          case 0xFFC2: // SOF2 (Start of Frame, Progressive DCT)\n            if (frame) {\n              throw new JpegError('Only single frame JPEGs supported');\n            }\n            readUint16(); // skip data length\n            frame = {};\n            frame.extended = (fileMarker === 0xFFC1);\n            frame.progressive = (fileMarker === 0xFFC2);\n            frame.precision = data[offset++];\n            const sofScanLines = readUint16();\n            frame.scanLines = dnlScanLines || sofScanLines;\n            frame.samplesPerLine = readUint16();\n            frame.components = [];\n            frame.componentIds = {};\n            var componentsCount = data[offset++], componentId;\n            var maxH = 0, maxV = 0;\n            for (i = 0; i < componentsCount; i++) {\n              componentId = data[offset];\n              var h = data[offset + 1] >> 4;\n              var v = data[offset + 1] & 15;\n              if (maxH < h) {\n                maxH = h;\n              }\n              if (maxV < v) {\n                maxV = v;\n              }\n              var qId = data[offset + 2];\n              l = frame.components.push({\n                h,\n                v,\n                quantizationId: qId,\n                quantizationTable: null, // See comment below.\n              });\n              frame.componentIds[componentId] = l - 1;\n              offset += 3;\n            }\n            frame.maxH = maxH;\n            frame.maxV = maxV;\n            prepareComponents(frame);\n            break;\n\n          case 0xFFC4: // DHT (Define Huffman Tables)\n            var huffmanLength = readUint16();\n            for (i = 2; i < huffmanLength;) {\n              var huffmanTableSpec = data[offset++];\n              var codeLengths = new Uint8Array(16);\n              var codeLengthSum = 0;\n              for (j = 0; j < 16; j++, offset++) {\n                codeLengthSum += (codeLengths[j] = data[offset]);\n              }\n              var huffmanValues = new Uint8Array(codeLengthSum);\n              for (j = 0; j < codeLengthSum; j++, offset++) {\n                huffmanValues[j] = data[offset];\n              }\n              i += 17 + codeLengthSum;\n\n              ((huffmanTableSpec >> 4) === 0 ?\n                huffmanTablesDC : huffmanTablesAC)[huffmanTableSpec & 15] =\n                buildHuffmanTable(codeLengths, huffmanValues);\n            }\n            break;\n\n          case 0xFFDD: // DRI (Define Restart Interval)\n            readUint16(); // skip data length\n            resetInterval = readUint16();\n            break;\n\n          case 0xFFDA: // SOS (Start of Scan)\n            // A DNL marker (0xFFDC), if it exists, is only allowed at the end\n            // of the first scan segment and may only occur once in an image.\n            // Furthermore, to prevent an infinite loop, do *not* attempt to\n            // parse DNL markers during re-parsing of the JPEG scan data.\n            const parseDNLMarker = (++numSOSMarkers) === 1 && !dnlScanLines;\n\n            readUint16(); // scanLength\n            var selectorsCount = data[offset++];\n            var components = [], component;\n            for (i = 0; i < selectorsCount; i++) {\n              var componentIndex = frame.componentIds[data[offset++]];\n              component = frame.components[componentIndex];\n              var tableSpec = data[offset++];\n              component.huffmanTableDC = huffmanTablesDC[tableSpec >> 4];\n              component.huffmanTableAC = huffmanTablesAC[tableSpec & 15];\n              components.push(component);\n            }\n            var spectralStart = data[offset++];\n            var spectralEnd = data[offset++];\n            var successiveApproximation = data[offset++];\n            try {\n              var processed = decodeScan(data, offset,\n                frame, components, resetInterval,\n                spectralStart, spectralEnd,\n                successiveApproximation >> 4, successiveApproximation & 15,\n                parseDNLMarker);\n              offset += processed;\n            } catch (ex) {\n              if (ex instanceof DNLMarkerError) {\n                warn(`${ex.message} -- attempting to re-parse the JPEG image.`);\n                return this.parse(data, { dnlScanLines: ex.scanLines, });\n              } else if (ex instanceof EOIMarkerError) {\n                warn(`${ex.message} -- ignoring the rest of the image data.`);\n                break markerLoop;\n              }\n              throw ex;\n            }\n            break;\n\n          case 0xFFDC: // DNL (Define Number of Lines)\n            // Ignore the marker, since it's being handled in `decodeScan`.\n            offset += 4;\n            break;\n\n          case 0xFFFF: // Fill bytes\n            if (data[offset] !== 0xFF) { // Avoid skipping a valid marker.\n              offset--;\n            }\n            break;\n\n          default:\n            if (data[offset - 3] === 0xFF &&\n                data[offset - 2] >= 0xC0 && data[offset - 2] <= 0xFE) {\n              // could be incorrect encoding -- last 0xFF byte of the previous\n              // block was eaten by the encoder\n              offset -= 3;\n              break;\n            }\n            let nextFileMarker = findNextFileMarker(data, offset - 2);\n            if (nextFileMarker && nextFileMarker.invalid) {\n              warn('JpegImage.parse - unexpected data, current marker is: ' +\n                   nextFileMarker.invalid);\n              offset = nextFileMarker.offset;\n              break;\n            }\n            throw new JpegError('unknown marker ' + fileMarker.toString(16));\n        }\n        fileMarker = readUint16();\n      }\n\n      this.width = frame.samplesPerLine;\n      this.height = frame.scanLines;\n      this.jfif = jfif;\n      this.adobe = adobe;\n      this.components = [];\n      for (i = 0; i < frame.components.length; i++) {\n        component = frame.components[i];\n\n        // Prevent errors when DQT markers are placed after SOF{n} markers,\n        // by assigning the `quantizationTable` entry after the entire image\n        // has been parsed (fixes issue7406.pdf).\n        var quantizationTable = quantizationTables[component.quantizationId];\n        if (quantizationTable) {\n          component.quantizationTable = quantizationTable;\n        }\n\n        this.components.push({\n          output: buildComponentData(frame, component),\n          scaleX: component.h / frame.maxH,\n          scaleY: component.v / frame.maxV,\n          blocksPerLine: component.blocksPerLine,\n          blocksPerColumn: component.blocksPerColumn,\n        });\n      }\n      this.numComponents = this.components.length;\n    },\n\n    _getLinearizedBlockData(width, height, isSourcePDF = false) {\n      var scaleX = this.width / width, scaleY = this.height / height;\n\n      var component, componentScaleX, componentScaleY, blocksPerScanline;\n      var x, y, i, j, k;\n      var index;\n      var offset = 0;\n      var output;\n      var numComponents = this.components.length;\n      var dataLength = width * height * numComponents;\n      var data = new Uint8ClampedArray(dataLength);\n      var xScaleBlockOffset = new Uint32Array(width);\n      var mask3LSB = 0xfffffff8; // used to clear the 3 LSBs\n\n      for (i = 0; i < numComponents; i++) {\n        component = this.components[i];\n        componentScaleX = component.scaleX * scaleX;\n        componentScaleY = component.scaleY * scaleY;\n        offset = i;\n        output = component.output;\n        blocksPerScanline = (component.blocksPerLine + 1) << 3;\n        // precalculate the xScaleBlockOffset\n        for (x = 0; x < width; x++) {\n          j = 0 | (x * componentScaleX);\n          xScaleBlockOffset[x] = ((j & mask3LSB) << 3) | (j & 7);\n        }\n        // linearize the blocks of the component\n        for (y = 0; y < height; y++) {\n          j = 0 | (y * componentScaleY);\n          index = blocksPerScanline * (j & mask3LSB) | ((j & 7) << 3);\n          for (x = 0; x < width; x++) {\n            data[offset] = output[index + xScaleBlockOffset[x]];\n            offset += numComponents;\n          }\n        }\n      }\n\n      // decodeTransform contains pairs of multiplier (-256..256) and additive\n      let transform = this._decodeTransform;\n\n      // In PDF files, JPEG images with CMYK colour spaces are usually inverted\n      // (this can be observed by extracting the raw image data).\n      // Since the conversion algorithms (see below) were written primarily for\n      // the PDF use-cases, attempting to use `JpegImage` to parse standalone\n      // JPEG (CMYK) images may thus result in inverted images (see issue 9513).\n      //\n      // Unfortunately it's not (always) possible to tell, from the image data\n      // alone, if it needs to be inverted. Thus in an attempt to provide better\n      // out-of-box behaviour when `JpegImage` is used standalone, default to\n      // inverting JPEG (CMYK) images if and only if the image data does *not*\n      // come from a PDF file and no `decodeTransform` was passed by the user.\n      if (!isSourcePDF && numComponents === 4 && !transform) {\n        transform = new Int32Array([\n          -256, 255, -256, 255, -256, 255, -256, 255]);\n      }\n\n      if (transform) {\n        for (i = 0; i < dataLength;) {\n          for (j = 0, k = 0; j < numComponents; j++, i++, k += 2) {\n            data[i] = ((data[i] * transform[k]) >> 8) + transform[k + 1];\n          }\n        }\n      }\n      return data;\n    },\n\n    get _isColorConversionNeeded() {\n      if (this.adobe) {\n        // The adobe transform marker overrides any previous setting.\n        return !!this.adobe.transformCode;\n      }\n      if (this.numComponents === 3) {\n        if (this._colorTransform === 0) {\n          // If the Adobe transform marker is not present and the image\n          // dictionary has a 'ColorTransform' entry, explicitly set to `0`,\n          // then the colours should *not* be transformed.\n          return false;\n        }\n        return true;\n      }\n      // `this.numComponents !== 3`\n      if (this._colorTransform === 1) {\n        // If the Adobe transform marker is not present and the image\n        // dictionary has a 'ColorTransform' entry, explicitly set to `1`,\n        // then the colours should be transformed.\n        return true;\n      }\n      return false;\n    },\n\n    _convertYccToRgb: function convertYccToRgb(data) {\n      var Y, Cb, Cr;\n      for (var i = 0, length = data.length; i < length; i += 3) {\n        Y = data[i];\n        Cb = data[i + 1];\n        Cr = data[i + 2];\n        data[i] = Y - 179.456 + 1.402 * Cr;\n        data[i + 1] = Y + 135.459 - 0.344 * Cb - 0.714 * Cr;\n        data[i + 2] = Y - 226.816 + 1.772 * Cb;\n      }\n      return data;\n    },\n\n    _convertYcckToRgb: function convertYcckToRgb(data) {\n      var Y, Cb, Cr, k;\n      var offset = 0;\n      for (var i = 0, length = data.length; i < length; i += 4) {\n        Y = data[i];\n        Cb = data[i + 1];\n        Cr = data[i + 2];\n        k = data[i + 3];\n\n        data[offset++] = -122.67195406894 +\n          Cb * (-6.60635669420364e-5 * Cb + 0.000437130475926232 * Cr -\n                5.4080610064599e-5 * Y + 0.00048449797120281 * k -\n                0.154362151871126) +\n          Cr * (-0.000957964378445773 * Cr + 0.000817076911346625 * Y -\n                0.00477271405408747 * k + 1.53380253221734) +\n          Y * (0.000961250184130688 * Y - 0.00266257332283933 * k +\n               0.48357088451265) +\n          k * (-0.000336197177618394 * k + 0.484791561490776);\n\n        data[offset++] = 107.268039397724 +\n          Cb * (2.19927104525741e-5 * Cb - 0.000640992018297945 * Cr +\n                0.000659397001245577 * Y + 0.000426105652938837 * k -\n                0.176491792462875) +\n          Cr * (-0.000778269941513683 * Cr + 0.00130872261408275 * Y +\n                0.000770482631801132 * k - 0.151051492775562) +\n          Y * (0.00126935368114843 * Y - 0.00265090189010898 * k +\n               0.25802910206845) +\n          k * (-0.000318913117588328 * k - 0.213742400323665);\n\n        data[offset++] = -20.810012546947 +\n          Cb * (-0.000570115196973677 * Cb - 2.63409051004589e-5 * Cr +\n                0.0020741088115012 * Y - 0.00288260236853442 * k +\n                0.814272968359295) +\n          Cr * (-1.53496057440975e-5 * Cr - 0.000132689043961446 * Y +\n                0.000560833691242812 * k - 0.195152027534049) +\n          Y * (0.00174418132927582 * Y - 0.00255243321439347 * k +\n               0.116935020465145) +\n          k * (-0.000343531996510555 * k + 0.24165260232407);\n      }\n      // Ensure that only the converted RGB data is returned.\n      return data.subarray(0, offset);\n    },\n\n    _convertYcckToCmyk: function convertYcckToCmyk(data) {\n      var Y, Cb, Cr;\n      for (var i = 0, length = data.length; i < length; i += 4) {\n        Y = data[i];\n        Cb = data[i + 1];\n        Cr = data[i + 2];\n        data[i] = 434.456 - Y - 1.402 * Cr;\n        data[i + 1] = 119.541 - Y + 0.344 * Cb + 0.714 * Cr;\n        data[i + 2] = 481.816 - Y - 1.772 * Cb;\n        // K in data[i + 3] is unchanged\n      }\n      return data;\n    },\n\n    _convertCmykToRgb: function convertCmykToRgb(data) {\n      var c, m, y, k;\n      var offset = 0;\n      var scale = 1 / 255;\n      for (var i = 0, length = data.length; i < length; i += 4) {\n        c = data[i] * scale;\n        m = data[i + 1] * scale;\n        y = data[i + 2] * scale;\n        k = data[i + 3] * scale;\n\n        data[offset++] = 255 +\n          c * (-4.387332384609988 * c + 54.48615194189176 * m +\n               18.82290502165302 * y + 212.25662451639585 * k -\n               285.2331026137004) +\n          m * (1.7149763477362134 * m - 5.6096736904047315 * y -\n               17.873870861415444 * k - 5.497006427196366) +\n          y * (-2.5217340131683033 * y - 21.248923337353073 * k +\n               17.5119270841813) -\n          k * (21.86122147463605 * k + 189.48180835922747);\n\n        data[offset++] = 255 +\n          c * (8.841041422036149 * c + 60.118027045597366 * m +\n               6.871425592049007 * y + 31.159100130055922 * k -\n               79.2970844816548) +\n          m * (-15.310361306967817 * m + 17.575251261109482 * y +\n               131.35250912493976 * k - 190.9453302588951) +\n          y * (4.444339102852739 * y + 9.8632861493405 * k -\n               24.86741582555878) -\n          k * (20.737325471181034 * k + 187.80453709719578);\n\n        data[offset++] = 255 +\n          c * (0.8842522430003296 * c + 8.078677503112928 * m +\n               30.89978309703729 * y - 0.23883238689178934 * k -\n               14.183576799673286) +\n          m * (10.49593273432072 * m + 63.02378494754052 * y +\n               50.606957656360734 * k - 112.23884253719248) +\n          y * (0.03296041114873217 * y + 115.60384449646641 * k -\n               193.58209356861505) -\n          k * (22.33816807309886 * k + 180.12613974708367);\n      }\n      // Ensure that only the converted RGB data is returned.\n      return data.subarray(0, offset);\n    },\n\n    getData({ width, height, forceRGB = false, isSourcePDF = false, }) {\n      if (typeof PDFJSDev !== 'undefined' && PDFJSDev.test('TESTING && !LIB')) {\n        assert(isSourcePDF === true,\n          'JpegImage.getData: Unexpected \"isSourcePDF\" value for PDF files.');\n      }\n      if (this.numComponents > 4) {\n        throw new JpegError('Unsupported color mode');\n      }\n      // Type of data: Uint8ClampedArray(width * height * numComponents)\n      var data = this._getLinearizedBlockData(width, height, isSourcePDF);\n\n      if (this.numComponents === 1 && forceRGB) {\n        var dataLength = data.length;\n        var rgbData = new Uint8ClampedArray(dataLength * 3);\n        var offset = 0;\n        for (var i = 0; i < dataLength; i++) {\n          var grayColor = data[i];\n          rgbData[offset++] = grayColor;\n          rgbData[offset++] = grayColor;\n          rgbData[offset++] = grayColor;\n        }\n        return rgbData;\n      } else if (this.numComponents === 3 && this._isColorConversionNeeded) {\n        return this._convertYccToRgb(data);\n      } else if (this.numComponents === 4) {\n        if (this._isColorConversionNeeded) {\n          if (forceRGB) {\n            return this._convertYcckToRgb(data);\n          }\n          return this._convertYcckToCmyk(data);\n        } else if (forceRGB) {\n          return this._convertCmykToRgb(data);\n        }\n      }\n      return data;\n    },\n  };\n\n  return JpegImage;\n})();\n\nexport {\n  JpegImage,\n};\n","/* Copyright 2012 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  info, log2, readUint16, readUint32, warn\n} from '../shared/util';\nimport { ArithmeticDecoder } from './arithmetic_decoder';\n\nlet JpxError = (function JpxErrorClosure() {\n  function JpxError(msg) {\n    this.message = 'JPX error: ' + msg;\n  }\n\n  JpxError.prototype = new Error();\n  JpxError.prototype.name = 'JpxError';\n  JpxError.constructor = JpxError;\n\n  return JpxError;\n})();\n\nvar JpxImage = (function JpxImageClosure() {\n  // Table E.1\n  var SubbandsGainLog2 = {\n    'LL': 0,\n    'LH': 1,\n    'HL': 1,\n    'HH': 2,\n  };\n  function JpxImage() {\n    this.failOnCorruptedImage = false;\n  }\n  JpxImage.prototype = {\n    parse: function JpxImage_parse(data) {\n\n      var head = readUint16(data, 0);\n      // No box header, immediate start of codestream (SOC)\n      if (head === 0xFF4F) {\n        this.parseCodestream(data, 0, data.length);\n        return;\n      }\n\n      var position = 0, length = data.length;\n      while (position < length) {\n        var headerSize = 8;\n        var lbox = readUint32(data, position);\n        var tbox = readUint32(data, position + 4);\n        position += headerSize;\n        if (lbox === 1) {\n          // XLBox: read UInt64 according to spec.\n          // JavaScript's int precision of 53 bit should be sufficient here.\n          lbox = readUint32(data, position) * 4294967296 +\n                 readUint32(data, position + 4);\n          position += 8;\n          headerSize += 8;\n        }\n        if (lbox === 0) {\n          lbox = length - position + headerSize;\n        }\n        if (lbox < headerSize) {\n          throw new JpxError('Invalid box field size');\n        }\n        var dataLength = lbox - headerSize;\n        var jumpDataLength = true;\n        switch (tbox) {\n          case 0x6A703268: // 'jp2h'\n            jumpDataLength = false; // parsing child boxes\n            break;\n          case 0x636F6C72: // 'colr'\n            // Colorspaces are not used, the CS from the PDF is used.\n            var method = data[position];\n            if (method === 1) {\n              // enumerated colorspace\n              var colorspace = readUint32(data, position + 3);\n              switch (colorspace) {\n                case 16: // this indicates a sRGB colorspace\n                case 17: // this indicates a grayscale colorspace\n                case 18: // this indicates a YUV colorspace\n                  break;\n                default:\n                  warn('Unknown colorspace ' + colorspace);\n                  break;\n              }\n            } else if (method === 2) {\n              info('ICC profile not supported');\n            }\n            break;\n          case 0x6A703263: // 'jp2c'\n            this.parseCodestream(data, position, position + dataLength);\n            break;\n          case 0x6A502020: // 'jP\\024\\024'\n            if (readUint32(data, position) !== 0x0d0a870a) {\n              warn('Invalid JP2 signature');\n            }\n            break;\n          // The following header types are valid but currently not used:\n          case 0x6A501A1A: // 'jP\\032\\032'\n          case 0x66747970: // 'ftyp'\n          case 0x72726571: // 'rreq'\n          case 0x72657320: // 'res '\n          case 0x69686472: // 'ihdr'\n            break;\n          default:\n            var headerType = String.fromCharCode((tbox >> 24) & 0xFF,\n                                                 (tbox >> 16) & 0xFF,\n                                                 (tbox >> 8) & 0xFF,\n                                                 tbox & 0xFF);\n            warn('Unsupported header type ' + tbox + ' (' + headerType + ')');\n            break;\n        }\n        if (jumpDataLength) {\n          position += dataLength;\n        }\n      }\n    },\n    parseImageProperties: function JpxImage_parseImageProperties(stream) {\n      var newByte = stream.getByte();\n      while (newByte >= 0) {\n        var oldByte = newByte;\n        newByte = stream.getByte();\n        var code = (oldByte << 8) | newByte;\n        // Image and tile size (SIZ)\n        if (code === 0xFF51) {\n          stream.skip(4);\n          var Xsiz = stream.getInt32() >>> 0; // Byte 4\n          var Ysiz = stream.getInt32() >>> 0; // Byte 8\n          var XOsiz = stream.getInt32() >>> 0; // Byte 12\n          var YOsiz = stream.getInt32() >>> 0; // Byte 16\n          stream.skip(16);\n          var Csiz = stream.getUint16(); // Byte 36\n          this.width = Xsiz - XOsiz;\n          this.height = Ysiz - YOsiz;\n          this.componentsCount = Csiz;\n          // Results are always returned as `Uint8ClampedArray`s.\n          this.bitsPerComponent = 8;\n          return;\n        }\n      }\n      throw new JpxError('No size marker found in JPX stream');\n    },\n    parseCodestream: function JpxImage_parseCodestream(data, start, end) {\n      var context = {};\n      var doNotRecover = false;\n      try {\n        var position = start;\n        while (position + 1 < end) {\n          var code = readUint16(data, position);\n          position += 2;\n\n          var length = 0, j, sqcd, spqcds, spqcdSize, scalarExpounded, tile;\n          switch (code) {\n            case 0xFF4F: // Start of codestream (SOC)\n              context.mainHeader = true;\n              break;\n            case 0xFFD9: // End of codestream (EOC)\n              break;\n            case 0xFF51: // Image and tile size (SIZ)\n              length = readUint16(data, position);\n              var siz = {};\n              siz.Xsiz = readUint32(data, position + 4);\n              siz.Ysiz = readUint32(data, position + 8);\n              siz.XOsiz = readUint32(data, position + 12);\n              siz.YOsiz = readUint32(data, position + 16);\n              siz.XTsiz = readUint32(data, position + 20);\n              siz.YTsiz = readUint32(data, position + 24);\n              siz.XTOsiz = readUint32(data, position + 28);\n              siz.YTOsiz = readUint32(data, position + 32);\n              var componentsCount = readUint16(data, position + 36);\n              siz.Csiz = componentsCount;\n              var components = [];\n              j = position + 38;\n              for (var i = 0; i < componentsCount; i++) {\n                var component = {\n                  precision: (data[j] & 0x7F) + 1,\n                  isSigned: !!(data[j] & 0x80),\n                  XRsiz: data[j + 1],\n                  YRsiz: data[j + 2],\n                };\n                j += 3;\n                calculateComponentDimensions(component, siz);\n                components.push(component);\n              }\n              context.SIZ = siz;\n              context.components = components;\n              calculateTileGrids(context, components);\n              context.QCC = [];\n              context.COC = [];\n              break;\n            case 0xFF5C: // Quantization default (QCD)\n              length = readUint16(data, position);\n              var qcd = {};\n              j = position + 2;\n              sqcd = data[j++];\n              switch (sqcd & 0x1F) {\n                case 0:\n                  spqcdSize = 8;\n                  scalarExpounded = true;\n                  break;\n                case 1:\n                  spqcdSize = 16;\n                  scalarExpounded = false;\n                  break;\n                case 2:\n                  spqcdSize = 16;\n                  scalarExpounded = true;\n                  break;\n                default:\n                  throw new Error('Invalid SQcd value ' + sqcd);\n              }\n              qcd.noQuantization = (spqcdSize === 8);\n              qcd.scalarExpounded = scalarExpounded;\n              qcd.guardBits = sqcd >> 5;\n              spqcds = [];\n              while (j < length + position) {\n                var spqcd = {};\n                if (spqcdSize === 8) {\n                  spqcd.epsilon = data[j++] >> 3;\n                  spqcd.mu = 0;\n                } else {\n                  spqcd.epsilon = data[j] >> 3;\n                  spqcd.mu = ((data[j] & 0x7) << 8) | data[j + 1];\n                  j += 2;\n                }\n                spqcds.push(spqcd);\n              }\n              qcd.SPqcds = spqcds;\n              if (context.mainHeader) {\n                context.QCD = qcd;\n              } else {\n                context.currentTile.QCD = qcd;\n                context.currentTile.QCC = [];\n              }\n              break;\n            case 0xFF5D: // Quantization component (QCC)\n              length = readUint16(data, position);\n              var qcc = {};\n              j = position + 2;\n              var cqcc;\n              if (context.SIZ.Csiz < 257) {\n                cqcc = data[j++];\n              } else {\n                cqcc = readUint16(data, j);\n                j += 2;\n              }\n              sqcd = data[j++];\n              switch (sqcd & 0x1F) {\n                case 0:\n                  spqcdSize = 8;\n                  scalarExpounded = true;\n                  break;\n                case 1:\n                  spqcdSize = 16;\n                  scalarExpounded = false;\n                  break;\n                case 2:\n                  spqcdSize = 16;\n                  scalarExpounded = true;\n                  break;\n                default:\n                  throw new Error('Invalid SQcd value ' + sqcd);\n              }\n              qcc.noQuantization = (spqcdSize === 8);\n              qcc.scalarExpounded = scalarExpounded;\n              qcc.guardBits = sqcd >> 5;\n              spqcds = [];\n              while (j < (length + position)) {\n                spqcd = {};\n                if (spqcdSize === 8) {\n                  spqcd.epsilon = data[j++] >> 3;\n                  spqcd.mu = 0;\n                } else {\n                  spqcd.epsilon = data[j] >> 3;\n                  spqcd.mu = ((data[j] & 0x7) << 8) | data[j + 1];\n                  j += 2;\n                }\n                spqcds.push(spqcd);\n              }\n              qcc.SPqcds = spqcds;\n              if (context.mainHeader) {\n                context.QCC[cqcc] = qcc;\n              } else {\n                context.currentTile.QCC[cqcc] = qcc;\n              }\n              break;\n            case 0xFF52: // Coding style default (COD)\n              length = readUint16(data, position);\n              var cod = {};\n              j = position + 2;\n              var scod = data[j++];\n              cod.entropyCoderWithCustomPrecincts = !!(scod & 1);\n              cod.sopMarkerUsed = !!(scod & 2);\n              cod.ephMarkerUsed = !!(scod & 4);\n              cod.progressionOrder = data[j++];\n              cod.layersCount = readUint16(data, j);\n              j += 2;\n              cod.multipleComponentTransform = data[j++];\n\n              cod.decompositionLevelsCount = data[j++];\n              cod.xcb = (data[j++] & 0xF) + 2;\n              cod.ycb = (data[j++] & 0xF) + 2;\n              var blockStyle = data[j++];\n              cod.selectiveArithmeticCodingBypass = !!(blockStyle & 1);\n              cod.resetContextProbabilities = !!(blockStyle & 2);\n              cod.terminationOnEachCodingPass = !!(blockStyle & 4);\n              cod.verticallyStripe = !!(blockStyle & 8);\n              cod.predictableTermination = !!(blockStyle & 16);\n              cod.segmentationSymbolUsed = !!(blockStyle & 32);\n              cod.reversibleTransformation = data[j++];\n              if (cod.entropyCoderWithCustomPrecincts) {\n                var precinctsSizes = [];\n                while (j < length + position) {\n                  var precinctsSize = data[j++];\n                  precinctsSizes.push({\n                    PPx: precinctsSize & 0xF,\n                    PPy: precinctsSize >> 4,\n                  });\n                }\n                cod.precinctsSizes = precinctsSizes;\n              }\n              var unsupported = [];\n              if (cod.selectiveArithmeticCodingBypass) {\n                unsupported.push('selectiveArithmeticCodingBypass');\n              }\n              if (cod.resetContextProbabilities) {\n                unsupported.push('resetContextProbabilities');\n              }\n              if (cod.terminationOnEachCodingPass) {\n                unsupported.push('terminationOnEachCodingPass');\n              }\n              if (cod.verticallyStripe) {\n                unsupported.push('verticallyStripe');\n              }\n              if (cod.predictableTermination) {\n                unsupported.push('predictableTermination');\n              }\n              if (unsupported.length > 0) {\n                doNotRecover = true;\n                throw new Error('Unsupported COD options (' +\n                                unsupported.join(', ') + ')');\n              }\n              if (context.mainHeader) {\n                context.COD = cod;\n              } else {\n                context.currentTile.COD = cod;\n                context.currentTile.COC = [];\n              }\n              break;\n            case 0xFF90: // Start of tile-part (SOT)\n              length = readUint16(data, position);\n              tile = {};\n              tile.index = readUint16(data, position + 2);\n              tile.length = readUint32(data, position + 4);\n              tile.dataEnd = tile.length + position - 2;\n              tile.partIndex = data[position + 8];\n              tile.partsCount = data[position + 9];\n\n              context.mainHeader = false;\n              if (tile.partIndex === 0) {\n                // reset component specific settings\n                tile.COD = context.COD;\n                tile.COC = context.COC.slice(0); // clone of the global COC\n                tile.QCD = context.QCD;\n                tile.QCC = context.QCC.slice(0); // clone of the global COC\n              }\n              context.currentTile = tile;\n              break;\n            case 0xFF93: // Start of data (SOD)\n              tile = context.currentTile;\n              if (tile.partIndex === 0) {\n                initializeTile(context, tile.index);\n                buildPackets(context);\n              }\n\n              // moving to the end of the data\n              length = tile.dataEnd - position;\n              parseTilePackets(context, data, position, length);\n              break;\n            case 0xFF55: // Tile-part lengths, main header (TLM)\n            case 0xFF57: // Packet length, main header (PLM)\n            case 0xFF58: // Packet length, tile-part header (PLT)\n            case 0xFF64: // Comment (COM)\n              length = readUint16(data, position);\n              // skipping content\n              break;\n            case 0xFF53: // Coding style component (COC)\n              throw new Error('Codestream code 0xFF53 (COC) is ' +\n                              'not implemented');\n            default:\n              throw new Error('Unknown codestream code: ' + code.toString(16));\n          }\n          position += length;\n        }\n      } catch (e) {\n        if (doNotRecover || this.failOnCorruptedImage) {\n          throw new JpxError(e.message);\n        } else {\n          warn('JPX: Trying to recover from: ' + e.message);\n        }\n      }\n      this.tiles = transformComponents(context);\n      this.width = context.SIZ.Xsiz - context.SIZ.XOsiz;\n      this.height = context.SIZ.Ysiz - context.SIZ.YOsiz;\n      this.componentsCount = context.SIZ.Csiz;\n    },\n  };\n  function calculateComponentDimensions(component, siz) {\n    // Section B.2 Component mapping\n    component.x0 = Math.ceil(siz.XOsiz / component.XRsiz);\n    component.x1 = Math.ceil(siz.Xsiz / component.XRsiz);\n    component.y0 = Math.ceil(siz.YOsiz / component.YRsiz);\n    component.y1 = Math.ceil(siz.Ysiz / component.YRsiz);\n    component.width = component.x1 - component.x0;\n    component.height = component.y1 - component.y0;\n  }\n  function calculateTileGrids(context, components) {\n    var siz = context.SIZ;\n    // Section B.3 Division into tile and tile-components\n    var tile, tiles = [];\n    var numXtiles = Math.ceil((siz.Xsiz - siz.XTOsiz) / siz.XTsiz);\n    var numYtiles = Math.ceil((siz.Ysiz - siz.YTOsiz) / siz.YTsiz);\n    for (var q = 0; q < numYtiles; q++) {\n      for (var p = 0; p < numXtiles; p++) {\n        tile = {};\n        tile.tx0 = Math.max(siz.XTOsiz + p * siz.XTsiz, siz.XOsiz);\n        tile.ty0 = Math.max(siz.YTOsiz + q * siz.YTsiz, siz.YOsiz);\n        tile.tx1 = Math.min(siz.XTOsiz + (p + 1) * siz.XTsiz, siz.Xsiz);\n        tile.ty1 = Math.min(siz.YTOsiz + (q + 1) * siz.YTsiz, siz.Ysiz);\n        tile.width = tile.tx1 - tile.tx0;\n        tile.height = tile.ty1 - tile.ty0;\n        tile.components = [];\n        tiles.push(tile);\n      }\n    }\n    context.tiles = tiles;\n\n    var componentsCount = siz.Csiz;\n    for (var i = 0, ii = componentsCount; i < ii; i++) {\n      var component = components[i];\n      for (var j = 0, jj = tiles.length; j < jj; j++) {\n        var tileComponent = {};\n        tile = tiles[j];\n        tileComponent.tcx0 = Math.ceil(tile.tx0 / component.XRsiz);\n        tileComponent.tcy0 = Math.ceil(tile.ty0 / component.YRsiz);\n        tileComponent.tcx1 = Math.ceil(tile.tx1 / component.XRsiz);\n        tileComponent.tcy1 = Math.ceil(tile.ty1 / component.YRsiz);\n        tileComponent.width = tileComponent.tcx1 - tileComponent.tcx0;\n        tileComponent.height = tileComponent.tcy1 - tileComponent.tcy0;\n        tile.components[i] = tileComponent;\n      }\n    }\n  }\n  function getBlocksDimensions(context, component, r) {\n    var codOrCoc = component.codingStyleParameters;\n    var result = {};\n    if (!codOrCoc.entropyCoderWithCustomPrecincts) {\n      result.PPx = 15;\n      result.PPy = 15;\n    } else {\n      result.PPx = codOrCoc.precinctsSizes[r].PPx;\n      result.PPy = codOrCoc.precinctsSizes[r].PPy;\n    }\n    // calculate codeblock size as described in section B.7\n    result.xcb_ = (r > 0 ? Math.min(codOrCoc.xcb, result.PPx - 1) :\n                   Math.min(codOrCoc.xcb, result.PPx));\n    result.ycb_ = (r > 0 ? Math.min(codOrCoc.ycb, result.PPy - 1) :\n                   Math.min(codOrCoc.ycb, result.PPy));\n    return result;\n  }\n  function buildPrecincts(context, resolution, dimensions) {\n    // Section B.6 Division resolution to precincts\n    var precinctWidth = 1 << dimensions.PPx;\n    var precinctHeight = 1 << dimensions.PPy;\n    // Jasper introduces codeblock groups for mapping each subband codeblocks\n    // to precincts. Precinct partition divides a resolution according to width\n    // and height parameters. The subband that belongs to the resolution level\n    // has a different size than the level, unless it is the zero resolution.\n\n    // From Jasper documentation: jpeg2000.pdf, section K: Tier-2 coding:\n    // The precinct partitioning for a particular subband is derived from a\n    // partitioning of its parent LL band (i.e., the LL band at the next higher\n    // resolution level)... The LL band associated with each resolution level is\n    // divided into precincts... Each of the resulting precinct regions is then\n    // mapped into its child subbands (if any) at the next lower resolution\n    // level. This is accomplished by using the coordinate transformation\n    // (u, v) = (ceil(x/2), ceil(y/2)) where (x, y) and (u, v) are the\n    // coordinates of a point in the LL band and child subband, respectively.\n    var isZeroRes = resolution.resLevel === 0;\n    var precinctWidthInSubband = 1 << (dimensions.PPx + (isZeroRes ? 0 : -1));\n    var precinctHeightInSubband = 1 << (dimensions.PPy + (isZeroRes ? 0 : -1));\n    var numprecinctswide = (resolution.trx1 > resolution.trx0 ?\n      Math.ceil(resolution.trx1 / precinctWidth) -\n      Math.floor(resolution.trx0 / precinctWidth) : 0);\n    var numprecinctshigh = (resolution.try1 > resolution.try0 ?\n      Math.ceil(resolution.try1 / precinctHeight) -\n      Math.floor(resolution.try0 / precinctHeight) : 0);\n    var numprecincts = numprecinctswide * numprecinctshigh;\n\n    resolution.precinctParameters = {\n      precinctWidth,\n      precinctHeight,\n      numprecinctswide,\n      numprecinctshigh,\n      numprecincts,\n      precinctWidthInSubband,\n      precinctHeightInSubband,\n    };\n  }\n  function buildCodeblocks(context, subband, dimensions) {\n    // Section B.7 Division sub-band into code-blocks\n    var xcb_ = dimensions.xcb_;\n    var ycb_ = dimensions.ycb_;\n    var codeblockWidth = 1 << xcb_;\n    var codeblockHeight = 1 << ycb_;\n    var cbx0 = subband.tbx0 >> xcb_;\n    var cby0 = subband.tby0 >> ycb_;\n    var cbx1 = (subband.tbx1 + codeblockWidth - 1) >> xcb_;\n    var cby1 = (subband.tby1 + codeblockHeight - 1) >> ycb_;\n    var precinctParameters = subband.resolution.precinctParameters;\n    var codeblocks = [];\n    var precincts = [];\n    var i, j, codeblock, precinctNumber;\n    for (j = cby0; j < cby1; j++) {\n      for (i = cbx0; i < cbx1; i++) {\n        codeblock = {\n          cbx: i,\n          cby: j,\n          tbx0: codeblockWidth * i,\n          tby0: codeblockHeight * j,\n          tbx1: codeblockWidth * (i + 1),\n          tby1: codeblockHeight * (j + 1),\n        };\n\n        codeblock.tbx0_ = Math.max(subband.tbx0, codeblock.tbx0);\n        codeblock.tby0_ = Math.max(subband.tby0, codeblock.tby0);\n        codeblock.tbx1_ = Math.min(subband.tbx1, codeblock.tbx1);\n        codeblock.tby1_ = Math.min(subband.tby1, codeblock.tby1);\n\n        // Calculate precinct number for this codeblock, codeblock position\n        // should be relative to its subband, use actual dimension and position\n        // See comment about codeblock group width and height\n        var pi = Math.floor((codeblock.tbx0_ - subband.tbx0) /\n          precinctParameters.precinctWidthInSubband);\n        var pj = Math.floor((codeblock.tby0_ - subband.tby0) /\n          precinctParameters.precinctHeightInSubband);\n        precinctNumber = pi + (pj * precinctParameters.numprecinctswide);\n\n        codeblock.precinctNumber = precinctNumber;\n        codeblock.subbandType = subband.type;\n        codeblock.Lblock = 3;\n\n        if (codeblock.tbx1_ <= codeblock.tbx0_ ||\n            codeblock.tby1_ <= codeblock.tby0_) {\n          continue;\n        }\n        codeblocks.push(codeblock);\n        // building precinct for the sub-band\n        var precinct = precincts[precinctNumber];\n        if (precinct !== undefined) {\n          if (i < precinct.cbxMin) {\n            precinct.cbxMin = i;\n          } else if (i > precinct.cbxMax) {\n            precinct.cbxMax = i;\n          }\n          if (j < precinct.cbyMin) {\n            precinct.cbxMin = j;\n          } else if (j > precinct.cbyMax) {\n            precinct.cbyMax = j;\n          }\n        } else {\n          precincts[precinctNumber] = precinct = {\n            cbxMin: i,\n            cbyMin: j,\n            cbxMax: i,\n            cbyMax: j,\n          };\n        }\n        codeblock.precinct = precinct;\n      }\n    }\n    subband.codeblockParameters = {\n      codeblockWidth: xcb_,\n      codeblockHeight: ycb_,\n      numcodeblockwide: cbx1 - cbx0 + 1,\n      numcodeblockhigh: cby1 - cby0 + 1,\n    };\n    subband.codeblocks = codeblocks;\n    subband.precincts = precincts;\n  }\n  function createPacket(resolution, precinctNumber, layerNumber) {\n    var precinctCodeblocks = [];\n    // Section B.10.8 Order of info in packet\n    var subbands = resolution.subbands;\n    // sub-bands already ordered in 'LL', 'HL', 'LH', and 'HH' sequence\n    for (var i = 0, ii = subbands.length; i < ii; i++) {\n      var subband = subbands[i];\n      var codeblocks = subband.codeblocks;\n      for (var j = 0, jj = codeblocks.length; j < jj; j++) {\n        var codeblock = codeblocks[j];\n        if (codeblock.precinctNumber !== precinctNumber) {\n          continue;\n        }\n        precinctCodeblocks.push(codeblock);\n      }\n    }\n    return {\n      layerNumber,\n      codeblocks: precinctCodeblocks,\n    };\n  }\n  function LayerResolutionComponentPositionIterator(context) {\n    var siz = context.SIZ;\n    var tileIndex = context.currentTile.index;\n    var tile = context.tiles[tileIndex];\n    var layersCount = tile.codingStyleDefaultParameters.layersCount;\n    var componentsCount = siz.Csiz;\n    var maxDecompositionLevelsCount = 0;\n    for (var q = 0; q < componentsCount; q++) {\n      maxDecompositionLevelsCount = Math.max(maxDecompositionLevelsCount,\n        tile.components[q].codingStyleParameters.decompositionLevelsCount);\n    }\n\n    var l = 0, r = 0, i = 0, k = 0;\n\n    this.nextPacket = function JpxImage_nextPacket() {\n      // Section B.12.1.1 Layer-resolution-component-position\n      for (; l < layersCount; l++) {\n        for (; r <= maxDecompositionLevelsCount; r++) {\n          for (; i < componentsCount; i++) {\n            var component = tile.components[i];\n            if (r > component.codingStyleParameters.decompositionLevelsCount) {\n              continue;\n            }\n\n            var resolution = component.resolutions[r];\n            var numprecincts = resolution.precinctParameters.numprecincts;\n            for (; k < numprecincts;) {\n              var packet = createPacket(resolution, k, l);\n              k++;\n              return packet;\n            }\n            k = 0;\n          }\n          i = 0;\n        }\n        r = 0;\n      }\n      throw new JpxError('Out of packets');\n    };\n  }\n  function ResolutionLayerComponentPositionIterator(context) {\n    var siz = context.SIZ;\n    var tileIndex = context.currentTile.index;\n    var tile = context.tiles[tileIndex];\n    var layersCount = tile.codingStyleDefaultParameters.layersCount;\n    var componentsCount = siz.Csiz;\n    var maxDecompositionLevelsCount = 0;\n    for (var q = 0; q < componentsCount; q++) {\n      maxDecompositionLevelsCount = Math.max(maxDecompositionLevelsCount,\n        tile.components[q].codingStyleParameters.decompositionLevelsCount);\n    }\n\n    var r = 0, l = 0, i = 0, k = 0;\n\n    this.nextPacket = function JpxImage_nextPacket() {\n      // Section B.12.1.2 Resolution-layer-component-position\n      for (; r <= maxDecompositionLevelsCount; r++) {\n        for (; l < layersCount; l++) {\n          for (; i < componentsCount; i++) {\n            var component = tile.components[i];\n            if (r > component.codingStyleParameters.decompositionLevelsCount) {\n              continue;\n            }\n\n            var resolution = component.resolutions[r];\n            var numprecincts = resolution.precinctParameters.numprecincts;\n            for (; k < numprecincts;) {\n              var packet = createPacket(resolution, k, l);\n              k++;\n              return packet;\n            }\n            k = 0;\n          }\n          i = 0;\n        }\n        l = 0;\n      }\n      throw new JpxError('Out of packets');\n    };\n  }\n  function ResolutionPositionComponentLayerIterator(context) {\n    var siz = context.SIZ;\n    var tileIndex = context.currentTile.index;\n    var tile = context.tiles[tileIndex];\n    var layersCount = tile.codingStyleDefaultParameters.layersCount;\n    var componentsCount = siz.Csiz;\n    var l, r, c, p;\n    var maxDecompositionLevelsCount = 0;\n    for (c = 0; c < componentsCount; c++) {\n      var component = tile.components[c];\n      maxDecompositionLevelsCount = Math.max(maxDecompositionLevelsCount,\n        component.codingStyleParameters.decompositionLevelsCount);\n    }\n    var maxNumPrecinctsInLevel = new Int32Array(\n      maxDecompositionLevelsCount + 1);\n    for (r = 0; r <= maxDecompositionLevelsCount; ++r) {\n      var maxNumPrecincts = 0;\n      for (c = 0; c < componentsCount; ++c) {\n        var resolutions = tile.components[c].resolutions;\n        if (r < resolutions.length) {\n          maxNumPrecincts = Math.max(maxNumPrecincts,\n            resolutions[r].precinctParameters.numprecincts);\n        }\n      }\n      maxNumPrecinctsInLevel[r] = maxNumPrecincts;\n    }\n    l = 0;\n    r = 0;\n    c = 0;\n    p = 0;\n\n    this.nextPacket = function JpxImage_nextPacket() {\n      // Section B.12.1.3 Resolution-position-component-layer\n      for (; r <= maxDecompositionLevelsCount; r++) {\n        for (; p < maxNumPrecinctsInLevel[r]; p++) {\n          for (; c < componentsCount; c++) {\n            var component = tile.components[c];\n            if (r > component.codingStyleParameters.decompositionLevelsCount) {\n              continue;\n            }\n            var resolution = component.resolutions[r];\n            var numprecincts = resolution.precinctParameters.numprecincts;\n            if (p >= numprecincts) {\n              continue;\n            }\n            for (; l < layersCount;) {\n              var packet = createPacket(resolution, p, l);\n              l++;\n              return packet;\n            }\n            l = 0;\n          }\n          c = 0;\n        }\n        p = 0;\n      }\n      throw new JpxError('Out of packets');\n    };\n  }\n  function PositionComponentResolutionLayerIterator(context) {\n    var siz = context.SIZ;\n    var tileIndex = context.currentTile.index;\n    var tile = context.tiles[tileIndex];\n    var layersCount = tile.codingStyleDefaultParameters.layersCount;\n    var componentsCount = siz.Csiz;\n    var precinctsSizes = getPrecinctSizesInImageScale(tile);\n    var precinctsIterationSizes = precinctsSizes;\n    var l = 0, r = 0, c = 0, px = 0, py = 0;\n\n    this.nextPacket = function JpxImage_nextPacket() {\n      // Section B.12.1.4 Position-component-resolution-layer\n      for (; py < precinctsIterationSizes.maxNumHigh; py++) {\n        for (; px < precinctsIterationSizes.maxNumWide; px++) {\n          for (; c < componentsCount; c++) {\n            var component = tile.components[c];\n            var decompositionLevelsCount =\n              component.codingStyleParameters.decompositionLevelsCount;\n            for (; r <= decompositionLevelsCount; r++) {\n              var resolution = component.resolutions[r];\n              var sizeInImageScale =\n                precinctsSizes.components[c].resolutions[r];\n              var k = getPrecinctIndexIfExist(\n                px,\n                py,\n                sizeInImageScale,\n                precinctsIterationSizes,\n                resolution);\n              if (k === null) {\n                continue;\n              }\n              for (; l < layersCount;) {\n                var packet = createPacket(resolution, k, l);\n                l++;\n                return packet;\n              }\n              l = 0;\n            }\n            r = 0;\n          }\n          c = 0;\n        }\n        px = 0;\n      }\n      throw new JpxError('Out of packets');\n    };\n  }\n  function ComponentPositionResolutionLayerIterator(context) {\n    var siz = context.SIZ;\n    var tileIndex = context.currentTile.index;\n    var tile = context.tiles[tileIndex];\n    var layersCount = tile.codingStyleDefaultParameters.layersCount;\n    var componentsCount = siz.Csiz;\n    var precinctsSizes = getPrecinctSizesInImageScale(tile);\n    var l = 0, r = 0, c = 0, px = 0, py = 0;\n\n    this.nextPacket = function JpxImage_nextPacket() {\n      // Section B.12.1.5 Component-position-resolution-layer\n      for (; c < componentsCount; ++c) {\n        var component = tile.components[c];\n        var precinctsIterationSizes = precinctsSizes.components[c];\n        var decompositionLevelsCount =\n          component.codingStyleParameters.decompositionLevelsCount;\n        for (; py < precinctsIterationSizes.maxNumHigh; py++) {\n          for (; px < precinctsIterationSizes.maxNumWide; px++) {\n            for (; r <= decompositionLevelsCount; r++) {\n              var resolution = component.resolutions[r];\n              var sizeInImageScale = precinctsIterationSizes.resolutions[r];\n              var k = getPrecinctIndexIfExist(\n                px,\n                py,\n                sizeInImageScale,\n                precinctsIterationSizes,\n                resolution);\n              if (k === null) {\n                continue;\n              }\n              for (; l < layersCount;) {\n                var packet = createPacket(resolution, k, l);\n                l++;\n                return packet;\n              }\n              l = 0;\n            }\n            r = 0;\n          }\n          px = 0;\n        }\n        py = 0;\n      }\n      throw new JpxError('Out of packets');\n    };\n  }\n  function getPrecinctIndexIfExist(\n    pxIndex, pyIndex, sizeInImageScale, precinctIterationSizes, resolution) {\n    var posX = pxIndex * precinctIterationSizes.minWidth;\n    var posY = pyIndex * precinctIterationSizes.minHeight;\n    if (posX % sizeInImageScale.width !== 0 ||\n        posY % sizeInImageScale.height !== 0) {\n      return null;\n    }\n    var startPrecinctRowIndex =\n      (posY / sizeInImageScale.width) *\n      resolution.precinctParameters.numprecinctswide;\n    return (posX / sizeInImageScale.height) + startPrecinctRowIndex;\n  }\n  function getPrecinctSizesInImageScale(tile) {\n    var componentsCount = tile.components.length;\n    var minWidth = Number.MAX_VALUE;\n    var minHeight = Number.MAX_VALUE;\n    var maxNumWide = 0;\n    var maxNumHigh = 0;\n    var sizePerComponent = new Array(componentsCount);\n    for (var c = 0; c < componentsCount; c++) {\n      var component = tile.components[c];\n      var decompositionLevelsCount =\n        component.codingStyleParameters.decompositionLevelsCount;\n      var sizePerResolution = new Array(decompositionLevelsCount + 1);\n      var minWidthCurrentComponent = Number.MAX_VALUE;\n      var minHeightCurrentComponent = Number.MAX_VALUE;\n      var maxNumWideCurrentComponent = 0;\n      var maxNumHighCurrentComponent = 0;\n      var scale = 1;\n      for (var r = decompositionLevelsCount; r >= 0; --r) {\n        var resolution = component.resolutions[r];\n        var widthCurrentResolution =\n          scale * resolution.precinctParameters.precinctWidth;\n        var heightCurrentResolution =\n          scale * resolution.precinctParameters.precinctHeight;\n        minWidthCurrentComponent = Math.min(\n          minWidthCurrentComponent,\n          widthCurrentResolution);\n        minHeightCurrentComponent = Math.min(\n          minHeightCurrentComponent,\n          heightCurrentResolution);\n        maxNumWideCurrentComponent = Math.max(maxNumWideCurrentComponent,\n          resolution.precinctParameters.numprecinctswide);\n        maxNumHighCurrentComponent = Math.max(maxNumHighCurrentComponent,\n          resolution.precinctParameters.numprecinctshigh);\n        sizePerResolution[r] = {\n          width: widthCurrentResolution,\n          height: heightCurrentResolution,\n        };\n        scale <<= 1;\n      }\n      minWidth = Math.min(minWidth, minWidthCurrentComponent);\n      minHeight = Math.min(minHeight, minHeightCurrentComponent);\n      maxNumWide = Math.max(maxNumWide, maxNumWideCurrentComponent);\n      maxNumHigh = Math.max(maxNumHigh, maxNumHighCurrentComponent);\n      sizePerComponent[c] = {\n        resolutions: sizePerResolution,\n        minWidth: minWidthCurrentComponent,\n        minHeight: minHeightCurrentComponent,\n        maxNumWide: maxNumWideCurrentComponent,\n        maxNumHigh: maxNumHighCurrentComponent,\n      };\n    }\n    return {\n      components: sizePerComponent,\n      minWidth,\n      minHeight,\n      maxNumWide,\n      maxNumHigh,\n    };\n  }\n  function buildPackets(context) {\n    var siz = context.SIZ;\n    var tileIndex = context.currentTile.index;\n    var tile = context.tiles[tileIndex];\n    var componentsCount = siz.Csiz;\n    // Creating resolutions and sub-bands for each component\n    for (var c = 0; c < componentsCount; c++) {\n      var component = tile.components[c];\n      var decompositionLevelsCount =\n        component.codingStyleParameters.decompositionLevelsCount;\n      // Section B.5 Resolution levels and sub-bands\n      var resolutions = [];\n      var subbands = [];\n      for (var r = 0; r <= decompositionLevelsCount; r++) {\n        var blocksDimensions = getBlocksDimensions(context, component, r);\n        var resolution = {};\n        var scale = 1 << (decompositionLevelsCount - r);\n        resolution.trx0 = Math.ceil(component.tcx0 / scale);\n        resolution.try0 = Math.ceil(component.tcy0 / scale);\n        resolution.trx1 = Math.ceil(component.tcx1 / scale);\n        resolution.try1 = Math.ceil(component.tcy1 / scale);\n        resolution.resLevel = r;\n        buildPrecincts(context, resolution, blocksDimensions);\n        resolutions.push(resolution);\n\n        var subband;\n        if (r === 0) {\n          // one sub-band (LL) with last decomposition\n          subband = {};\n          subband.type = 'LL';\n          subband.tbx0 = Math.ceil(component.tcx0 / scale);\n          subband.tby0 = Math.ceil(component.tcy0 / scale);\n          subband.tbx1 = Math.ceil(component.tcx1 / scale);\n          subband.tby1 = Math.ceil(component.tcy1 / scale);\n          subband.resolution = resolution;\n          buildCodeblocks(context, subband, blocksDimensions);\n          subbands.push(subband);\n          resolution.subbands = [subband];\n        } else {\n          var bscale = 1 << (decompositionLevelsCount - r + 1);\n          var resolutionSubbands = [];\n          // three sub-bands (HL, LH and HH) with rest of decompositions\n          subband = {};\n          subband.type = 'HL';\n          subband.tbx0 = Math.ceil(component.tcx0 / bscale - 0.5);\n          subband.tby0 = Math.ceil(component.tcy0 / bscale);\n          subband.tbx1 = Math.ceil(component.tcx1 / bscale - 0.5);\n          subband.tby1 = Math.ceil(component.tcy1 / bscale);\n          subband.resolution = resolution;\n          buildCodeblocks(context, subband, blocksDimensions);\n          subbands.push(subband);\n          resolutionSubbands.push(subband);\n\n          subband = {};\n          subband.type = 'LH';\n          subband.tbx0 = Math.ceil(component.tcx0 / bscale);\n          subband.tby0 = Math.ceil(component.tcy0 / bscale - 0.5);\n          subband.tbx1 = Math.ceil(component.tcx1 / bscale);\n          subband.tby1 = Math.ceil(component.tcy1 / bscale - 0.5);\n          subband.resolution = resolution;\n          buildCodeblocks(context, subband, blocksDimensions);\n          subbands.push(subband);\n          resolutionSubbands.push(subband);\n\n          subband = {};\n          subband.type = 'HH';\n          subband.tbx0 = Math.ceil(component.tcx0 / bscale - 0.5);\n          subband.tby0 = Math.ceil(component.tcy0 / bscale - 0.5);\n          subband.tbx1 = Math.ceil(component.tcx1 / bscale - 0.5);\n          subband.tby1 = Math.ceil(component.tcy1 / bscale - 0.5);\n          subband.resolution = resolution;\n          buildCodeblocks(context, subband, blocksDimensions);\n          subbands.push(subband);\n          resolutionSubbands.push(subband);\n\n          resolution.subbands = resolutionSubbands;\n        }\n      }\n      component.resolutions = resolutions;\n      component.subbands = subbands;\n    }\n    // Generate the packets sequence\n    var progressionOrder = tile.codingStyleDefaultParameters.progressionOrder;\n    switch (progressionOrder) {\n      case 0:\n        tile.packetsIterator =\n          new LayerResolutionComponentPositionIterator(context);\n        break;\n      case 1:\n        tile.packetsIterator =\n          new ResolutionLayerComponentPositionIterator(context);\n        break;\n      case 2:\n        tile.packetsIterator =\n          new ResolutionPositionComponentLayerIterator(context);\n        break;\n      case 3:\n        tile.packetsIterator =\n          new PositionComponentResolutionLayerIterator(context);\n        break;\n      case 4:\n        tile.packetsIterator =\n          new ComponentPositionResolutionLayerIterator(context);\n        break;\n      default:\n        throw new JpxError(`Unsupported progression order ${progressionOrder}`);\n    }\n  }\n  function parseTilePackets(context, data, offset, dataLength) {\n    var position = 0;\n    var buffer, bufferSize = 0, skipNextBit = false;\n    function readBits(count) {\n      while (bufferSize < count) {\n        var b = data[offset + position];\n        position++;\n        if (skipNextBit) {\n          buffer = (buffer << 7) | b;\n          bufferSize += 7;\n          skipNextBit = false;\n        } else {\n          buffer = (buffer << 8) | b;\n          bufferSize += 8;\n        }\n        if (b === 0xFF) {\n          skipNextBit = true;\n        }\n      }\n      bufferSize -= count;\n      return (buffer >>> bufferSize) & ((1 << count) - 1);\n    }\n    function skipMarkerIfEqual(value) {\n      if (data[offset + position - 1] === 0xFF &&\n          data[offset + position] === value) {\n        skipBytes(1);\n        return true;\n      } else if (data[offset + position] === 0xFF &&\n                 data[offset + position + 1] === value) {\n        skipBytes(2);\n        return true;\n      }\n      return false;\n    }\n    function skipBytes(count) {\n      position += count;\n    }\n    function alignToByte() {\n      bufferSize = 0;\n      if (skipNextBit) {\n        position++;\n        skipNextBit = false;\n      }\n    }\n    function readCodingpasses() {\n      if (readBits(1) === 0) {\n        return 1;\n      }\n      if (readBits(1) === 0) {\n        return 2;\n      }\n      var value = readBits(2);\n      if (value < 3) {\n        return value + 3;\n      }\n      value = readBits(5);\n      if (value < 31) {\n        return value + 6;\n      }\n      value = readBits(7);\n      return value + 37;\n    }\n    var tileIndex = context.currentTile.index;\n    var tile = context.tiles[tileIndex];\n    var sopMarkerUsed = context.COD.sopMarkerUsed;\n    var ephMarkerUsed = context.COD.ephMarkerUsed;\n    var packetsIterator = tile.packetsIterator;\n    while (position < dataLength) {\n      alignToByte();\n      if (sopMarkerUsed && skipMarkerIfEqual(0x91)) {\n        // Skip also marker segment length and packet sequence ID\n        skipBytes(4);\n      }\n      var packet = packetsIterator.nextPacket();\n      if (!readBits(1)) {\n        continue;\n      }\n      var layerNumber = packet.layerNumber;\n      var queue = [], codeblock;\n      for (var i = 0, ii = packet.codeblocks.length; i < ii; i++) {\n        codeblock = packet.codeblocks[i];\n        var precinct = codeblock.precinct;\n        var codeblockColumn = codeblock.cbx - precinct.cbxMin;\n        var codeblockRow = codeblock.cby - precinct.cbyMin;\n        var codeblockIncluded = false;\n        var firstTimeInclusion = false;\n        var valueReady;\n        if (codeblock['included'] !== undefined) {\n          codeblockIncluded = !!readBits(1);\n        } else {\n          // reading inclusion tree\n          precinct = codeblock.precinct;\n          var inclusionTree, zeroBitPlanesTree;\n          if (precinct['inclusionTree'] !== undefined) {\n            inclusionTree = precinct.inclusionTree;\n          } else {\n            // building inclusion and zero bit-planes trees\n            var width = precinct.cbxMax - precinct.cbxMin + 1;\n            var height = precinct.cbyMax - precinct.cbyMin + 1;\n            inclusionTree = new InclusionTree(width, height, layerNumber);\n            zeroBitPlanesTree = new TagTree(width, height);\n            precinct.inclusionTree = inclusionTree;\n            precinct.zeroBitPlanesTree = zeroBitPlanesTree;\n          }\n\n          if (inclusionTree.reset(codeblockColumn, codeblockRow, layerNumber)) {\n            while (true) {\n              if (readBits(1)) {\n                valueReady = !inclusionTree.nextLevel();\n                if (valueReady) {\n                  codeblock.included = true;\n                  codeblockIncluded = firstTimeInclusion = true;\n                  break;\n                }\n              } else {\n                inclusionTree.incrementValue(layerNumber);\n                break;\n              }\n            }\n          }\n        }\n        if (!codeblockIncluded) {\n          continue;\n        }\n        if (firstTimeInclusion) {\n          zeroBitPlanesTree = precinct.zeroBitPlanesTree;\n          zeroBitPlanesTree.reset(codeblockColumn, codeblockRow);\n          while (true) {\n            if (readBits(1)) {\n              valueReady = !zeroBitPlanesTree.nextLevel();\n              if (valueReady) {\n                break;\n              }\n            } else {\n              zeroBitPlanesTree.incrementValue();\n            }\n          }\n          codeblock.zeroBitPlanes = zeroBitPlanesTree.value;\n        }\n        var codingpasses = readCodingpasses();\n        while (readBits(1)) {\n          codeblock.Lblock++;\n        }\n        var codingpassesLog2 = log2(codingpasses);\n        // rounding down log2\n        var bits = ((codingpasses < (1 << codingpassesLog2)) ?\n          codingpassesLog2 - 1 : codingpassesLog2) + codeblock.Lblock;\n        var codedDataLength = readBits(bits);\n        queue.push({\n          codeblock,\n          codingpasses,\n          dataLength: codedDataLength,\n        });\n      }\n      alignToByte();\n      if (ephMarkerUsed) {\n        skipMarkerIfEqual(0x92);\n      }\n      while (queue.length > 0) {\n        var packetItem = queue.shift();\n        codeblock = packetItem.codeblock;\n        if (codeblock['data'] === undefined) {\n          codeblock.data = [];\n        }\n        codeblock.data.push({\n          data,\n          start: offset + position,\n          end: offset + position + packetItem.dataLength,\n          codingpasses: packetItem.codingpasses,\n        });\n        position += packetItem.dataLength;\n      }\n    }\n    return position;\n  }\n  function copyCoefficients(coefficients, levelWidth, levelHeight, subband,\n                            delta, mb, reversible, segmentationSymbolUsed) {\n    var x0 = subband.tbx0;\n    var y0 = subband.tby0;\n    var width = subband.tbx1 - subband.tbx0;\n    var codeblocks = subband.codeblocks;\n    var right = subband.type.charAt(0) === 'H' ? 1 : 0;\n    var bottom = subband.type.charAt(1) === 'H' ? levelWidth : 0;\n\n    for (var i = 0, ii = codeblocks.length; i < ii; ++i) {\n      var codeblock = codeblocks[i];\n      var blockWidth = codeblock.tbx1_ - codeblock.tbx0_;\n      var blockHeight = codeblock.tby1_ - codeblock.tby0_;\n      if (blockWidth === 0 || blockHeight === 0) {\n        continue;\n      }\n      if (codeblock['data'] === undefined) {\n        continue;\n      }\n\n      var bitModel, currentCodingpassType;\n      bitModel = new BitModel(blockWidth, blockHeight, codeblock.subbandType,\n                              codeblock.zeroBitPlanes, mb);\n      currentCodingpassType = 2; // first bit plane starts from cleanup\n\n      // collect data\n      var data = codeblock.data, totalLength = 0, codingpasses = 0;\n      var j, jj, dataItem;\n      for (j = 0, jj = data.length; j < jj; j++) {\n        dataItem = data[j];\n        totalLength += dataItem.end - dataItem.start;\n        codingpasses += dataItem.codingpasses;\n      }\n      var encodedData = new Uint8Array(totalLength);\n      var position = 0;\n      for (j = 0, jj = data.length; j < jj; j++) {\n        dataItem = data[j];\n        var chunk = dataItem.data.subarray(dataItem.start, dataItem.end);\n        encodedData.set(chunk, position);\n        position += chunk.length;\n      }\n      // decoding the item\n      var decoder = new ArithmeticDecoder(encodedData, 0, totalLength);\n      bitModel.setDecoder(decoder);\n\n      for (j = 0; j < codingpasses; j++) {\n        switch (currentCodingpassType) {\n          case 0:\n            bitModel.runSignificancePropagationPass();\n            break;\n          case 1:\n            bitModel.runMagnitudeRefinementPass();\n            break;\n          case 2:\n            bitModel.runCleanupPass();\n            if (segmentationSymbolUsed) {\n              bitModel.checkSegmentationSymbol();\n            }\n            break;\n        }\n        currentCodingpassType = (currentCodingpassType + 1) % 3;\n      }\n\n      var offset = (codeblock.tbx0_ - x0) + (codeblock.tby0_ - y0) * width;\n      var sign = bitModel.coefficentsSign;\n      var magnitude = bitModel.coefficentsMagnitude;\n      var bitsDecoded = bitModel.bitsDecoded;\n      var magnitudeCorrection = reversible ? 0 : 0.5;\n      var k, n, nb;\n      position = 0;\n      // Do the interleaving of Section F.3.3 here, so we do not need\n      // to copy later. LL level is not interleaved, just copied.\n      var interleave = (subband.type !== 'LL');\n      for (j = 0; j < blockHeight; j++) {\n        var row = (offset / width) | 0; // row in the non-interleaved subband\n        var levelOffset = 2 * row * (levelWidth - width) + right + bottom;\n        for (k = 0; k < blockWidth; k++) {\n          n = magnitude[position];\n          if (n !== 0) {\n            n = (n + magnitudeCorrection) * delta;\n            if (sign[position] !== 0) {\n              n = -n;\n            }\n            nb = bitsDecoded[position];\n            var pos = interleave ? (levelOffset + (offset << 1)) : offset;\n            if (reversible && (nb >= mb)) {\n              coefficients[pos] = n;\n            } else {\n              coefficients[pos] = n * (1 << (mb - nb));\n            }\n          }\n          offset++;\n          position++;\n        }\n        offset += width - blockWidth;\n      }\n    }\n  }\n  function transformTile(context, tile, c) {\n    var component = tile.components[c];\n    var codingStyleParameters = component.codingStyleParameters;\n    var quantizationParameters = component.quantizationParameters;\n    var decompositionLevelsCount =\n      codingStyleParameters.decompositionLevelsCount;\n    var spqcds = quantizationParameters.SPqcds;\n    var scalarExpounded = quantizationParameters.scalarExpounded;\n    var guardBits = quantizationParameters.guardBits;\n    var segmentationSymbolUsed = codingStyleParameters.segmentationSymbolUsed;\n    var precision = context.components[c].precision;\n\n    var reversible = codingStyleParameters.reversibleTransformation;\n    var transform = (reversible ? new ReversibleTransform() :\n                                  new IrreversibleTransform());\n\n    var subbandCoefficients = [];\n    var b = 0;\n    for (var i = 0; i <= decompositionLevelsCount; i++) {\n      var resolution = component.resolutions[i];\n\n      var width = resolution.trx1 - resolution.trx0;\n      var height = resolution.try1 - resolution.try0;\n      // Allocate space for the whole sublevel.\n      var coefficients = new Float32Array(width * height);\n\n      for (var j = 0, jj = resolution.subbands.length; j < jj; j++) {\n        var mu, epsilon;\n        if (!scalarExpounded) {\n          // formula E-5\n          mu = spqcds[0].mu;\n          epsilon = spqcds[0].epsilon + (i > 0 ? 1 - i : 0);\n        } else {\n          mu = spqcds[b].mu;\n          epsilon = spqcds[b].epsilon;\n          b++;\n        }\n\n        var subband = resolution.subbands[j];\n        var gainLog2 = SubbandsGainLog2[subband.type];\n\n        // calculate quantization coefficient (Section E.1.1.1)\n        var delta = (reversible ? 1 :\n          Math.pow(2, precision + gainLog2 - epsilon) * (1 + mu / 2048));\n        var mb = (guardBits + epsilon - 1);\n\n        // In the first resolution level, copyCoefficients will fill the\n        // whole array with coefficients. In the succeeding passes,\n        // copyCoefficients will consecutively fill in the values that belong\n        // to the interleaved positions of the HL, LH, and HH coefficients.\n        // The LL coefficients will then be interleaved in Transform.iterate().\n        copyCoefficients(coefficients, width, height, subband, delta, mb,\n                         reversible, segmentationSymbolUsed);\n      }\n      subbandCoefficients.push({\n        width,\n        height,\n        items: coefficients,\n      });\n    }\n\n    var result = transform.calculate(subbandCoefficients,\n                                     component.tcx0, component.tcy0);\n    return {\n      left: component.tcx0,\n      top: component.tcy0,\n      width: result.width,\n      height: result.height,\n      items: result.items,\n    };\n  }\n  function transformComponents(context) {\n    var siz = context.SIZ;\n    var components = context.components;\n    var componentsCount = siz.Csiz;\n    var resultImages = [];\n    for (var i = 0, ii = context.tiles.length; i < ii; i++) {\n      var tile = context.tiles[i];\n      var transformedTiles = [];\n      var c;\n      for (c = 0; c < componentsCount; c++) {\n        transformedTiles[c] = transformTile(context, tile, c);\n      }\n      var tile0 = transformedTiles[0];\n      var out = new Uint8ClampedArray(tile0.items.length * componentsCount);\n      var result = {\n        left: tile0.left,\n        top: tile0.top,\n        width: tile0.width,\n        height: tile0.height,\n        items: out,\n      };\n\n      // Section G.2.2 Inverse multi component transform\n      var shift, offset;\n      var pos = 0, j, jj, y0, y1, y2;\n      if (tile.codingStyleDefaultParameters.multipleComponentTransform) {\n        var fourComponents = componentsCount === 4;\n        var y0items = transformedTiles[0].items;\n        var y1items = transformedTiles[1].items;\n        var y2items = transformedTiles[2].items;\n        var y3items = fourComponents ? transformedTiles[3].items : null;\n\n        // HACK: The multiple component transform formulas below assume that\n        // all components have the same precision. With this in mind, we\n        // compute shift and offset only once.\n        shift = components[0].precision - 8;\n        offset = (128 << shift) + 0.5;\n\n        var component0 = tile.components[0];\n        var alpha01 = componentsCount - 3;\n        jj = y0items.length;\n        if (!component0.codingStyleParameters.reversibleTransformation) {\n          // inverse irreversible multiple component transform\n          for (j = 0; j < jj; j++, pos += alpha01) {\n            y0 = y0items[j] + offset;\n            y1 = y1items[j];\n            y2 = y2items[j];\n            out[pos++] = (y0 + 1.402 * y2) >> shift;\n            out[pos++] = (y0 - 0.34413 * y1 - 0.71414 * y2) >> shift;\n            out[pos++] = (y0 + 1.772 * y1) >> shift;\n          }\n        } else {\n          // inverse reversible multiple component transform\n          for (j = 0; j < jj; j++, pos += alpha01) {\n            y0 = y0items[j] + offset;\n            y1 = y1items[j];\n            y2 = y2items[j];\n            let g = y0 - ((y2 + y1) >> 2);\n\n            out[pos++] = (g + y2) >> shift;\n            out[pos++] = g >> shift;\n            out[pos++] = (g + y1) >> shift;\n          }\n        }\n        if (fourComponents) {\n          for (j = 0, pos = 3; j < jj; j++, pos += 4) {\n            out[pos] = (y3items[j] + offset) >> shift;\n          }\n        }\n      } else { // no multi-component transform\n        for (c = 0; c < componentsCount; c++) {\n          var items = transformedTiles[c].items;\n          shift = components[c].precision - 8;\n          offset = (128 << shift) + 0.5;\n          for (pos = c, j = 0, jj = items.length; j < jj; j++) {\n            out[pos] = (items[j] + offset) >> shift;\n            pos += componentsCount;\n          }\n        }\n      }\n      resultImages.push(result);\n    }\n    return resultImages;\n  }\n  function initializeTile(context, tileIndex) {\n    var siz = context.SIZ;\n    var componentsCount = siz.Csiz;\n    var tile = context.tiles[tileIndex];\n    for (var c = 0; c < componentsCount; c++) {\n      var component = tile.components[c];\n      var qcdOrQcc = (context.currentTile.QCC[c] !== undefined ?\n        context.currentTile.QCC[c] : context.currentTile.QCD);\n      component.quantizationParameters = qcdOrQcc;\n      var codOrCoc = (context.currentTile.COC[c] !== undefined ?\n        context.currentTile.COC[c] : context.currentTile.COD);\n      component.codingStyleParameters = codOrCoc;\n    }\n    tile.codingStyleDefaultParameters = context.currentTile.COD;\n  }\n\n  // Section B.10.2 Tag trees\n  var TagTree = (function TagTreeClosure() {\n    function TagTree(width, height) {\n      var levelsLength = log2(Math.max(width, height)) + 1;\n      this.levels = [];\n      for (var i = 0; i < levelsLength; i++) {\n        var level = {\n          width,\n          height,\n          items: [],\n        };\n        this.levels.push(level);\n        width = Math.ceil(width / 2);\n        height = Math.ceil(height / 2);\n      }\n    }\n    TagTree.prototype = {\n      reset: function TagTree_reset(i, j) {\n        var currentLevel = 0, value = 0, level;\n        while (currentLevel < this.levels.length) {\n          level = this.levels[currentLevel];\n          var index = i + j * level.width;\n          if (level.items[index] !== undefined) {\n            value = level.items[index];\n            break;\n          }\n          level.index = index;\n          i >>= 1;\n          j >>= 1;\n          currentLevel++;\n        }\n        currentLevel--;\n        level = this.levels[currentLevel];\n        level.items[level.index] = value;\n        this.currentLevel = currentLevel;\n        delete this.value;\n      },\n      incrementValue: function TagTree_incrementValue() {\n        var level = this.levels[this.currentLevel];\n        level.items[level.index]++;\n      },\n      nextLevel: function TagTree_nextLevel() {\n        var currentLevel = this.currentLevel;\n        var level = this.levels[currentLevel];\n        var value = level.items[level.index];\n        currentLevel--;\n        if (currentLevel < 0) {\n          this.value = value;\n          return false;\n        }\n\n        this.currentLevel = currentLevel;\n        level = this.levels[currentLevel];\n        level.items[level.index] = value;\n        return true;\n      },\n    };\n    return TagTree;\n  })();\n\n  var InclusionTree = (function InclusionTreeClosure() {\n    function InclusionTree(width, height, defaultValue) {\n      var levelsLength = log2(Math.max(width, height)) + 1;\n      this.levels = [];\n      for (var i = 0; i < levelsLength; i++) {\n        var items = new Uint8Array(width * height);\n        for (var j = 0, jj = items.length; j < jj; j++) {\n          items[j] = defaultValue;\n        }\n\n        var level = {\n          width,\n          height,\n          items,\n        };\n        this.levels.push(level);\n\n        width = Math.ceil(width / 2);\n        height = Math.ceil(height / 2);\n      }\n    }\n    InclusionTree.prototype = {\n      reset: function InclusionTree_reset(i, j, stopValue) {\n        var currentLevel = 0;\n        while (currentLevel < this.levels.length) {\n          var level = this.levels[currentLevel];\n          var index = i + j * level.width;\n          level.index = index;\n          var value = level.items[index];\n\n          if (value === 0xFF) {\n            break;\n          }\n\n          if (value > stopValue) {\n            this.currentLevel = currentLevel;\n            // already know about this one, propagating the value to top levels\n            this.propagateValues();\n            return false;\n          }\n\n          i >>= 1;\n          j >>= 1;\n          currentLevel++;\n        }\n        this.currentLevel = currentLevel - 1;\n        return true;\n      },\n      incrementValue: function InclusionTree_incrementValue(stopValue) {\n        var level = this.levels[this.currentLevel];\n        level.items[level.index] = stopValue + 1;\n        this.propagateValues();\n      },\n      propagateValues: function InclusionTree_propagateValues() {\n        var levelIndex = this.currentLevel;\n        var level = this.levels[levelIndex];\n        var currentValue = level.items[level.index];\n        while (--levelIndex >= 0) {\n          level = this.levels[levelIndex];\n          level.items[level.index] = currentValue;\n        }\n      },\n      nextLevel: function InclusionTree_nextLevel() {\n        var currentLevel = this.currentLevel;\n        var level = this.levels[currentLevel];\n        var value = level.items[level.index];\n        level.items[level.index] = 0xFF;\n        currentLevel--;\n        if (currentLevel < 0) {\n          return false;\n        }\n\n        this.currentLevel = currentLevel;\n        level = this.levels[currentLevel];\n        level.items[level.index] = value;\n        return true;\n      },\n    };\n    return InclusionTree;\n  })();\n\n  // Section D. Coefficient bit modeling\n  var BitModel = (function BitModelClosure() {\n    var UNIFORM_CONTEXT = 17;\n    var RUNLENGTH_CONTEXT = 18;\n    // Table D-1\n    // The index is binary presentation: 0dddvvhh, ddd - sum of Di (0..4),\n    // vv - sum of Vi (0..2), and hh - sum of Hi (0..2)\n    var LLAndLHContextsLabel = new Uint8Array([\n      0, 5, 8, 0, 3, 7, 8, 0, 4, 7, 8, 0, 0, 0, 0, 0, 1, 6, 8, 0, 3, 7, 8, 0, 4,\n      7, 8, 0, 0, 0, 0, 0, 2, 6, 8, 0, 3, 7, 8, 0, 4, 7, 8, 0, 0, 0, 0, 0, 2, 6,\n      8, 0, 3, 7, 8, 0, 4, 7, 8, 0, 0, 0, 0, 0, 2, 6, 8, 0, 3, 7, 8, 0, 4, 7, 8\n    ]);\n    var HLContextLabel = new Uint8Array([\n      0, 3, 4, 0, 5, 7, 7, 0, 8, 8, 8, 0, 0, 0, 0, 0, 1, 3, 4, 0, 6, 7, 7, 0, 8,\n      8, 8, 0, 0, 0, 0, 0, 2, 3, 4, 0, 6, 7, 7, 0, 8, 8, 8, 0, 0, 0, 0, 0, 2, 3,\n      4, 0, 6, 7, 7, 0, 8, 8, 8, 0, 0, 0, 0, 0, 2, 3, 4, 0, 6, 7, 7, 0, 8, 8, 8\n    ]);\n    var HHContextLabel = new Uint8Array([\n      0, 1, 2, 0, 1, 2, 2, 0, 2, 2, 2, 0, 0, 0, 0, 0, 3, 4, 5, 0, 4, 5, 5, 0, 5,\n      5, 5, 0, 0, 0, 0, 0, 6, 7, 7, 0, 7, 7, 7, 0, 7, 7, 7, 0, 0, 0, 0, 0, 8, 8,\n      8, 0, 8, 8, 8, 0, 8, 8, 8, 0, 0, 0, 0, 0, 8, 8, 8, 0, 8, 8, 8, 0, 8, 8, 8\n    ]);\n\n    function BitModel(width, height, subband, zeroBitPlanes, mb) {\n      this.width = width;\n      this.height = height;\n\n      this.contextLabelTable = (subband === 'HH' ? HHContextLabel :\n        (subband === 'HL' ? HLContextLabel : LLAndLHContextsLabel));\n\n      var coefficientCount = width * height;\n\n      // coefficients outside the encoding region treated as insignificant\n      // add border state cells for significanceState\n      this.neighborsSignificance = new Uint8Array(coefficientCount);\n      this.coefficentsSign = new Uint8Array(coefficientCount);\n      this.coefficentsMagnitude = mb > 14 ? new Uint32Array(coefficientCount) :\n                                  mb > 6 ? new Uint16Array(coefficientCount) :\n                                  new Uint8Array(coefficientCount);\n      this.processingFlags = new Uint8Array(coefficientCount);\n\n      var bitsDecoded = new Uint8Array(coefficientCount);\n      if (zeroBitPlanes !== 0) {\n        for (var i = 0; i < coefficientCount; i++) {\n          bitsDecoded[i] = zeroBitPlanes;\n        }\n      }\n      this.bitsDecoded = bitsDecoded;\n\n      this.reset();\n    }\n\n    BitModel.prototype = {\n      setDecoder: function BitModel_setDecoder(decoder) {\n        this.decoder = decoder;\n      },\n      reset: function BitModel_reset() {\n        // We have 17 contexts that are accessed via context labels,\n        // plus the uniform and runlength context.\n        this.contexts = new Int8Array(19);\n\n        // Contexts are packed into 1 byte:\n        // highest 7 bits carry the index, lowest bit carries mps\n        this.contexts[0] = (4 << 1) | 0;\n        this.contexts[UNIFORM_CONTEXT] = (46 << 1) | 0;\n        this.contexts[RUNLENGTH_CONTEXT] = (3 << 1) | 0;\n      },\n      setNeighborsSignificance:\n        function BitModel_setNeighborsSignificance(row, column, index) {\n        var neighborsSignificance = this.neighborsSignificance;\n        var width = this.width, height = this.height;\n        var left = (column > 0);\n        var right = (column + 1 < width);\n        var i;\n\n        if (row > 0) {\n          i = index - width;\n          if (left) {\n            neighborsSignificance[i - 1] += 0x10;\n          }\n          if (right) {\n            neighborsSignificance[i + 1] += 0x10;\n          }\n          neighborsSignificance[i] += 0x04;\n        }\n\n        if (row + 1 < height) {\n          i = index + width;\n          if (left) {\n            neighborsSignificance[i - 1] += 0x10;\n          }\n          if (right) {\n            neighborsSignificance[i + 1] += 0x10;\n          }\n          neighborsSignificance[i] += 0x04;\n        }\n\n        if (left) {\n          neighborsSignificance[index - 1] += 0x01;\n        }\n        if (right) {\n          neighborsSignificance[index + 1] += 0x01;\n        }\n        neighborsSignificance[index] |= 0x80;\n      },\n      runSignificancePropagationPass:\n        function BitModel_runSignificancePropagationPass() {\n        var decoder = this.decoder;\n        var width = this.width, height = this.height;\n        var coefficentsMagnitude = this.coefficentsMagnitude;\n        var coefficentsSign = this.coefficentsSign;\n        var neighborsSignificance = this.neighborsSignificance;\n        var processingFlags = this.processingFlags;\n        var contexts = this.contexts;\n        var labels = this.contextLabelTable;\n        var bitsDecoded = this.bitsDecoded;\n        var processedInverseMask = ~1;\n        var processedMask = 1;\n        var firstMagnitudeBitMask = 2;\n\n        for (var i0 = 0; i0 < height; i0 += 4) {\n          for (var j = 0; j < width; j++) {\n            var index = i0 * width + j;\n            for (var i1 = 0; i1 < 4; i1++, index += width) {\n              var i = i0 + i1;\n              if (i >= height) {\n                break;\n              }\n              // clear processed flag first\n              processingFlags[index] &= processedInverseMask;\n\n              if (coefficentsMagnitude[index] ||\n                  !neighborsSignificance[index]) {\n                continue;\n              }\n\n              var contextLabel = labels[neighborsSignificance[index]];\n              var decision = decoder.readBit(contexts, contextLabel);\n              if (decision) {\n                var sign = this.decodeSignBit(i, j, index);\n                coefficentsSign[index] = sign;\n                coefficentsMagnitude[index] = 1;\n                this.setNeighborsSignificance(i, j, index);\n                processingFlags[index] |= firstMagnitudeBitMask;\n              }\n              bitsDecoded[index]++;\n              processingFlags[index] |= processedMask;\n            }\n          }\n        }\n      },\n      decodeSignBit: function BitModel_decodeSignBit(row, column, index) {\n        var width = this.width, height = this.height;\n        var coefficentsMagnitude = this.coefficentsMagnitude;\n        var coefficentsSign = this.coefficentsSign;\n        var contribution, sign0, sign1, significance1;\n        var contextLabel, decoded;\n\n        // calculate horizontal contribution\n        significance1 = (column > 0 && coefficentsMagnitude[index - 1] !== 0);\n        if (column + 1 < width && coefficentsMagnitude[index + 1] !== 0) {\n          sign1 = coefficentsSign[index + 1];\n          if (significance1) {\n            sign0 = coefficentsSign[index - 1];\n            contribution = 1 - sign1 - sign0;\n          } else {\n            contribution = 1 - sign1 - sign1;\n          }\n        } else if (significance1) {\n          sign0 = coefficentsSign[index - 1];\n          contribution = 1 - sign0 - sign0;\n        } else {\n          contribution = 0;\n        }\n        var horizontalContribution = 3 * contribution;\n\n        // calculate vertical contribution and combine with the horizontal\n        significance1 = (row > 0 && coefficentsMagnitude[index - width] !== 0);\n        if (row + 1 < height && coefficentsMagnitude[index + width] !== 0) {\n          sign1 = coefficentsSign[index + width];\n          if (significance1) {\n            sign0 = coefficentsSign[index - width];\n            contribution = 1 - sign1 - sign0 + horizontalContribution;\n          } else {\n            contribution = 1 - sign1 - sign1 + horizontalContribution;\n          }\n        } else if (significance1) {\n          sign0 = coefficentsSign[index - width];\n          contribution = 1 - sign0 - sign0 + horizontalContribution;\n        } else {\n          contribution = horizontalContribution;\n        }\n\n        if (contribution >= 0) {\n          contextLabel = 9 + contribution;\n          decoded = this.decoder.readBit(this.contexts, contextLabel);\n        } else {\n          contextLabel = 9 - contribution;\n          decoded = this.decoder.readBit(this.contexts, contextLabel) ^ 1;\n        }\n        return decoded;\n      },\n      runMagnitudeRefinementPass:\n        function BitModel_runMagnitudeRefinementPass() {\n        var decoder = this.decoder;\n        var width = this.width, height = this.height;\n        var coefficentsMagnitude = this.coefficentsMagnitude;\n        var neighborsSignificance = this.neighborsSignificance;\n        var contexts = this.contexts;\n        var bitsDecoded = this.bitsDecoded;\n        var processingFlags = this.processingFlags;\n        var processedMask = 1;\n        var firstMagnitudeBitMask = 2;\n        var length = width * height;\n        var width4 = width * 4;\n\n        for (var index0 = 0, indexNext; index0 < length; index0 = indexNext) {\n          indexNext = Math.min(length, index0 + width4);\n          for (var j = 0; j < width; j++) {\n            for (var index = index0 + j; index < indexNext; index += width) {\n\n              // significant but not those that have just become\n              if (!coefficentsMagnitude[index] ||\n                (processingFlags[index] & processedMask) !== 0) {\n                continue;\n              }\n\n              var contextLabel = 16;\n              if ((processingFlags[index] & firstMagnitudeBitMask) !== 0) {\n                processingFlags[index] ^= firstMagnitudeBitMask;\n                // first refinement\n               var significance = neighborsSignificance[index] & 127;\n               contextLabel = significance === 0 ? 15 : 14;\n              }\n\n              var bit = decoder.readBit(contexts, contextLabel);\n              coefficentsMagnitude[index] =\n                (coefficentsMagnitude[index] << 1) | bit;\n              bitsDecoded[index]++;\n              processingFlags[index] |= processedMask;\n            }\n          }\n        }\n      },\n      runCleanupPass: function BitModel_runCleanupPass() {\n        var decoder = this.decoder;\n        var width = this.width, height = this.height;\n        var neighborsSignificance = this.neighborsSignificance;\n        var coefficentsMagnitude = this.coefficentsMagnitude;\n        var coefficentsSign = this.coefficentsSign;\n        var contexts = this.contexts;\n        var labels = this.contextLabelTable;\n        var bitsDecoded = this.bitsDecoded;\n        var processingFlags = this.processingFlags;\n        var processedMask = 1;\n        var firstMagnitudeBitMask = 2;\n        var oneRowDown = width;\n        var twoRowsDown = width * 2;\n        var threeRowsDown = width * 3;\n        var iNext;\n        for (var i0 = 0; i0 < height; i0 = iNext) {\n          iNext = Math.min(i0 + 4, height);\n          var indexBase = i0 * width;\n          var checkAllEmpty = i0 + 3 < height;\n          for (var j = 0; j < width; j++) {\n            var index0 = indexBase + j;\n            // using the property: labels[neighborsSignificance[index]] === 0\n            // when neighborsSignificance[index] === 0\n            var allEmpty = (checkAllEmpty &&\n              processingFlags[index0] === 0 &&\n              processingFlags[index0 + oneRowDown] === 0 &&\n              processingFlags[index0 + twoRowsDown] === 0 &&\n              processingFlags[index0 + threeRowsDown] === 0 &&\n              neighborsSignificance[index0] === 0 &&\n              neighborsSignificance[index0 + oneRowDown] === 0 &&\n              neighborsSignificance[index0 + twoRowsDown] === 0 &&\n              neighborsSignificance[index0 + threeRowsDown] === 0);\n            var i1 = 0, index = index0;\n            var i = i0, sign;\n            if (allEmpty) {\n              var hasSignificantCoefficent =\n                decoder.readBit(contexts, RUNLENGTH_CONTEXT);\n              if (!hasSignificantCoefficent) {\n                bitsDecoded[index0]++;\n                bitsDecoded[index0 + oneRowDown]++;\n                bitsDecoded[index0 + twoRowsDown]++;\n                bitsDecoded[index0 + threeRowsDown]++;\n                continue; // next column\n              }\n              i1 = (decoder.readBit(contexts, UNIFORM_CONTEXT) << 1) |\n                    decoder.readBit(contexts, UNIFORM_CONTEXT);\n              if (i1 !== 0) {\n                i = i0 + i1;\n                index += i1 * width;\n              }\n\n              sign = this.decodeSignBit(i, j, index);\n              coefficentsSign[index] = sign;\n              coefficentsMagnitude[index] = 1;\n              this.setNeighborsSignificance(i, j, index);\n              processingFlags[index] |= firstMagnitudeBitMask;\n\n              index = index0;\n              for (var i2 = i0; i2 <= i; i2++, index += width) {\n                bitsDecoded[index]++;\n              }\n\n              i1++;\n            }\n            for (i = i0 + i1; i < iNext; i++, index += width) {\n              if (coefficentsMagnitude[index] ||\n                (processingFlags[index] & processedMask) !== 0) {\n                continue;\n              }\n\n              var contextLabel = labels[neighborsSignificance[index]];\n              var decision = decoder.readBit(contexts, contextLabel);\n              if (decision === 1) {\n                sign = this.decodeSignBit(i, j, index);\n                coefficentsSign[index] = sign;\n                coefficentsMagnitude[index] = 1;\n                this.setNeighborsSignificance(i, j, index);\n                processingFlags[index] |= firstMagnitudeBitMask;\n              }\n              bitsDecoded[index]++;\n            }\n          }\n        }\n      },\n      checkSegmentationSymbol: function BitModel_checkSegmentationSymbol() {\n        var decoder = this.decoder;\n        var contexts = this.contexts;\n        var symbol = (decoder.readBit(contexts, UNIFORM_CONTEXT) << 3) |\n                     (decoder.readBit(contexts, UNIFORM_CONTEXT) << 2) |\n                     (decoder.readBit(contexts, UNIFORM_CONTEXT) << 1) |\n                      decoder.readBit(contexts, UNIFORM_CONTEXT);\n        if (symbol !== 0xA) {\n          throw new JpxError('Invalid segmentation symbol');\n        }\n      },\n    };\n\n    return BitModel;\n  })();\n\n  // Section F, Discrete wavelet transformation\n  var Transform = (function TransformClosure() {\n    function Transform() {}\n\n    Transform.prototype.calculate =\n      function transformCalculate(subbands, u0, v0) {\n      var ll = subbands[0];\n      for (var i = 1, ii = subbands.length; i < ii; i++) {\n        ll = this.iterate(ll, subbands[i], u0, v0);\n      }\n      return ll;\n    };\n    Transform.prototype.extend = function extend(buffer, offset, size) {\n      // Section F.3.7 extending... using max extension of 4\n      var i1 = offset - 1, j1 = offset + 1;\n      var i2 = offset + size - 2, j2 = offset + size;\n      buffer[i1--] = buffer[j1++];\n      buffer[j2++] = buffer[i2--];\n      buffer[i1--] = buffer[j1++];\n      buffer[j2++] = buffer[i2--];\n      buffer[i1--] = buffer[j1++];\n      buffer[j2++] = buffer[i2--];\n      buffer[i1] = buffer[j1];\n      buffer[j2] = buffer[i2];\n    };\n    Transform.prototype.iterate = function Transform_iterate(ll, hl_lh_hh,\n                                                             u0, v0) {\n      var llWidth = ll.width, llHeight = ll.height, llItems = ll.items;\n      var width = hl_lh_hh.width;\n      var height = hl_lh_hh.height;\n      var items = hl_lh_hh.items;\n      var i, j, k, l, u, v;\n\n      // Interleave LL according to Section F.3.3\n      for (k = 0, i = 0; i < llHeight; i++) {\n        l = i * 2 * width;\n        for (j = 0; j < llWidth; j++, k++, l += 2) {\n          items[l] = llItems[k];\n        }\n      }\n      // The LL band is not needed anymore.\n      llItems = ll.items = null;\n\n      var bufferPadding = 4;\n      var rowBuffer = new Float32Array(width + 2 * bufferPadding);\n\n      // Section F.3.4 HOR_SR\n      if (width === 1) {\n        // if width = 1, when u0 even keep items as is, when odd divide by 2\n        if ((u0 & 1) !== 0) {\n          for (v = 0, k = 0; v < height; v++, k += width) {\n            items[k] *= 0.5;\n          }\n        }\n      } else {\n        for (v = 0, k = 0; v < height; v++, k += width) {\n          rowBuffer.set(items.subarray(k, k + width), bufferPadding);\n\n          this.extend(rowBuffer, bufferPadding, width);\n          this.filter(rowBuffer, bufferPadding, width);\n\n          items.set(\n            rowBuffer.subarray(bufferPadding, bufferPadding + width),\n            k);\n        }\n      }\n\n      // Accesses to the items array can take long, because it may not fit into\n      // CPU cache and has to be fetched from main memory. Since subsequent\n      // accesses to the items array are not local when reading columns, we\n      // have a cache miss every time. To reduce cache misses, get up to\n      // 'numBuffers' items at a time and store them into the individual\n      // buffers. The colBuffers should be small enough to fit into CPU cache.\n      var numBuffers = 16;\n      var colBuffers = [];\n      for (i = 0; i < numBuffers; i++) {\n        colBuffers.push(new Float32Array(height + 2 * bufferPadding));\n      }\n      var b, currentBuffer = 0;\n      ll = bufferPadding + height;\n\n      // Section F.3.5 VER_SR\n      if (height === 1) {\n          // if height = 1, when v0 even keep items as is, when odd divide by 2\n        if ((v0 & 1) !== 0) {\n          for (u = 0; u < width; u++) {\n            items[u] *= 0.5;\n          }\n        }\n      } else {\n        for (u = 0; u < width; u++) {\n          // if we ran out of buffers, copy several image columns at once\n          if (currentBuffer === 0) {\n            numBuffers = Math.min(width - u, numBuffers);\n            for (k = u, l = bufferPadding; l < ll; k += width, l++) {\n              for (b = 0; b < numBuffers; b++) {\n                colBuffers[b][l] = items[k + b];\n              }\n            }\n            currentBuffer = numBuffers;\n          }\n\n          currentBuffer--;\n          var buffer = colBuffers[currentBuffer];\n          this.extend(buffer, bufferPadding, height);\n          this.filter(buffer, bufferPadding, height);\n\n          // If this is last buffer in this group of buffers, flush all buffers.\n          if (currentBuffer === 0) {\n            k = u - numBuffers + 1;\n            for (l = bufferPadding; l < ll; k += width, l++) {\n              for (b = 0; b < numBuffers; b++) {\n                items[k + b] = colBuffers[b][l];\n              }\n            }\n          }\n        }\n      }\n\n      return {\n        width,\n        height,\n        items,\n      };\n    };\n    return Transform;\n  })();\n\n  // Section 3.8.2 Irreversible 9-7 filter\n  var IrreversibleTransform = (function IrreversibleTransformClosure() {\n    function IrreversibleTransform() {\n      Transform.call(this);\n    }\n\n    IrreversibleTransform.prototype = Object.create(Transform.prototype);\n    IrreversibleTransform.prototype.filter =\n      function irreversibleTransformFilter(x, offset, length) {\n      var len = length >> 1;\n      offset = offset | 0;\n      var j, n, current, next;\n\n      var alpha = -1.586134342059924;\n      var beta = -0.052980118572961;\n      var gamma = 0.882911075530934;\n      var delta = 0.443506852043971;\n      var K = 1.230174104914001;\n      var K_ = 1 / K;\n\n      // step 1 is combined with step 3\n\n      // step 2\n      j = offset - 3;\n      for (n = len + 4; n--; j += 2) {\n        x[j] *= K_;\n      }\n\n      // step 1 & 3\n      j = offset - 2;\n      current = delta * x[j - 1];\n      for (n = len + 3; n--; j += 2) {\n        next = delta * x[j + 1];\n        x[j] = K * x[j] - current - next;\n        if (n--) {\n          j += 2;\n          current = delta * x[j + 1];\n          x[j] = K * x[j] - current - next;\n        } else {\n          break;\n        }\n      }\n\n      // step 4\n      j = offset - 1;\n      current = gamma * x[j - 1];\n      for (n = len + 2; n--; j += 2) {\n        next = gamma * x[j + 1];\n        x[j] -= current + next;\n        if (n--) {\n          j += 2;\n          current = gamma * x[j + 1];\n          x[j] -= current + next;\n        } else {\n          break;\n        }\n      }\n\n      // step 5\n      j = offset;\n      current = beta * x[j - 1];\n      for (n = len + 1; n--; j += 2) {\n        next = beta * x[j + 1];\n        x[j] -= current + next;\n        if (n--) {\n          j += 2;\n          current = beta * x[j + 1];\n          x[j] -= current + next;\n        } else {\n          break;\n        }\n      }\n\n      // step 6\n      if (len !== 0) {\n        j = offset + 1;\n        current = alpha * x[j - 1];\n        for (n = len; n--; j += 2) {\n          next = alpha * x[j + 1];\n          x[j] -= current + next;\n          if (n--) {\n            j += 2;\n            current = alpha * x[j + 1];\n            x[j] -= current + next;\n          } else {\n            break;\n          }\n        }\n      }\n    };\n\n    return IrreversibleTransform;\n  })();\n\n  // Section 3.8.1 Reversible 5-3 filter\n  var ReversibleTransform = (function ReversibleTransformClosure() {\n    function ReversibleTransform() {\n      Transform.call(this);\n    }\n\n    ReversibleTransform.prototype = Object.create(Transform.prototype);\n    ReversibleTransform.prototype.filter =\n      function reversibleTransformFilter(x, offset, length) {\n      var len = length >> 1;\n      offset = offset | 0;\n      var j, n;\n\n      for (j = offset, n = len + 1; n--; j += 2) {\n        x[j] -= (x[j - 1] + x[j + 1] + 2) >> 2;\n      }\n\n      for (j = offset + 1, n = len; n--; j += 2) {\n        x[j] += (x[j - 1] + x[j + 1]) >> 1;\n      }\n    };\n\n    return ReversibleTransform;\n  })();\n\n  return JpxImage;\n})();\n\nexport {\n  JpxImage,\n};\n"],"sourceRoot":""}