{"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/is_node.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/src/core/jbig2.js","webpack://pdfjs-dist/image_decoders/pdf.image_decoders/src/core/core_utils.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","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","AnnotationStateModelType","MARKED","REVIEW","AnnotationMarkedState","UNMARKED","AnnotationReviewState","ACCEPTED","REJECTED","CANCELLED","COMPLETED","NONE","AnnotationReplyType","GROUP","REPLY","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","RLX","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","errorTilingPattern","errorExtGState","errorXObject","errorFontLoadType3","errorFontState","errorFontMissing","errorFontTranslate","errorColorSpace","errorOperatorList","errorFontToUnicode","errorFontLoadNative","errorFontGetPath","errorMarkedContent","PasswordResponses","NEED_PASSWORD","INCORRECT_PASSWORD","verbosity","Number","console","unreachable","base","other","url","absoluteUrl","baseUrl","_isValidProtocol","Object","enumerable","configurable","writable","BaseException","constructor","NullCharactersRegExp","warn","str","assert","bytes","length","MAX_ARGUMENT_COUNT","String","strBuf","i","chunkEnd","Math","chunk","arr","resultLength","arrayByteLength","pos","data","item","stringToBytes","itemLength","value","buffer8","view32","IsLittleEndianCached","shadow","isLittleEndian","IsEvalSupportedCached","isEvalSupported","rgbBuf","m1","m2","xt","p","m","yt","d","p1","Util","p2","r","p3","p4","v","transpose","a","b","c","first","second","sx","sy","rect","orderedX","rect1","rect2","orderedY","result","PDFStringTranslateTable","code","decodeURIComponent","escape","unescape","encodeURIComponent","arr1","arr2","element","date","Date","buffer","capability","isSettled","get","resolve","reject","createObjectURL","digits","forceDataSchema","URL","blob","type","ii","b1","b2","b3","d1","d2","d3","d4","isNodeJS","process","Jbig2Image","ContextCache","getContexts","id","DecodingContext","decoder","cache","contexts","contextCache","prev","bit","sign","readBits","codeLength","SegmentTypes","CodingTemplates","x","y","RefinementTemplates","coding","reference","ReusedContexts","RefinementReusedContexts","decodingContext","bitmap","OLD_PIXEL_MASK","row","row1","row2","contextLabel","j","pixel","input","decodeMMRBitmap","templateIndex","at","decodeBitmapTemplate0","useskip","template","templateLength","templateX","templateY","changingTemplateEntries","reuseMask","minX","maxX","minY","k","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","log2","symbols","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","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","start","segmentType","pageAssociationFieldSize","referredFlags","referredToCount","retainBits","position","referredToSegmentNumberSize","referredTo","number","readUint16","genericRegionInfo","readRegionSegmentInformation","genericRegionSegmentFlags","genericRegionMmr","searchPatternLength","searchPattern","segments","readSegmentHeader","segment","header","height","RegionSegmentInformationFieldLength","end","dictionary","dictionaryFlags","atLength","readInt8","args","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","offset","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","next","currentIndex","index","codes","runCodesTable","numberOfRepeats","repeatedLength","symbolIDTable","customIndex","tableFirstS","getCustomHuffmanTable","tableDeltaS","tableDeltaT","tableDeltaHeight","tableDeltaWidth","tableBitmapSize","tableAggregateInstances","params","K","Columns","Rows","BlackIs1","EndOfBlock","eof","currentByte","endOfBlock","lookForEOFLimit","parseChunks","parseJbig2Chunks","parse","parseJbig2","lookup","initializer","getArray","stopWhenFound","LOOP_LIMIT","loopCount","dict","values","ROMAN_NUMBER_MAP","lowerCase","romanBuf","romanStr","ch","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","source","eoblock","code1","readNextChar","refLine","codingLine","columns","refPos","blackPixels","code2","code3","gotEOL","bits","_addPixels","codingPos","a1","_addPixelsNeg","_findTableCode","limitValue","limit","_getTwoDimCode","_getWhiteCode","_getBlackCode","_lookBits","n","_eatBits","JpegImage","dctZigZag","dctCos1","dctSin1","dctCos3","dctSin3","dctCos6","dctSin6","dctSqrt2","dctSqrt1d2","decodeTransform","colorTransform","codeLengths","children","parseDNLMarker","mcusPerLine","frame","progressive","startOffset","bitsData","bitsCount","nextByte","scanLines","maybeScanLines","blockRow","receive","decodeHuffman","component","diff","receiveAndExtend","rs","s","z","blockOffset","eobrun","e","successiveACState","offsetZ","successiveACNextValue","mcuRow","mcu","mcuCol","blockCol","getBlockBufferOffset","componentsLength","components","spectralStart","decodeFn","successivePrev","mcuExpected","mcuToRead","resetInterval","decodeBlock","h","decodeMcu","fileMarker","findNextFileMarker","partialMsg","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","invalid","marker","newMarker","dnlScanLines","endOffset","array","mcusPerColumn","blocksPerLineForMcu","blocksPerColumnForMcu","blocksBufferSize","jfif","adobe","numSOSMarkers","quantizationTables","huffmanTablesAC","huffmanTablesDC","appData","readDataBlock","version","major","minor","densityUnits","xDensity","yDensity","thumbWidth","thumbHeight","thumbData","flags0","flags1","transformCode","quantizationTablesLength","quantizationTablesEnd","quantizationTableSpec","tableData","sofScanLines","componentsCount","maxH","maxV","componentId","qId","l","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","lastComponentScaleX","_convertYccToRgb","Y","Cb","Cr","_convertYcckToRgb","_convertYcckToCmyk","_convertCmykToRgb","getData","forceRGB","rgbData","grayColor","JpxImage","SubbandsGainLog2","LL","LH","HL","HH","head","headerSize","lbox","tbox","jumpDataLength","method","colorspace","headerType","parseImageProperties","newByte","stream","oldByte","Xsiz","Ysiz","XOsiz","YOsiz","Csiz","parseCodestream","context","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","px","py","decompositionLevelsCount","sizeInImageScale","getPrecinctIndexIfExist","posX","pxIndex","precinctIterationSizes","posY","pyIndex","startPrecinctRowIndex","minWidth","minHeight","maxNumWide","maxNumHigh","sizePerComponent","sizePerResolution","minWidthCurrentComponent","minHeightCurrentComponent","maxNumWideCurrentComponent","maxNumHighCurrentComponent","scale","widthCurrentResolution","heightCurrentResolution","blocksDimensions","getBlocksDimensions","buildPrecincts","buildCodeblocks","bscale","resolutionSubbands","progressionOrder","bufferSize","skipNextBit","skipBytes","sopMarkerUsed","ephMarkerUsed","packetsIterator","alignToByte","skipMarkerIfEqual","layerNumber","queue","codeblockColumn","codeblockRow","codeblockIncluded","firstTimeInclusion","inclusionTree","zeroBitPlanesTree","valueReady","codingpasses","readCodingpasses","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","out","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","contextLabelTable","coefficientCount","coefficentsMagnitude","zeroBitPlanes","setDecoder","setNeighborsSignificance","neighborsSignificance","column","runSignificancePropagationPass","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","u","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\nimport { getVerbosityLevel, setVerbosityLevel } from \"./shared/util.js\";\nimport { Jbig2mage } from \"./core/jbig2.js\";\nimport { JpegImage } from \"./core/jpg.js\";\nimport { JpxImage } from \"./core/jpx.js\";\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\n// eslint-disable-next-line no-unused-vars\nconst pdfjsVersion = PDFJSDev.eval(\"BUNDLE_VERSION\");\n// eslint-disable-next-line no-unused-vars\nconst pdfjsBuild = PDFJSDev.eval(\"BUNDLE_BUILD\");\n\nexport { Jbig2mage, JpegImage, JpxImage, getVerbosityLevel, setVerbosityLevel };\n","/* Copyright 2012 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/* eslint no-var: error */\n\nimport \"./compatibility.js\";\n\nconst IDENTITY_MATRIX = [1, 0, 0, 1, 0, 0];\nconst FONT_IDENTITY_MATRIX = [0.001, 0, 0, 0.001, 0, 0];\n\n// Permission flags from Table 22, Section 7.6.3.2 of the PDF specification.\nconst PermissionFlag = {\n  PRINT: 0x04,\n  MODIFY_CONTENTS: 0x08,\n  COPY: 0x10,\n  MODIFY_ANNOTATIONS: 0x20,\n  FILL_INTERACTIVE_FORMS: 0x100,\n  COPY_FOR_ACCESSIBILITY: 0x200,\n  ASSEMBLE: 0x400,\n  PRINT_HIGH_QUALITY: 0x800,\n};\n\nconst TextRenderingMode = {\n  FILL: 0,\n  STROKE: 1,\n  FILL_STROKE: 2,\n  INVISIBLE: 3,\n  FILL_ADD_TO_PATH: 4,\n  STROKE_ADD_TO_PATH: 5,\n  FILL_STROKE_ADD_TO_PATH: 6,\n  ADD_TO_PATH: 7,\n  FILL_STROKE_MASK: 3,\n  ADD_TO_PATH_FLAG: 4,\n};\n\nconst ImageKind = {\n  GRAYSCALE_1BPP: 1,\n  RGB_24BPP: 2,\n  RGBA_32BPP: 3,\n};\n\nconst AnnotationType = {\n  TEXT: 1,\n  LINK: 2,\n  FREETEXT: 3,\n  LINE: 4,\n  SQUARE: 5,\n  CIRCLE: 6,\n  POLYGON: 7,\n  POLYLINE: 8,\n  HIGHLIGHT: 9,\n  UNDERLINE: 10,\n  SQUIGGLY: 11,\n  STRIKEOUT: 12,\n  STAMP: 13,\n  CARET: 14,\n  INK: 15,\n  POPUP: 16,\n  FILEATTACHMENT: 17,\n  SOUND: 18,\n  MOVIE: 19,\n  WIDGET: 20,\n  SCREEN: 21,\n  PRINTERMARK: 22,\n  TRAPNET: 23,\n  WATERMARK: 24,\n  THREED: 25,\n  REDACT: 26,\n};\n\nconst AnnotationStateModelType = {\n  MARKED: \"Marked\",\n  REVIEW: \"Review\",\n};\n\nconst AnnotationMarkedState = {\n  MARKED: \"Marked\",\n  UNMARKED: \"Unmarked\",\n};\n\nconst AnnotationReviewState = {\n  ACCEPTED: \"Accepted\",\n  REJECTED: \"Rejected\",\n  CANCELLED: \"Cancelled\",\n  COMPLETED: \"Completed\",\n  NONE: \"None\",\n};\n\nconst AnnotationReplyType = {\n  GROUP: \"Group\",\n  REPLY: \"R\",\n};\n\nconst AnnotationFlag = {\n  INVISIBLE: 0x01,\n  HIDDEN: 0x02,\n  PRINT: 0x04,\n  NOZOOM: 0x08,\n  NOROTATE: 0x10,\n  NOVIEW: 0x20,\n  READONLY: 0x40,\n  LOCKED: 0x80,\n  TOGGLENOVIEW: 0x100,\n  LOCKEDCONTENTS: 0x200,\n};\n\nconst AnnotationFieldFlag = {\n  READONLY: 0x0000001,\n  REQUIRED: 0x0000002,\n  NOEXPORT: 0x0000004,\n  MULTILINE: 0x0001000,\n  PASSWORD: 0x0002000,\n  NOTOGGLETOOFF: 0x0004000,\n  RADIO: 0x0008000,\n  PUSHBUTTON: 0x0010000,\n  COMBO: 0x0020000,\n  EDIT: 0x0040000,\n  SORT: 0x0080000,\n  FILESELECT: 0x0100000,\n  MULTISELECT: 0x0200000,\n  DONOTSPELLCHECK: 0x0400000,\n  DONOTSCROLL: 0x0800000,\n  COMB: 0x1000000,\n  RICHTEXT: 0x2000000,\n  RADIOSINUNISON: 0x2000000,\n  COMMITONSELCHANGE: 0x4000000,\n};\n\nconst AnnotationBorderStyleType = {\n  SOLID: 1,\n  DASHED: 2,\n  BEVELED: 3,\n  INSET: 4,\n  UNDERLINE: 5,\n};\n\nconst StreamType = {\n  UNKNOWN: \"UNKNOWN\",\n  FLATE: \"FLATE\",\n  LZW: \"LZW\",\n  DCT: \"DCT\",\n  JPX: \"JPX\",\n  JBIG: \"JBIG\",\n  A85: \"A85\",\n  AHX: \"AHX\",\n  CCF: \"CCF\",\n  RLX: \"RLX\", // PDF short name is 'RL', but telemetry requires three chars.\n};\n\nconst FontType = {\n  UNKNOWN: \"UNKNOWN\",\n  TYPE1: \"TYPE1\",\n  TYPE1C: \"TYPE1C\",\n  CIDFONTTYPE0: \"CIDFONTTYPE0\",\n  CIDFONTTYPE0C: \"CIDFONTTYPE0C\",\n  TRUETYPE: \"TRUETYPE\",\n  CIDFONTTYPE2: \"CIDFONTTYPE2\",\n  TYPE3: \"TYPE3\",\n  OPENTYPE: \"OPENTYPE\",\n  TYPE0: \"TYPE0\",\n  MMTYPE1: \"MMTYPE1\",\n};\n\nconst VerbosityLevel = {\n  ERRORS: 0,\n  WARNINGS: 1,\n  INFOS: 5,\n};\n\nconst CMapCompressionType = {\n  NONE: 0,\n  BINARY: 1,\n  STREAM: 2,\n};\n\n// All the possible operations for an operator list.\nconst OPS = {\n  // Intentionally start from 1 so it is easy to spot bad operators that will be\n  // 0's.\n  dependency: 1,\n  setLineWidth: 2,\n  setLineCap: 3,\n  setLineJoin: 4,\n  setMiterLimit: 5,\n  setDash: 6,\n  setRenderingIntent: 7,\n  setFlatness: 8,\n  setGState: 9,\n  save: 10,\n  restore: 11,\n  transform: 12,\n  moveTo: 13,\n  lineTo: 14,\n  curveTo: 15,\n  curveTo2: 16,\n  curveTo3: 17,\n  closePath: 18,\n  rectangle: 19,\n  stroke: 20,\n  closeStroke: 21,\n  fill: 22,\n  eoFill: 23,\n  fillStroke: 24,\n  eoFillStroke: 25,\n  closeFillStroke: 26,\n  closeEOFillStroke: 27,\n  endPath: 28,\n  clip: 29,\n  eoClip: 30,\n  beginText: 31,\n  endText: 32,\n  setCharSpacing: 33,\n  setWordSpacing: 34,\n  setHScale: 35,\n  setLeading: 36,\n  setFont: 37,\n  setTextRenderingMode: 38,\n  setTextRise: 39,\n  moveText: 40,\n  setLeadingMoveText: 41,\n  setTextMatrix: 42,\n  nextLine: 43,\n  showText: 44,\n  showSpacedText: 45,\n  nextLineShowText: 46,\n  nextLineSetSpacingShowText: 47,\n  setCharWidth: 48,\n  setCharWidthAndBounds: 49,\n  setStrokeColorSpace: 50,\n  setFillColorSpace: 51,\n  setStrokeColor: 52,\n  setStrokeColorN: 53,\n  setFillColor: 54,\n  setFillColorN: 55,\n  setStrokeGray: 56,\n  setFillGray: 57,\n  setStrokeRGBColor: 58,\n  setFillRGBColor: 59,\n  setStrokeCMYKColor: 60,\n  setFillCMYKColor: 61,\n  shadingFill: 62,\n  beginInlineImage: 63,\n  beginImageData: 64,\n  endInlineImage: 65,\n  paintXObject: 66,\n  markPoint: 67,\n  markPointProps: 68,\n  beginMarkedContent: 69,\n  beginMarkedContentProps: 70,\n  endMarkedContent: 71,\n  beginCompat: 72,\n  endCompat: 73,\n  paintFormXObjectBegin: 74,\n  paintFormXObjectEnd: 75,\n  beginGroup: 76,\n  endGroup: 77,\n  beginAnnotations: 78,\n  endAnnotations: 79,\n  beginAnnotation: 80,\n  endAnnotation: 81,\n  paintJpegXObject: 82,\n  paintImageMaskXObject: 83,\n  paintImageMaskXObjectGroup: 84,\n  paintImageXObject: 85,\n  paintInlineImageXObject: 86,\n  paintInlineImageXObjectGroup: 87,\n  paintImageXObjectRepeat: 88,\n  paintImageMaskXObjectRepeat: 89,\n  paintSolidColorImageMask: 90,\n  constructPath: 91,\n};\n\nconst UNSUPPORTED_FEATURES = {\n  /** @deprecated unused */\n  unknown: \"unknown\",\n  forms: \"forms\",\n  javaScript: \"javaScript\",\n  smask: \"smask\",\n  shadingPattern: \"shadingPattern\",\n  /** @deprecated unused */\n  font: \"font\",\n  errorTilingPattern: \"errorTilingPattern\",\n  errorExtGState: \"errorExtGState\",\n  errorXObject: \"errorXObject\",\n  errorFontLoadType3: \"errorFontLoadType3\",\n  errorFontState: \"errorFontState\",\n  errorFontMissing: \"errorFontMissing\",\n  errorFontTranslate: \"errorFontTranslate\",\n  errorColorSpace: \"errorColorSpace\",\n  errorOperatorList: \"errorOperatorList\",\n  errorFontToUnicode: \"errorFontToUnicode\",\n  errorFontLoadNative: \"errorFontLoadNative\",\n  errorFontGetPath: \"errorFontGetPath\",\n  errorMarkedContent: \"errorMarkedContent\",\n};\n\nconst PasswordResponses = {\n  NEED_PASSWORD: 1,\n  INCORRECT_PASSWORD: 2,\n};\n\nlet verbosity = VerbosityLevel.WARNINGS;\n\nfunction setVerbosityLevel(level) {\n  if (Number.isInteger(level)) {\n    verbosity = level;\n  }\n}\n\nfunction getVerbosityLevel() {\n  return verbosity;\n}\n\n// A notice for devs. These are good for things that are helpful to devs, such\n// as warning that Workers were disabled, which is important to devs but not\n// end users.\nfunction info(msg) {\n  if (verbosity >= VerbosityLevel.INFOS) {\n    console.log(`Info: ${msg}`);\n  }\n}\n\n// Non-fatal warnings.\nfunction warn(msg) {\n  if (verbosity >= VerbosityLevel.WARNINGS) {\n    console.log(`Warning: ${msg}`);\n  }\n}\n\nfunction unreachable(msg) {\n  throw new Error(msg);\n}\n\nfunction assert(cond, msg) {\n  if (!cond) {\n    unreachable(msg);\n  }\n}\n\n// Checks if URLs have the same origin. For non-HTTP based URLs, returns false.\nfunction isSameOrigin(baseUrl, otherUrl) {\n  let base;\n  try {\n    base = new URL(baseUrl);\n    if (!base.origin || base.origin === \"null\") {\n      return false; // non-HTTP url\n    }\n  } catch (e) {\n    return false;\n  }\n\n  const other = new URL(otherUrl, base);\n  return base.origin === other.origin;\n}\n\n// Checks if URLs use one of the allowed protocols, e.g. to avoid XSS.\nfunction _isValidProtocol(url) {\n  if (!url) {\n    return false;\n  }\n  switch (url.protocol) {\n    case \"http:\":\n    case \"https:\":\n    case \"ftp:\":\n    case \"mailto:\":\n    case \"tel:\":\n      return true;\n    default:\n      return false;\n  }\n}\n\n/**\n * Attempts to create a valid absolute URL.\n *\n * @param {URL|string} url - An absolute, or relative, URL.\n * @param {URL|string} baseUrl - An absolute URL.\n * @returns Either a valid {URL}, or `null` otherwise.\n */\nfunction createValidAbsoluteUrl(url, baseUrl) {\n  if (!url) {\n    return null;\n  }\n  try {\n    const absoluteUrl = baseUrl ? new URL(url, baseUrl) : new URL(url);\n    if (_isValidProtocol(absoluteUrl)) {\n      return absoluteUrl;\n    }\n  } catch (ex) {\n    /* `new URL()` will throw on incorrect data. */\n  }\n  return null;\n}\n\nfunction shadow(obj, prop, value) {\n  Object.defineProperty(obj, prop, {\n    value,\n    enumerable: true,\n    configurable: true,\n    writable: false,\n  });\n  return value;\n}\n\n/**\n * @type {any}\n */\nconst BaseException = (function BaseExceptionClosure() {\n  // eslint-disable-next-line no-shadow\n  function BaseException(message) {\n    if (this.constructor === BaseException) {\n      unreachable(\"Cannot initialize BaseException.\");\n    }\n    this.message = message;\n    this.name = this.constructor.name;\n  }\n  BaseException.prototype = new Error();\n  BaseException.constructor = BaseException;\n\n  return BaseException;\n})();\n\nclass PasswordException extends BaseException {\n  constructor(msg, code) {\n    super(msg);\n    this.code = code;\n  }\n}\n\nclass UnknownErrorException extends BaseException {\n  constructor(msg, details) {\n    super(msg);\n    this.details = details;\n  }\n}\n\nclass InvalidPDFException extends BaseException {}\n\nclass MissingPDFException extends BaseException {}\n\nclass UnexpectedResponseException extends BaseException {\n  constructor(msg, status) {\n    super(msg);\n    this.status = status;\n  }\n}\n\n/**\n * Error caused during parsing PDF data.\n */\nclass FormatError extends BaseException {}\n\n/**\n * Error used to indicate task cancellation.\n */\nclass AbortException extends BaseException {}\n\nconst NullCharactersRegExp = /\\x00/g;\n\n/**\n * @param {string} str\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(\n    bytes !== null && typeof bytes === \"object\" && bytes.length !== undefined,\n    \"Invalid argument for bytesToString\"\n  );\n  const length = bytes.length;\n  const MAX_ARGUMENT_COUNT = 8192;\n  if (length < MAX_ARGUMENT_COUNT) {\n    return String.fromCharCode.apply(null, bytes);\n  }\n  const strBuf = [];\n  for (let i = 0; i < length; i += MAX_ARGUMENT_COUNT) {\n    const chunkEnd = Math.min(i + MAX_ARGUMENT_COUNT, length);\n    const chunk = bytes.subarray(i, chunkEnd);\n    strBuf.push(String.fromCharCode.apply(null, chunk));\n  }\n  return strBuf.join(\"\");\n}\n\nfunction stringToBytes(str) {\n  assert(typeof str === \"string\", \"Invalid argument for stringToBytes\");\n  const length = str.length;\n  const bytes = new Uint8Array(length);\n  for (let i = 0; i < length; ++i) {\n    bytes[i] = str.charCodeAt(i) & 0xff;\n  }\n  return bytes;\n}\n\n/**\n * Gets length of the array (Array, Uint8Array, or string) in bytes.\n * @param {Array<any>|Uint8Array|string} arr\n * @returns {number}\n */\nfunction arrayByteLength(arr) {\n  if (arr.length !== undefined) {\n    return arr.length;\n  }\n  assert(arr.byteLength !== undefined, \"arrayByteLength - invalid argument.\");\n  return arr.byteLength;\n}\n\n/**\n * Combines array items (arrays) into single Uint8Array object.\n * @param {Array<Array<any>|Uint8Array|string>} arr - the array of the arrays\n *   (Array, Uint8Array, or string).\n * @returns {Uint8Array}\n */\nfunction arraysToBytes(arr) {\n  const length = arr.length;\n  // Shortcut: if first and only item is Uint8Array, return it.\n  if (length === 1 && arr[0] instanceof Uint8Array) {\n    return arr[0];\n  }\n  let resultLength = 0;\n  for (let i = 0; i < length; i++) {\n    resultLength += arrayByteLength(arr[i]);\n  }\n  let pos = 0;\n  const data = new Uint8Array(resultLength);\n  for (let i = 0; i < length; i++) {\n    let item = arr[i];\n    if (!(item instanceof Uint8Array)) {\n      if (typeof item === \"string\") {\n        item = stringToBytes(item);\n      } else {\n        item = new Uint8Array(item);\n      }\n    }\n    const itemLength = item.byteLength;\n    data.set(item, pos);\n    pos += itemLength;\n  }\n  return data;\n}\n\nfunction string32(value) {\n  return String.fromCharCode(\n    (value >> 24) & 0xff,\n    (value >> 16) & 0xff,\n    (value >> 8) & 0xff,\n    value & 0xff\n  );\n}\n\n// Checks the endianness of the platform.\nfunction isLittleEndian() {\n  const buffer8 = new Uint8Array(4);\n  buffer8[0] = 1;\n  const view32 = new Uint32Array(buffer8.buffer, 0, 1);\n  return view32[0] === 1;\n}\nconst IsLittleEndianCached = {\n  get value() {\n    return shadow(this, \"value\", isLittleEndian());\n  },\n};\n\n// Checks if it's possible to eval JS expressions.\nfunction isEvalSupported() {\n  try {\n    new Function(\"\"); // eslint-disable-line no-new, no-new-func\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\nconst IsEvalSupportedCached = {\n  get value() {\n    return shadow(this, \"value\", isEvalSupported());\n  },\n};\n\nconst rgbBuf = [\"rgb(\", 0, \",\", 0, \",\", 0, \")\"];\n\nclass Util {\n  // makeCssRgb() can be called thousands of times. Using ´rgbBuf` avoids\n  // creating many intermediate strings.\n  static 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  static transform(m1, m2) {\n    return [\n      m1[0] * m2[0] + m1[2] * m2[1],\n      m1[1] * m2[0] + m1[3] * m2[1],\n      m1[0] * m2[2] + m1[2] * m2[3],\n      m1[1] * m2[2] + m1[3] * m2[3],\n      m1[0] * m2[4] + m1[2] * m2[5] + m1[4],\n      m1[1] * m2[4] + m1[3] * m2[5] + m1[5],\n    ];\n  }\n\n  // For 2d affine transforms\n  static applyTransform(p, m) {\n    const xt = p[0] * m[0] + p[1] * m[2] + m[4];\n    const yt = p[0] * m[1] + p[1] * m[3] + m[5];\n    return [xt, yt];\n  }\n\n  static applyInverseTransform(p, m) {\n    const d = m[0] * m[3] - m[1] * m[2];\n    const xt = (p[0] * m[3] - p[1] * m[2] + m[2] * m[5] - m[4] * m[3]) / d;\n    const yt = (-p[0] * m[1] + p[1] * m[0] + m[4] * m[1] - m[5] * m[0]) / d;\n    return [xt, yt];\n  }\n\n  // Applies the transform to the rectangle and finds the minimum axially\n  // aligned bounding box.\n  static getAxialAlignedBoundingBox(r, m) {\n    const p1 = Util.applyTransform(r, m);\n    const p2 = Util.applyTransform(r.slice(2, 4), m);\n    const p3 = Util.applyTransform([r[0], r[3]], m);\n    const p4 = Util.applyTransform([r[2], r[1]], m);\n    return [\n      Math.min(p1[0], p2[0], p3[0], p4[0]),\n      Math.min(p1[1], p2[1], p3[1], p4[1]),\n      Math.max(p1[0], p2[0], p3[0], p4[0]),\n      Math.max(p1[1], p2[1], p3[1], p4[1]),\n    ];\n  }\n\n  static inverseTransform(m) {\n    const d = m[0] * m[3] - m[1] * m[2];\n    return [\n      m[3] / d,\n      -m[1] / d,\n      -m[2] / d,\n      m[0] / d,\n      (m[2] * m[5] - m[4] * m[3]) / d,\n      (m[4] * m[1] - m[5] * m[0]) / d,\n    ];\n  }\n\n  // Apply a generic 3d matrix M on a 3-vector v:\n  //   | a b c |   | X |\n  //   | d e f | x | Y |\n  //   | g h i |   | Z |\n  // M is assumed to be serialized as [a,b,c,d,e,f,g,h,i],\n  // with v as [X,Y,Z]\n  static apply3dTransform(m, v) {\n    return [\n      m[0] * v[0] + m[1] * v[1] + m[2] * v[2],\n      m[3] * v[0] + m[4] * v[1] + m[5] * v[2],\n      m[6] * v[0] + m[7] * v[1] + m[8] * v[2],\n    ];\n  }\n\n  // This calculation uses Singular Value Decomposition.\n  // The SVD can be represented with formula A = USV. We are interested in the\n  // matrix S here because it represents the scale values.\n  static singularValueDecompose2dScale(m) {\n    const transpose = [m[0], m[2], m[1], m[3]];\n\n    // Multiply matrix m with its transpose.\n    const a = m[0] * transpose[0] + m[1] * transpose[2];\n    const b = m[0] * transpose[1] + m[1] * transpose[3];\n    const c = m[2] * transpose[0] + m[3] * transpose[2];\n    const d = m[2] * transpose[1] + m[3] * transpose[3];\n\n    // Solve the second degree polynomial to get roots.\n    const first = (a + d) / 2;\n    const second = Math.sqrt((a + d) * (a + d) - 4 * (a * d - c * b)) / 2;\n    const sx = first + second || 1;\n    const sy = first - second || 1;\n\n    // Scale values are the square roots of the eigenvalues.\n    return [Math.sqrt(sx), Math.sqrt(sy)];\n  }\n\n  // Normalize rectangle rect=[x1, y1, x2, y2] so that (x1,y1) < (x2,y2)\n  // For coordinate systems whose origin lies in the bottom-left, this\n  // means normalization to (BL,TR) ordering. For systems with origin in the\n  // top-left, this means (TL,BR) ordering.\n  static normalizeRect(rect) {\n    const r = rect.slice(0); // clone rect\n    if (rect[0] > rect[2]) {\n      r[0] = rect[2];\n      r[2] = rect[0];\n    }\n    if (rect[1] > rect[3]) {\n      r[1] = rect[3];\n      r[3] = rect[1];\n    }\n    return r;\n  }\n\n  // Returns a rectangle [x1, y1, x2, y2] corresponding to the\n  // intersection of rect1 and rect2. If no intersection, returns 'false'\n  // The rectangle coordinates of rect1, rect2 should be [x1, y1, x2, y2]\n  static intersect(rect1, rect2) {\n    function compare(a, b) {\n      return a - b;\n    }\n\n    // Order points along the axes\n    const orderedX = [rect1[0], rect1[2], rect2[0], rect2[2]].sort(compare);\n    const orderedY = [rect1[1], rect1[3], rect2[1], rect2[3]].sort(compare);\n    const result = [];\n\n    rect1 = Util.normalizeRect(rect1);\n    rect2 = Util.normalizeRect(rect2);\n\n    // X: first and second points belong to different rectangles?\n    if (\n      (orderedX[0] === rect1[0] && orderedX[1] === rect2[0]) ||\n      (orderedX[0] === rect2[0] && orderedX[1] === rect1[0])\n    ) {\n      // Intersection must be between second and third points\n      result[0] = orderedX[1];\n      result[2] = orderedX[2];\n    } else {\n      return null;\n    }\n\n    // Y: first and second points belong to different rectangles?\n    if (\n      (orderedY[0] === rect1[1] && orderedY[1] === rect2[1]) ||\n      (orderedY[0] === rect2[1] && orderedY[1] === rect1[1])\n    ) {\n      // Intersection must be between second and third points\n      result[1] = orderedY[1];\n      result[3] = orderedY[2];\n    } else {\n      return null;\n    }\n\n    return result;\n  }\n}\n\n// prettier-ignore\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  const length = str.length,\n    strBuf = [];\n  if (str[0] === \"\\xFE\" && str[1] === \"\\xFF\") {\n    // UTF16BE BOM\n    for (let i = 2; i < length; i += 2) {\n      strBuf.push(\n        String.fromCharCode((str.charCodeAt(i) << 8) | str.charCodeAt(i + 1))\n      );\n    }\n  } else if (str[0] === \"\\xFF\" && str[1] === \"\\xFE\") {\n    // UTF16LE BOM\n    for (let i = 2; i < length; i += 2) {\n      strBuf.push(\n        String.fromCharCode((str.charCodeAt(i + 1) << 8) | str.charCodeAt(i))\n      );\n    }\n  } else {\n    for (let i = 0; i < length; ++i) {\n      const code = PDFStringTranslateTable[str.charCodeAt(i)];\n      strBuf.push(code ? String.fromCharCode(code) : str.charAt(i));\n    }\n  }\n  return strBuf.join(\"\");\n}\n\nfunction escapeString(str) {\n  // replace \"(\", \")\" and \"\\\" by \"\\(\", \"\\)\" and \"\\\\\"\n  // in order to write it in a PDF file.\n  return str.replace(/([\\(\\)\\\\])/g, \"\\\\$1\");\n}\n\nfunction stringToUTF8String(str) {\n  return decodeURIComponent(escape(str));\n}\n\nfunction utf8StringToString(str) {\n  return unescape(encodeURIComponent(str));\n}\n\nfunction isBool(v) {\n  return typeof v === \"boolean\";\n}\n\nfunction isNum(v) {\n  return typeof v === \"number\";\n}\n\nfunction isString(v) {\n  return typeof v === \"string\";\n}\n\nfunction isArrayBuffer(v) {\n  return typeof v === \"object\" && v !== null && v.byteLength !== undefined;\n}\n\nfunction isArrayEqual(arr1, arr2) {\n  if (arr1.length !== arr2.length) {\n    return false;\n  }\n  return arr1.every(function (element, index) {\n    return element === arr2[index];\n  });\n}\n\nfunction getModificationDate(date = new Date(Date.now())) {\n  const buffer = [\n    date.getUTCFullYear().toString(),\n    (date.getUTCMonth() + 1).toString().padStart(2, \"0\"),\n    (date.getUTCDate() + 1).toString().padStart(2, \"0\"),\n    date.getUTCHours().toString().padStart(2, \"0\"),\n    date.getUTCMinutes().toString().padStart(2, \"0\"),\n    date.getUTCSeconds().toString().padStart(2, \"0\"),\n  ];\n\n  return buffer.join(\"\");\n}\n\n/**\n * Promise Capability object.\n *\n * @typedef {Object} PromiseCapability\n * @property {Promise<any>} promise - A Promise object.\n * @property {boolean} settled - If the Promise has been fulfilled/rejected.\n * @property {function} resolve - Fulfills the Promise.\n * @property {function} reject - Rejects the Promise.\n */\n\n/**\n * Creates a promise capability object.\n * @alias createPromiseCapability\n *\n * @returns {PromiseCapability}\n */\nfunction createPromiseCapability() {\n  const capability = Object.create(null);\n  let isSettled = false;\n\n  Object.defineProperty(capability, \"settled\", {\n    get() {\n      return isSettled;\n    },\n  });\n  capability.promise = new Promise(function (resolve, reject) {\n    capability.resolve = function (data) {\n      isSettled = true;\n      resolve(data);\n    };\n    capability.reject = function (reason) {\n      isSettled = true;\n      reject(reason);\n    };\n  });\n  return capability;\n}\n\nconst createObjectURL = (function createObjectURLClosure() {\n  // Blob/createObjectURL is not available, falling back to data schema.\n  const digits =\n    \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\";\n\n  // eslint-disable-next-line no-shadow\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    let buffer = `data:${contentType};base64,`;\n    for (let i = 0, ii = data.length; i < ii; i += 3) {\n      const b1 = data[i] & 0xff;\n      const b2 = data[i + 1] & 0xff;\n      const b3 = data[i + 2] & 0xff;\n      const d1 = b1 >> 2,\n        d2 = ((b1 & 3) << 4) | (b2 >> 4);\n      const d3 = i + 1 < ii ? ((b2 & 0xf) << 2) | (b3 >> 6) : 64;\n      const d4 = i + 2 < ii ? b3 & 0x3f : 64;\n      buffer += digits[d1] + digits[d2] + digits[d3] + digits[d4];\n    }\n    return buffer;\n  };\n})();\n\nexport {\n  BaseException,\n  FONT_IDENTITY_MATRIX,\n  IDENTITY_MATRIX,\n  OPS,\n  VerbosityLevel,\n  UNSUPPORTED_FEATURES,\n  AnnotationBorderStyleType,\n  AnnotationFieldFlag,\n  AnnotationFlag,\n  AnnotationMarkedState,\n  AnnotationReplyType,\n  AnnotationReviewState,\n  AnnotationStateModelType,\n  AnnotationType,\n  FontType,\n  ImageKind,\n  CMapCompressionType,\n  AbortException,\n  InvalidPDFException,\n  MissingPDFException,\n  PasswordException,\n  PasswordResponses,\n  PermissionFlag,\n  StreamType,\n  TextRenderingMode,\n  UnexpectedResponseException,\n  UnknownErrorException,\n  Util,\n  FormatError,\n  arrayByteLength,\n  arraysToBytes,\n  assert,\n  bytesToString,\n  createPromiseCapability,\n  createObjectURL,\n  escapeString,\n  getModificationDate,\n  getVerbosityLevel,\n  info,\n  isArrayBuffer,\n  isArrayEqual,\n  isBool,\n  isNum,\n  isString,\n  isSameOrigin,\n  createValidAbsoluteUrl,\n  IsLittleEndianCached,\n  IsEvalSupportedCached,\n  removeNullCharacters,\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/* eslint no-var: error */\n\nimport { isNodeJS } from \"./is_node.js\";\n\n// Skip compatibility checks for modern builds and if we already ran the module.\nif (\n  (typeof PDFJSDev === \"undefined\" || !PDFJSDev.test(\"SKIP_BABEL\")) &&\n  (typeof globalThis === \"undefined\" || !globalThis._pdfjsCompatibilityChecked)\n) {\n  // Provides support for globalThis in legacy browsers.\n  // Support: IE11/Edge, Opera\n  if (typeof globalThis === \"undefined\" || globalThis.Math !== Math) {\n    // eslint-disable-next-line no-global-assign\n    globalThis = require(\"core-js/es/global-this\");\n  }\n  globalThis._pdfjsCompatibilityChecked = true;\n\n  const hasDOM = typeof window === \"object\" && typeof document === \"object\";\n  const userAgent =\n    (typeof navigator !== \"undefined\" && navigator.userAgent) || \"\";\n  const isIE = /Trident/.test(userAgent);\n\n  // Support: Node.js\n  (function checkNodeBtoa() {\n    if (globalThis.btoa || !isNodeJS) {\n      return;\n    }\n    globalThis.btoa = function (chars) {\n      // eslint-disable-next-line no-undef\n      return Buffer.from(chars, \"binary\").toString(\"base64\");\n    };\n  })();\n\n  // Support: Node.js\n  (function checkNodeAtob() {\n    if (globalThis.atob || !isNodeJS) {\n      return;\n    }\n    globalThis.atob = function (input) {\n      // eslint-disable-next-line no-undef\n      return Buffer.from(input, \"base64\").toString(\"binary\");\n    };\n  })();\n\n  // 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.{add, remove}, with more than\n  // one parameter, in legacy browsers.\n  // Support: IE\n  (function checkDOMTokenListAddRemove() {\n    if (!hasDOM || isNodeJS) {\n      return;\n    }\n    const div = document.createElement(\"div\");\n    div.classList.add(\"testOne\", \"testTwo\");\n\n    if (\n      div.classList.contains(\"testOne\") === true &&\n      div.classList.contains(\"testTwo\") === true\n    ) {\n      return;\n    }\n    const OriginalDOMTokenListAdd = DOMTokenList.prototype.add;\n    const OriginalDOMTokenListRemove = DOMTokenList.prototype.remove;\n\n    DOMTokenList.prototype.add = function (...tokens) {\n      for (const token of tokens) {\n        OriginalDOMTokenListAdd.call(this, token);\n      }\n    };\n    DOMTokenList.prototype.remove = function (...tokens) {\n      for (const token of tokens) {\n        OriginalDOMTokenListRemove.call(this, token);\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\n    DOMTokenList.prototype.toggle = function (token) {\n      const force =\n        arguments.length > 1 ? !!arguments[1] : !this.contains(token);\n      return this[force ? \"add\" : \"remove\"](token), force;\n    };\n  })();\n\n  // Provides support for window.history.{pushState, replaceState}, with the\n  // `url` parameter set to `undefined`, without breaking the document URL.\n  // Support: IE\n  (function checkWindowHistoryPushStateReplaceState() {\n    if (!hasDOM || !isIE) {\n      return;\n    }\n    const OriginalPushState = window.history.pushState;\n    const OriginalReplaceState = window.history.replaceState;\n\n    window.history.pushState = function (state, title, url) {\n      const args = url === undefined ? [state, title] : [state, title, url];\n      OriginalPushState.apply(this, args);\n    };\n    window.history.replaceState = function (state, title, url) {\n      const args = url === undefined ? [state, title] : [state, title, url];\n      OriginalReplaceState.apply(this, args);\n    };\n  })();\n\n  // Provides support for String.prototype.startsWith in legacy browsers.\n  // Support: IE, Chrome<41\n  (function checkStringStartsWith() {\n    if (String.prototype.startsWith) {\n      return;\n    }\n    require(\"core-js/es/string/starts-with.js\");\n  })();\n\n  // Provides support for String.prototype.endsWith in legacy browsers.\n  // Support: IE, Chrome<41\n  (function checkStringEndsWith() {\n    if (String.prototype.endsWith) {\n      return;\n    }\n    require(\"core-js/es/string/ends-with.js\");\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/es/string/includes.js\");\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/es/array/includes.js\");\n  })();\n\n  // Provides support for Array.from in legacy browsers.\n  // Support: IE\n  (function checkArrayFrom() {\n    if (Array.from) {\n      return;\n    }\n    require(\"core-js/es/array/from.js\");\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/es/object/assign.js\");\n  })();\n\n  // Provides support for Object.fromEntries in legacy browsers.\n  // Support: IE, Chrome<73\n  (function checkObjectFromEntries() {\n    if (Object.fromEntries) {\n      return;\n    }\n    require(\"core-js/es/object/from-entries.js\");\n  })();\n\n  // Provides support for 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/es/math/log2.js\");\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/es/number/is-nan.js\");\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/es/number/is-integer.js\");\n  })();\n\n  // Provides support for TypedArray.prototype.slice in legacy browsers.\n  // Support: IE\n  (function checkTypedArraySlice() {\n    if (Uint8Array.prototype.slice) {\n      return;\n    }\n    require(\"core-js/es/typed-array/slice\");\n  })();\n\n  // Support: IE, Safari<11, Chrome<63\n  (function checkPromise() {\n    if (typeof PDFJSDev !== \"undefined\" && PDFJSDev.test(\"IMAGE_DECODERS\")) {\n      // The current image decoders are synchronous, hence `Promise` shouldn't\n      // need to be polyfilled for the IMAGE_DECODERS build target.\n      return;\n    }\n    if (globalThis.Promise && globalThis.Promise.allSettled) {\n      return;\n    }\n    globalThis.Promise = require(\"core-js/es/promise/index.js\");\n  })();\n\n  // Support: IE\n  (function checkURL() {\n    if (typeof PDFJSDev === \"undefined\" || !PDFJSDev.test(\"PRODUCTION\")) {\n      // Prevent \"require is not a function\" errors in development mode,\n      // since the `URL` constructor should be available in modern browers.\n      return;\n    } else if (!PDFJSDev.test(\"GENERIC\")) {\n      // The `URL` constructor is assumed to be available in the extension\n      // builds.\n      return;\n    } else if (PDFJSDev.test(\"IMAGE_DECODERS\")) {\n      // The current image decoders don't use the `URL` constructor, so it\n      // doesn't need to be polyfilled for the IMAGE_DECODERS build target.\n      return;\n    }\n    globalThis.URL = require(\"core-js/web/url.js\");\n  })();\n\n  // Support: IE, Node.js\n  (function checkReadableStream() {\n    if (typeof PDFJSDev !== \"undefined\" && PDFJSDev.test(\"IMAGE_DECODERS\")) {\n      // The current image decoders are synchronous, hence `ReadableStream`\n      // shouldn't need to be polyfilled for the IMAGE_DECODERS build target.\n      return;\n    }\n    let isReadableStreamSupported = false;\n\n    if (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    }\n    if (isReadableStreamSupported) {\n      return;\n    }\n    globalThis.ReadableStream = require(\"web-streams-polyfill/dist/ponyfill.js\").ReadableStream;\n  })();\n\n  // We want to support Map iteration, but it doesn't seem possible to easily\n  // test for that specifically; hence using a similarly unsupported property.\n  // Support: IE11\n  (function checkMapEntries() {\n    if (globalThis.Map && globalThis.Map.prototype.entries) {\n      return;\n    }\n    globalThis.Map = require(\"core-js/es/map/index.js\");\n  })();\n\n  // We want to support Set iteration, but it doesn't seem possible to easily\n  // test for that specifically; hence using a similarly unsupported property.\n  // Support: IE11\n  (function checkSetEntries() {\n    if (globalThis.Set && globalThis.Set.prototype.entries) {\n      return;\n    }\n    globalThis.Set = require(\"core-js/es/set/index.js\");\n  })();\n\n  // Support: IE<11, Safari<8, Chrome<36\n  (function checkWeakMap() {\n    if (globalThis.WeakMap) {\n      return;\n    }\n    globalThis.WeakMap = require(\"core-js/es/weak-map/index.js\");\n  })();\n\n  // Support: IE11\n  (function checkWeakSet() {\n    if (globalThis.WeakSet) {\n      return;\n    }\n    globalThis.WeakSet = require(\"core-js/es/weak-set/index.js\");\n  })();\n\n  // Provides support for String.codePointAt in legacy browsers.\n  // Support: IE11.\n  (function checkStringCodePointAt() {\n    if (String.prototype.codePointAt) {\n      return;\n    }\n    require(\"core-js/es/string/code-point-at.js\");\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/es/string/from-code-point.js\");\n  })();\n\n  // Support: IE\n  (function checkSymbol() {\n    if (globalThis.Symbol) {\n      return;\n    }\n    require(\"core-js/es/symbol/index.js\");\n  })();\n\n  // Provides support for String.prototype.padStart in legacy browsers.\n  // Support: IE, Chrome<57\n  (function checkStringPadStart() {\n    if (String.prototype.padStart) {\n      return;\n    }\n    require(\"core-js/es/string/pad-start.js\");\n  })();\n\n  // Provides support for String.prototype.padEnd in legacy browsers.\n  // Support: IE, Chrome<57\n  (function checkStringPadEnd() {\n    if (String.prototype.padEnd) {\n      return;\n    }\n    require(\"core-js/es/string/pad-end.js\");\n  })();\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/es/object/values.js\");\n  })();\n\n  // Provides support for Object.entries in legacy browsers.\n  // Support: IE, Chrome<54\n  (function checkObjectEntries() {\n    if (Object.entries) {\n      return;\n    }\n    Object.entries = require(\"core-js/es/object/entries.js\");\n  })();\n}\n","/* Copyright 2018 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/* globals process */\n\n// NW.js / Electron is a browser context, but copies some Node.js objects; see\n// http://docs.nwjs.io/en/latest/For%20Users/Advanced/JavaScript%20Contexts%20in%20NW.js/#access-nodejs-and-nwjs-api-in-browser-context\n// https://www.electronjs.org/docs/api/process#processversionselectron-readonly\n// https://www.electronjs.org/docs/api/process#processtype-readonly\nconst isNodeJS =\n  typeof process === \"object\" &&\n  process + \"\" === \"[object process]\" &&\n  !process.versions.nw &&\n  !(process.versions.electron && process.type && process.type !== \"browser\");\n\nexport { isNodeJS };\n","/* 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 { BaseException, shadow } from \"../shared/util.js\";\nimport { log2, readInt8, readUint16, readUint32 } from \"./core_utils.js\";\nimport { ArithmeticDecoder } from \"./arithmetic_decoder.js\";\nimport { CCITTFaxDecoder } from \"./ccitt.js\";\n\nclass Jbig2Error extends BaseException {\n  constructor(msg) {\n    super(`JBIG2 error: ${msg}`);\n  }\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 =\n          prev < 256 ? (prev << 1) | bit : (((prev << 1) | bit) & 511) | 256;\n        v = (v << 1) | bit;\n      }\n      return v >>> 0;\n    }\n\n    var sign = readBits(1);\n    // prettier-ignore\n    /* eslint-disable no-nested-ternary */\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    /* eslint-enable no-nested-ternary */\n    if (sign === 0) {\n      return value;\n    } else if (value > 0) {\n      return -value;\n    }\n    return 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\",\n    null,\n    null,\n    null,\n    \"IntermediateTextRegion\",\n    null,\n    \"ImmediateTextRegion\",\n    \"ImmediateLosslessTextRegion\",\n    null,\n    null,\n    null,\n    null,\n    null,\n    null,\n    null,\n    null,\n    \"PatternDictionary\",\n    null,\n    null,\n    null,\n    \"IntermediateHalftoneRegion\",\n    null,\n    \"ImmediateHalftoneRegion\",\n    \"ImmediateLosslessHalftoneRegion\",\n    null,\n    null,\n    null,\n    null,\n    null,\n    null,\n    null,\n    null,\n    null,\n    null,\n    null,\n    null,\n    \"IntermediateGenericRegion\",\n    null,\n    \"ImmediateGenericRegion\",\n    \"ImmediateLosslessGenericRegion\",\n    \"IntermediateGenericRefinementRegion\",\n    null,\n    \"ImmediateGenericRefinementRegion\",\n    \"ImmediateLosslessGenericRefinementRegion\",\n    null,\n    null,\n    null,\n    null,\n    \"PageInformation\",\n    \"EndOfPage\",\n    \"EndOfStripe\",\n    \"EndOfFile\",\n    \"Profiles\",\n    \"Tables\",\n    null,\n    null,\n    null,\n    null,\n    null,\n    null,\n    null,\n    null,\n    \"Extension\",\n  ];\n\n  var CodingTemplates = [\n    [\n      { x: -1, y: -2 },\n      { x: 0, y: -2 },\n      { x: 1, y: -2 },\n      { x: -2, y: -1 },\n      { x: -1, y: -1 },\n      { x: 0, y: -1 },\n      { x: 1, y: -1 },\n      { x: 2, y: -1 },\n      { x: -4, y: 0 },\n      { x: -3, y: 0 },\n      { x: -2, y: 0 },\n      { x: -1, y: 0 },\n    ],\n    [\n      { x: -1, y: -2 },\n      { x: 0, y: -2 },\n      { x: 1, y: -2 },\n      { x: 2, y: -2 },\n      { x: -2, y: -1 },\n      { x: -1, y: -1 },\n      { x: 0, y: -1 },\n      { x: 1, y: -1 },\n      { x: 2, y: -1 },\n      { x: -3, y: 0 },\n      { x: -2, y: 0 },\n      { x: -1, y: 0 },\n    ],\n    [\n      { x: -1, y: -2 },\n      { x: 0, y: -2 },\n      { x: 1, y: -2 },\n      { x: -2, y: -1 },\n      { x: -1, y: -1 },\n      { x: 0, y: -1 },\n      { x: 1, y: -1 },\n      { x: -2, y: 0 },\n      { x: -1, y: 0 },\n    ],\n    [\n      { x: -3, y: -1 },\n      { x: -2, y: -1 },\n      { x: -1, y: -1 },\n      { x: 0, y: -1 },\n      { x: 1, y: -1 },\n      { x: -4, y: 0 },\n      { x: -3, y: 0 },\n      { x: -2, y: 0 },\n      { x: -1, y: 0 },\n    ],\n  ];\n\n  var RefinementTemplates = [\n    {\n      coding: [\n        { x: 0, y: -1 },\n        { x: 1, y: -1 },\n        { x: -1, y: 0 },\n      ],\n      reference: [\n        { x: 0, y: -1 },\n        { x: 1, y: -1 },\n        { x: -1, y: 0 },\n        { x: 0, y: 0 },\n        { x: 1, y: 0 },\n        { x: -1, y: 1 },\n        { x: 0, y: 1 },\n        { x: 1, y: 1 },\n      ],\n    },\n    {\n      coding: [\n        { x: -1, y: -1 },\n        { x: 0, y: -1 },\n        { x: 1, y: -1 },\n        { x: -1, y: 0 },\n      ],\n      reference: [\n        { x: 0, y: -1 },\n        { x: -1, y: 0 },\n        { x: 0, y: 0 },\n        { x: 1, y: 0 },\n        { x: 0, y: 1 },\n        { x: 1, y: 1 },\n      ],\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,\n      i,\n      j,\n      pixel,\n      row,\n      row1,\n      row2,\n      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 =\n        (row2[0] << 13) |\n        (row2[1] << 12) |\n        (row2[2] << 11) |\n        (row1[0] << 7) |\n        (row1[1] << 6) |\n        (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 =\n          ((contextLabel & OLD_PIXEL_MASK) << 1) |\n          (j + 3 < width ? row2[j + 3] << 11 : 0) |\n          (j + 4 < width ? row1[j + 4] << 4 : 0) |\n          pixel;\n      }\n    }\n\n    return bitmap;\n  }\n\n  // 6.2 Generic Region Decoding Procedure\n  function decodeBitmap(\n    mmr,\n    width,\n    height,\n    templateIndex,\n    prediction,\n    skip,\n    at,\n    decodingContext\n  ) {\n    if (mmr) {\n      const input = new Reader(\n        decodingContext.data,\n        decodingContext.start,\n        decodingContext.end\n      );\n      return decodeMMRBitmap(input, width, height, false);\n    }\n\n    // Use optimized version for the most common case\n    if (\n      templateIndex === 0 &&\n      !skip &&\n      !prediction &&\n      at.length === 4 &&\n      at[0].x === 3 &&\n      at[0].y === -1 &&\n      at[1].x === -3 &&\n      at[1].y === -1 &&\n      at[2].x === 2 &&\n      at[2].y === -2 &&\n      at[3].x === -2 &&\n      at[3].y === -2\n    ) {\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,\n      minX = 0,\n      maxX = 0,\n      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 (\n        k < templateLength - 1 &&\n        template[k].y === template[k + 1].y &&\n        template[k].x === template[k + 1].x - 1\n      ) {\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,\n      j,\n      i0,\n      j0,\n      contextLabel = 0,\n      bit,\n      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(\n    width,\n    height,\n    templateIndex,\n    referenceBitmap,\n    offsetX,\n    offsetY,\n    prediction,\n    at,\n    decodingContext\n  ) {\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 (\n            i0 < 0 ||\n            i0 >= referenceHeight ||\n            j0 < 0 ||\n            j0 >= referenceWidth\n          ) {\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(\n    huffman,\n    refinement,\n    symbols,\n    numberOfNewSymbols,\n    numberOfExportedSymbols,\n    huffmanTables,\n    templateIndex,\n    at,\n    refinementTemplateIndex,\n    refinementAt,\n    decodingContext,\n    huffmanInput\n  ) {\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,\n        totalWidth = 0;\n      const 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(\n              huffman,\n              refinement,\n              currentWidth,\n              currentHeight,\n              0,\n              numberOfInstances,\n              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,\n              refinementAt,\n              decodingContext,\n              0,\n              huffmanInput\n            );\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 =\n              symbolId < symbols.length\n                ? symbols[symbolId]\n                : newSymbols[symbolId - symbols.length];\n            bitmap = decodeRefinement(\n              currentWidth,\n              currentHeight,\n              refinementTemplateIndex,\n              symbol,\n              rdx,\n              rdy,\n              false,\n              refinementAt,\n              decodingContext\n            );\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(\n            false,\n            currentWidth,\n            currentHeight,\n            templateIndex,\n            false,\n            null,\n            at,\n            decodingContext\n          );\n          newSymbols.push(bitmap);\n        }\n      }\n      if (huffman && !refinement) {\n        // 6.5.9 Height class collective bitmap\n        const bitmapSize = huffmanTables.tableBitmapSize.decode(huffmanInput);\n        huffmanInput.byteAlign();\n        let collectiveBitmap;\n        if (bitmapSize === 0) {\n          // Uncompressed collective bitmap\n          collectiveBitmap = readUncompressedBitmap(\n            huffmanInput,\n            totalWidth,\n            currentHeight\n          );\n        } else {\n          // MMR collective bitmap\n          const originalEnd = huffmanInput.end;\n          const bitmapEnd = huffmanInput.position + bitmapSize;\n          huffmanInput.end = bitmapEnd;\n          collectiveBitmap = decodeMMRBitmap(\n            huffmanInput,\n            totalWidth,\n            currentHeight,\n            false\n          );\n          huffmanInput.end = originalEnd;\n          huffmanInput.position = bitmapEnd;\n        }\n        const 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,\n            y,\n            xMin = 0,\n            xMax,\n            bitmapWidth,\n            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 = [],\n      currentFlag = false;\n    var totalSymbolsLength = symbols.length + numberOfNewSymbols;\n    while (flags.length < totalSymbolsLength) {\n      var runLength = huffman\n        ? 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(\n    huffman,\n    refinement,\n    width,\n    height,\n    defaultPixelValue,\n    numberOfSymbolInstances,\n    stripSize,\n    inputSymbols,\n    symbolCodeLength,\n    transposed,\n    dsOffset,\n    referenceCorner,\n    combinationOperator,\n    huffmanTables,\n    refinementTemplateIndex,\n    refinementAt,\n    decodingContext,\n    logStripSize,\n    huffmanInput\n  ) {\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\n      ? -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\n        ? 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\n            ? 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 =\n          refinement &&\n          (huffman\n            ? 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(\n            symbolWidth,\n            symbolHeight,\n            refinementTemplateIndex,\n            symbolBitmap,\n            (rdw >> 1) + rdx,\n            (rdh >> 1) + rdy,\n            false,\n            refinementAt,\n            decodingContext\n          );\n        }\n        var offsetT = t - (referenceCorner & 1 ? 0 : symbolHeight - 1);\n        var offsetS = currentS - (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          }\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          }\n          currentS += symbolWidth - 1;\n        }\n        i++;\n        var deltaS = huffman\n          ? 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(\n    mmr,\n    patternWidth,\n    patternHeight,\n    maxPatternIndex,\n    template,\n    decodingContext\n  ) {\n    const 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    const collectiveWidth = (maxPatternIndex + 1) * patternWidth;\n    const collectiveBitmap = decodeBitmap(\n      mmr,\n      collectiveWidth,\n      patternHeight,\n      template,\n      false,\n      null,\n      at,\n      decodingContext\n    );\n    // Divide collective bitmap into patterns.\n    const patterns = [];\n    for (let i = 0; i <= maxPatternIndex; i++) {\n      const patternBitmap = [];\n      const xMin = patternWidth * i;\n      const xMax = xMin + patternWidth;\n      for (let y = 0; y < patternHeight; y++) {\n        patternBitmap.push(collectiveBitmap[y].subarray(xMin, xMax));\n      }\n      patterns.push(patternBitmap);\n    }\n    return patterns;\n  }\n\n  function decodeHalftoneRegion(\n    mmr,\n    patterns,\n    template,\n    regionWidth,\n    regionHeight,\n    defaultPixelValue,\n    enableSkip,\n    combinationOperator,\n    gridWidth,\n    gridHeight,\n    gridOffsetX,\n    gridOffsetY,\n    gridVectorX,\n    gridVectorY,\n    decodingContext\n  ) {\n    const skip = null;\n    if (enableSkip) {\n      throw new Jbig2Error(\"skip is not supported\");\n    }\n    if (combinationOperator !== 0) {\n      throw new Jbig2Error(\n        \"operator \" +\n          combinationOperator +\n          \" is not supported in halftone region\"\n      );\n    }\n\n    // Prepare bitmap.\n    const 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    const numberOfPatterns = patterns.length;\n    const pattern0 = patterns[0];\n    const patternWidth = pattern0[0].length,\n      patternHeight = pattern0.length;\n    const bitsPerValue = log2(numberOfPatterns);\n    const 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    const grayScaleBitPlanes = [];\n    let 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(\n        decodingContext.data,\n        decodingContext.start,\n        decodingContext.end\n      );\n    }\n    for (i = bitsPerValue - 1; i >= 0; i--) {\n      if (mmr) {\n        bitmap = decodeMMRBitmap(mmrInput, gridWidth, gridHeight, true);\n      } else {\n        bitmap = decodeBitmap(\n          false,\n          gridWidth,\n          gridHeight,\n          template,\n          false,\n          skip,\n          at,\n          decodingContext\n        );\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 (\n          x >= 0 &&\n          x + patternWidth <= regionWidth &&\n          y >= 0 &&\n          y + patternHeight <= regionHeight\n        ) {\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\n    let referredToSegmentNumberSize = 4;\n    if (segmentHeader.number <= 256) {\n      referredToSegmentNumberSize = 1;\n    } else if (segmentHeader.number <= 65536) {\n      referredToSegmentNumberSize = 2;\n    }\n    var referredTo = [];\n    var i, ii;\n    for (i = 0; i < referredToCount; i++) {\n      let number;\n      if (referredToSegmentNumberSize === 1) {\n        number = data[position];\n      } else if (referredToSegmentNumberSize === 2) {\n        number = readUint16(data, position);\n      } else {\n        number = readUint32(data, position);\n      }\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) {\n        // ImmediateGenericRegion\n        var genericRegionInfo = readRegionSegmentInformation(data, position);\n        var genericRegionSegmentFlags =\n          data[position + 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,\n      position = segment.start,\n      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 = [\n          dictionary,\n          header.number,\n          header.referredTo,\n          data,\n          position,\n          end,\n        ];\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        }\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        const patternDictionary = {};\n        const 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        const halftoneRegion = {};\n        halftoneRegion.info = readRegionSegmentInformation(data, position);\n        position += RegionSegmentInformationFieldLength;\n        const 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(\n          `segment type ${header.typeName}(${header.type})` +\n            \" is not implemented\"\n        );\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    const end = data.length;\n    let position = 0;\n\n    if (\n      data[position] !== 0x97 ||\n      data[position + 1] !== 0x4a ||\n      data[position + 2] !== 0x42 ||\n      data[position + 3] !== 0x32 ||\n      data[position + 4] !== 0x0d ||\n      data[position + 5] !== 0x0a ||\n      data[position + 6] !== 0x1a ||\n      data[position + 7] !== 0x0a\n    ) {\n      throw new Jbig2Error(\"parseJbig2 - invalid header.\");\n    }\n\n    const 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    const segments = readSegments(header, data, position, end);\n    const visitor = new SimpleSegmentVisitor();\n    processSegments(segments, visitor);\n\n    const { width, height } = visitor.currentPageInfo;\n    const bitPacked = visitor.buffer;\n    const imgData = new Uint8ClampedArray(width * height);\n    let q = 0,\n      k = 0;\n    for (let i = 0; i < height; i++) {\n      let mask = 0,\n        buffer;\n      for (let j = 0; j < width; j++) {\n        if (!mask) {\n          mask = 128;\n          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,\n        height = regionInfo.height;\n      var rowSize = (pageInfo.width + 7) >> 3;\n      var combinationOperator = pageInfo.combinationOperatorOverride\n        ? regionInfo.combinationOperator\n        : 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    },\n    onImmediateGenericRegion: function SimpleSegmentVisitor_onImmediateGenericRegion(\n      region,\n      data,\n      start,\n      end\n    ) {\n      var regionInfo = region.info;\n      var decodingContext = new DecodingContext(data, start, end);\n      var bitmap = decodeBitmap(\n        region.mmr,\n        regionInfo.width,\n        regionInfo.height,\n        region.template,\n        region.prediction,\n        null,\n        region.at,\n        decodingContext\n      );\n      this.drawBitmap(regionInfo, bitmap);\n    },\n    onImmediateLosslessGenericRegion: function SimpleSegmentVisitor_onImmediateLosslessGenericRegion() {\n      this.onImmediateGenericRegion.apply(this, arguments);\n    },\n    onSymbolDictionary: function SimpleSegmentVisitor_onSymbolDictionary(\n      dictionary,\n      currentSegment,\n      referredSegments,\n      data,\n      start,\n      end\n    ) {\n      let huffmanTables, huffmanInput;\n      if (dictionary.huffman) {\n        huffmanTables = getSymbolDictionaryHuffmanTables(\n          dictionary,\n          referredSegments,\n          this.customTables\n        );\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        const 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(\n        dictionary.huffman,\n        dictionary.refinement,\n        inputSymbols,\n        dictionary.numberOfNewSymbols,\n        dictionary.numberOfExportedSymbols,\n        huffmanTables,\n        dictionary.template,\n        dictionary.at,\n        dictionary.refinementTemplate,\n        dictionary.refinementAt,\n        decodingContext,\n        huffmanInput\n      );\n    },\n    onImmediateTextRegion: function SimpleSegmentVisitor_onImmediateTextRegion(\n      region,\n      referredSegments,\n      data,\n      start,\n      end\n    ) {\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        const 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(\n          region,\n          referredSegments,\n          this.customTables,\n          inputSymbols.length,\n          huffmanInput\n        );\n      }\n\n      var decodingContext = new DecodingContext(data, start, end);\n      var bitmap = decodeTextRegion(\n        region.huffman,\n        region.refinement,\n        regionInfo.width,\n        regionInfo.height,\n        region.defaultPixelValue,\n        region.numberOfSymbolInstances,\n        region.stripSize,\n        inputSymbols,\n        symbolCodeLength,\n        region.transposed,\n        region.dsOffset,\n        region.referenceCorner,\n        region.combinationOperator,\n        huffmanTables,\n        region.refinementTemplate,\n        region.refinementAt,\n        decodingContext,\n        region.logStripSize,\n        huffmanInput\n      );\n      this.drawBitmap(regionInfo, bitmap);\n    },\n    onImmediateLosslessTextRegion: 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      const decodingContext = new DecodingContext(data, start, end);\n      patterns[currentSegment] = decodePatternDictionary(\n        dictionary.mmr,\n        dictionary.patternWidth,\n        dictionary.patternHeight,\n        dictionary.maxPatternIndex,\n        dictionary.template,\n        decodingContext\n      );\n    },\n    onImmediateHalftoneRegion(region, referredSegments, data, start, end) {\n      // HalftoneRegion refers to exactly one PatternDictionary.\n      const patterns = this.patterns[referredSegments[0]];\n      const regionInfo = region.info;\n      const decodingContext = new DecodingContext(data, start, end);\n      const bitmap = decodeHalftoneRegion(\n        region.mmr,\n        patterns,\n        region.template,\n        regionInfo.width,\n        regionInfo.height,\n        region.defaultPixelValue,\n        region.enableSkip,\n        region.combinationOperator,\n        region.gridWidth,\n        region.gridHeight,\n        region.gridOffsetX,\n        region.gridOffsetY,\n        region.gridVectorX,\n        region.gridVectorY,\n        decodingContext\n      );\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      const 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        const htOffset = reader.readBits(this.rangeLength);\n        return this.rangeLow + (this.isLowerRange ? -htOffset : htOffset);\n      }\n      const 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    for (let i = 0, ii = lines.length; i < ii; i++) {\n      const 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      const linesLength = lines.length;\n      let prefixLengthMax = 0;\n      for (let i = 0; i < linesLength; i++) {\n        prefixLengthMax = Math.max(prefixLengthMax, lines[i].prefixLength);\n      }\n\n      const histogram = new Uint32Array(prefixLengthMax + 1);\n      for (let i = 0; i < linesLength; i++) {\n        histogram[lines[i].prefixLength]++;\n      }\n      let currentLength = 1,\n        firstCode = 0,\n        currentCode,\n        currentTemp,\n        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    const flags = data[start];\n    const lowestValue = readUint32(data, start + 1) & 0xffffffff;\n    const highestValue = readUint32(data, start + 5) & 0xffffffff;\n    const reader = new Reader(data, start + 9, end);\n\n    const prefixSizeBits = ((flags >> 1) & 7) + 1;\n    const rangeSizeBits = ((flags >> 4) & 7) + 1;\n    const lines = [];\n    let prefixLength,\n      rangeLength,\n      currentRangeLow = lowestValue;\n\n    // Normal table lines\n    do {\n      prefixLength = reader.readBits(prefixSizeBits);\n      rangeLength = reader.readBits(rangeSizeBits);\n      lines.push(\n        new HuffmanLine([currentRangeLow, prefixLength, rangeLength, 0])\n      );\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\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  const 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    for (let i = 0, ii = lines.length; i < ii; 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      const bit = (this.currentByte >> this.shift) & 1;\n      this.shift--;\n      return bit;\n    },\n\n    readBits(numBits) {\n      let result = 0,\n        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;\n    for (let i = 0, ii = referredTo.length; i < ii; i++) {\n      const 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(\n    textRegion,\n    referredTo,\n    customTables,\n    numberOfSymbols,\n    reader\n  ) {\n    // 7.4.3.1.7 Symbol ID Huffman table decoding\n\n    // Read code lengths for RUNCODEs 0...34.\n    const codes = [];\n    for (let i = 0; i <= 34; i++) {\n      const codeLength = reader.readBits(4);\n      codes.push(new HuffmanLine([i, codeLength, 0, 0]));\n    }\n    // Assign Huffman codes for RUNCODEs.\n    const 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 (let i = 0; i < numberOfSymbols; ) {\n      const 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    const symbolIDTable = new HuffmanTable(codes, false);\n\n    // 7.4.3.1.6 Text region segment Huffman table selection\n\n    let customIndex = 0,\n      tableFirstS,\n      tableDeltaS,\n      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(\n          customIndex,\n          referredTo,\n          customTables\n        );\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(\n          customIndex,\n          referredTo,\n          customTables\n        );\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(\n          customIndex,\n          referredTo,\n          customTables\n        );\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(\n    dictionary,\n    referredTo,\n    customTables\n  ) {\n    // 7.4.2.1.6 Symbol dictionary segment Huffman table selection\n\n    let customIndex = 0,\n      tableDeltaHeight,\n      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(\n          customIndex,\n          referredTo,\n          customTables\n        );\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(\n          customIndex,\n          referredTo,\n          customTables\n        );\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(\n        customIndex,\n        referredTo,\n        customTables\n      );\n      customIndex++;\n    } else {\n      tableBitmapSize = getStandardTable(1);\n    }\n\n    if (dictionary.aggregationInstancesSelector) {\n      tableAggregateInstances = getCustomHuffmanTable(\n        customIndex,\n        referredTo,\n        customTables\n      );\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    const bitmap = [];\n    for (let y = 0; y < height; y++) {\n      const row = new Uint8Array(width);\n      bitmap.push(row);\n      for (let 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    const params = {\n      K: -1,\n      Columns: width,\n      Rows: height,\n      BlackIs1: true,\n      EndOfBlock: endOfBlock,\n    };\n    const decoder = new CCITTFaxDecoder(input, params);\n    const bitmap = [];\n    let currentByte,\n      eof = false;\n\n    for (let y = 0; y < height; y++) {\n      const row = new Uint8Array(width);\n      bitmap.push(row);\n      let shift = -1;\n      for (let 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  // eslint-disable-next-line no-shadow\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 { Jbig2Image };\n","/* Copyright 2019 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 no-var: error */\n\nimport { assert, BaseException, warn } from \"../shared/util.js\";\n\nfunction getLookupTableFactory(initializer) {\n  let 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\nclass MissingDataException extends BaseException {\n  constructor(begin, end) {\n    super(`Missing data [${begin}, ${end})`);\n    this.begin = begin;\n    this.end = end;\n  }\n}\n\nclass XRefEntryException extends BaseException {}\n\nclass XRefParseException extends BaseException {}\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({\n  dict,\n  key,\n  getArray = false,\n  stopWhenFound = true,\n}) {\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\n// prettier-ignore\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 {number} 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 * @returns {string} The resulting Roman number.\n */\nfunction toRomanNumerals(number, lowerCase = false) {\n  assert(\n    Number.isInteger(number) && number > 0,\n    \"The number should be a positive integer.\"\n  );\n  const romanBuf = [];\n  let pos;\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\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, offset) {\n  return (data[offset] << 24) >> 24;\n}\n\nfunction readUint16(data, offset) {\n  return (data[offset] << 8) | data[offset + 1];\n}\n\nfunction readUint32(data, offset) {\n  return (\n    ((data[offset] << 24) |\n      (data[offset + 1] << 16) |\n      (data[offset + 2] << 8) |\n      data[offset + 3]) >>>\n    0\n  );\n}\n\n// Checks if ch is one of the following characters: SPACE, TAB, CR or LF.\nfunction isWhiteSpace(ch) {\n  return ch === 0x20 || ch === 0x09 || ch === 0x0d || ch === 0x0a;\n}\n\nexport {\n  getLookupTableFactory,\n  MissingDataException,\n  XRefEntryException,\n  XRefParseException,\n  getInheritableProperty,\n  toRomanNumerals,\n  log2,\n  readInt8,\n  readUint16,\n  readUint32,\n  isWhiteSpace,\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/* eslint no-var: error */\n\n// Table C-2\nconst 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/**\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 */\nclass ArithmeticDecoder {\n  // C.3.5 Initialisation of the decoder (INITDEC)\n  constructor(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  // C.3.4 Compressed data input (BYTEIN)\n  byteIn() {\n    const data = this.data;\n    let bp = this.bp;\n\n    if (data[bp] === 0xff) {\n      if (data[bp + 1] > 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\n  // C.3.2 Decoding a decision (DECODE)\n  readBit(contexts, pos) {\n    // Contexts are packed into 1 byte:\n    // highest 7 bits carry cx.index, lowest bit carries cx.mps\n    let cx_index = contexts[pos] >> 1,\n      cx_mps = contexts[pos] & 1;\n    const qeTableIcx = QeTable[cx_index];\n    const qeIcx = qeTableIcx.qe;\n    let d;\n    let 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\nexport { ArithmeticDecoder };\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.js\";\n\nconst CCITTFaxDecoder = (function CCITTFaxDecoder() {\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  // prettier-ignore\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  // prettier-ignore\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  // prettier-ignore\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  // prettier-ignore\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  // prettier-ignore\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  // prettier-ignore\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] - Decoding options.\n   */\n  // eslint-disable-next-line no-shadow\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      const refLine = this.refLine;\n      const codingLine = this.codingLine;\n      const 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(\n                  codingLine[this.codingPos] + code1,\n                  blackPixels\n                );\n                if (codingLine[this.codingPos] < columns) {\n                  this._addPixels(\n                    codingLine[this.codingPos] + code2,\n                    blackPixels ^ 1\n                  );\n                }\n                while (\n                  refLine[refPos] <= codingLine[this.codingPos] &&\n                  refLine[refPos] < columns\n                ) {\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 (\n                    refLine[refPos] <= codingLine[this.codingPos] &&\n                    refLine[refPos] < columns\n                  ) {\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 (\n                    refLine[refPos] <= codingLine[this.codingPos] &&\n                    refLine[refPos] < columns\n                  ) {\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 (\n                    refLine[refPos] <= codingLine[this.codingPos] &&\n                    refLine[refPos] < columns\n                  ) {\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 (\n                    refLine[refPos] <= codingLine[this.codingPos] &&\n                    refLine[refPos] < columns\n                  ) {\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 (\n                    refLine[refPos] <= codingLine[this.codingPos] &&\n                    refLine[refPos] < columns\n                  ) {\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 (\n                    refLine[refPos] <= codingLine[this.codingPos] &&\n                    refLine[refPos] < columns\n                  ) {\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 (\n                    refLine[refPos] <= codingLine[this.codingPos] &&\n                    refLine[refPos] < columns\n                  ) {\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 =\n            codingLine[this.codingPos] - 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 =\n                codingLine[this.codingPos] - 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      const 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      const 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      const 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          const 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        const 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)) & (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 { CCITTFaxDecoder };\n","/* Copyright 2014 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the 'License');\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an 'AS IS' BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { assert, BaseException, warn } from \"../shared/util.js\";\nimport { readUint16 } from \"./core_utils.js\";\n\nclass JpegError extends BaseException {\n  constructor(msg) {\n    super(`JPEG error: ${msg}`);\n  }\n}\n\nclass DNLMarkerError extends BaseException {\n  constructor(message, scanLines) {\n    super(message);\n    this.scanLines = scanLines;\n  }\n}\n\nclass EOIMarkerError extends BaseException {}\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  // prettier-ignore\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  // eslint-disable-next-line no-shadow\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,\n      code = [],\n      i,\n      j,\n      length = 16;\n    while (length > 0 && !codeLengths[length - 1]) {\n      length--;\n    }\n    code.push({ children: [], index: 0 });\n    var p = code[0],\n      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(\n    data,\n    offset,\n    frame,\n    components,\n    resetInterval,\n    spectralStart,\n    spectralEnd,\n    successivePrev,\n    successive,\n    parseDNLMarker = false\n  ) {\n    var mcusPerLine = frame.mcusPerLine;\n    var progressive = frame.progressive;\n\n    const startOffset = offset;\n    let bitsData = 0,\n      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 === /* DNL = */ 0xdc && parseDNLMarker) {\n            offset += 2; // Skip marker length.\n\n            const scanLines = readUint16(data, offset);\n            offset += 2;\n            if (scanLines > 0 && scanLines !== frame.scanLines) {\n              throw new DNLMarkerError(\n                \"Found DNL marker (0xFFDC) while parsing scan data\",\n                scanLines\n              );\n            }\n          } else if (nextByte === /* EOI = */ 0xd9) {\n            if (parseDNLMarker) {\n              // NOTE: only 8-bit JPEG images are supported in this decoder.\n              const maybeScanLines = blockRow * (frame.precision === 8 ? 8 : 0);\n              // Heuristic to attempt to handle corrupt JPEG images with too\n              // large `scanLines` parameter, by falling back to the currently\n              // parsed number of scanLines when it's at least (approximately)\n              // one order of magnitude smaller than expected (fixes\n              // issue10880.pdf and issue10989.pdf).\n              if (\n                maybeScanLines > 0 &&\n                Math.round(frame.scanLines / maybeScanLines) >= 10\n              ) {\n                throw new DNLMarkerError(\n                  \"Found EOI marker (0xFFD9) while parsing scan data, \" +\n                    \"possibly caused by incorrect `scanLines` parameter\",\n                  maybeScanLines\n                );\n              }\n            }\n            throw new EOIMarkerError(\n              \"Found EOI marker (0xFFD9) while parsing scan data\"\n            );\n          }\n          throw new JpegError(\n            `unexpected marker ${((bitsData << 8) | nextByte).toString(16)}`\n          );\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        switch (typeof node) {\n          case \"number\":\n            return node;\n          case \"object\":\n            continue;\n        }\n        throw new JpegError(\"invalid huffman sequence\");\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, blockOffset) {\n      var t = decodeHuffman(component.huffmanTableDC);\n      var diff = t === 0 ? 0 : receiveAndExtend(t);\n      component.blockData[blockOffset] = component.pred += diff;\n      var k = 1;\n      while (k < 64) {\n        var rs = decodeHuffman(component.huffmanTableAC);\n        var s = rs & 15,\n          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[blockOffset + z] = receiveAndExtend(s);\n        k++;\n      }\n    }\n\n    function decodeDCFirst(component, blockOffset) {\n      var t = decodeHuffman(component.huffmanTableDC);\n      var diff = t === 0 ? 0 : receiveAndExtend(t) << successive;\n      component.blockData[blockOffset] = component.pred += diff;\n    }\n\n    function decodeDCSuccessive(component, blockOffset) {\n      component.blockData[blockOffset] |= readBit() << successive;\n    }\n\n    var eobrun = 0;\n    function decodeACFirst(component, blockOffset) {\n      if (eobrun > 0) {\n        eobrun--;\n        return;\n      }\n      var k = spectralStart,\n        e = spectralEnd;\n      while (k <= e) {\n        var rs = decodeHuffman(component.huffmanTableAC);\n        var s = rs & 15,\n          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[blockOffset + z] =\n          receiveAndExtend(s) * (1 << successive);\n        k++;\n      }\n    }\n\n    var successiveACState = 0,\n      successiveACNextValue;\n    function decodeACSuccessive(component, blockOffset) {\n      var k = spectralStart;\n      var e = spectralEnd;\n      var r = 0;\n      var s;\n      var rs;\n      while (k <= e) {\n        const offsetZ = blockOffset + dctZigZag[k];\n        const 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    let blockRow = 0;\n    function decodeMcu(component, decode, mcu, row, col) {\n      var mcuRow = (mcu / mcusPerLine) | 0;\n      var mcuCol = mcu % mcusPerLine;\n      blockRow = mcuRow * component.v + row;\n      var blockCol = mcuCol * component.h + col;\n      const blockOffset = getBlockBufferOffset(component, blockRow, blockCol);\n      decode(component, blockOffset);\n    }\n\n    function decodeBlock(component, decode, mcu) {\n      blockRow = (mcu / component.blocksPerLine) | 0;\n      var blockCol = mcu % component.blocksPerLine;\n      const blockOffset = getBlockBufferOffset(component, blockRow, blockCol);\n      decode(component, blockOffset);\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,\n      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)\n        : mcuExpected;\n\n      // The `mcuToRead === 0` case should only occur when all of the expected\n      // MCU data has been already parsed, i.e. when `mcu === mcuExpected`, but\n      // some corrupt JPEG images contain more data than intended and we thus\n      // want to skip over any extra RSTx markers below (fixes issue11794.pdf).\n      if (mcuToRead > 0) {\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\n      // find marker\n      bitsCount = 0;\n      fileMarker = findNextFileMarker(data, offset);\n      if (!fileMarker) {\n        break; // Reached the end of the image data without finding any marker.\n      }\n      if (fileMarker.invalid) {\n        // Some bad images seem to pad Scan blocks with e.g. zero bytes, skip\n        // past those to attempt to find a valid marker (fixes issue4090.pdf).\n        const partialMsg = mcuToRead > 0 ? \"unexpected\" : \"excessive\";\n        warn(\n          `decodeScan - ${partialMsg} MCU data, current marker is: ${fileMarker.invalid}`\n        );\n        offset = fileMarker.offset;\n      }\n      if (fileMarker.marker >= 0xffd0 && fileMarker.marker <= 0xffd7) {\n        // RSTx\n        offset += 2;\n      } else {\n        break;\n      }\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,\n      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        if (t < -2040) {\n          t = 0;\n        } else if (t >= 2024) {\n          t = 255;\n        } else {\n          t = (t + 2056) >> 4;\n        }\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      if (p0 < 16) {\n        p0 = 0;\n      } else if (p0 >= 4080) {\n        p0 = 255;\n      } else {\n        p0 >>= 4;\n      }\n      if (p1 < 16) {\n        p1 = 0;\n      } else if (p1 >= 4080) {\n        p1 = 255;\n      } else {\n        p1 >>= 4;\n      }\n      if (p2 < 16) {\n        p2 = 0;\n      } else if (p2 >= 4080) {\n        p2 = 255;\n      } else {\n        p2 >>= 4;\n      }\n      if (p3 < 16) {\n        p3 = 0;\n      } else if (p3 >= 4080) {\n        p3 = 255;\n      } else {\n        p3 >>= 4;\n      }\n      if (p4 < 16) {\n        p4 = 0;\n      } else if (p4 >= 4080) {\n        p4 = 255;\n      } else {\n        p4 >>= 4;\n      }\n      if (p5 < 16) {\n        p5 = 0;\n      } else if (p5 >= 4080) {\n        p5 = 255;\n      } else {\n        p5 >>= 4;\n      }\n      if (p6 < 16) {\n        p6 = 0;\n      } else if (p6 >= 4080) {\n        p6 = 255;\n      } else {\n        p6 >>= 4;\n      }\n      if (p7 < 16) {\n        p7 = 0;\n      } else if (p7 >= 4080) {\n        p7 = 255;\n      } else {\n        p7 >>= 4;\n      }\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    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 = readUint16(data, currentPos);\n    if (currentMarker >= 0xffc0 && currentMarker <= 0xfffe) {\n      return {\n        invalid: null,\n        marker: currentMarker,\n        offset: currentPos,\n      };\n    }\n    var newMarker = readUint16(data, 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 = readUint16(data, 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      function readDataBlock() {\n        const length = readUint16(data, offset);\n        offset += 2;\n        let endOffset = offset + length - 2;\n\n        var fileMarker = findNextFileMarker(data, endOffset, offset);\n        if (fileMarker && fileMarker.invalid) {\n          warn(\n            \"readDataBlock - incorrect length, current marker is: \" +\n              fileMarker.invalid\n          );\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(\n            (Math.ceil(frame.samplesPerLine / 8) * component.h) / frame.maxH\n          );\n          var blocksPerColumn = Math.ceil(\n            (Math.ceil(frame.scanLines / 8) * component.v) / frame.maxV\n          );\n          var blocksPerLineForMcu = mcusPerLine * component.h;\n          var blocksPerColumnForMcu = mcusPerColumn * component.v;\n\n          var blocksBufferSize =\n            64 * blocksPerColumnForMcu * (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 = [],\n        huffmanTablesDC = [];\n\n      let fileMarker = readUint16(data, offset);\n      offset += 2;\n      if (fileMarker !== /* SOI (Start of Image) = */ 0xffd8) {\n        throw new JpegError(\"SOI not found\");\n      }\n      fileMarker = readUint16(data, offset);\n      offset += 2;\n\n      markerLoop: while (fileMarker !== /* EOI (End of Image) = */ 0xffd9) {\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              // 'JFIF\\x00'\n              if (\n                appData[0] === 0x4a &&\n                appData[1] === 0x46 &&\n                appData[2] === 0x49 &&\n                appData[3] === 0x46 &&\n                appData[4] === 0\n              ) {\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(\n                    14,\n                    14 + 3 * appData[12] * appData[13]\n                  ),\n                };\n              }\n            }\n            // TODO APP1 - Exif\n            if (fileMarker === 0xffee) {\n              // 'Adobe'\n              if (\n                appData[0] === 0x41 &&\n                appData[1] === 0x64 &&\n                appData[2] === 0x6f &&\n                appData[3] === 0x62 &&\n                appData[4] === 0x65\n              ) {\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            const quantizationTablesLength = readUint16(data, offset);\n            offset += 2;\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) {\n                // 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) {\n                // 16 bit values\n                for (j = 0; j < 64; j++) {\n                  z = dctZigZag[j];\n                  tableData[z] = readUint16(data, offset);\n                  offset += 2;\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            offset += 2; // Skip marker length.\n\n            frame = {};\n            frame.extended = fileMarker === 0xffc1;\n            frame.progressive = fileMarker === 0xffc2;\n            frame.precision = data[offset++];\n            const sofScanLines = readUint16(data, offset);\n            offset += 2;\n            frame.scanLines = dnlScanLines || sofScanLines;\n            frame.samplesPerLine = readUint16(data, offset);\n            offset += 2;\n            frame.components = [];\n            frame.componentIds = {};\n            var componentsCount = data[offset++],\n              componentId;\n            var maxH = 0,\n              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            const huffmanLength = readUint16(data, offset);\n            offset += 2;\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 ? huffmanTablesDC : huffmanTablesAC)[\n                huffmanTableSpec & 15\n              ] = buildHuffmanTable(codeLengths, huffmanValues);\n            }\n            break;\n\n          case 0xffdd: // DRI (Define Restart Interval)\n            offset += 2; // Skip marker length.\n\n            resetInterval = readUint16(data, offset);\n            offset += 2;\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            offset += 2; // Skip marker length.\n\n            var selectorsCount = data[offset++];\n            var components = [],\n              component;\n            for (i = 0; i < selectorsCount; i++) {\n              const index = data[offset++];\n              var componentIndex = frame.componentIds[index];\n              component = frame.components[componentIndex];\n              component.index = index;\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(\n                data,\n                offset,\n                frame,\n                components,\n                resetInterval,\n                spectralStart,\n                spectralEnd,\n                successiveApproximation >> 4,\n                successiveApproximation & 15,\n                parseDNLMarker\n              );\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) {\n              // Avoid skipping a valid marker.\n              offset--;\n            }\n            break;\n\n          default:\n            // Could be incorrect encoding -- the last 0xFF byte of the previous\n            // block could have been eaten by the encoder, hence we fallback to\n            // `startPos = offset - 3` when looking for the next valid marker.\n            const nextFileMarker = findNextFileMarker(\n              data,\n              /* currentPos = */ offset - 2,\n              /* startPos = */ offset - 3\n            );\n            if (nextFileMarker && nextFileMarker.invalid) {\n              warn(\n                \"JpegImage.parse - unexpected data, current marker is: \" +\n                  nextFileMarker.invalid\n              );\n              offset = nextFileMarker.offset;\n              break;\n            }\n            if (offset >= data.length - 1) {\n              warn(\n                \"JpegImage.parse - reached the end of the image data \" +\n                  \"without finding an EOI marker (0xFFD9).\"\n              );\n              break markerLoop;\n            }\n            throw new JpegError(\n              \"JpegImage.parse - unknown marker: \" + fileMarker.toString(16)\n            );\n        }\n        fileMarker = readUint16(data, offset);\n        offset += 2;\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          index: component.index,\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      return undefined;\n    },\n\n    _getLinearizedBlockData(width, height, isSourcePDF = false) {\n      var scaleX = this.width / width,\n        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      let lastComponentScaleX;\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`. Since it doesn't depend on the\n        // component data, that's only necessary when `componentScaleX` changes.\n        if (componentScaleX !== lastComponentScaleX) {\n          for (x = 0; x < width; x++) {\n            j = 0 | (x * componentScaleX);\n            xScaleBlockOffset[x] = ((j & mask3LSB) << 3) | (j & 7);\n          }\n          lastComponentScaleX = componentScaleX;\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        // prettier-ignore\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        } else if (\n          this.components[0].index === /* \"R\" = */ 0x52 &&\n          this.components[1].index === /* \"G\" = */ 0x47 &&\n          this.components[2].index === /* \"B\" = */ 0x42\n        ) {\n          // If the three components are indexed as RGB in ASCII\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++] =\n          -122.67195406894 +\n          Cb *\n            (-6.60635669420364e-5 * Cb +\n              0.000437130475926232 * Cr -\n              5.4080610064599e-5 * Y +\n              0.00048449797120281 * k -\n              0.154362151871126) +\n          Cr *\n            (-0.000957964378445773 * Cr +\n              0.000817076911346625 * Y -\n              0.00477271405408747 * k +\n              1.53380253221734) +\n          Y *\n            (0.000961250184130688 * Y -\n              0.00266257332283933 * k +\n              0.48357088451265) +\n          k * (-0.000336197177618394 * k + 0.484791561490776);\n\n        data[offset++] =\n          107.268039397724 +\n          Cb *\n            (2.19927104525741e-5 * Cb -\n              0.000640992018297945 * Cr +\n              0.000659397001245577 * Y +\n              0.000426105652938837 * k -\n              0.176491792462875) +\n          Cr *\n            (-0.000778269941513683 * Cr +\n              0.00130872261408275 * Y +\n              0.000770482631801132 * k -\n              0.151051492775562) +\n          Y *\n            (0.00126935368114843 * Y -\n              0.00265090189010898 * k +\n              0.25802910206845) +\n          k * (-0.000318913117588328 * k - 0.213742400323665);\n\n        data[offset++] =\n          -20.810012546947 +\n          Cb *\n            (-0.000570115196973677 * Cb -\n              2.63409051004589e-5 * Cr +\n              0.0020741088115012 * Y -\n              0.00288260236853442 * k +\n              0.814272968359295) +\n          Cr *\n            (-1.53496057440975e-5 * Cr -\n              0.000132689043961446 * Y +\n              0.000560833691242812 * k -\n              0.195152027534049) +\n          Y *\n            (0.00174418132927582 * Y -\n              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      for (var i = 0, length = data.length; i < length; i += 4) {\n        c = data[i];\n        m = data[i + 1];\n        y = data[i + 2];\n        k = data[i + 3];\n\n        data[offset++] =\n          255 +\n          c *\n            (-0.00006747147073602441 * c +\n              0.0008379262121013727 * m +\n              0.0002894718188643294 * y +\n              0.003264231057537806 * k -\n              1.1185611867203937) +\n          m *\n            (0.000026374107616089405 * m -\n              0.00008626949158638572 * y -\n              0.0002748769067499491 * k -\n              0.02155688794978967) +\n          y *\n            (-0.00003878099212869363 * y -\n              0.0003267808279485286 * k +\n              0.0686742238595345) -\n          k * (0.0003361971776183937 * k + 0.7430659151342254);\n\n        data[offset++] =\n          255 +\n          c *\n            (0.00013596372813588848 * c +\n              0.000924537132573585 * m +\n              0.00010567359618683593 * y +\n              0.0004791864687436512 * k -\n              0.3109689587515875) +\n          m *\n            (-0.00023545346108370344 * m +\n              0.0002702845253534714 * y +\n              0.0020200308977307156 * k -\n              0.7488052167015494) +\n          y *\n            (0.00006834815998235662 * y +\n              0.00015168452363460973 * k -\n              0.09751927774728933) -\n          k * (0.00031891311758832814 * k + 0.7364883807733168);\n\n        data[offset++] =\n          255 +\n          c *\n            (0.000013598650411385307 * c +\n              0.00012423956175490851 * m +\n              0.0004751985097583589 * y -\n              0.0000036729317476630422 * k -\n              0.05562186980264034) +\n          m *\n            (0.00016141380598724676 * m +\n              0.0009692239130725186 * y +\n              0.0007782692450036253 * k -\n              0.44015232367526463) +\n          y *\n            (5.068882914068769e-7 * y +\n              0.0017778369011375071 * k -\n              0.7591454649749609) -\n          k * (0.0003435319965105553 * k + 0.7063770186160144);\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 (\n        typeof PDFJSDev === \"undefined\" ||\n        PDFJSDev.test(\"!PRODUCTION || TESTING\")\n      ) {\n        assert(\n          isSourcePDF === true,\n          'JpegImage.getData: Unexpected \"isSourcePDF\" value for PDF files.'\n        );\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 { JpegImage };\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 { BaseException, info, warn } from \"../shared/util.js\";\nimport { log2, readUint16, readUint32 } from \"./core_utils.js\";\nimport { ArithmeticDecoder } from \"./arithmetic_decoder.js\";\n\nclass JpxError extends BaseException {\n  constructor(msg) {\n    super(`JPX error: ${msg}`);\n  }\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\n  // eslint-disable-next-line no-shadow\n  function JpxImage() {\n    this.failOnCorruptedImage = false;\n  }\n  JpxImage.prototype = {\n    parse: function JpxImage_parse(data) {\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,\n        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 =\n            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(\n              (tbox >> 24) & 0xff,\n              (tbox >> 16) & 0xff,\n              (tbox >> 8) & 0xff,\n              tbox & 0xff\n            );\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,\n            j,\n            sqcd,\n            spqcds,\n            spqcdSize,\n            scalarExpounded,\n            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(\n                  \"Unsupported COD options (\" + unsupported.join(\", \") + \")\"\n                );\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(\n                \"Codestream code 0xFF53 (COC) is not implemented\"\n              );\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,\n      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_ =\n      r > 0\n        ? Math.min(codOrCoc.xcb, result.PPx - 1)\n        : Math.min(codOrCoc.xcb, result.PPx);\n    result.ycb_ =\n      r > 0\n        ? 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 =\n      resolution.trx1 > resolution.trx0\n        ? Math.ceil(resolution.trx1 / precinctWidth) -\n          Math.floor(resolution.trx0 / precinctWidth)\n        : 0;\n    var numprecinctshigh =\n      resolution.try1 > resolution.try0\n        ? Math.ceil(resolution.try1 / precinctHeight) -\n          Math.floor(resolution.try0 / precinctHeight)\n        : 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(\n          (codeblock.tbx0_ - subband.tbx0) /\n            precinctParameters.precinctWidthInSubband\n        );\n        var pj = Math.floor(\n          (codeblock.tby0_ - subband.tby0) /\n            precinctParameters.precinctHeightInSubband\n        );\n        precinctNumber = pi + pj * precinctParameters.numprecinctswide;\n\n        codeblock.precinctNumber = precinctNumber;\n        codeblock.subbandType = subband.type;\n        codeblock.Lblock = 3;\n\n        if (\n          codeblock.tbx1_ <= codeblock.tbx0_ ||\n          codeblock.tby1_ <= codeblock.tby0_\n        ) {\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(\n        maxDecompositionLevelsCount,\n        tile.components[q].codingStyleParameters.decompositionLevelsCount\n      );\n    }\n\n    var l = 0,\n      r = 0,\n      i = 0,\n      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(\n        maxDecompositionLevelsCount,\n        tile.components[q].codingStyleParameters.decompositionLevelsCount\n      );\n    }\n\n    var r = 0,\n      l = 0,\n      i = 0,\n      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      const component = tile.components[c];\n      maxDecompositionLevelsCount = Math.max(\n        maxDecompositionLevelsCount,\n        component.codingStyleParameters.decompositionLevelsCount\n      );\n    }\n    var maxNumPrecinctsInLevel = new Int32Array(\n      maxDecompositionLevelsCount + 1\n    );\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(\n            maxNumPrecincts,\n            resolutions[r].precinctParameters.numprecincts\n          );\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            const 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,\n      r = 0,\n      c = 0,\n      px = 0,\n      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              );\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,\n      r = 0,\n      c = 0,\n      px = 0,\n      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              );\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,\n    pyIndex,\n    sizeInImageScale,\n    precinctIterationSizes,\n    resolution\n  ) {\n    var posX = pxIndex * precinctIterationSizes.minWidth;\n    var posY = pyIndex * precinctIterationSizes.minHeight;\n    if (\n      posX % sizeInImageScale.width !== 0 ||\n      posY % sizeInImageScale.height !== 0\n    ) {\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        );\n        minHeightCurrentComponent = Math.min(\n          minHeightCurrentComponent,\n          heightCurrentResolution\n        );\n        maxNumWideCurrentComponent = Math.max(\n          maxNumWideCurrentComponent,\n          resolution.precinctParameters.numprecinctswide\n        );\n        maxNumHighCurrentComponent = Math.max(\n          maxNumHighCurrentComponent,\n          resolution.precinctParameters.numprecinctshigh\n        );\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 = new LayerResolutionComponentPositionIterator(\n          context\n        );\n        break;\n      case 1:\n        tile.packetsIterator = new ResolutionLayerComponentPositionIterator(\n          context\n        );\n        break;\n      case 2:\n        tile.packetsIterator = new ResolutionPositionComponentLayerIterator(\n          context\n        );\n        break;\n      case 3:\n        tile.packetsIterator = new PositionComponentResolutionLayerIterator(\n          context\n        );\n        break;\n      case 4:\n        tile.packetsIterator = new ComponentPositionResolutionLayerIterator(\n          context\n        );\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,\n      bufferSize = 0,\n      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 (\n        data[offset + position - 1] === 0xff &&\n        data[offset + position] === value\n      ) {\n        skipBytes(1);\n        return true;\n      } else if (\n        data[offset + position] === 0xff &&\n        data[offset + position + 1] === value\n      ) {\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 = [],\n        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 =\n          (codingpasses < 1 << codingpassesLog2\n            ? codingpassesLog2 - 1\n            : 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(\n    coefficients,\n    levelWidth,\n    levelHeight,\n    subband,\n    delta,\n    mb,\n    reversible,\n    segmentationSymbolUsed\n  ) {\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(\n        blockWidth,\n        blockHeight,\n        codeblock.subbandType,\n        codeblock.zeroBitPlanes,\n        mb\n      );\n      currentCodingpassType = 2; // first bit plane starts from cleanup\n\n      // collect data\n      var data = codeblock.data,\n        totalLength = 0,\n        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\n      ? 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\n          ? 1\n          : 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(\n          coefficients,\n          width,\n          height,\n          subband,\n          delta,\n          mb,\n          reversible,\n          segmentationSymbolUsed\n        );\n      }\n      subbandCoefficients.push({\n        width,\n        height,\n        items: coefficients,\n      });\n    }\n\n    var result = transform.calculate(\n      subbandCoefficients,\n      component.tcx0,\n      component.tcy0\n    );\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,\n        j,\n        jj,\n        y0,\n        y1,\n        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            const 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 {\n        // 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 =\n        context.currentTile.QCC[c] !== undefined\n          ? context.currentTile.QCC[c]\n          : context.currentTile.QCD;\n      component.quantizationParameters = qcdOrQcc;\n      var codOrCoc =\n        context.currentTile.COC[c] !== undefined\n          ? context.currentTile.COC[c]\n          : 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    // eslint-disable-next-line no-shadow\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,\n          value = 0,\n          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    // eslint-disable-next-line no-shadow\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    // prettier-ignore\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    // prettier-ignore\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    // prettier-ignore\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    // eslint-disable-next-line no-shadow\n    function BitModel(width, height, subband, zeroBitPlanes, mb) {\n      this.width = width;\n      this.height = height;\n\n      let contextLabelTable;\n      if (subband === \"HH\") {\n        contextLabelTable = HHContextLabel;\n      } else if (subband === \"HL\") {\n        contextLabelTable = HLContextLabel;\n      } else {\n        contextLabelTable = LLAndLHContextsLabel;\n      }\n      this.contextLabelTable = contextLabelTable;\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      let coefficentsMagnitude;\n      if (mb > 14) {\n        coefficentsMagnitude = new Uint32Array(coefficientCount);\n      } else if (mb > 6) {\n        coefficentsMagnitude = new Uint16Array(coefficientCount);\n      } else {\n        coefficentsMagnitude = new Uint8Array(coefficientCount);\n      }\n      this.coefficentsMagnitude = coefficentsMagnitude;\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: function BitModel_setNeighborsSignificance(\n        row,\n        column,\n        index\n      ) {\n        var neighborsSignificance = this.neighborsSignificance;\n        var width = this.width,\n          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: function BitModel_runSignificancePropagationPass() {\n        var decoder = this.decoder;\n        var width = this.width,\n          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 (\n                coefficentsMagnitude[index] ||\n                !neighborsSignificance[index]\n              ) {\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,\n          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: function BitModel_runMagnitudeRefinementPass() {\n        var decoder = this.decoder;\n        var width = this.width,\n          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              // significant but not those that have just become\n              if (\n                !coefficentsMagnitude[index] ||\n                (processingFlags[index] & processedMask) !== 0\n              ) {\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,\n          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 =\n              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,\n              index = index0;\n            var i = i0,\n              sign;\n            if (allEmpty) {\n              var hasSignificantCoefficent = decoder.readBit(\n                contexts,\n                RUNLENGTH_CONTEXT\n              );\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 =\n                (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 (\n                coefficentsMagnitude[index] ||\n                (processingFlags[index] & processedMask) !== 0\n              ) {\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 =\n          (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    // eslint-disable-next-line no-shadow\n    function Transform() {}\n\n    Transform.prototype.calculate = function transformCalculate(\n      subbands,\n      u0,\n      v0\n    ) {\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,\n        j1 = offset + 1;\n      var i2 = offset + size - 2,\n        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(\n      ll,\n      hl_lh_hh,\n      u0,\n      v0\n    ) {\n      var llWidth = ll.width,\n        llHeight = ll.height,\n        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\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,\n        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    // eslint-disable-next-line no-shadow\n    function IrreversibleTransform() {\n      Transform.call(this);\n    }\n\n    IrreversibleTransform.prototype = Object.create(Transform.prototype);\n    IrreversibleTransform.prototype.filter = function irreversibleTransformFilter(\n      x,\n      offset,\n      length\n    ) {\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    // eslint-disable-next-line no-shadow\n    function ReversibleTransform() {\n      Transform.call(this);\n    }\n\n    ReversibleTransform.prototype = Object.create(Transform.prototype);\n    ReversibleTransform.prototype.filter = function reversibleTransformFilter(\n      x,\n      offset,\n      length\n    ) {\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 { JpxImage };\n"],"sourceRoot":""}