@loaders.gl/compression 3.3.0-alpha.5 → 3.3.0-alpha.6

package/dist/esm/brotli/decode.js

@@ -1,3 +1,5 @@
+
+
 let Options;
 
 let makeBrotliDecode = () => {
@@ -19,57 +21,45 @@ let makeBrotliDecode = () => {
   {
     unpackCommandLookupTable(CMD_LOOKUP);
   }
-
   function log2floor(i) {
     let result = -1;
     let step = 16;
-
     while (step > 0) {
       if (i >>> step != 0) {
         result += step;
         i = i >>> step;
       }
-
       step = step >> 1;
     }
-
     return result + i;
   }
-
   function calculateDistanceAlphabetSize(npostfix, ndirect, maxndistbits) {
     return 16 + ndirect + 2 * (maxndistbits << npostfix);
   }
-
   function calculateDistanceAlphabetLimit(maxDistance, npostfix, ndirect) {
     if (maxDistance < ndirect + (2 << npostfix)) {
       throw 'maxDistance is too small';
     }
-
     let offset = (maxDistance - ndirect >> npostfix) + 4;
     let ndistbits = log2floor(offset) - 1;
     let group = ndistbits - 1 << 1 | offset >> ndistbits & 1;
     return (group - 1 << npostfix) + (1 << npostfix) + ndirect + 16;
   }
-
   function unpackCommandLookupTable(cmdLookup) {
     let insertLengthOffsets = new Int16Array(24);
     let copyLengthOffsets = new Int16Array(24);
     copyLengthOffsets[0] = 2;
-
     for (let i = 0; i < 23; ++i) {
       insertLengthOffsets[i + 1] = insertLengthOffsets[i] + (1 << INSERT_LENGTH_N_BITS[i]);
       copyLengthOffsets[i + 1] = copyLengthOffsets[i] + (1 << COPY_LENGTH_N_BITS[i]);
     }
-
     for (let cmdCode = 0; cmdCode < 704; ++cmdCode) {
       let rangeIdx = cmdCode >>> 6;
       let distanceContextOffset = -4;
-
       if (rangeIdx >= 2) {
         rangeIdx -= 2;
         distanceContextOffset = 0;
       }
-
       let insertCode = (0x29850 >>> rangeIdx * 2 & 0x3) << 3 | cmdCode >>> 3 & 7;
       let copyCode = (0x26244 >>> rangeIdx * 2 & 0x3) << 3 | cmdCode & 7;
       let copyLengthOffset = copyLengthOffsets[copyCode];
@@ -81,97 +71,74 @@ let makeBrotliDecode = () => {
       cmdLookup[index + 3] = distanceContext;
     }
   }
-
   function decodeWindowBits(s) {
     let largeWindowEnabled = s.isLargeWindow;
     s.isLargeWindow = 0;
-
     if (s.bitOffset >= 16) {
       s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
       s.bitOffset -= 16;
     }
-
     if (readFewBits(s, 1) == 0) {
       return 16;
     }
-
     let n = readFewBits(s, 3);
-
     if (n != 0) {
       return 17 + n;
     }
-
     n = readFewBits(s, 3);
-
     if (n != 0) {
       if (n == 1) {
         if (largeWindowEnabled == 0) {
           return -1;
         }
-
         s.isLargeWindow = 1;
-
         if (readFewBits(s, 1) == 1) {
           return -1;
         }
-
         n = readFewBits(s, 6);
-
         if (n < 10 || n > 30) {
           return -1;
         }
-
         return n;
       } else {
         return 8 + n;
       }
     }
-
     return 17;
   }
-
   function enableEagerOutput(s) {
     if (s.runningState != 1) {
       throw 'State MUST be freshly initialized';
     }
-
     s.isEager = 1;
   }
-
   function enableLargeWindow(s) {
     if (s.runningState != 1) {
       throw 'State MUST be freshly initialized';
     }
-
     s.isLargeWindow = 1;
   }
-
   function attachDictionaryChunk(s, data) {
     if (s.runningState != 1) {
       throw 'State MUST be freshly initialized';
     }
-
     if (s.cdNumChunks == 0) {
       s.cdChunks = new Array(16);
       s.cdChunkOffsets = new Int32Array(16);
       s.cdBlockBits = -1;
     }
-
     if (s.cdNumChunks == 15) {
       throw 'Too many dictionary chunks';
     }
-
     s.cdChunks[s.cdNumChunks] = data;
     s.cdNumChunks++;
     s.cdTotalSize += data.length;
     s.cdChunkOffsets[s.cdNumChunks] = s.cdTotalSize;
   }
-
   function initState(s, input) {
     if (s.runningState != 0) {
       throw 'State MUST be uninitialized';
     }
-
     s.blockTrees = new Int32Array(3091);
     s.blockTrees[0] = 7;
     s.distRbIdx = 3;
@@ -182,85 +149,65 @@ let makeBrotliDecode = () => {
     initBitReader(s);
     s.runningState = 1;
   }
-
   function close(s) {
     if (s.runningState == 0) {
       throw 'State MUST be initialized';
     }
-
     if (s.runningState == 11) {
       return;
     }
-
     s.runningState = 11;
-
     if (s.input != null) {
       closeInput(s.input);
       s.input = null;
     }
   }
-
   function decodeVarLenUnsignedByte(s) {
     if (s.bitOffset >= 16) {
       s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
       s.bitOffset -= 16;
     }
-
     if (readFewBits(s, 1) != 0) {
       let n = readFewBits(s, 3);
-
       if (n == 0) {
         return 1;
       } else {
         return readFewBits(s, n) + (1 << n);
       }
     }
-
     return 0;
   }
-
   function decodeMetaBlockLength(s) {
     if (s.bitOffset >= 16) {
       s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
       s.bitOffset -= 16;
     }
-
     s.inputEnd = readFewBits(s, 1);
     s.metaBlockLength = 0;
     s.isUncompressed = 0;
     s.isMetadata = 0;
-
     if (s.inputEnd != 0 && readFewBits(s, 1) != 0) {
       return;
     }
-
     let sizeNibbles = readFewBits(s, 2) + 4;
-
     if (sizeNibbles == 7) {
       s.isMetadata = 1;
-
       if (readFewBits(s, 1) != 0) {
         throw 'Corrupted reserved bit';
       }
-
       let sizeBytes = readFewBits(s, 2);
-
       if (sizeBytes == 0) {
         return;
       }
-
       for (let i = 0; i < sizeBytes; i++) {
         if (s.bitOffset >= 16) {
           s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
           s.bitOffset -= 16;
         }
-
         let bits = readFewBits(s, 8);
-
         if (bits == 0 && i + 1 == sizeBytes && sizeBytes > 1) {
           throw 'Exuberant nibble';
         }
-
         s.metaBlockLength |= bits << i * 8;
       }
     } else {
@@ -269,87 +216,67 @@ let makeBrotliDecode = () => {
           s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
           s.bitOffset -= 16;
         }
-
         let bits = readFewBits(s, 4);
-
         if (bits == 0 && i + 1 == sizeNibbles && sizeNibbles > 4) {
           throw 'Exuberant nibble';
         }
-
         s.metaBlockLength |= bits << i * 4;
       }
     }
-
     s.metaBlockLength++;
-
     if (s.inputEnd == 0) {
       s.isUncompressed = readFewBits(s, 1);
     }
   }
-
   function readSymbol(tableGroup, tableIdx, s) {
     let offset = tableGroup[tableIdx];
     let val = s.accumulator32 >>> s.bitOffset;
     offset += val & 0xff;
     let bits = tableGroup[offset] >> 16;
     let sym = tableGroup[offset] & 0xffff;
-
     if (bits <= 8) {
       s.bitOffset += bits;
       return sym;
     }
-
     offset += sym;
     let mask = (1 << bits) - 1;
     offset += (val & mask) >>> 8;
     s.bitOffset += (tableGroup[offset] >> 16) + 8;
     return tableGroup[offset] & 0xffff;
   }
-
   function readBlockLength(tableGroup, tableIdx, s) {
     if (s.bitOffset >= 16) {
       s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
       s.bitOffset -= 16;
     }
-
     let code = readSymbol(tableGroup, tableIdx, s);
     let n = BLOCK_LENGTH_N_BITS[code];
-
     if (s.bitOffset >= 16) {
       s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
       s.bitOffset -= 16;
     }
-
     return BLOCK_LENGTH_OFFSET[code] + (n <= 16 ? readFewBits(s, n) : readManyBits(s, n));
   }
-
   function moveToFront(v, index) {
     let value = v[index];
-
     for (; index > 0; index--) {
       v[index] = v[index - 1];
     }
-
     v[0] = value;
   }
-
   function inverseMoveToFrontTransform(v, vLen) {
     let mtf = new Int32Array(256);
-
     for (let i = 0; i < 256; i++) {
       mtf[i] = i;
     }
-
     for (let i = 0; i < vLen; i++) {
       let index = v[i] & 0xff;
       v[i] = mtf[index];
-
       if (index != 0) {
         moveToFront(mtf, index);
       }
     }
   }
-
   function readHuffmanCodeLengths(codeLengthCodeLengths, numSymbols, codeLengths, s) {
     let symbol = 0;
     let prevCodeLen = 8;
@@ -359,25 +286,20 @@ let makeBrotliDecode = () => {
     let table = new Int32Array(32 + 1);
     let tableIdx = table.length - 1;
     buildHuffmanTable(table, tableIdx, 5, codeLengthCodeLengths, 18);
-
     while (symbol < numSymbols && space > 0) {
       if (s.halfOffset > 2030) {
         doReadMoreInput(s);
       }
-
       if (s.bitOffset >= 16) {
         s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
         s.bitOffset -= 16;
       }
-
       let p = s.accumulator32 >>> s.bitOffset & 31;
       s.bitOffset += table[p] >> 16;
       let codeLen = table[p] & 0xffff;
-
       if (codeLen < 16) {
         repeat = 0;
         codeLengths[symbol++] = codeLen;
-
         if (codeLen != 0) {
           prevCodeLen = codeLen;
           space -= 32768 >> codeLen;
@@ -385,52 +307,40 @@ let makeBrotliDecode = () => {
       } else {
         let extraBits = codeLen - 14;
         let newLen = 0;
-
         if (codeLen == 16) {
           newLen = prevCodeLen;
         }
-
         if (repeatCodeLen != newLen) {
           repeat = 0;
           repeatCodeLen = newLen;
         }
-
         let oldRepeat = repeat;
-
         if (repeat > 0) {
           repeat -= 2;
           repeat <<= extraBits;
         }
-
         if (s.bitOffset >= 16) {
           s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
           s.bitOffset -= 16;
         }
-
         repeat += readFewBits(s, extraBits) + 3;
         let repeatDelta = repeat - oldRepeat;
-
         if (symbol + repeatDelta > numSymbols) {
           throw 'symbol + repeatDelta > numSymbols';
         }
-
         for (let i = 0; i < repeatDelta; i++) {
           codeLengths[symbol++] = repeatCodeLen;
         }
-
         if (repeatCodeLen != 0) {
           space -= repeatDelta << 15 - repeatCodeLen;
         }
       }
     }
-
     if (space != 0) {
       throw 'Unused space';
     }
-
     codeLengths.fill(0, symbol, numSymbols);
   }
-
   function checkDupes(symbols, length) {
     for (let i = 0; i < length - 1; ++i) {
       for (let j = i + 1; j < length; ++j) {
@@ -440,166 +350,130 @@ let makeBrotliDecode = () => {
       }
     }
   }
-
   function readSimpleHuffmanCode(alphabetSizeMax, alphabetSizeLimit, tableGroup, tableIdx, s) {
     let codeLengths = new Int32Array(alphabetSizeLimit);
     let symbols = new Int32Array(4);
     let maxBits = 1 + log2floor(alphabetSizeMax - 1);
     let numSymbols = readFewBits(s, 2) + 1;
-
     for (let i = 0; i < numSymbols; i++) {
       if (s.bitOffset >= 16) {
         s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
         s.bitOffset -= 16;
       }
-
       let symbol = readFewBits(s, maxBits);
-
       if (symbol >= alphabetSizeLimit) {
         throw "Can't readHuffmanCode";
       }
-
       symbols[i] = symbol;
     }
-
     checkDupes(symbols, numSymbols);
     let histogramId = numSymbols;
-
     if (numSymbols == 4) {
       histogramId += readFewBits(s, 1);
     }
-
     switch (histogramId) {
       case 1:
         codeLengths[symbols[0]] = 1;
         break;
-
       case 2:
         codeLengths[symbols[0]] = 1;
         codeLengths[symbols[1]] = 1;
         break;
-
       case 3:
         codeLengths[symbols[0]] = 1;
         codeLengths[symbols[1]] = 2;
         codeLengths[symbols[2]] = 2;
         break;
-
       case 4:
         codeLengths[symbols[0]] = 2;
         codeLengths[symbols[1]] = 2;
         codeLengths[symbols[2]] = 2;
         codeLengths[symbols[3]] = 2;
         break;
-
       case 5:
         codeLengths[symbols[0]] = 1;
         codeLengths[symbols[1]] = 2;
         codeLengths[symbols[2]] = 3;
         codeLengths[symbols[3]] = 3;
         break;
-
       default:
         break;
     }
-
     return buildHuffmanTable(tableGroup, tableIdx, 8, codeLengths, alphabetSizeLimit);
   }
-
   function readComplexHuffmanCode(alphabetSizeLimit, skip, tableGroup, tableIdx, s) {
     let codeLengths = new Int32Array(alphabetSizeLimit);
     let codeLengthCodeLengths = new Int32Array(18);
     let space = 32;
     let numCodes = 0;
-
     for (let i = skip; i < 18 && space > 0; i++) {
       let codeLenIdx = CODE_LENGTH_CODE_ORDER[i];
-
       if (s.bitOffset >= 16) {
         s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
         s.bitOffset -= 16;
       }
-
       let p = s.accumulator32 >>> s.bitOffset & 15;
       s.bitOffset += FIXED_TABLE[p] >> 16;
       let v = FIXED_TABLE[p] & 0xffff;
       codeLengthCodeLengths[codeLenIdx] = v;
-
       if (v != 0) {
         space -= 32 >> v;
         numCodes++;
       }
     }
-
     if (space != 0 && numCodes != 1) {
       throw 'Corrupted Huffman code histogram';
     }
-
     readHuffmanCodeLengths(codeLengthCodeLengths, alphabetSizeLimit, codeLengths, s);
     return buildHuffmanTable(tableGroup, tableIdx, 8, codeLengths, alphabetSizeLimit);
   }
-
   function readHuffmanCode(alphabetSizeMax, alphabetSizeLimit, tableGroup, tableIdx, s) {
     if (s.halfOffset > 2030) {
       doReadMoreInput(s);
     }
-
     if (s.bitOffset >= 16) {
       s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
       s.bitOffset -= 16;
     }
-
     let simpleCodeOrSkip = readFewBits(s, 2);
-
     if (simpleCodeOrSkip == 1) {
       return readSimpleHuffmanCode(alphabetSizeMax, alphabetSizeLimit, tableGroup, tableIdx, s);
     } else {
       return readComplexHuffmanCode(alphabetSizeLimit, simpleCodeOrSkip, tableGroup, tableIdx, s);
     }
   }
-
   function decodeContextMap(contextMapSize, contextMap, s) {
     if (s.halfOffset > 2030) {
       doReadMoreInput(s);
     }
-
     let numTrees = decodeVarLenUnsignedByte(s) + 1;
-
     if (numTrees == 1) {
       contextMap.fill(0, 0, contextMapSize);
       return numTrees;
     }
-
     if (s.bitOffset >= 16) {
       s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
       s.bitOffset -= 16;
     }
-
     let useRleForZeros = readFewBits(s, 1);
     let maxRunLengthPrefix = 0;
-
     if (useRleForZeros != 0) {
       maxRunLengthPrefix = readFewBits(s, 4) + 1;
     }
-
     let alphabetSize = numTrees + maxRunLengthPrefix;
     let tableSize = MAX_HUFFMAN_TABLE_SIZE[alphabetSize + 31 >> 5];
     let table = new Int32Array(tableSize + 1);
     let tableIdx = table.length - 1;
     readHuffmanCode(alphabetSize, alphabetSize, table, tableIdx, s);
-
     for (let i = 0; i < contextMapSize;) {
       if (s.halfOffset > 2030) {
         doReadMoreInput(s);
       }
-
       if (s.bitOffset >= 16) {
         s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
         s.bitOffset -= 16;
       }
-
       let code = readSymbol(table, tableIdx, s);
-
       if (code == 0) {
         contextMap[i] = 0;
         i++;
@@ -608,14 +482,11 @@ let makeBrotliDecode = () => {
           s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
           s.bitOffset -= 16;
         }
-
         let reps = (1 << code) + readFewBits(s, code);
-
         while (reps != 0) {
           if (i >= contextMapSize) {
             throw 'Corrupted context map';
           }
-
           contextMap[i] = 0;
           i++;
           reps--;
@@ -625,31 +496,24 @@ let makeBrotliDecode = () => {
         i++;
       }
     }
-
     if (s.bitOffset >= 16) {
       s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
       s.bitOffset -= 16;
     }
-
     if (readFewBits(s, 1) == 1) {
       inverseMoveToFrontTransform(contextMap, contextMapSize);
     }
-
     return numTrees;
   }
-
   function decodeBlockTypeAndLength(s, treeType, numBlockTypes) {
     let ringBuffers = s.rings;
     let offset = 4 + treeType * 2;
-
     if (s.bitOffset >= 16) {
       s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
       s.bitOffset -= 16;
     }
-
     let blockType = readSymbol(s.blockTrees, 2 * treeType, s);
     let result = readBlockLength(s.blockTrees, 2 * treeType + 1, s);
-
     if (blockType == 1) {
       blockType = ringBuffers[offset + 1] + 1;
     } else if (blockType == 0) {
@@ -657,16 +521,13 @@ let makeBrotliDecode = () => {
     } else {
       blockType -= 2;
     }
-
     if (blockType >= numBlockTypes) {
       blockType -= numBlockTypes;
     }
-
     ringBuffers[offset] = ringBuffers[offset + 1];
     ringBuffers[offset + 1] = blockType;
     return result;
   }
-
   function decodeLiteralBlockSwitch(s) {
     s.literalBlockLength = decodeBlockTypeAndLength(s, 0, s.numLiteralBlockTypes);
     let literalBlockType = s.rings[5];
@@ -676,99 +537,76 @@ let makeBrotliDecode = () => {
     s.contextLookupOffset1 = contextMode << 9;
     s.contextLookupOffset2 = s.contextLookupOffset1 + 256;
   }
-
   function decodeCommandBlockSwitch(s) {
     s.commandBlockLength = decodeBlockTypeAndLength(s, 1, s.numCommandBlockTypes);
     s.commandTreeIdx = s.rings[7];
   }
-
   function decodeDistanceBlockSwitch(s) {
     s.distanceBlockLength = decodeBlockTypeAndLength(s, 2, s.numDistanceBlockTypes);
     s.distContextMapSlice = s.rings[9] << 2;
   }
-
   function maybeReallocateRingBuffer(s) {
     let newSize = s.maxRingBufferSize;
-
     if (newSize > s.expectedTotalSize) {
       let minimalNewSize = s.expectedTotalSize;
-
       while (newSize >> 1 > minimalNewSize) {
         newSize >>= 1;
       }
-
       if (s.inputEnd == 0 && newSize < 16384 && s.maxRingBufferSize >= 16384) {
         newSize = 16384;
       }
     }
-
     if (newSize <= s.ringBufferSize) {
       return;
     }
-
     let ringBufferSizeWithSlack = newSize + 37;
     let newBuffer = new Int8Array(ringBufferSizeWithSlack);
-
     if (s.ringBuffer.length != 0) {
       newBuffer.set(s.ringBuffer.subarray(0, 0 + s.ringBufferSize), 0);
     }
-
     s.ringBuffer = newBuffer;
     s.ringBufferSize = newSize;
   }
-
   function readNextMetablockHeader(s) {
     if (s.inputEnd != 0) {
       s.nextRunningState = 10;
       s.runningState = 12;
       return;
     }
-
     s.literalTreeGroup = new Int32Array(0);
     s.commandTreeGroup = new Int32Array(0);
     s.distanceTreeGroup = new Int32Array(0);
-
     if (s.halfOffset > 2030) {
       doReadMoreInput(s);
     }
-
     decodeMetaBlockLength(s);
-
     if (s.metaBlockLength == 0 && s.isMetadata == 0) {
       return;
     }
-
     if (s.isUncompressed != 0 || s.isMetadata != 0) {
       jumpToByteBoundary(s);
       s.runningState = s.isMetadata != 0 ? 5 : 6;
     } else {
       s.runningState = 3;
     }
-
     if (s.isMetadata != 0) {
       return;
     }
-
     s.expectedTotalSize += s.metaBlockLength;
-
     if (s.expectedTotalSize > 1 << 30) {
       s.expectedTotalSize = 1 << 30;
     }
-
     if (s.ringBufferSize < s.maxRingBufferSize) {
       maybeReallocateRingBuffer(s);
     }
   }
-
   function readMetablockPartition(s, treeType, numBlockTypes) {
     let offset = s.blockTrees[2 * treeType];
-
     if (numBlockTypes <= 1) {
       s.blockTrees[2 * treeType + 1] = offset;
       s.blockTrees[2 * treeType + 2] = offset;
       return 1 << 28;
     }
-
     let blockTypeAlphabetSize = numBlockTypes + 2;
     offset += readHuffmanCode(blockTypeAlphabetSize, blockTypeAlphabetSize, s.blockTrees, 2 * treeType, s);
     s.blockTrees[2 * treeType + 1] = offset;
@@ -777,7 +615,6 @@ let makeBrotliDecode = () => {
     s.blockTrees[2 * treeType + 2] = offset;
     return readBlockLength(s.blockTrees, 2 * treeType + 1, s);
   }
-
   function calculateDistanceLut(s, alphabetSizeLimit) {
     let distExtraBits = s.distExtraBits;
     let distOffset = s.distOffset;
@@ -787,27 +624,22 @@ let makeBrotliDecode = () => {
     let bits = 1;
     let half = 0;
     let i = 16;
-
     for (let j = 0; j < ndirect; ++j) {
       distExtraBits[i] = 0;
       distOffset[i] = j + 1;
       ++i;
     }
-
     while (i < alphabetSizeLimit) {
       let base = ndirect + ((2 + half << bits) - 4 << npostfix) + 1;
-
       for (let j = 0; j < postfix; ++j) {
         distExtraBits[i] = bits;
         distOffset[i] = base + j;
         ++i;
       }
-
       bits = bits + half;
       half = half ^ 1;
     }
   }
-
   function readMetablockHuffmanCodesAndContextMaps(s) {
     s.numLiteralBlockTypes = decodeVarLenUnsignedByte(s) + 1;
     s.literalBlockLength = readMetablockPartition(s, 0, s.numLiteralBlockTypes);
@@ -815,60 +647,48 @@ let makeBrotliDecode = () => {
     s.commandBlockLength = readMetablockPartition(s, 1, s.numCommandBlockTypes);
     s.numDistanceBlockTypes = decodeVarLenUnsignedByte(s) + 1;
     s.distanceBlockLength = readMetablockPartition(s, 2, s.numDistanceBlockTypes);
-
     if (s.halfOffset > 2030) {
       doReadMoreInput(s);
     }
-
     if (s.bitOffset >= 16) {
       s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
       s.bitOffset -= 16;
     }
-
     s.distancePostfixBits = readFewBits(s, 2);
     s.numDirectDistanceCodes = readFewBits(s, 4) << s.distancePostfixBits;
     s.contextModes = new Int8Array(s.numLiteralBlockTypes);
-
     for (let i = 0; i < s.numLiteralBlockTypes;) {
       let limit = min(i + 96, s.numLiteralBlockTypes);
-
       for (; i < limit; ++i) {
         if (s.bitOffset >= 16) {
           s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
           s.bitOffset -= 16;
         }
-
         s.contextModes[i] = readFewBits(s, 2);
       }
-
       if (s.halfOffset > 2030) {
         doReadMoreInput(s);
       }
     }
-
     s.contextMap = new Int8Array(s.numLiteralBlockTypes << 6);
     let numLiteralTrees = decodeContextMap(s.numLiteralBlockTypes << 6, s.contextMap, s);
     s.trivialLiteralContext = 1;
-
     for (let j = 0; j < s.numLiteralBlockTypes << 6; j++) {
       if (s.contextMap[j] != j >> 6) {
         s.trivialLiteralContext = 0;
         break;
       }
     }
-
     s.distContextMap = new Int8Array(s.numDistanceBlockTypes << 2);
     let numDistTrees = decodeContextMap(s.numDistanceBlockTypes << 2, s.distContextMap, s);
     s.literalTreeGroup = decodeHuffmanTreeGroup(256, 256, numLiteralTrees, s);
     s.commandTreeGroup = decodeHuffmanTreeGroup(704, 704, s.numCommandBlockTypes, s);
     let distanceAlphabetSizeMax = calculateDistanceAlphabetSize(s.distancePostfixBits, s.numDirectDistanceCodes, 24);
     let distanceAlphabetSizeLimit = distanceAlphabetSizeMax;
-
     if (s.isLargeWindow == 1) {
       distanceAlphabetSizeMax = calculateDistanceAlphabetSize(s.distancePostfixBits, s.numDirectDistanceCodes, 62);
       distanceAlphabetSizeLimit = calculateDistanceAlphabetLimit(0x7ffffffc, s.distancePostfixBits, s.numDirectDistanceCodes);
     }
-
     s.distanceTreeGroup = decodeHuffmanTreeGroup(distanceAlphabetSizeMax, distanceAlphabetSizeLimit, numDistTrees, s);
     calculateDistanceLut(s, distanceAlphabetSizeLimit);
     s.contextMapSlice = 0;
@@ -884,157 +704,122 @@ let makeBrotliDecode = () => {
     s.rings[8] = 1;
     s.rings[9] = 0;
   }
-
   function copyUncompressedData(s) {
     let ringBuffer = s.ringBuffer;
-
     if (s.metaBlockLength <= 0) {
       reload(s);
       s.runningState = 2;
       return;
     }
-
     let chunkLength = min(s.ringBufferSize - s.pos, s.metaBlockLength);
     copyRawBytes(s, ringBuffer, s.pos, chunkLength);
     s.metaBlockLength -= chunkLength;
     s.pos += chunkLength;
-
     if (s.pos == s.ringBufferSize) {
       s.nextRunningState = 6;
       s.runningState = 12;
       return;
     }
-
     reload(s);
     s.runningState = 2;
   }
-
   function writeRingBuffer(s) {
     let toWrite = min(s.outputLength - s.outputUsed, s.ringBufferBytesReady - s.ringBufferBytesWritten);
-
     if (toWrite != 0) {
       s.output.set(s.ringBuffer.subarray(s.ringBufferBytesWritten, s.ringBufferBytesWritten + toWrite), s.outputOffset + s.outputUsed);
       s.outputUsed += toWrite;
       s.ringBufferBytesWritten += toWrite;
     }
-
     if (s.outputUsed < s.outputLength) {
       return 1;
     } else {
       return 0;
     }
   }
-
   function decodeHuffmanTreeGroup(alphabetSizeMax, alphabetSizeLimit, n, s) {
     let maxTableSize = MAX_HUFFMAN_TABLE_SIZE[alphabetSizeLimit + 31 >> 5];
     let group = new Int32Array(n + n * maxTableSize);
     let next = n;
-
     for (let i = 0; i < n; ++i) {
       group[i] = next;
       next += readHuffmanCode(alphabetSizeMax, alphabetSizeLimit, group, i, s);
     }
-
     return group;
   }
-
   function calculateFence(s) {
     let result = s.ringBufferSize;
-
     if (s.isEager != 0) {
       result = min(result, s.ringBufferBytesWritten + s.outputLength - s.outputUsed);
     }
-
     return result;
   }
-
   function doUseDictionary(s, fence) {
     if (s.distance > 0x7ffffffc) {
       throw 'Invalid backward reference';
     }
-
     let address = s.distance - s.maxDistance - 1 - s.cdTotalSize;
-
     if (address < 0) {
       initializeCompoundDictionaryCopy(s, -address - 1, s.copyLength);
       s.runningState = 14;
     } else {
       let dictionaryData = data;
       let wordLength = s.copyLength;
-
       if (wordLength > 31) {
         throw 'Invalid backward reference';
       }
-
       let shift = sizeBits[wordLength];
-
       if (shift == 0) {
         throw 'Invalid backward reference';
       }
-
       let offset = offsets[wordLength];
       let mask = (1 << shift) - 1;
       let wordIdx = address & mask;
       let transformIdx = address >>> shift;
       offset += wordIdx * wordLength;
       let transforms = RFC_TRANSFORMS;
-
       if (transformIdx >= transforms.numTransforms) {
         throw 'Invalid backward reference';
       }
-
       let len = transformDictionaryWord(s.ringBuffer, s.pos, dictionaryData, offset, wordLength, transforms, transformIdx);
       s.pos += len;
       s.metaBlockLength -= len;
-
       if (s.pos >= fence) {
         s.nextRunningState = 4;
         s.runningState = 12;
         return;
       }
-
       s.runningState = 4;
     }
   }
-
   function initializeCompoundDictionary(s) {
     s.cdBlockMap = new Int8Array(256);
     let blockBits = 8;
-
     while (s.cdTotalSize - 1 >>> blockBits != 0) {
       blockBits++;
     }
-
     blockBits -= 8;
     s.cdBlockBits = blockBits;
     let cursor = 0;
     let index = 0;
-
     while (cursor < s.cdTotalSize) {
       while (s.cdChunkOffsets[index + 1] < cursor) {
         index++;
       }
-
       s.cdBlockMap[cursor >>> blockBits] = index;
       cursor += 1 << blockBits;
     }
   }
-
   function initializeCompoundDictionaryCopy(s, address, length) {
     if (s.cdBlockBits == -1) {
       initializeCompoundDictionary(s);
     }
-
     let index = s.cdBlockMap[address >>> s.cdBlockBits];
-
     while (address >= s.cdChunkOffsets[index + 1]) {
       index++;
     }
-
     if (s.cdTotalSize > address + length) {
       throw 'Invalid backward reference';
     }
-
     s.distRbIdx = s.distRbIdx + 1 & 0x3;
     s.rings[s.distRbIdx] = s.distance;
     s.metaBlockLength -= length;
@@ -1043,152 +828,119 @@ let makeBrotliDecode = () => {
     s.cdBrLength = length;
     s.cdBrCopied = 0;
   }
-
   function copyFromCompoundDictionary(s, fence) {
     let pos = s.pos;
     let origPos = pos;
-
     while (s.cdBrLength != s.cdBrCopied) {
       let space = fence - pos;
       let chunkLength = s.cdChunkOffsets[s.cdBrIndex + 1] - s.cdChunkOffsets[s.cdBrIndex];
       let remChunkLength = chunkLength - s.cdBrOffset;
       let length = s.cdBrLength - s.cdBrCopied;
-
       if (length > remChunkLength) {
         length = remChunkLength;
       }
-
       if (length > space) {
         length = space;
       }
-
       copyBytes(s.ringBuffer, pos, s.cdChunks[s.cdBrIndex], s.cdBrOffset, s.cdBrOffset + length);
       pos += length;
       s.cdBrOffset += length;
       s.cdBrCopied += length;
-
       if (length == remChunkLength) {
         s.cdBrIndex++;
         s.cdBrOffset = 0;
       }
-
       if (pos >= fence) {
         break;
       }
     }
-
     return pos - origPos;
   }
-
   function decompress(s) {
     if (s.runningState == 0) {
       throw "Can't decompress until initialized";
     }
-
     if (s.runningState == 11) {
       throw "Can't decompress after close";
     }
-
     if (s.runningState == 1) {
       let windowBits = decodeWindowBits(s);
-
       if (windowBits == -1) {
         throw "Invalid 'windowBits' code";
       }
-
       s.maxRingBufferSize = 1 << windowBits;
       s.maxBackwardDistance = s.maxRingBufferSize - 16;
       s.runningState = 2;
     }
-
     let fence = calculateFence(s);
     let ringBufferMask = s.ringBufferSize - 1;
     let ringBuffer = s.ringBuffer;
-
     while (s.runningState != 10) {
       switch (s.runningState) {
         case 2:
           if (s.metaBlockLength < 0) {
             throw 'Invalid metablock length';
           }
-
           readNextMetablockHeader(s);
           fence = calculateFence(s);
           ringBufferMask = s.ringBufferSize - 1;
           ringBuffer = s.ringBuffer;
           continue;
-
         case 3:
           readMetablockHuffmanCodesAndContextMaps(s);
           s.runningState = 4;
-
         case 4:
           if (s.metaBlockLength <= 0) {
             s.runningState = 2;
             continue;
           }
-
           if (s.halfOffset > 2030) {
             doReadMoreInput(s);
           }
-
           if (s.commandBlockLength == 0) {
             decodeCommandBlockSwitch(s);
           }
-
           s.commandBlockLength--;
-
           if (s.bitOffset >= 16) {
             s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
             s.bitOffset -= 16;
           }
-
           let cmdCode = readSymbol(s.commandTreeGroup, s.commandTreeIdx, s) << 2;
           let insertAndCopyExtraBits = CMD_LOOKUP[cmdCode];
           let insertLengthOffset = CMD_LOOKUP[cmdCode + 1];
           let copyLengthOffset = CMD_LOOKUP[cmdCode + 2];
           s.distanceCode = CMD_LOOKUP[cmdCode + 3];
-
           if (s.bitOffset >= 16) {
             s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
             s.bitOffset -= 16;
           }
-
           let insertLengthExtraBits = insertAndCopyExtraBits & 0xff;
           s.insertLength = insertLengthOffset + (insertLengthExtraBits <= 16 ? readFewBits(s, insertLengthExtraBits) : readManyBits(s, insertLengthExtraBits));
-
           if (s.bitOffset >= 16) {
             s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
             s.bitOffset -= 16;
           }
-
           let copyLengthExtraBits = insertAndCopyExtraBits >> 8;
           s.copyLength = copyLengthOffset + (copyLengthExtraBits <= 16 ? readFewBits(s, copyLengthExtraBits) : readManyBits(s, copyLengthExtraBits));
           s.j = 0;
           s.runningState = 7;
-
         case 7:
           if (s.trivialLiteralContext != 0) {
             while (s.j < s.insertLength) {
               if (s.halfOffset > 2030) {
                 doReadMoreInput(s);
               }
-
               if (s.literalBlockLength == 0) {
                 decodeLiteralBlockSwitch(s);
               }
-
               s.literalBlockLength--;
-
               if (s.bitOffset >= 16) {
                 s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
                 s.bitOffset -= 16;
               }
-
               ringBuffer[s.pos] = readSymbol(s.literalTreeGroup, s.literalTreeIdx, s);
               s.pos++;
               s.j++;
-
               if (s.pos >= fence) {
                 s.nextRunningState = 7;
                 s.runningState = 12;
@@ -1198,31 +950,25 @@ let makeBrotliDecode = () => {
           } else {
             let prevByte1 = ringBuffer[s.pos - 1 & ringBufferMask] & 0xff;
             let prevByte2 = ringBuffer[s.pos - 2 & ringBufferMask] & 0xff;
-
             while (s.j < s.insertLength) {
               if (s.halfOffset > 2030) {
                 doReadMoreInput(s);
               }
-
               if (s.literalBlockLength == 0) {
                 decodeLiteralBlockSwitch(s);
               }
-
               let literalContext = LOOKUP[s.contextLookupOffset1 + prevByte1] | LOOKUP[s.contextLookupOffset2 + prevByte2];
               let literalTreeIdx = s.contextMap[s.contextMapSlice + literalContext] & 0xff;
               s.literalBlockLength--;
               prevByte2 = prevByte1;
-
               if (s.bitOffset >= 16) {
                 s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
                 s.bitOffset -= 16;
               }
-
               prevByte1 = readSymbol(s.literalTreeGroup, literalTreeIdx, s);
               ringBuffer[s.pos] = prevByte1;
               s.pos++;
               s.j++;
-
               if (s.pos >= fence) {
                 s.nextRunningState = 7;
                 s.runningState = 12;
@@ -1230,52 +976,40 @@ let makeBrotliDecode = () => {
               }
             }
           }
-
           if (s.runningState != 7) {
             continue;
           }
-
           s.metaBlockLength -= s.insertLength;
-
           if (s.metaBlockLength <= 0) {
             s.runningState = 4;
             continue;
           }
-
           let distanceCode = s.distanceCode;
-
           if (distanceCode < 0) {
             s.distance = s.rings[s.distRbIdx];
           } else {
             if (s.halfOffset > 2030) {
               doReadMoreInput(s);
             }
-
             if (s.distanceBlockLength == 0) {
               decodeDistanceBlockSwitch(s);
             }
-
             s.distanceBlockLength--;
-
             if (s.bitOffset >= 16) {
               s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
               s.bitOffset -= 16;
             }
-
             let distTreeIdx = s.distContextMap[s.distContextMapSlice + distanceCode] & 0xff;
             distanceCode = readSymbol(s.distanceTreeGroup, distTreeIdx, s);
-
             if (distanceCode < 16) {
               let index = s.distRbIdx + DISTANCE_SHORT_CODE_INDEX_OFFSET[distanceCode] & 0x3;
               s.distance = s.rings[index] + DISTANCE_SHORT_CODE_VALUE_OFFSET[distanceCode];
-
               if (s.distance < 0) {
                 throw 'Negative distance';
               }
             } else {
               let extraBits = s.distExtraBits[distanceCode];
               let bits;
-
               if (s.bitOffset + extraBits <= 32) {
                 bits = readFewBits(s, extraBits);
               } else {
@@ -1283,44 +1017,35 @@ let makeBrotliDecode = () => {
                   s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
                   s.bitOffset -= 16;
                 }
-
                 bits = extraBits <= 16 ? readFewBits(s, extraBits) : readManyBits(s, extraBits);
               }
-
               s.distance = s.distOffset[distanceCode] + (bits << s.distancePostfixBits);
             }
           }
-
           if (s.maxDistance != s.maxBackwardDistance && s.pos < s.maxBackwardDistance) {
             s.maxDistance = s.pos;
           } else {
             s.maxDistance = s.maxBackwardDistance;
           }
-
           if (s.distance > s.maxDistance) {
             s.runningState = 9;
             continue;
           }
-
           if (distanceCode > 0) {
             s.distRbIdx = s.distRbIdx + 1 & 0x3;
             s.rings[s.distRbIdx] = s.distance;
           }
-
           if (s.copyLength > s.metaBlockLength) {
             throw 'Invalid backward reference';
           }
-
           s.j = 0;
           s.runningState = 8;
-
         case 8:
           let src = s.pos - s.distance & ringBufferMask;
           let dst = s.pos;
           let copyLength = s.copyLength - s.j;
           let srcEnd = src + copyLength;
           let dstEnd = dst + copyLength;
-
           if (srcEnd < ringBufferMask && dstEnd < ringBufferMask) {
             if (copyLength < 12 || srcEnd > dst && dstEnd > src) {
               for (let k = 0; k < copyLength; k += 4) {
@@ -1332,7 +1057,6 @@ let makeBrotliDecode = () => {
             } else {
               ringBuffer.copyWithin(dst, src, srcEnd);
             }
-
             s.j += copyLength;
             s.metaBlockLength -= copyLength;
             s.pos += copyLength;
@@ -1342,7 +1066,6 @@ let makeBrotliDecode = () => {
               s.metaBlockLength--;
               s.pos++;
               s.j++;
-
               if (s.pos >= fence) {
                 s.nextRunningState = 8;
                 s.runningState = 12;
@@ -1350,86 +1073,66 @@ let makeBrotliDecode = () => {
               }
             }
           }
-
           if (s.runningState == 8) {
             s.runningState = 4;
           }
-
           continue;
-
         case 9:
           doUseDictionary(s, fence);
           continue;
-
         case 14:
           s.pos += copyFromCompoundDictionary(s, fence);
-
           if (s.pos >= fence) {
             s.nextRunningState = 14;
             s.runningState = 12;
             return;
           }
-
           s.runningState = 4;
           continue;
-
         case 5:
           while (s.metaBlockLength > 0) {
             if (s.halfOffset > 2030) {
               doReadMoreInput(s);
             }
-
             if (s.bitOffset >= 16) {
               s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
               s.bitOffset -= 16;
             }
-
             readFewBits(s, 8);
             s.metaBlockLength--;
           }
-
           s.runningState = 2;
           continue;
-
         case 6:
           copyUncompressedData(s);
           continue;
-
         case 12:
           s.ringBufferBytesReady = min(s.pos, s.ringBufferSize);
           s.runningState = 13;
-
         case 13:
           if (writeRingBuffer(s) == 0) {
             return;
           }
-
           if (s.pos >= s.maxBackwardDistance) {
             s.maxDistance = s.maxBackwardDistance;
           }
-
           if (s.pos >= s.ringBufferSize) {
             if (s.pos > s.ringBufferSize) {
               ringBuffer.copyWithin(0, s.ringBufferSize, s.pos);
             }
-
             s.pos &= ringBufferMask;
             s.ringBufferBytesWritten = 0;
           }
-
           s.runningState = s.nextRunningState;
           continue;
-
         default:
           throw 'Unexpected state ' + s.runningState;
       }
     }
-
     if (s.runningState == 10) {
       if (s.metaBlockLength < 0) {
         throw 'Invalid metablock length';
       }
-
       jumpToByteBoundary(s);
       checkHealth(s, 1);
     }
@@ -1449,31 +1152,25 @@ let makeBrotliDecode = () => {
   }
 
   let RFC_TRANSFORMS = new Transforms(121, 167, 50);
-
   function unpackTransforms(prefixSuffix, prefixSuffixHeads, transforms, prefixSuffixSrc, transformsSrc) {
     let n = prefixSuffixSrc.length;
     let index = 1;
     let j = 0;
-
     for (let i = 0; i < n; ++i) {
       let c = prefixSuffixSrc.charCodeAt(i);
-
       if (c == 35) {
         prefixSuffixHeads[index++] = j;
       } else {
         prefixSuffix[j++] = c;
       }
     }
-
     for (let i = 0; i < 363; ++i) {
       transforms[i] = transformsSrc.charCodeAt(i) - 32;
     }
   }
-
   {
     unpackTransforms(RFC_TRANSFORMS.prefixSuffixStorage, RFC_TRANSFORMS.prefixSuffixHeads, RFC_TRANSFORMS.triplets, '# #s #, #e #.# the #.com/#\xC2\xA0# of # and # in # to #"#">#\n#]# for # a # that #. # with #\'# from # by #. The # on # as # is #ing #\n\t#:#ed #(# at #ly #="# of the #. This #,# not #er #al #=\'#ful #ive #less #est #ize #ous #', '     !! ! ,  *!  &!  " !  ) *   * -  ! # !  #!*!  +  ,$ !  -  %  .  / #   0  1 .  "   2  3!*   4%  ! # /   5  6  7  8 0  1 &   $   9 +   :  ;  < \'  !=  >  ?! 4  @ 4  2  &   A *# (   B  C& ) %  ) !*# *-% A +! *.  D! %\'  & E *6  F  G% ! *A *%  H! D  I!+!  J!+   K +- *4! A  L!*4  M  N +6  O!*% +.! K *G  P +%(  ! G *D +D  Q +# *K!*G!+D!+# +G +A +4!+% +K!+4!*D!+K!*K');
   }
-
   function transformDictionaryWord(dst, dstOffset, src, srcOffset, len, transforms, transformIndex) {
     let offset = dstOffset;
     let triplets = transforms.triplets;
@@ -1489,48 +1186,37 @@ let makeBrotliDecode = () => {
     let suffixEnd = prefixSuffixHeads[suffixIdx + 1];
     let omitFirst = transformType - 11;
     let omitLast = transformType - 0;
-
     if (omitFirst < 1 || omitFirst > 9) {
       omitFirst = 0;
     }
-
     if (omitLast < 1 || omitLast > 9) {
       omitLast = 0;
     }
-
     while (prefix != prefixEnd) {
       dst[offset++] = prefixSuffixStorage[prefix++];
     }
-
     if (omitFirst > len) {
       omitFirst = len;
     }
-
     srcOffset += omitFirst;
     len -= omitFirst;
     len -= omitLast;
     let i = len;
-
     while (i > 0) {
       dst[offset++] = src[srcOffset++];
       i--;
     }
-
     if (transformType == 10 || transformType == 11) {
       let uppercaseOffset = offset - len;
-
       if (transformType == 10) {
         len = 1;
       }
-
       while (len > 0) {
         let c0 = dst[uppercaseOffset] & 0xff;
-
         if (c0 < 0xc0) {
           if (c0 >= 97 && c0 <= 122) {
             dst[uppercaseOffset] ^= 32;
           }
-
           uppercaseOffset += 1;
           len -= 1;
         } else if (c0 < 0xe0) {
@@ -1547,11 +1233,9 @@ let makeBrotliDecode = () => {
       let shiftOffset = offset - len;
       let param = transforms.params[transformIndex];
       let scalar = (param & 0x7fff) + (0x1000000 - (param & 0x8000));
-
       while (len > 0) {
         let step = 1;
         let c0 = dst[shiftOffset] & 0xff;
-
         if (c0 < 0x80) {
           scalar += c0;
           dst[shiftOffset] = scalar & 0x7f;
@@ -1592,57 +1276,44 @@ let makeBrotliDecode = () => {
             step = len;
           }
         }
-
         shiftOffset += step;
         len -= step;
-
         if (transformType == 21) {
           len = 0;
         }
       }
     }
-
     while (suffix != suffixEnd) {
       dst[offset++] = prefixSuffixStorage[suffix++];
     }
-
     return offset - dstOffset;
   }
 
   function getNextKey(key, len) {
     let step = 1 << len - 1;
-
     while ((key & step) != 0) {
       step >>= 1;
     }
-
     return (key & step - 1) + step;
   }
-
   function replicateValue(table, offset, step, end, item) {
     do {
       end -= step;
       table[offset + end] = item;
     } while (end > 0);
   }
-
   function nextTableBitSize(count, len, rootBits) {
     let left = 1 << len - rootBits;
-
     while (len < 15) {
       left -= count[len];
-
       if (left <= 0) {
         break;
       }
-
       len++;
       left <<= 1;
     }
-
     return len - rootBits;
   }
-
   function buildHuffmanTable(tableGroup, tableIdx, rootBits, codeLengths, codeLengthsSize) {
     let tableOffset = tableGroup[tableIdx];
     let key;
@@ -1650,49 +1321,38 @@ let makeBrotliDecode = () => {
     let count = new Int32Array(16);
     let offset = new Int32Array(16);
     let symbol;
-
     for (symbol = 0; symbol < codeLengthsSize; symbol++) {
       count[codeLengths[symbol]]++;
     }
-
     offset[1] = 0;
-
     for (let len = 1; len < 15; len++) {
       offset[len + 1] = offset[len] + count[len];
     }
-
     for (symbol = 0; symbol < codeLengthsSize; symbol++) {
       if (codeLengths[symbol] != 0) {
         sorted[offset[codeLengths[symbol]]++] = symbol;
       }
     }
-
     let tableBits = rootBits;
     let tableSize = 1 << tableBits;
     let totalSize = tableSize;
-
     if (offset[15] == 1) {
       for (key = 0; key < totalSize; key++) {
         tableGroup[tableOffset + key] = sorted[0];
       }
-
       return totalSize;
     }
-
     key = 0;
     symbol = 0;
-
     for (let len = 1, step = 2; len <= rootBits; len++, step <<= 1) {
       for (; count[len] > 0; count[len]--) {
         replicateValue(tableGroup, tableOffset + key, step, tableSize, len << 16 | sorted[symbol++]);
         key = getNextKey(key, len);
       }
     }
-
     let mask = totalSize - 1;
     let low = -1;
     let currentOffset = tableOffset;
-
     for (let len = rootBits + 1, step = 2; len <= 15; len++, step <<= 1) {
       for (; count[len] > 0; count[len]--) {
         if ((key & mask) != low) {
@@ -1703,12 +1363,10 @@ let makeBrotliDecode = () => {
           low = key & mask;
           tableGroup[tableOffset + low] = tableBits + rootBits << 16 | currentOffset - tableOffset - low;
         }
-
         replicateValue(tableGroup, currentOffset + (key >> rootBits), step, tableSize, len - rootBits << 16 | sorted[symbol++]);
         key = getNextKey(key, len);
       }
     }
-
     return totalSize;
   }
 
@@ -1717,67 +1375,53 @@ let makeBrotliDecode = () => {
       if (halfAvailable(s) >= -2) {
         return;
       }
-
       throw 'No more input';
     }
-
     let readOffset = s.halfOffset << 1;
     let bytesInBuffer = 4096 - readOffset;
     s.byteBuffer.copyWithin(0, readOffset, 4096);
     s.halfOffset = 0;
-
     while (bytesInBuffer < 4096) {
       let spaceLeft = 4096 - bytesInBuffer;
       let len = readInput(s.input, s.byteBuffer, bytesInBuffer, spaceLeft);
-
       if (len <= 0) {
         s.endOfStreamReached = 1;
         s.tailBytes = bytesInBuffer;
         bytesInBuffer += 1;
         break;
       }
-
       bytesInBuffer += len;
     }
-
     bytesToNibbles(s, bytesInBuffer);
   }
-
   function checkHealth(s, endOfStream) {
     if (s.endOfStreamReached == 0) {
       return;
     }
-
     let byteOffset = (s.halfOffset << 1) + (s.bitOffset + 7 >> 3) - 4;
-
     if (byteOffset > s.tailBytes) {
       throw 'Read after end';
     }
-
     if (endOfStream != 0 && byteOffset != s.tailBytes) {
       throw 'Unused bytes after end';
     }
   }
-
   function assertAccumulatorHealthy(s) {
     if (s.bitOffset > 32) {
       throw 'Accumulator underloaded: ' + s.bitOffset;
     }
   }
-
   function readFewBits(s, n) {
     let val = s.accumulator32 >>> s.bitOffset & (1 << n) - 1;
     s.bitOffset += n;
     return val;
   }
-
   function readManyBits(s, n) {
     let low = readFewBits(s, 16);
     s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
     s.bitOffset -= 16;
     return low | readFewBits(s, n - 16) << 16;
   }
-
   function initBitReader(s) {
     s.byteBuffer = new Int8Array(4160);
     s.accumulator32 = 0;
@@ -1787,64 +1431,50 @@ let makeBrotliDecode = () => {
     s.endOfStreamReached = 0;
     prepare(s);
   }
-
   function prepare(s) {
     if (s.halfOffset > 2030) {
       doReadMoreInput(s);
     }
-
     checkHealth(s, 0);
     s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
     s.bitOffset -= 16;
     s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
     s.bitOffset -= 16;
   }
-
   function reload(s) {
     if (s.bitOffset == 32) {
       prepare(s);
     }
   }
-
   function jumpToByteBoundary(s) {
     let padding = 32 - s.bitOffset & 7;
-
     if (padding != 0) {
       let paddingBits = readFewBits(s, padding);
-
       if (paddingBits != 0) {
         throw 'Corrupted padding bits';
       }
     }
   }
-
   function halfAvailable(s) {
     let limit = 2048;
-
     if (s.endOfStreamReached != 0) {
       limit = s.tailBytes + 1 >> 1;
     }
-
     return limit - s.halfOffset;
   }
-
   function copyRawBytes(s, data, offset, length) {
     if ((s.bitOffset & 7) != 0) {
       throw 'Unaligned copyBytes';
     }
-
     while (s.bitOffset != 32 && length != 0) {
       data[offset++] = s.accumulator32 >>> s.bitOffset;
       s.bitOffset += 8;
       length--;
     }
-
     if (length == 0) {
       return;
     }
-
     let copyNibbles = min(halfAvailable(s), length >> 1);
-
     if (copyNibbles > 0) {
       let readOffset = s.halfOffset << 1;
       let delta = copyNibbles << 1;
@@ -1853,91 +1483,72 @@ let makeBrotliDecode = () => {
       length -= delta;
       s.halfOffset += copyNibbles;
     }
-
     if (length == 0) {
       return;
     }
-
     if (halfAvailable(s) > 0) {
       if (s.bitOffset >= 16) {
         s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
         s.bitOffset -= 16;
       }
-
       while (length != 0) {
         data[offset++] = s.accumulator32 >>> s.bitOffset;
         s.bitOffset += 8;
         length--;
       }
-
       checkHealth(s, 0);
       return;
     }
-
     while (length > 0) {
       let len = readInput(s.input, data, offset, length);
-
       if (len == -1) {
         throw 'Unexpected end of input';
       }
-
       offset += len;
       length -= len;
     }
   }
-
   function bytesToNibbles(s, byteLen) {
     let byteBuffer = s.byteBuffer;
     let halfLen = byteLen >> 1;
     let shortBuffer = s.shortBuffer;
-
     for (let i = 0; i < halfLen; ++i) {
       shortBuffer[i] = byteBuffer[i * 2] & 0xff | (byteBuffer[i * 2 + 1] & 0xff) << 8;
     }
   }
 
   let LOOKUP = new Int32Array(2048);
-
   function unpackLookupTable(lookup, map, rle) {
     for (let i = 0; i < 256; ++i) {
       lookup[i] = i & 0x3f;
       lookup[512 + i] = i >> 2;
       lookup[1792 + i] = 2 + (i >> 6);
     }
-
     for (let i = 0; i < 128; ++i) {
       lookup[1024 + i] = 4 * (map.charCodeAt(i) - 32);
     }
-
     for (let i = 0; i < 64; ++i) {
       lookup[1152 + i] = i & 1;
       lookup[1216 + i] = 2 + (i & 1);
     }
-
     let offset = 1280;
-
     for (let k = 0; k < 19; ++k) {
       let value = k & 3;
       let rep = rle.charCodeAt(k) - 32;
-
       for (let i = 0; i < rep; ++i) {
         lookup[offset++] = value;
       }
     }
-
     for (let i = 0; i < 16; ++i) {
       lookup[1792 + i] = 1;
       lookup[2032 + i] = 6;
     }
-
     lookup[1792] = 0;
     lookup[2047] = 7;
-
     for (let i = 0; i < 256; ++i) {
       lookup[1536 + i] = lookup[1792 + i] << 3;
     }
   }
-
   {
     unpackLookupTable(LOOKUP, "         !!  !                  \"#$##%#$&'##(#)#++++++++++((&*'##,---,---,-----,-----,-----&#'###.///.///./////./////./////&#'# ", "A/*  ':  & : $  \x81 @");
   }
@@ -2025,88 +1636,69 @@ let makeBrotliDecode = () => {
   let data = null;
   let offsets = new Int32Array(32);
   let sizeBits = new Int32Array(32);
-
   function setData(newData, newSizeBits) {
     if (isDirect(newData) == 0 || isReadOnly(newData) == 0) {
       throw 'newData must be a direct read-only byte buffer';
     }
-
     if (newSizeBits.length > 31) {
       throw 'sizeBits length must be at most ' + 31;
     }
-
     for (let i = 0; i < 4; ++i) {
       if (newSizeBits[i] != 0) {
         throw 'first ' + 4 + ' must be 0';
       }
     }
-
     let dictionaryOffsets = offsets;
     let dictionarySizeBits = sizeBits;
     dictionarySizeBits.set(newSizeBits.subarray(0, 0 + newSizeBits.length), 0);
     let pos = 0;
     let limit = newData.length;
-
     for (let i = 0; i < newSizeBits.length; ++i) {
       dictionaryOffsets[i] = pos;
       let bits = dictionarySizeBits[i];
-
       if (bits != 0) {
         if (bits >= 31) {
           throw 'newSizeBits values must be less than 31';
         }
-
         pos += i << bits;
-
         if (pos <= 0 || pos > limit) {
           throw 'newSizeBits is inconsistent: overflow';
         }
       }
     }
-
     for (let i = newSizeBits.length; i < 32; ++i) {
       dictionaryOffsets[i] = pos;
     }
-
     if (pos != limit) {
       throw 'newSizeBits is inconsistent: underflow';
     }
-
     data = newData;
   }
 
   function unpackDictionaryData(dictionary, data0, data1, skipFlip, sizeBits, sizeBitsData) {
     let dict = toUsAsciiBytes(data0 + data1);
-
     if (dict.length != dictionary.length) {
       throw 'Corrupted brotli dictionary';
     }
-
     let offset = 0;
     let n = skipFlip.length;
-
     for (let i = 0; i < n; i += 2) {
       let skip = skipFlip.charCodeAt(i) - 36;
       let flip = skipFlip.charCodeAt(i + 1) - 36;
-
       for (let j = 0; j < skip; ++j) {
         dict[offset] ^= 3;
         offset++;
       }
-
       for (let j = 0; j < flip; ++j) {
         dict[offset] ^= 236;
         offset++;
       }
     }
-
     for (let i = 0; i < sizeBitsData.length; ++i) {
       sizeBits[i] = sizeBitsData.charCodeAt(i) - 65;
     }
-
     dictionary.set(dict);
   }
-
   {
     let dictionaryData = new Int8Array(122784);
     let dictionarySizeBits = new Int32Array(25);
@@ -2148,31 +1740,27 @@ let makeBrotliDecode = () => {
     return 1;
   }
 
-  function flipBuffer(buffer) {}
+  function flipBuffer(buffer) {
+  }
 
   function toUsAsciiBytes(src) {
     let n = src.length;
     let result = new Int8Array(n);
-
     for (let i = 0; i < n; ++i) {
       result[i] = src.charCodeAt(i);
     }
-
     return result;
   }
 
   function decode(bytes, options) {
     let s = new State();
     initState(s, new InputStream(bytes));
-
     if (options) {
       let customDictionary = options['customDictionary'];
       if (customDictionary) attachDictionaryChunk(s, customDictionary);
     }
-
     let totalOutput = 0;
     let chunks = [];
-
     while (true) {
       let chunk = new Int8Array(16384);
       chunks.push(chunk);
@@ -2184,28 +1772,22 @@ let makeBrotliDecode = () => {
       totalOutput += s.outputUsed;
       if (s.outputUsed < 16384) break;
     }
-
     close(s);
     let result = new Int8Array(totalOutput);
     let offset = 0;
-
     for (let i = 0; i < chunks.length; ++i) {
       let chunk = chunks[i];
       let end = min(totalOutput, offset + 16384);
       let len = end - offset;
-
       if (len < 16384) {
         result.set(chunk.subarray(0, len), offset);
       } else {
         result.set(chunk, offset);
       }
-
       offset += len;
     }
-
     return result;
   }
-
   return decode;
 };