{"version":3,"file":"ej2-compression.min.js","sources":["../../src/utils.js","../../src/zip-archive.js","../../src/compression-writer.js","../../src/decompressor-huffman-tree.js","../../src/checksum-calculator.js","../../src/compression-reader.js"],"sourcesContent":["/* eslint-disable */\nvar Utils = /** @class */ (function () {\n    function Utils() {\n    }\n    Utils.bitReverse = function (value) {\n        return (Utils.reverseBits[value & 15] << 12\n            | Utils.reverseBits[(value >> 4) & 15] << 8\n            | Utils.reverseBits[(value >> 8) & 15] << 4\n            | Utils.reverseBits[value >> 12]);\n    };\n    Utils.bitConverterToInt32 = function (value, index) {\n        return value[index] | value[index + 1] << 8 | value[index + 2] << 16 | value[index + 3] << 24;\n    };\n    Utils.bitConverterToInt16 = function (value, index) {\n        return value[index] | value[index + 1] << 8;\n    };\n    Utils.bitConverterToUInt32 = function (value) {\n        var uint = new Uint32Array(1);\n        uint[0] = value;\n        return uint[0];\n    };\n    Utils.bitConverterToUInt16 = function (value, index) {\n        var uint = new Uint16Array(1);\n        uint[0] = (value[index] | value[index + 1] << 8);\n        return uint[0];\n    };\n    Utils.bitConverterUintToInt32 = function (value) {\n        var uint = new Int32Array(1);\n        uint[0] = value;\n        return uint[0];\n    };\n    Utils.bitConverterInt32ToUint = function (value) {\n        var uint = new Uint32Array(1);\n        uint[0] = value;\n        return uint[0];\n    };\n    Utils.bitConverterInt32ToInt16 = function (value) {\n        var uint = new Int16Array(1);\n        uint[0] = value;\n        return uint[0];\n    };\n    Utils.byteToString = function (value) {\n        var str = '';\n        for (var i = 0; i < value.length; i++) {\n            str += String.fromCharCode(value[i]);\n        }\n        return str;\n    };\n    Utils.byteIntToString = function (value) {\n        var str = '';\n        for (var i = 0; i < value.length; i++) {\n            str += String.fromCharCode(value[i]);\n        }\n        return str;\n    };\n    Utils.arrayCopy = function (source, sourceIndex, destination, destinationIndex, dataToCopy) {\n        var temp = new Uint8Array(source.buffer, sourceIndex);\n        var data = temp.subarray(0, dataToCopy);\n        destination.set(data, destinationIndex);\n    };\n    Utils.mergeArray = function (arrayOne, arrayTwo) {\n        var mergedArray = new Uint8Array(arrayOne.length + arrayTwo.length);\n        mergedArray.set(arrayOne);\n        mergedArray.set(arrayTwo, arrayOne.length);\n        return mergedArray;\n    };\n    /**\n     * @private\n     */\n    Utils.encodedString = function (input) {\n        var keyStr = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';\n        var chr1;\n        var chr2;\n        var chr3;\n        var encode1;\n        var encode2;\n        var encode3;\n        var encode4;\n        var count = 0;\n        var resultIndex = 0;\n        /*let dataUrlPrefix: string = 'data:';*/\n        input = input.replace(/[^A-Za-z0-9\\+\\/\\=]/g, '');\n        var totalLength = input.length * 3 / 4;\n        if (input.charAt(input.length - 1) === keyStr.charAt(64)) {\n            totalLength--;\n        }\n        if (input.charAt(input.length - 2) === keyStr.charAt(64)) {\n            totalLength--;\n        }\n        if (totalLength % 1 !== 0) {\n            // totalLength is not an integer, the length does not match a valid\n            // base64 content. That can happen if:\n            // - the input is not a base64 content\n            // - the input is *almost* a base64 content, with a extra chars at the\n            // beginning or at the end\n            // - the input uses a base64 variant (base64url for example)\n            throw new Error('Invalid base64 input, bad content length.');\n        }\n        var output = new Uint8Array(totalLength | 0);\n        while (count < input.length) {\n            encode1 = keyStr.indexOf(input.charAt(count++));\n            encode2 = keyStr.indexOf(input.charAt(count++));\n            encode3 = keyStr.indexOf(input.charAt(count++));\n            encode4 = keyStr.indexOf(input.charAt(count++));\n            chr1 = (encode1 << 2) | (encode2 >> 4);\n            chr2 = ((encode2 & 15) << 4) | (encode3 >> 2);\n            chr3 = ((encode3 & 3) << 6) | encode4;\n            output[resultIndex++] = chr1;\n            if (encode3 !== 64) {\n                output[resultIndex++] = chr2;\n            }\n            if (encode4 !== 64) {\n                output[resultIndex++] = chr3;\n            }\n        }\n        return output;\n    };\n    Utils.reverseBits = [0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15];\n    Utils.huffCodeLengthOrders = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];\n    return Utils;\n}());\nexport { Utils };\n/* eslint-enable */ \n","/* eslint-disable */\nimport { CompressedStreamWriter, Stream, CompressedStreamReader } from './index';\nimport { Save } from '@syncfusion/ej2-file-utils';\nimport { Utils } from './utils';\nvar CRC32TABLE = [];\n/// <summary>\n/// Size of the int value in bytes.\n/// </summary>\nvar INT_SIZE = 4;\n/// <summary>\n/// Size of the short value in bytes.\n/// </summary>\nvar SHORT_SIZE = 2;\n/// <summary>\n/// End of central directory signature.\n/// </summary>\nvar CentralDirectoryEndSignature = 0x06054b50;\n/// <summary>\n/// Offset to the size field in the End of central directory record.\n/// </summary>\nvar CentralDirSizeOffset = 12;\n/// <summary>\n/// Central header signature.\n/// </summary>\nvar CentralHeaderSignature = 0x02014b50;\n/// <summary>\n/// Buffer size.\n/// </summary>\nvar BufferSize = 4096;\n/**\n * class provide compression library\n * ```typescript\n * let archive = new ZipArchive();\n * archive.compressionLevel = 'Normal';\n * let archiveItem = new ZipArchiveItem(archive, 'directoryName\\fileName.txt');\n * archive.addItem(archiveItem);\n * archive.save(fileName.zip);\n * ```\n */\nvar ZipArchive = /** @class */ (function () {\n    /**\n     * constructor for creating ZipArchive instance\n     */\n    function ZipArchive() {\n        if (CRC32TABLE.length === 0) {\n            ZipArchive.initCrc32Table();\n        }\n        this.files = [];\n        this.level = 'Normal';\n        Save.isMicrosoftBrowser = !(!navigator.msSaveBlob);\n    }\n    Object.defineProperty(ZipArchive.prototype, \"items\", {\n        get: function () {\n            return this.files;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(ZipArchive.prototype, \"compressionLevel\", {\n        /**\n         * gets compression level\n         */\n        get: function () {\n            return this.level;\n        },\n        /**\n         * sets compression level\n         */\n        set: function (level) {\n            this.level = level;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(ZipArchive.prototype, \"length\", {\n        /**\n         * gets items count\n         */\n        get: function () {\n            if (this.files === undefined) {\n                return 0;\n            }\n            return this.files.length;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    /**\n     * add new item to archive\n     * @param {ZipArchiveItem} item - item to be added\n     * @returns {void}\n     */\n    ZipArchive.prototype.addItem = function (item) {\n        if (item === null || item === undefined) {\n            throw new Error('ArgumentException: item cannot be null or undefined');\n        }\n        for (var i = 0; i < this.files.length; i++) {\n            var file = this.files[i];\n            if (file instanceof ZipArchiveItem) {\n                if (file.name === item.name) {\n                    throw new Error('item with same name already exist');\n                }\n            }\n        }\n        this.files.push(item);\n    };\n    /**\n     * add new directory to archive\n     * @param directoryName directoryName to be created\n     * @returns {void}\n     */\n    ZipArchive.prototype.addDirectory = function (directoryName) {\n        if (directoryName === null || directoryName === undefined) {\n            throw new Error('ArgumentException: string cannot be null or undefined');\n        }\n        if (directoryName.length === 0) {\n            throw new Error('ArgumentException: string cannot be empty');\n        }\n        if (directoryName.slice(-1) !== '/') {\n            directoryName += '/';\n        }\n        if (this.files.indexOf(directoryName) !== -1) {\n            throw new Error('item with same name already exist');\n        }\n        this.files.push(directoryName);\n    };\n    /**\n     * gets item at specified index\n     * @param {number} index - item index\n     * @returns {ZipArchiveItem}\n     */\n    ZipArchive.prototype.getItem = function (index) {\n        if (index >= 0 && index < this.files.length) {\n            return this.files[index];\n        }\n        return undefined;\n    };\n    /**\n     * determines whether an element is in the collection\n     * @param {string | ZipArchiveItem} item - item to search\n     * @returns {boolean}\n     */\n    ZipArchive.prototype.contains = function (item) {\n        return this.files.indexOf(item) !== -1 ? true : false;\n    };\n    ZipArchive.prototype.open = function (base64String) {\n        //return promise = new Promise((resolve: Function, reject: Function) => {\n        var zipArchive = this;\n        var zipByteArray = Utils.encodedString(base64String);\n        if (zipByteArray.length == 0)\n            throw new DOMException(\"stream\");\n        var stream = new Stream(zipByteArray);\n        //let lCentralDirEndPosition = this.findValueFromEnd( arrBuffer, Constants.CentralDirectoryEndSignature, 65557 );\n        var lCentralDirEndPosition = ZipArchive.findValueFromEnd(stream, CentralDirectoryEndSignature, 65557);\n        if (lCentralDirEndPosition < 0)\n            throw new DOMException(\"Can't locate end of central directory record. Possible wrong file format or archive is corrupt.\");\n        // Step2. Locate central directory and iterate through all items\n        stream.position = lCentralDirEndPosition + CentralDirSizeOffset;\n        var iCentralDirSize = ZipArchive.ReadInt32(stream);\n        var lCentralDirPosition = lCentralDirEndPosition - iCentralDirSize;\n        // verify that this is really central directory\n        stream.position = lCentralDirPosition;\n        this.readCentralDirectoryDataAndExtractItems(stream);\n        //});\n        // let zipArchive: ZipArchive = this;\n        //let promise: Promise<ZipArchive>;\n        // return promise = new Promise((resolve: Function, reject: Function) => {\n        //     let reader: FileReader = new FileReader();\n        //     reader.onload = (e: Event) => {\n        //         let data: Uint8Array = new Uint8Array((e.target as any).result);\n        //         let zipReader: ZipReader = new ZipReader(data);\n        //         zipReader.readEntries().then((entries: ZipEntry[]) => {\n        //             for (let i: number = 0; i < entries.length; i++) {\n        //                 let entry: ZipEntry = entries[i];\n        //                 let item: ZipArchiveItem = new ZipArchiveItem(zipArchive, entry.fileName);\n        //                 item.data = entry.data;\n        //                 item.compressionMethod = entry.compressionMethod;\n        //                 item.crc = entry.crc;\n        //                 item.lastModified = entry.lastModified;\n        //                 item.lastModifiedDate = entry.lastModifiedDate;\n        //                 item.size = entry.size;\n        //                 item.uncompressedSize = entry.uncompressedSize;\n        //                 zipArchive.addItem(item);\n        //             }\n        //             resolve(zipArchive);\n        //         });\n        //     };\n        //     reader.readAsArrayBuffer(fileName);\n        // });\n    };\n    /// <summary>\n    /// Read central directory record from the stream.\n    /// </summary>\n    /// <param name=\"stream\">Stream to read from.</param>\n    ZipArchive.prototype.readCentralDirectoryDataAndExtractItems = function (stream) {\n        if (stream == null)\n            throw new DOMException(\"stream\");\n        var itemHelper;\n        while (ZipArchive.ReadInt32(stream) == CentralHeaderSignature) {\n            itemHelper = new ZipArchiveItemHelper();\n            itemHelper.readCentralDirectoryData(stream);\n            itemHelper;\n            // let item: ZipArchiveItem = new ZipArchiveItem(this);\n            // item.ReadCentralDirectoryData(stream);\n            // m_arrItems.Add(item);\n        }\n        itemHelper.readData(stream, itemHelper.checkCrc);\n        itemHelper.decompressData();\n        this.files.push(new ZipArchiveItem(itemHelper.unCompressedStream.buffer, itemHelper.name));\n    };\n    /**\n     * save archive with specified file name\n     * @param {string} fileName save archive with specified file name\n     * @returns {Promise<ZipArchive>}\n     */\n    ZipArchive.prototype.save = function (fileName) {\n        if (fileName === null || fileName === undefined || fileName.length === 0) {\n            throw new Error('ArgumentException: fileName cannot be null or undefined');\n        }\n        if (this.files.length === 0) {\n            throw new Error('InvalidOperation');\n        }\n        var zipArchive = this;\n        var promise;\n        return promise = new Promise(function (resolve, reject) {\n            zipArchive.saveInternal(fileName, false).then(function () {\n                resolve(zipArchive);\n            });\n        });\n    };\n    /**\n     * Save archive as blob\n     * @return {Promise<Blob>}\n     */\n    ZipArchive.prototype.saveAsBlob = function () {\n        var zipArchive = this;\n        var promise;\n        return promise = new Promise(function (resolve, reject) {\n            zipArchive.saveInternal('', true).then(function (blob) {\n                resolve(blob);\n            });\n        });\n    };\n    ZipArchive.prototype.saveInternal = function (fileName, skipFileSave) {\n        var _this = this;\n        var zipArchive = this;\n        var promise;\n        return promise = new Promise(function (resolve, reject) {\n            var zipData = [];\n            var dirLength = 0;\n            for (var i = 0; i < zipArchive.files.length; i++) {\n                var compressedObject = _this.getCompressedData(_this.files[i]);\n                compressedObject.then(function (data) {\n                    dirLength = zipArchive.constructZippedObject(zipData, data, dirLength, data.isDirectory);\n                    if (zipData.length === zipArchive.files.length) {\n                        var blob = zipArchive.writeZippedContent(fileName, zipData, dirLength, skipFileSave);\n                        resolve(blob);\n                    }\n                });\n            }\n        });\n    };\n    /**\n     * release allocated un-managed resource\n     * @returns {void}\n     */\n    ZipArchive.prototype.destroy = function () {\n        if (this.files !== undefined && this.files.length > 0) {\n            for (var i = 0; i < this.files.length; i++) {\n                var file = this.files[i];\n                if (file instanceof ZipArchiveItem) {\n                    file.destroy();\n                }\n                file = undefined;\n            }\n            this.files = [];\n        }\n        this.files = undefined;\n        this.level = undefined;\n    };\n    ZipArchive.prototype.getCompressedData = function (item) {\n        var zipArchive = this;\n        var promise = new Promise(function (resolve, reject) {\n            if (item instanceof ZipArchiveItem) {\n                var reader_1 = new FileReader();\n                reader_1.onload = function () {\n                    var input = new Uint8Array(reader_1.result);\n                    var data = {\n                        fileName: item.name, crc32Value: 0, compressedData: [],\n                        compressedSize: undefined, uncompressedDataSize: input.length, compressionType: undefined,\n                        isDirectory: false\n                    };\n                    if (zipArchive.level === 'Normal') {\n                        zipArchive.compressData(input, data, CRC32TABLE);\n                        var length_1 = 0;\n                        for (var i = 0; i < data.compressedData.length; i++) {\n                            length_1 += data.compressedData[i].length;\n                        }\n                        data.compressedSize = length_1;\n                        data.compressionType = '\\x08\\x00'; //Deflated = 8\n                    }\n                    else {\n                        data.compressedSize = input.length;\n                        data.crc32Value = zipArchive.calculateCrc32Value(0, input, CRC32TABLE);\n                        data.compressionType = '\\x00\\x00'; // Stored = 0\n                        data.compressedData.push(input);\n                    }\n                    resolve(data);\n                };\n                reader_1.readAsArrayBuffer(item.data);\n            }\n            else {\n                var data = {\n                    fileName: item, crc32Value: 0, compressedData: '', compressedSize: 0, uncompressedDataSize: 0,\n                    compressionType: '\\x00\\x00', isDirectory: true\n                };\n                resolve(data);\n            }\n        });\n        return promise;\n    };\n    ZipArchive.prototype.compressData = function (input, data, crc32Table) {\n        var compressor = new CompressedStreamWriter(true);\n        var currentIndex = 0;\n        var nextIndex = 0;\n        do {\n            if (currentIndex >= input.length) {\n                compressor.close();\n                break;\n            }\n            nextIndex = Math.min(input.length, currentIndex + 16384);\n            var subArray = input.subarray(currentIndex, nextIndex);\n            data.crc32Value = this.calculateCrc32Value(data.crc32Value, subArray, crc32Table);\n            compressor.write(subArray, 0, nextIndex - currentIndex);\n            currentIndex = nextIndex;\n        } while (currentIndex <= input.length);\n        data.compressedData = compressor.compressedData;\n        compressor.destroy();\n    };\n    ZipArchive.prototype.constructZippedObject = function (zipParts, data, dirLength, isDirectory) {\n        var extFileAttr = 0;\n        var date = new Date();\n        if (isDirectory) {\n            extFileAttr = extFileAttr | 0x00010; // directory flag\n        }\n        extFileAttr = extFileAttr | (0 & 0x3F);\n        var header = this.writeHeader(data, date);\n        var localHeader = 'PK\\x03\\x04' + header + data.fileName;\n        var centralDir = this.writeCentralDirectory(data, header, dirLength, extFileAttr);\n        zipParts.push({ localHeader: localHeader, centralDir: centralDir, compressedData: data });\n        return dirLength + localHeader.length + data.compressedSize;\n    };\n    ZipArchive.prototype.writeHeader = function (data, date) {\n        var zipHeader = '';\n        zipHeader += '\\x0A\\x00' + '\\x00\\x00'; // version needed to extract & general purpose bit flag\n        zipHeader += data.compressionType; // compression method Deflate=8,Stored=0\n        zipHeader += this.getBytes(this.getModifiedTime(date), 2); // last modified Time\n        zipHeader += this.getBytes(this.getModifiedDate(date), 2); // last modified date\n        zipHeader += this.getBytes(data.crc32Value, 4); // crc-32 value\n        zipHeader += this.getBytes(data.compressedSize, 4); // compressed file size\n        zipHeader += this.getBytes(data.uncompressedDataSize, 4); // uncompressed file size\n        zipHeader += this.getBytes(data.fileName.length, 2); // file name length\n        zipHeader += this.getBytes(0, 2); // extra field length\n        return zipHeader;\n    };\n    ZipArchive.prototype.writeZippedContent = function (fileName, zipData, localDirLen, skipFileSave) {\n        var cenDirLen = 0;\n        var buffer = [];\n        for (var i = 0; i < zipData.length; i++) {\n            var item = zipData[i];\n            cenDirLen += item.centralDir.length;\n            buffer.push(this.getArrayBuffer(item.localHeader));\n            while (item.compressedData.compressedData.length) {\n                buffer.push(item.compressedData.compressedData.shift().buffer);\n            }\n        }\n        for (var i = 0; i < zipData.length; i++) {\n            buffer.push(this.getArrayBuffer(zipData[i].centralDir));\n        }\n        buffer.push(this.getArrayBuffer(this.writeFooter(zipData, cenDirLen, localDirLen)));\n        var blob = new Blob(buffer, { type: 'application/zip' });\n        if (!skipFileSave) {\n            Save.save(fileName, blob);\n        }\n        return blob;\n    };\n    ZipArchive.prototype.writeCentralDirectory = function (data, localHeader, offset, externalFileAttribute) {\n        var directoryHeader = 'PK\\x01\\x02' +\n            this.getBytes(0x0014, 2) + localHeader + // inherit from file header\n            this.getBytes(0, 2) + // comment length\n            '\\x00\\x00' + '\\x00\\x00' + // internal file attributes \n            this.getBytes(externalFileAttribute, 4) + // external file attributes\n            this.getBytes(offset, 4) + // local fileHeader relative offset\n            data.fileName;\n        return directoryHeader;\n    };\n    ZipArchive.prototype.writeFooter = function (zipData, centralLength, localLength) {\n        var dirEnd = 'PK\\x05\\x06' + '\\x00\\x00' + '\\x00\\x00' +\n            this.getBytes(zipData.length, 2) + this.getBytes(zipData.length, 2) +\n            this.getBytes(centralLength, 4) + this.getBytes(localLength, 4) +\n            this.getBytes(0, 2);\n        return dirEnd;\n    };\n    ZipArchive.prototype.getArrayBuffer = function (input) {\n        var a = new Uint8Array(input.length);\n        for (var j = 0; j < input.length; ++j) {\n            a[j] = input.charCodeAt(j) & 0xFF;\n        }\n        return a.buffer;\n    };\n    ZipArchive.prototype.getBytes = function (value, offset) {\n        var bytes = '';\n        for (var i = 0; i < offset; i++) {\n            bytes += String.fromCharCode(value & 0xff);\n            value = value >>> 8;\n        }\n        return bytes;\n    };\n    ZipArchive.prototype.getModifiedTime = function (date) {\n        var modTime = date.getHours();\n        modTime = modTime << 6;\n        modTime = modTime | date.getMinutes();\n        modTime = modTime << 5;\n        return modTime = modTime | date.getSeconds() / 2;\n    };\n    ZipArchive.prototype.getModifiedDate = function (date) {\n        var modiDate = date.getFullYear() - 1980;\n        modiDate = modiDate << 4;\n        modiDate = modiDate | (date.getMonth() + 1);\n        modiDate = modiDate << 5;\n        return modiDate = modiDate | date.getDate();\n    };\n    ZipArchive.prototype.calculateCrc32Value = function (crc32Value, input, crc32Table) {\n        crc32Value ^= -1;\n        for (var i = 0; i < input.length; i++) {\n            crc32Value = (crc32Value >>> 8) ^ crc32Table[(crc32Value ^ input[i]) & 0xFF];\n        }\n        return (crc32Value ^ (-1));\n    };\n    /**\n     * construct cyclic redundancy code table\n     * @private\n     */\n    ZipArchive.initCrc32Table = function () {\n        var i;\n        for (var j = 0; j < 256; j++) {\n            i = j;\n            for (var k = 0; k < 8; k++) {\n                i = ((i & 1) ? (0xEDB88320 ^ (i >>> 1)) : (i >>> 1));\n            }\n            CRC32TABLE[j] = i;\n        }\n    };\n    ZipArchive.findValueFromEnd = function (stream, value, maxCount) {\n        if (stream == null)\n            throw new DOMException(\"stream\");\n        //   if( !stream.CanSeek || !stream.CanRead )\n        //     throw new ArgumentOutOfRangeException( \"We need to have seekable and readable stream.\" );\n        // read last 4 bytes and compare with required value\n        var lStreamSize = stream.inputStream.buffer.byteLength;\n        if (lStreamSize < 4)\n            return -1;\n        var arrBuffer = new Uint8Array(4);\n        var lLastPos = Math.max(0, lStreamSize - maxCount);\n        var lCurrentPosition = lStreamSize - 1 - INT_SIZE;\n        stream.position = lCurrentPosition;\n        stream.read(arrBuffer, 0, INT_SIZE);\n        var uiCurValue = arrBuffer[0];\n        var bFound = (uiCurValue == value);\n        if (!bFound) {\n            while (lCurrentPosition > lLastPos) {\n                // remove unnecessary byte and replace it with new value.\n                uiCurValue <<= 8;\n                lCurrentPosition--;\n                stream.position = lCurrentPosition;\n                uiCurValue += stream.readByte();\n                if (uiCurValue == value) {\n                    bFound = true;\n                    break;\n                }\n            }\n        }\n        return bFound ? lCurrentPosition : -1;\n    };\n    /// <summary>\n    /// Extracts Int32 value from the stream.\n    /// </summary>\n    /// <param name=\"stream\">Stream to read data from.</param>\n    /// <returns>Extracted value.</returns>\n    ZipArchive.ReadInt32 = function (stream) {\n        var buffer = new Uint8Array(INT_SIZE);\n        if (stream.read(buffer, 0, INT_SIZE) != INT_SIZE) {\n            throw new DOMException(\"Unable to read value at the specified position - end of stream was reached.\");\n        }\n        return Utils.bitConverterToInt32(buffer, 0);\n    };\n    /// <summary>\n    /// Extracts Int16 value from the stream.\n    /// </summary>\n    /// <param name=\"stream\">Stream to read data from.</param>\n    /// <returns>Extracted value.</returns>\n    ZipArchive.ReadInt16 = function (stream) {\n        var buffer = new Uint8Array(SHORT_SIZE);\n        if (stream.read(buffer, 0, SHORT_SIZE) != SHORT_SIZE) {\n            throw new DOMException(\"Unable to read value at the specified position - end of stream was reached.\");\n        }\n        return Utils.bitConverterToInt16(buffer, 0);\n    };\n    /// <summary>\n    /// Extracts unsigned Int16 value from the stream.\n    /// </summary>\n    /// <param name=\"stream\">Stream to read data from.</param>\n    /// <returns>Extracted value.</returns>\n    ZipArchive.ReadUInt16 = function (stream) {\n        {\n            var buffer = new Uint8Array(SHORT_SIZE);\n            if (stream.read(buffer, 0, SHORT_SIZE) != SHORT_SIZE) {\n                throw new DOMException(\"Unable to read value at the specified position - end of stream was reached.\");\n            }\n            return Utils.bitConverterToInt16(buffer, 0);\n        }\n    };\n    return ZipArchive;\n}());\nexport { ZipArchive };\nvar ZipArchiveItemHelper = /** @class */ (function () {\n    function ZipArchiveItemHelper() {\n        /// <summary>\n        /// Zip header signature.\n        /// </summary>\n        this.headerSignature = 0x04034b50;\n        /// <summary>\n        /// Indicates whether we should check Crc value when reading item's data. Check\n        /// is performed when user gets access to decompressed data for the first time.\n        /// </summary>\n        this.checkCrc = true;\n        /// <summary>\n        /// Crc.\n        /// </summary>\n        this.crc32 = 0;\n    }\n    /// <summary>\n    /// Read data from the stream based on the central directory.\n    /// </summary>\n    /// <param name=\"stream\">Stream to read data from, stream.Position must point at just after correct file header.</param>\n    ZipArchiveItemHelper.prototype.readCentralDirectoryData = function (stream) {\n        // on the current moment we ignore \"version made by\" and \"version needed to extract\" fields.\n        stream.position += 4;\n        this.options = ZipArchive.ReadInt16(stream);\n        this.compressionMethod = ZipArchive.ReadInt16(stream);\n        this.checkCrc = (this.compressionMethod != 99); //COmpression.Defalte != SecurityConstants.AES\n        //m_bCompressed = true;\n        // on the current moment we ignore \"last mod file time\" and \"last mod file date\" fields.\n        var lastModified = ZipArchive.ReadInt32(stream);\n        //LastModified = ConvertToDateTime(lastModified);\n        this.crc32 = Utils.bitConverterToUInt32(ZipArchive.ReadInt32(stream));\n        this.compressedSize = ZipArchive.ReadInt32(stream);\n        this.originalSize = ZipArchive.ReadInt32(stream);\n        var iFileNameLength = ZipArchive.ReadInt16(stream);\n        var iExtraFieldLenth = ZipArchive.ReadInt16(stream);\n        var iCommentLength = ZipArchive.ReadInt16(stream);\n        // on the current moment we ignore and \"disk number start\" (2 bytes),\n        // \"internal file attributes\" (2 bytes).\n        stream.position += 4;\n        this.externalAttributes = ZipArchive.ReadInt32(stream);\n        this.localHeaderOffset = ZipArchive.ReadInt32(stream);\n        var arrBuffer = new Uint8Array(iFileNameLength);\n        stream.read(arrBuffer, 0, iFileNameLength);\n        var m_strItemName = Utils.byteToString(arrBuffer);\n        m_strItemName = m_strItemName.replace(\"\\\\\", \"/\");\n        this.name = m_strItemName;\n        stream.position += iExtraFieldLenth + iCommentLength;\n        if (this.options != 0)\n            this.options = 0;\n    };\n    /// <summary>\n    /// Reads zipped data from the stream.\n    /// </summary>\n    /// <param name=\"stream\">Stream to read data from.</param>\n    /// <param name=\"checkCrc\">Indicates whether we should check crc value after data decompression.</param>\n    ZipArchiveItemHelper.prototype.readData = function (stream, checkCrc) {\n        if (stream.length == 0)\n            throw new DOMException(\"stream\");\n        stream.position = this.localHeaderOffset;\n        this.checkCrc = checkCrc;\n        this.readLocalHeader(stream);\n        this.readCompressedData(stream);\n    };\n    ZipArchiveItemHelper.prototype.decompressData = function () {\n        if (this.compressionMethod == 8) {\n            if (this.originalSize > 0) {\n                this.decompressDataOld();\n            }\n        }\n    };\n    ZipArchiveItemHelper.prototype.decompressDataOld = function () {\n        var reader = new CompressedStreamReader(this.compressedStream, true);\n        var decompressedData;\n        if (this.originalSize > 0)\n            decompressedData = new Stream(new Uint8Array(this.originalSize));\n        var arrBuffer = new Uint8Array(BufferSize);\n        var iReadBytes;\n        var past = new Uint8Array(0);\n        while ((iReadBytes = reader.read(arrBuffer, 0, BufferSize)) > 0) {\n            //             past = new Uint8Array(decompressedData.length);\n            // let currentBlock: Uint8Array = arrBuffer.subarray(0, iReadBytes);\n            decompressedData.write(arrBuffer.subarray(0, iReadBytes), 0, iReadBytes);\n        }\n        this.unCompressedStream = decompressedData.toByteArray();\n        //   this.originalSize = decompressedData.Length;\n        //   m_bControlStream = true;\n        //   m_streamData = decompressedData;\n        //   decompressedData.SetLength( m_lOriginalSize );\n        //   decompressedData.Capacity = ( int )m_lOriginalSize;\n        if (this.checkCrc) {\n            //TODO: fix this\n            //CheckCrc(decompressedData.ToArray());\n        }\n        //m_streamData.Position = 0;\n    };\n    /// <summary>\n    /// Extracts local header from the stream.\n    /// </summary>\n    /// <param name=\"stream\">Stream to read data from.</param>\n    ZipArchiveItemHelper.prototype.readLocalHeader = function (stream) {\n        if (stream.length == 0)\n            throw new DOMException(\"stream\");\n        if (ZipArchive.ReadInt32(stream) != this.headerSignature)\n            throw new DOMException(\"Can't find local header signature - wrong file format or file is corrupt.\");\n        // TODO: it is good to verify data read from the central directory record,\n        // but on the current moment we simply skip it.\n        stream.position += 22;\n        var iNameLength = ZipArchive.ReadInt16(stream);\n        var iExtraLength = ZipArchive.ReadUInt16(stream);\n        if (this.compressionMethod == 99) //SecurityConstants.AES\n         {\n            // stream.Position += iNameLength + 8;\n            // m_archive.EncryptionAlgorithm = (EncryptionAlgorithm)stream.ReadByte();\n            // m_actualCompression = new byte[2];\n            // stream.Read(m_actualCompression, 0, 2);\n        }\n        else if (iExtraLength > 2) {\n            stream.position += iNameLength;\n            var headerVal = ZipArchive.ReadInt16(stream);\n            if (headerVal == 0x0017) //PKZipEncryptionHeader\n                throw new DOMException(\"UnSupported\");\n            else\n                stream.position += iExtraLength - 2;\n        }\n        else\n            stream.position += iNameLength + iExtraLength;\n    };\n    /// <summary>\n    /// Extracts compressed data from the stream.\n    /// </summary>\n    /// <param name=\"stream\">Stream to read data from.</param>\n    ZipArchiveItemHelper.prototype.readCompressedData = function (stream) {\n        var dataStream;\n        if (this.compressedSize > 0) {\n            var iBytesLeft = this.compressedSize;\n            dataStream = new Stream(new Uint8Array(iBytesLeft));\n            var arrBuffer = new Uint8Array(BufferSize);\n            while (iBytesLeft > 0) {\n                var iBytesToRead = Math.min(iBytesLeft, BufferSize);\n                if (stream.read(arrBuffer, 0, iBytesToRead) != iBytesToRead)\n                    throw new DOMException(\"End of file reached - wrong file format or file is corrupt.\");\n                dataStream.write(arrBuffer.subarray(0, iBytesToRead), 0, iBytesToRead);\n                iBytesLeft -= iBytesToRead;\n            }\n            // if(m_archive.Password != null)\n            // {\n            //     byte[] dataBuffer = new byte[dataStream.Length];\n            //     dataBuffer = dataStream.ToArray();\n            //     dataStream=new MemoryStream( Decrypt(dataBuffer));\n            // }\n            this.compressedStream = new Uint8Array(dataStream.inputStream);\n            // m_bControlStream = true;\n        }\n        else if (this.compressedSize < 0) //If compression size is negative, then read until the next header signature reached.\n         {\n            //   MemoryStream dataStream = new MemoryStream();\n            //   int bt = 0;\n            //   bool proceed=true;\n            //   while (proceed)\n            //   {\n            //       if ((bt = stream.ReadByte()) == Constants.HeaderSignatureStartByteValue)\n            //       {\n            //           stream.Position -= 1;\n            //           int headerSignature = ZipArchive.ReadInt32(stream);\n            //           if (headerSignature==Constants.CentralHeaderSignature || headerSignature==Constants.CentralHeaderSignature)\n            //           {\n            //               proceed = false;\n            //           }\n            //           stream.Position -= 3;\n            //       }\n            //       if (proceed)\n            //           dataStream.WriteByte((byte)bt);\n            //   }\n            //   m_streamData = dataStream;\n            //   m_lCompressedSize = m_streamData.Length;\n            //   m_bControlStream = true;\n        }\n        else if (this.compressedSize == 0) {\n            //  m_streamData = new MemoryStream();\n        }\n    };\n    return ZipArchiveItemHelper;\n}());\nexport { ZipArchiveItemHelper };\n/**\n * Class represent unique ZipArchive item\n * ```typescript\n * let archiveItem = new ZipArchiveItem(archive, 'directoryName\\fileName.txt');\n * ```\n */\nvar ZipArchiveItem = /** @class */ (function () {\n    /**\n     * constructor for creating {ZipArchiveItem} instance\n     * @param {Blob|ArrayBuffer} data file data\n     * @param {itemName} itemName absolute file path\n     */\n    function ZipArchiveItem(data, itemName) {\n        if (data === null || data === undefined) {\n            throw new Error('ArgumentException: data cannot be null or undefined');\n        }\n        if (itemName === null || itemName === undefined) {\n            throw new Error('ArgumentException: string cannot be null or undefined');\n        }\n        if (itemName.length === 0) {\n            throw new Error('string cannot be empty');\n        }\n        this.data = data;\n        this.name = itemName;\n    }\n    Object.defineProperty(ZipArchiveItem.prototype, \"dataStream\", {\n        get: function () {\n            return this.decompressedStream;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(ZipArchiveItem.prototype, \"name\", {\n        /**\n         * Get the name of archive item\n         * @returns string\n         */\n        get: function () {\n            return this.fileName;\n        },\n        /**\n         * Set the name of archive item\n         * @param  {string} value\n         */\n        set: function (value) {\n            this.fileName = value;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    /**\n     * release allocated un-managed resource\n     * @returns {void}\n     */\n    ZipArchiveItem.prototype.destroy = function () {\n        this.fileName = undefined;\n        this.data = undefined;\n    };\n    return ZipArchiveItem;\n}());\nexport { ZipArchiveItem };\n/* eslint-enable */ \n","/* eslint-disable */\nimport { Encoding } from '@syncfusion/ej2-file-utils';\n/**\n * array literal codes\n */\nvar ARR_LITERAL_CODES = new Int16Array(286);\nvar ARR_LITERAL_LENGTHS = new Uint8Array(286);\nvar ARR_DISTANCE_CODES = new Int16Array(30);\nvar ARR_DISTANCE_LENGTHS = new Uint8Array(30);\n/**\n * represent compression stream writer\n * ```typescript\n * let compressedWriter = new CompressedStreamWriter();\n * let text: string = 'Hello world!!!';\n * compressedWriter.write(text, 0, text.length);\n * compressedWriter.close();\n * ```\n */\nvar CompressedStreamWriter = /** @class */ (function () {\n    /**\n     * Initializes compressor and writes ZLib header if needed.\n     * @param {boolean} noWrap - optional if true, ZLib header and checksum will not be written.\n     */\n    function CompressedStreamWriter(noWrap) {\n        this.pendingBuffer = new Uint8Array(1 << 16);\n        this.pendingBufLength = 0;\n        this.pendingBufCache = 0;\n        this.pendingBufBitsInCache = 0;\n        this.bufferPosition = 0;\n        this.extraBits = 0;\n        this.currentHash = 0;\n        this.matchStart = 0;\n        this.matchLength = 0;\n        this.matchPrevAvail = false;\n        this.blockStart = 0;\n        this.stringStart = 0;\n        this.lookAhead = 0;\n        this.totalBytesIn = 0;\n        this.inputOffset = 0;\n        this.inputEnd = 0;\n        this.windowSize = 1 << 15;\n        this.windowMask = this.windowSize - 1;\n        this.hashSize = 1 << 15;\n        this.hashMask = this.hashSize - 1;\n        this.hashShift = Math.floor((15 + 3 - 1) / 3);\n        this.maxDist = this.windowSize - 262;\n        this.checkSum = 1;\n        this.noWrap = false;\n        if (!CompressedStreamWriter.isHuffmanTreeInitiated) {\n            CompressedStreamWriter.initHuffmanTree();\n            CompressedStreamWriter.isHuffmanTreeInitiated = true;\n        }\n        this.treeLiteral = new CompressorHuffmanTree(this, 286, 257, 15);\n        this.treeDistances = new CompressorHuffmanTree(this, 30, 1, 15);\n        this.treeCodeLengths = new CompressorHuffmanTree(this, 19, 4, 7);\n        this.arrDistances = new Uint16Array((1 << 14));\n        this.arrLiterals = new Uint8Array((1 << 14));\n        this.stream = [];\n        this.dataWindow = new Uint8Array(2 * this.windowSize);\n        this.hashHead = new Int16Array(this.hashSize);\n        this.hashPrevious = new Int16Array(this.windowSize);\n        this.blockStart = this.stringStart = 1;\n        this.noWrap = noWrap;\n        if (!noWrap) {\n            this.writeZLibHeader();\n        }\n    }\n    Object.defineProperty(CompressedStreamWriter.prototype, \"compressedData\", {\n        /**\n         * get compressed data\n         */\n        get: function () {\n            return this.stream;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(CompressedStreamWriter.prototype, \"getCompressedString\", {\n        get: function () {\n            var compressedString = '';\n            if (this.stream !== undefined) {\n                for (var i = 0; i < this.stream.length; i++) {\n                    compressedString += String.fromCharCode.apply(null, this.stream[i]);\n                }\n            }\n            return compressedString;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    /**\n     * Compresses data and writes it to the stream.\n     * @param {Uint8Array} data - data to compress\n     * @param {number} offset - offset in data\n     * @param {number} length - length of the data\n     * @returns {void}\n     */\n    CompressedStreamWriter.prototype.write = function (data, offset, length) {\n        if (data === undefined || data === null) {\n            throw new Error('ArgumentException: data cannot null or undefined');\n        }\n        var end = offset + length;\n        if (0 > offset || offset > end || end > data.length) {\n            throw new Error('ArgumentOutOfRangeException: Offset or length is incorrect');\n        }\n        if (typeof data === 'string') {\n            var encode = new Encoding(false);\n            encode.type = 'Utf8';\n            data = new Uint8Array(encode.getBytes(data, 0, data.length));\n            end = offset + data.length;\n        }\n        this.inputBuffer = data;\n        this.inputOffset = offset;\n        this.inputEnd = end;\n        if (!this.noWrap) {\n            this.checkSum = ChecksumCalculator.checksumUpdate(this.checkSum, this.inputBuffer, this.inputOffset, end);\n        }\n        while (!(this.inputEnd === this.inputOffset) || !(this.pendingBufLength === 0)) {\n            this.pendingBufferFlush();\n            this.compressData(false);\n        }\n    };\n    /**\n     * write ZLib header to the compressed data\n     * @return {void}\n     */\n    CompressedStreamWriter.prototype.writeZLibHeader = function () {\n        /* Initialize header.*/\n        var headerDate = (8 + (7 << 4)) << 8;\n        /* Save compression level.*/\n        headerDate |= ((5 >> 2) & 3) << 6;\n        /* Align header.*/\n        headerDate += 31 - (headerDate % 31);\n        /* Write header to stream.*/\n        this.pendingBufferWriteShortBytes(headerDate);\n    };\n    /**\n     *  Write Most Significant Bytes in to stream\n     * @param {number} s - check sum value\n     */\n    CompressedStreamWriter.prototype.pendingBufferWriteShortBytes = function (s) {\n        this.pendingBuffer[this.pendingBufLength++] = s >> 8;\n        this.pendingBuffer[this.pendingBufLength++] = s;\n    };\n    CompressedStreamWriter.prototype.compressData = function (finish) {\n        var success;\n        do {\n            this.fillWindow();\n            var canFlush = (finish && this.inputEnd === this.inputOffset);\n            success = this.compressSlow(canFlush, finish);\n        } while (this.pendingBufLength === 0 && success);\n        return success;\n    };\n    CompressedStreamWriter.prototype.compressSlow = function (flush, finish) {\n        if (this.lookAhead < 262 && !flush) {\n            return false;\n        }\n        while (this.lookAhead >= 262 || flush) {\n            if (this.lookAhead === 0) {\n                return this.lookAheadCompleted(finish);\n            }\n            if (this.stringStart >= 2 * this.windowSize - 262) {\n                this.slideWindow();\n            }\n            var prevMatch = this.matchStart;\n            var prevLen = this.matchLength;\n            if (this.lookAhead >= 3) {\n                this.discardMatch();\n            }\n            if (prevLen >= 3 && this.matchLength <= prevLen) {\n                prevLen = this.matchPreviousBest(prevMatch, prevLen);\n            }\n            else {\n                this.matchPreviousAvailable();\n            }\n            if (this.bufferPosition >= (1 << 14)) {\n                return this.huffmanIsFull(finish);\n            }\n        }\n        return true;\n    };\n    CompressedStreamWriter.prototype.discardMatch = function () {\n        var hashHead = this.insertString();\n        if (hashHead !== 0 && this.stringStart - hashHead <= this.maxDist && this.findLongestMatch(hashHead)) {\n            if (this.matchLength <= 5 && (this.matchLength === 3 && this.stringStart - this.matchStart > 4096)) {\n                this.matchLength = 3 - 1;\n            }\n        }\n    };\n    CompressedStreamWriter.prototype.matchPreviousAvailable = function () {\n        if (this.matchPrevAvail) {\n            this.huffmanTallyLit(this.dataWindow[this.stringStart - 1] & 0xff);\n        }\n        this.matchPrevAvail = true;\n        this.stringStart++;\n        this.lookAhead--;\n    };\n    CompressedStreamWriter.prototype.matchPreviousBest = function (prevMatch, prevLen) {\n        this.huffmanTallyDist(this.stringStart - 1 - prevMatch, prevLen);\n        prevLen -= 2;\n        do {\n            this.stringStart++;\n            this.lookAhead--;\n            if (this.lookAhead >= 3) {\n                this.insertString();\n            }\n        } while (--prevLen > 0);\n        this.stringStart++;\n        this.lookAhead--;\n        this.matchPrevAvail = false;\n        this.matchLength = 3 - 1;\n        return prevLen;\n    };\n    CompressedStreamWriter.prototype.lookAheadCompleted = function (finish) {\n        if (this.matchPrevAvail) {\n            this.huffmanTallyLit(this.dataWindow[this.stringStart - 1] & 0xff);\n        }\n        this.matchPrevAvail = false;\n        this.huffmanFlushBlock(this.dataWindow, this.blockStart, this.stringStart - this.blockStart, finish);\n        this.blockStart = this.stringStart;\n        return false;\n    };\n    CompressedStreamWriter.prototype.huffmanIsFull = function (finish) {\n        var len = this.stringStart - this.blockStart;\n        if (this.matchPrevAvail) {\n            len--;\n        }\n        var lastBlock = (finish && this.lookAhead === 0 && !this.matchPrevAvail);\n        this.huffmanFlushBlock(this.dataWindow, this.blockStart, len, lastBlock);\n        this.blockStart += len;\n        return !lastBlock;\n    };\n    CompressedStreamWriter.prototype.fillWindow = function () {\n        if (this.stringStart >= this.windowSize + this.maxDist) {\n            this.slideWindow();\n        }\n        while (this.lookAhead < 262 && this.inputOffset < this.inputEnd) {\n            var more = 2 * this.windowSize - this.lookAhead - this.stringStart;\n            if (more > this.inputEnd - this.inputOffset) {\n                more = this.inputEnd - this.inputOffset;\n            }\n            this.dataWindow.set(this.inputBuffer.subarray(this.inputOffset, this.inputOffset + more), this.stringStart + this.lookAhead);\n            this.inputOffset += more;\n            this.totalBytesIn += more;\n            this.lookAhead += more;\n        }\n        if (this.lookAhead >= 3) {\n            this.updateHash();\n        }\n    };\n    CompressedStreamWriter.prototype.slideWindow = function () {\n        this.dataWindow.set(this.dataWindow.subarray(this.windowSize, this.windowSize + this.windowSize), 0);\n        this.matchStart -= this.windowSize;\n        this.stringStart -= this.windowSize;\n        this.blockStart -= this.windowSize;\n        for (var i = 0; i < this.hashSize; ++i) {\n            var m = this.hashHead[i] & 0xffff;\n            this.hashHead[i] = (((m >= this.windowSize) ? (m - this.windowSize) : 0));\n        }\n        for (var i = 0; i < this.windowSize; i++) {\n            var m = this.hashPrevious[i] & 0xffff;\n            this.hashPrevious[i] = ((m >= this.windowSize) ? (m - this.windowSize) : 0);\n        }\n    };\n    CompressedStreamWriter.prototype.insertString = function () {\n        var match;\n        var hash = ((this.currentHash << this.hashShift) ^ this.dataWindow[this.stringStart + (3 - 1)]) & this.hashMask;\n        this.hashPrevious[this.stringStart & this.windowMask] = match = this.hashHead[hash];\n        this.hashHead[hash] = this.stringStart;\n        this.currentHash = hash;\n        return match & 0xffff;\n    };\n    CompressedStreamWriter.prototype.findLongestMatch = function (curMatch) {\n        var chainLen = 4096;\n        var niceLen = 258;\n        var scan = this.stringStart;\n        var match;\n        var bestEnd = this.stringStart + this.matchLength;\n        var bestLength = Math.max(this.matchLength, 3 - 1);\n        var limit = Math.max(this.stringStart - this.maxDist, 0);\n        var stringEnd = this.stringStart + 258 - 1;\n        var scanEnd1 = this.dataWindow[bestEnd - 1];\n        var scanEnd = this.dataWindow[bestEnd];\n        var data = this.dataWindow;\n        if (bestLength >= 32) {\n            chainLen >>= 2;\n        }\n        if (niceLen > this.lookAhead) {\n            niceLen = this.lookAhead;\n        }\n        do {\n            if (data[curMatch + bestLength] !== scanEnd ||\n                data[curMatch + bestLength - 1] !== scanEnd1 ||\n                data[curMatch] !== data[scan] ||\n                data[curMatch + 1] !== data[scan + 1]) {\n                continue;\n            }\n            match = curMatch + 2;\n            scan += 2;\n            /* tslint:disable */\n            while (data[++scan] === data[++match] && data[++scan] === data[++match] &&\n                data[++scan] === data[++match] && data[++scan] === data[++match] &&\n                data[++scan] === data[++match] && data[++scan] === data[++match] &&\n                data[++scan] === data[++match] && data[++scan] === data[++match] && scan < stringEnd) {\n                /* tslint:disable */\n            }\n            if (scan > bestEnd) {\n                this.matchStart = curMatch;\n                bestEnd = scan;\n                bestLength = scan - this.stringStart;\n                if (bestLength >= niceLen) {\n                    break;\n                }\n                scanEnd1 = data[bestEnd - 1];\n                scanEnd = data[bestEnd];\n            }\n            scan = this.stringStart;\n        } while ((curMatch = (this.hashPrevious[curMatch & this.windowMask] & 0xffff)) > limit && --chainLen !== 0);\n        this.matchLength = Math.min(bestLength, this.lookAhead);\n        return this.matchLength >= 3;\n    };\n    CompressedStreamWriter.prototype.updateHash = function () {\n        this.currentHash = (this.dataWindow[this.stringStart] << this.hashShift) ^ this.dataWindow[this.stringStart + 1];\n    };\n    CompressedStreamWriter.prototype.huffmanTallyLit = function (literal) {\n        this.arrDistances[this.bufferPosition] = 0;\n        this.arrLiterals[this.bufferPosition++] = literal;\n        this.treeLiteral.codeFrequencies[literal]++;\n        return this.bufferPosition >= (1 << 14);\n    };\n    CompressedStreamWriter.prototype.huffmanTallyDist = function (dist, len) {\n        this.arrDistances[this.bufferPosition] = dist;\n        this.arrLiterals[this.bufferPosition++] = (len - 3);\n        var lc = this.huffmanLengthCode(len - 3);\n        this.treeLiteral.codeFrequencies[lc]++;\n        if (lc >= 265 && lc < 285) {\n            this.extraBits += Math.floor((lc - 261) / 4);\n        }\n        var dc = this.huffmanDistanceCode(dist - 1);\n        this.treeDistances.codeFrequencies[dc]++;\n        if (dc >= 4) {\n            this.extraBits += Math.floor((dc / 2 - 1));\n        }\n        return this.bufferPosition >= (1 << 14);\n    };\n    CompressedStreamWriter.prototype.huffmanFlushBlock = function (stored, storedOffset, storedLength, lastBlock) {\n        this.treeLiteral.codeFrequencies[256]++;\n        this.treeLiteral.buildTree();\n        this.treeDistances.buildTree();\n        this.treeLiteral.calculateBLFreq(this.treeCodeLengths);\n        this.treeDistances.calculateBLFreq(this.treeCodeLengths);\n        this.treeCodeLengths.buildTree();\n        var blTreeCodes = 4;\n        for (var i = 18; i > blTreeCodes; i--) {\n            if (this.treeCodeLengths.codeLengths[CompressorHuffmanTree.huffCodeLengthOrders[i]] > 0) {\n                blTreeCodes = i + 1;\n            }\n        }\n        var opt_len = 14 + blTreeCodes * 3 + this.treeCodeLengths.getEncodedLength() +\n            this.treeLiteral.getEncodedLength() + this.treeDistances.getEncodedLength() + this.extraBits;\n        var static_len = this.extraBits;\n        for (var i = 0; i < 286; i++) {\n            static_len += this.treeLiteral.codeFrequencies[i] * ARR_LITERAL_LENGTHS[i];\n        }\n        for (var i = 0; i < 30; i++) {\n            static_len += this.treeDistances.codeFrequencies[i] * ARR_DISTANCE_LENGTHS[i];\n        }\n        if (opt_len >= static_len) {\n            // Force static trees.\n            opt_len = static_len;\n        }\n        if (storedOffset >= 0 && storedLength + 4 < opt_len >> 3) {\n            this.huffmanFlushStoredBlock(stored, storedOffset, storedLength, lastBlock);\n        }\n        else if (opt_len == static_len) {\n            // Encode with static tree.\n            this.pendingBufferWriteBits((1 << 1) + (lastBlock ? 1 : 0), 3);\n            this.treeLiteral.setStaticCodes(ARR_LITERAL_CODES, ARR_LITERAL_LENGTHS);\n            this.treeDistances.setStaticCodes(ARR_DISTANCE_CODES, ARR_DISTANCE_LENGTHS);\n            this.huffmanCompressBlock();\n            this.huffmanReset();\n        }\n        else {\n            this.pendingBufferWriteBits((2 << 1) + (lastBlock ? 1 : 0), 3);\n            this.huffmanSendAllTrees(blTreeCodes);\n            this.huffmanCompressBlock();\n            this.huffmanReset();\n        }\n    };\n    CompressedStreamWriter.prototype.huffmanFlushStoredBlock = function (stored, storedOffset, storedLength, lastBlock) {\n        this.pendingBufferWriteBits((0 << 1) + (lastBlock ? 1 : 0), 3);\n        this.pendingBufferAlignToByte();\n        this.pendingBufferWriteShort(storedLength);\n        this.pendingBufferWriteShort(~storedLength);\n        this.pendingBufferWriteByteBlock(stored, storedOffset, storedLength);\n        this.huffmanReset();\n    };\n    CompressedStreamWriter.prototype.huffmanLengthCode = function (len) {\n        if (len === 255) {\n            return 285;\n        }\n        var code = 257;\n        while (len >= 8) {\n            code += 4;\n            len >>= 1;\n        }\n        return code + len;\n    };\n    CompressedStreamWriter.prototype.huffmanDistanceCode = function (distance) {\n        var code = 0;\n        while (distance >= 4) {\n            code += 2;\n            distance >>= 1;\n        }\n        return code + distance;\n    };\n    CompressedStreamWriter.prototype.huffmanSendAllTrees = function (blTreeCodes) {\n        this.treeCodeLengths.buildCodes();\n        this.treeLiteral.buildCodes();\n        this.treeDistances.buildCodes();\n        this.pendingBufferWriteBits(this.treeLiteral.treeLength - 257, 5);\n        this.pendingBufferWriteBits(this.treeDistances.treeLength - 1, 5);\n        this.pendingBufferWriteBits(blTreeCodes - 4, 4);\n        for (var rank = 0; rank < blTreeCodes; rank++) {\n            this.pendingBufferWriteBits(this.treeCodeLengths.codeLengths[CompressorHuffmanTree.huffCodeLengthOrders[rank]], 3);\n        }\n        this.treeLiteral.writeTree(this.treeCodeLengths);\n        this.treeDistances.writeTree(this.treeCodeLengths);\n    };\n    CompressedStreamWriter.prototype.huffmanReset = function () {\n        this.bufferPosition = 0;\n        this.extraBits = 0;\n        this.treeLiteral.reset();\n        this.treeDistances.reset();\n        this.treeCodeLengths.reset();\n    };\n    CompressedStreamWriter.prototype.huffmanCompressBlock = function () {\n        for (var i = 0; i < this.bufferPosition; i++) {\n            var literalLen = this.arrLiterals[i] & 255;\n            var dist = this.arrDistances[i];\n            if (dist-- !== 0) {\n                var lc = this.huffmanLengthCode(literalLen);\n                this.treeLiteral.writeCodeToStream(lc);\n                var bits = Math.floor((lc - 261) / 4);\n                if (bits > 0 && bits <= 5) {\n                    this.pendingBufferWriteBits(literalLen & ((1 << bits) - 1), bits);\n                }\n                var dc = this.huffmanDistanceCode(dist);\n                this.treeDistances.writeCodeToStream(dc);\n                bits = Math.floor(dc / 2 - 1);\n                if (bits > 0) {\n                    this.pendingBufferWriteBits(dist & ((1 << bits) - 1), bits);\n                }\n            }\n            else {\n                this.treeLiteral.writeCodeToStream(literalLen);\n            }\n        }\n        this.treeLiteral.writeCodeToStream(256);\n    };\n    /**\n     * write bits in to internal buffer\n     * @param {number} b - source of bits\n     * @param {number} count - count of bits to write\n     */\n    CompressedStreamWriter.prototype.pendingBufferWriteBits = function (b, count) {\n        var uint = new Uint32Array(1);\n        uint[0] = this.pendingBufCache | (b << this.pendingBufBitsInCache);\n        this.pendingBufCache = uint[0];\n        this.pendingBufBitsInCache += count;\n        this.pendingBufferFlushBits();\n    };\n    CompressedStreamWriter.prototype.pendingBufferFlush = function (isClose) {\n        this.pendingBufferFlushBits();\n        if (this.pendingBufLength > 0) {\n            var array = new Uint8Array(this.pendingBufLength);\n            array.set(this.pendingBuffer.subarray(0, this.pendingBufLength), 0);\n            this.stream.push(array);\n        }\n        this.pendingBufLength = 0;\n    };\n    CompressedStreamWriter.prototype.pendingBufferFlushBits = function () {\n        var result = 0;\n        while (this.pendingBufBitsInCache >= 8 && this.pendingBufLength < (1 << 16)) {\n            this.pendingBuffer[this.pendingBufLength++] = this.pendingBufCache;\n            this.pendingBufCache >>= 8;\n            this.pendingBufBitsInCache -= 8;\n            result++;\n        }\n        return result;\n    };\n    CompressedStreamWriter.prototype.pendingBufferWriteByteBlock = function (data, offset, length) {\n        var array = data.subarray(offset, offset + length);\n        this.pendingBuffer.set(array, this.pendingBufLength);\n        this.pendingBufLength += length;\n    };\n    CompressedStreamWriter.prototype.pendingBufferWriteShort = function (s) {\n        this.pendingBuffer[this.pendingBufLength++] = s;\n        this.pendingBuffer[this.pendingBufLength++] = (s >> 8);\n    };\n    CompressedStreamWriter.prototype.pendingBufferAlignToByte = function () {\n        if (this.pendingBufBitsInCache > 0) {\n            this.pendingBuffer[this.pendingBufLength++] = this.pendingBufCache;\n        }\n        this.pendingBufCache = 0;\n        this.pendingBufBitsInCache = 0;\n    };\n    /**\n     * Huffman Tree literal calculation\n     * @private\n     */\n    CompressedStreamWriter.initHuffmanTree = function () {\n        var i = 0;\n        while (i < 144) {\n            ARR_LITERAL_CODES[i] = CompressorHuffmanTree.bitReverse((0x030 + i) << 8);\n            ARR_LITERAL_LENGTHS[i++] = 8;\n        }\n        while (i < 256) {\n            ARR_LITERAL_CODES[i] = CompressorHuffmanTree.bitReverse((0x190 - 144 + i) << 7);\n            ARR_LITERAL_LENGTHS[i++] = 9;\n        }\n        while (i < 280) {\n            ARR_LITERAL_CODES[i] = CompressorHuffmanTree.bitReverse((0x000 - 256 + i) << 9);\n            ARR_LITERAL_LENGTHS[i++] = 7;\n        }\n        while (i < 286) {\n            ARR_LITERAL_CODES[i] = CompressorHuffmanTree.bitReverse((0x0c0 - 280 + i) << 8);\n            ARR_LITERAL_LENGTHS[i++] = 8;\n        }\n        for (i = 0; i < 30; i++) {\n            ARR_DISTANCE_CODES[i] = CompressorHuffmanTree.bitReverse(i << 11);\n            ARR_DISTANCE_LENGTHS[i] = 5;\n        }\n    };\n    /**\n     * close the stream and write all pending buffer in to stream\n     * @returns {void}\n     */\n    CompressedStreamWriter.prototype.close = function () {\n        do {\n            this.pendingBufferFlush(true);\n            if (!this.compressData(true)) {\n                this.pendingBufferFlush(true);\n                this.pendingBufferAlignToByte();\n                if (!this.noWrap) {\n                    this.pendingBufferWriteShortBytes(this.checkSum >> 16);\n                    this.pendingBufferWriteShortBytes(this.checkSum & 0xffff);\n                }\n                this.pendingBufferFlush(true);\n            }\n        } while (!(this.inputEnd === this.inputOffset) ||\n            !(this.pendingBufLength === 0));\n    };\n    /**\n     * release allocated un-managed resource\n     * @returns {void}\n     */\n    CompressedStreamWriter.prototype.destroy = function () {\n        this.stream = [];\n        this.stream = undefined;\n        this.pendingBuffer = undefined;\n        this.treeLiteral = undefined;\n        this.treeDistances = undefined;\n        this.treeCodeLengths = undefined;\n        this.arrLiterals = undefined;\n        this.arrDistances = undefined;\n        this.hashHead = undefined;\n        this.hashPrevious = undefined;\n        this.dataWindow = undefined;\n        this.inputBuffer = undefined;\n        this.pendingBufLength = undefined;\n        this.pendingBufCache = undefined;\n        this.pendingBufBitsInCache = undefined;\n        this.bufferPosition = undefined;\n        this.extraBits = undefined;\n        this.currentHash = undefined;\n        this.matchStart = undefined;\n        this.matchLength = undefined;\n        this.matchPrevAvail = undefined;\n        this.blockStart = undefined;\n        this.stringStart = undefined;\n        this.lookAhead = undefined;\n        this.totalBytesIn = undefined;\n        this.inputOffset = undefined;\n        this.inputEnd = undefined;\n        this.windowSize = undefined;\n        this.windowMask = undefined;\n        this.hashSize = undefined;\n        this.hashMask = undefined;\n        this.hashShift = undefined;\n        this.maxDist = undefined;\n        this.checkSum = undefined;\n        this.noWrap = undefined;\n    };\n    CompressedStreamWriter.isHuffmanTreeInitiated = false;\n    return CompressedStreamWriter;\n}());\nexport { CompressedStreamWriter };\n/**\n * represent the Huffman Tree\n */\nvar CompressorHuffmanTree = /** @class */ (function () {\n    /**\n     * Create new Huffman Tree\n     * @param {CompressedStreamWriter} writer instance\n     * @param {number} elementCount - element count\n     * @param {number} minCodes - minimum count\n     * @param {number} maxLength - maximum count\n     */\n    function CompressorHuffmanTree(writer, elementCount, minCodes, maxLength) {\n        this.writer = writer;\n        this.codeMinCount = minCodes;\n        this.maxLength = maxLength;\n        this.codeFrequency = new Uint16Array(elementCount);\n        this.lengthCount = new Int32Array(maxLength);\n    }\n    Object.defineProperty(CompressorHuffmanTree.prototype, \"treeLength\", {\n        get: function () {\n            return this.codeCount;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(CompressorHuffmanTree.prototype, \"codeLengths\", {\n        get: function () {\n            return this.codeLength;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(CompressorHuffmanTree.prototype, \"codeFrequencies\", {\n        get: function () {\n            return this.codeFrequency;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    CompressorHuffmanTree.prototype.setStaticCodes = function (codes, lengths) {\n        var temp = new Int16Array(codes.length);\n        temp.set(codes, 0);\n        this.codes = temp;\n        var lengthTemp = new Uint8Array(lengths.length);\n        lengthTemp.set(lengths, 0);\n        this.codeLength = lengthTemp;\n    };\n    /**\n     * reset all code data in tree\n     * @returns {void}\n     */\n    CompressorHuffmanTree.prototype.reset = function () {\n        for (var i = 0; i < this.codeFrequency.length; i++) {\n            this.codeFrequency[i] = 0;\n        }\n        this.codes = undefined;\n        this.codeLength = undefined;\n    };\n    /**\n     * write code to the compressor output stream\n     * @param {number} code - code to be written\n     * @returns {void}\n     */\n    CompressorHuffmanTree.prototype.writeCodeToStream = function (code) {\n        this.writer.pendingBufferWriteBits(this.codes[code] & 0xffff, this.codeLength[code]);\n    };\n    /**\n     * calculate code from their frequencies\n     * @returns {void}\n     */\n    CompressorHuffmanTree.prototype.buildCodes = function () {\n        var nextCode = new Int32Array(this.maxLength);\n        this.codes = new Int16Array(this.codeCount);\n        var code = 0;\n        for (var bitsCount = 0; bitsCount < this.maxLength; bitsCount++) {\n            nextCode[bitsCount] = code;\n            code += this.lengthCount[bitsCount] << (15 - bitsCount);\n        }\n        for (var i = 0; i < this.codeCount; i++) {\n            var bits = this.codeLength[i];\n            if (bits > 0) {\n                this.codes[i] = CompressorHuffmanTree.bitReverse(nextCode[bits - 1]);\n                nextCode[bits - 1] += 1 << (16 - bits);\n            }\n        }\n    };\n    CompressorHuffmanTree.bitReverse = function (value) {\n        return (CompressorHuffmanTree.reverseBits[value & 15] << 12\n            | CompressorHuffmanTree.reverseBits[(value >> 4) & 15] << 8\n            | CompressorHuffmanTree.reverseBits[(value >> 8) & 15] << 4\n            | CompressorHuffmanTree.reverseBits[value >> 12]);\n    };\n    /**\n     * calculate length of compressed data\n     * @returns {number}\n     */\n    CompressorHuffmanTree.prototype.getEncodedLength = function () {\n        var len = 0;\n        for (var i = 0; i < this.codeFrequency.length; i++) {\n            len += this.codeFrequency[i] * this.codeLength[i];\n        }\n        return len;\n    };\n    /**\n     * calculate code frequencies\n     * @param {CompressorHuffmanTree} blTree\n     * @returns {void}\n     */\n    CompressorHuffmanTree.prototype.calculateBLFreq = function (blTree) {\n        var maxCount;\n        var minCount;\n        var count;\n        var curLen = -1;\n        var i = 0;\n        while (i < this.codeCount) {\n            count = 1;\n            var nextLen = this.codeLength[i];\n            if (nextLen === 0) {\n                maxCount = 138;\n                minCount = 3;\n            }\n            else {\n                maxCount = 6;\n                minCount = 3;\n                if (curLen !== nextLen) {\n                    blTree.codeFrequency[nextLen]++;\n                    count = 0;\n                }\n            }\n            curLen = nextLen;\n            i++;\n            while (i < this.codeCount && curLen === this.codeLength[i]) {\n                i++;\n                if (++count >= maxCount) {\n                    break;\n                }\n            }\n            if (count < minCount) {\n                blTree.codeFrequency[curLen] += count;\n            }\n            else if (curLen !== 0) {\n                blTree.codeFrequency[16]++;\n            }\n            else if (count <= 10) {\n                blTree.codeFrequency[17]++;\n            }\n            else {\n                blTree.codeFrequency[18]++;\n            }\n        }\n    };\n    /**\n     * @param {CompressorHuffmanTree} blTree - write tree to output stream\n     * @returns {void}\n     */\n    CompressorHuffmanTree.prototype.writeTree = function (blTree) {\n        var maxRepeatCount;\n        var minRepeatCount;\n        var currentRepeatCount;\n        var currentCodeLength = -1;\n        var i = 0;\n        while (i < this.codeCount) {\n            currentRepeatCount = 1;\n            var nextLen = this.codeLength[i];\n            if (nextLen === 0) {\n                maxRepeatCount = 138;\n                minRepeatCount = 3;\n            }\n            else {\n                maxRepeatCount = 6;\n                minRepeatCount = 3;\n                if (currentCodeLength !== nextLen) {\n                    blTree.writeCodeToStream(nextLen);\n                    currentRepeatCount = 0;\n                }\n            }\n            currentCodeLength = nextLen;\n            i++;\n            while (i < this.codeCount && currentCodeLength === this.codeLength[i]) {\n                i++;\n                if (++currentRepeatCount >= maxRepeatCount) {\n                    break;\n                }\n            }\n            if (currentRepeatCount < minRepeatCount) {\n                while (currentRepeatCount-- > 0) {\n                    blTree.writeCodeToStream(currentCodeLength);\n                }\n            }\n            else if (currentCodeLength !== 0) {\n                blTree.writeCodeToStream(16);\n                this.writer.pendingBufferWriteBits(currentRepeatCount - 3, 2);\n            }\n            else if (currentRepeatCount <= 10) {\n                blTree.writeCodeToStream(17);\n                this.writer.pendingBufferWriteBits(currentRepeatCount - 3, 3);\n            }\n            else {\n                blTree.writeCodeToStream(18);\n                this.writer.pendingBufferWriteBits(currentRepeatCount - 11, 7);\n            }\n        }\n    };\n    /**\n     * Build huffman tree\n     * @returns {void}\n     */\n    CompressorHuffmanTree.prototype.buildTree = function () {\n        var codesCount = this.codeFrequency.length;\n        var arrTree = new Int32Array(codesCount);\n        var treeLength = 0;\n        var maxCount = 0;\n        for (var n = 0; n < codesCount; n++) {\n            var freq = this.codeFrequency[n];\n            if (freq !== 0) {\n                var pos = treeLength++;\n                var pPos = 0;\n                while (pos > 0 && this.codeFrequency[arrTree[pPos = Math.floor((pos - 1) / 2)]] > freq) {\n                    arrTree[pos] = arrTree[pPos];\n                    pos = pPos;\n                }\n                arrTree[pos] = n;\n                maxCount = n;\n            }\n        }\n        while (treeLength < 2) {\n            arrTree[treeLength++] =\n                (maxCount < 2) ? ++maxCount : 0;\n        }\n        this.codeCount = Math.max(maxCount + 1, this.codeMinCount);\n        var leafsCount = treeLength;\n        var nodesCount = leafsCount;\n        var child = new Int32Array(4 * treeLength - 2);\n        var values = new Int32Array(2 * treeLength - 1);\n        for (var i = 0; i < treeLength; i++) {\n            var node = arrTree[i];\n            var iIndex = 2 * i;\n            child[iIndex] = node;\n            child[iIndex + 1] = -1;\n            values[i] = (this.codeFrequency[node] << 8);\n            arrTree[i] = i;\n        }\n        this.constructHuffmanTree(arrTree, treeLength, values, nodesCount, child);\n        this.buildLength(child);\n    };\n    CompressorHuffmanTree.prototype.constructHuffmanTree = function (arrTree, treeLength, values, nodesCount, child) {\n        do {\n            var first = arrTree[0];\n            var last = arrTree[--treeLength];\n            var lastVal = values[last];\n            var pPos = 0;\n            var path = 1;\n            while (path < treeLength) {\n                if (path + 1 < treeLength && values[arrTree[path]] > values[arrTree[path + 1]]) {\n                    path++;\n                }\n                arrTree[pPos] = arrTree[path];\n                pPos = path;\n                path = pPos * 2 + 1;\n            }\n            while ((path = pPos) > 0 && values[arrTree[pPos = Math.floor((path - 1) / 2)]] > lastVal) {\n                arrTree[path] = arrTree[pPos];\n            }\n            arrTree[path] = last;\n            var second = arrTree[0];\n            last = nodesCount++;\n            child[2 * last] = first;\n            child[2 * last + 1] = second;\n            var minDepth = Math.min(values[first] & 0xff, values[second] & 0xff);\n            values[last] = lastVal = values[first] + values[second] - minDepth + 1;\n            pPos = 0;\n            path = 1;\n            /* tslint:disable */\n            while (path < treeLength) {\n                if (path + 1 < treeLength && values[arrTree[path]] > values[arrTree[path + 1]]) {\n                    path++;\n                }\n                arrTree[pPos] = arrTree[path];\n                pPos = path;\n                path = pPos * 2 + 1;\n            } /* tslint:disable */\n            while ((path = pPos) > 0 && values[arrTree[pPos = Math.floor((path - 1) / 2)]] > lastVal) {\n                arrTree[path] = arrTree[pPos];\n            }\n            arrTree[path] = last;\n        } while (treeLength > 1);\n    };\n    CompressorHuffmanTree.prototype.buildLength = function (child) {\n        this.codeLength = new Uint8Array(this.codeFrequency.length);\n        var numNodes = Math.floor(child.length / 2);\n        var numLeafs = Math.floor((numNodes + 1) / 2);\n        var overflow = 0;\n        for (var i = 0; i < this.maxLength; i++) {\n            this.lengthCount[i] = 0;\n        }\n        overflow = this.calculateOptimalCodeLength(child, overflow, numNodes);\n        if (overflow === 0) {\n            return;\n        }\n        var iIncreasableLength = this.maxLength - 1;\n        do {\n            while (this.lengthCount[--iIncreasableLength] === 0) {\n                /* tslint:disable */\n            }\n            do {\n                this.lengthCount[iIncreasableLength]--;\n                this.lengthCount[++iIncreasableLength]++;\n                overflow -= (1 << (this.maxLength - 1 - iIncreasableLength));\n            } while (overflow > 0 && iIncreasableLength < this.maxLength - 1);\n        } while (overflow > 0);\n        this.recreateTree(child, overflow, numLeafs);\n    };\n    CompressorHuffmanTree.prototype.recreateTree = function (child, overflow, numLeafs) {\n        this.lengthCount[this.maxLength - 1] += overflow;\n        this.lengthCount[this.maxLength - 2] -= overflow;\n        var nodePtr = 2 * numLeafs;\n        for (var bits = this.maxLength; bits !== 0; bits--) {\n            var n = this.lengthCount[bits - 1];\n            while (n > 0) {\n                var childPtr = 2 * child[nodePtr++];\n                if (child[childPtr + 1] === -1) {\n                    this.codeLength[child[childPtr]] = bits;\n                    n--;\n                }\n            }\n        }\n    };\n    CompressorHuffmanTree.prototype.calculateOptimalCodeLength = function (child, overflow, numNodes) {\n        var lengths = new Int32Array(numNodes);\n        lengths[numNodes - 1] = 0;\n        for (var i = numNodes - 1; i >= 0; i--) {\n            var childIndex = 2 * i + 1;\n            if (child[childIndex] !== -1) {\n                var bitLength = lengths[i] + 1;\n                if (bitLength > this.maxLength) {\n                    bitLength = this.maxLength;\n                    overflow++;\n                }\n                lengths[child[childIndex - 1]] = lengths[child[childIndex]] = bitLength;\n            }\n            else {\n                var bitLength = lengths[i];\n                this.lengthCount[bitLength - 1]++;\n                this.codeLength[child[childIndex - 1]] = lengths[i];\n            }\n        }\n        return overflow;\n    };\n    CompressorHuffmanTree.reverseBits = [0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15];\n    CompressorHuffmanTree.huffCodeLengthOrders = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];\n    return CompressorHuffmanTree;\n}());\nexport { CompressorHuffmanTree };\n/**\n * Checksum calculator, based on Adler32 algorithm.\n */\nvar ChecksumCalculator = /** @class */ (function () {\n    function ChecksumCalculator() {\n    }\n    /**\n     * Updates checksum by calculating checksum of the\n     * given buffer and adding it to current value.\n     * @param {number} checksum - current checksum.\n     * @param {Uint8Array} buffer - data byte array.\n     * @param {number} offset - offset in the buffer.\n     * @param {number} length - length of data to be used from the stream.\n     * @returns {number}\n     */\n    ChecksumCalculator.checksumUpdate = function (checksum, buffer, offset, length) {\n        var uint = new Uint32Array(1);\n        uint[0] = checksum;\n        var checksum_uint = uint[0];\n        var s1 = uint[0] = checksum_uint & 65535;\n        var s2 = uint[0] = checksum_uint >> ChecksumCalculator.checkSumBitOffset;\n        while (length > 0) {\n            var steps = Math.min(length, ChecksumCalculator.checksumIterationCount);\n            length -= steps;\n            while (--steps >= 0) {\n                s1 = s1 + (uint[0] = (buffer[offset++] & 255));\n                s2 = s2 + s1;\n            }\n            s1 %= ChecksumCalculator.checksumBase;\n            s2 %= ChecksumCalculator.checksumBase;\n        }\n        checksum_uint = (s2 << ChecksumCalculator.checkSumBitOffset) | s1;\n        return checksum_uint;\n    };\n    ChecksumCalculator.checkSumBitOffset = 16;\n    ChecksumCalculator.checksumBase = 65521;\n    ChecksumCalculator.checksumIterationCount = 3800;\n    return ChecksumCalculator;\n}());\nexport { ChecksumCalculator };\n/* eslint-enable */ \n","/* eslint-disable */\nimport { Utils } from './index';\nvar DecompressorHuffmanTree = /** @class */ (function () {\n    function DecompressorHuffmanTree(lengths) {\n        this.buildTree(lengths);\n    }\n    DecompressorHuffmanTree.init = function () {\n        var lengths;\n        var index;\n        // Generate huffman tree for lengths.\n        lengths = new Uint8Array(288);\n        index = 0;\n        while (index < 144) {\n            lengths[index++] = 8;\n        }\n        while (index < 256) {\n            lengths[index++] = 9;\n        }\n        while (index < 280) {\n            lengths[index++] = 7;\n        }\n        while (index < 288) {\n            lengths[index++] = 8;\n        }\n        DecompressorHuffmanTree.m_LengthTree = new DecompressorHuffmanTree(lengths);\n        // Generate huffman tree for distances.\n        lengths = new Uint8Array(32);\n        index = 0;\n        while (index < 32) {\n            lengths[index++] = 5;\n        }\n        DecompressorHuffmanTree.m_DistanceTree = new DecompressorHuffmanTree(lengths);\n    };\n    /// <summary>\n    /// Prepares data for generating huffman tree.\n    /// </summary>\n    /// <param name=\"blCount\">Array of counts of each code length.</param>\n    /// <param name=\"nextCode\">Numerical values of the smallest code for each code length.</param>\n    /// <param name=\"lengths\">Array of code lengths.</param>\n    /// <param name=\"treeSize\">Calculated tree size.</param>\n    /// <returns>Code.</returns>\n    DecompressorHuffmanTree.prototype.prepareData = function (blCount, nextCode, lengths) {\n        var code = 0;\n        var treeSize = 512;\n        // Count number of codes for each code length.\n        for (var i = 0; i < lengths.length; i++) {\n            var length_1 = lengths[i];\n            if (length_1 > 0) {\n                blCount[length_1]++;\n            }\n        }\n        for (var bits = 1; bits <= DecompressorHuffmanTree.MAX_BITLEN; bits++) {\n            nextCode[bits] = code;\n            code += blCount[bits] << (16 - bits);\n            if (bits >= 10) {\n                var start = nextCode[bits] & 0x1ff80;\n                var end = code & 0x1ff80;\n                treeSize += (end - start) >> (16 - bits);\n            }\n        }\n        /*      if( code != 65536 )\n          throw new ZipException( \"Code lengths don't add up properly.\" );*/\n        return { 'code': code, 'treeSize': treeSize };\n    };\n    /// <summary>\n    /// Generates huffman tree.\n    /// </summary>\n    /// <param name=\"blCount\">Array of counts of each code length.</param>\n    /// <param name=\"nextCode\">Numerical values of the smallest code for each code length.</param>\n    /// <param name=\"code\">Precalculated code.</param>\n    /// <param name=\"lengths\">Array of code lengths.</param>\n    /// <param name=\"treeSize\">Calculated size of the tree.</param>\n    /// <returns>Generated tree.</returns>\n    DecompressorHuffmanTree.prototype.treeFromData = function (blCount, nextCode, lengths, code, treeSize) {\n        var tree = new Int16Array(treeSize);\n        var pointer = 512;\n        var increment = 1 << 7;\n        for (var bits = DecompressorHuffmanTree.MAX_BITLEN; bits >= 10; bits--) {\n            var end = code & 0x1ff80;\n            code -= blCount[bits] << (16 - bits);\n            var start = code & 0x1ff80;\n            for (var i = start; i < end; i += increment) {\n                tree[Utils.bitReverse(i)] = Utils.bitConverterInt32ToInt16((-pointer << 4) | bits);\n                pointer += 1 << (bits - 9);\n            }\n        }\n        for (var i = 0; i < lengths.length; i++) {\n            var bits = lengths[i];\n            if (bits == 0) {\n                continue;\n            }\n            code = nextCode[bits];\n            var revcode = Utils.bitReverse(code);\n            if (bits <= 9) {\n                do {\n                    tree[revcode] = Utils.bitConverterInt32ToInt16((i << 4) | bits);\n                    revcode += 1 << bits;\n                } while (revcode < 512);\n            }\n            else {\n                var subTree = tree[revcode & 511];\n                var treeLen = 1 << (subTree & 15);\n                subTree = -(subTree >> 4);\n                do {\n                    tree[subTree | (revcode >> 9)] = Utils.bitConverterInt32ToInt16((i << 4) | bits);\n                    revcode += 1 << bits;\n                } while (revcode < treeLen);\n            }\n            nextCode[bits] = code + (1 << (16 - bits));\n        }\n        return tree;\n    };\n    /// <summary>\n    /// Builds huffman tree from array of code lengths.\n    /// </summary>\n    /// <param name=\"lengths\">Array of code lengths.</param>\n    DecompressorHuffmanTree.prototype.buildTree = function (lengths) {\n        // Count of codes for each code length.\n        var blCount = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];\n        // Numerical value of the smallest code for each code length.\n        var nextCode = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];\n        var prepareData = this.prepareData(blCount, nextCode, lengths);\n        this.m_Tree = this.treeFromData(blCount, nextCode, lengths, prepareData.code, prepareData.treeSize);\n    };\n    /// <summary>\n    /// Reads and decompresses one symbol.\n    /// </summary>\n    /// <param name=\"input\"></param>\n    /// <returns></returns>\n    DecompressorHuffmanTree.prototype.unpackSymbol = function (input) {\n        var lookahead;\n        var symbol;\n        if ((lookahead = input.peekBits(9)) >= 0) {\n            if ((symbol = this.m_Tree[lookahead]) >= 0) {\n                input.skipBits((symbol & 15));\n                return symbol >> 4;\n            }\n            var subtree = -(symbol >> 4);\n            var bitlen = symbol & 15;\n            if ((lookahead = input.peekBits(bitlen)) >= 0) {\n                symbol = this.m_Tree[subtree | (lookahead >> 9)];\n                input.skipBits((symbol & 15));\n                return symbol >> 4;\n            }\n            else {\n                var bits = input.availableBits;\n                lookahead = input.peekBits(bits);\n                symbol = this.m_Tree[subtree | (lookahead >> 9)];\n                if ((symbol & 15) <= bits) {\n                    input.skipBits((symbol & 15));\n                    return symbol >> 4;\n                }\n                else {\n                    return -1;\n                }\n            }\n        }\n        else {\n            var bits = input.availableBits;\n            lookahead = input.peekBits(bits);\n            symbol = this.m_Tree[lookahead];\n            if (symbol >= 0 && (symbol & 15) <= bits) {\n                input.skipBits((symbol & 15));\n                return symbol >> 4;\n            }\n            else {\n                return -1;\n            }\n        }\n    };\n    Object.defineProperty(DecompressorHuffmanTree, \"lengthTree\", {\n        /// <summary>\n        /// GET huffman tree for encoding and decoding lengths.\n        /// </summary>\n        get: function () {\n            return this.m_LengthTree;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(DecompressorHuffmanTree, \"distanceTree\", {\n        /// <summary>\n        /// GET huffman tree for encoding and decoding distances.\n        /// </summary>\n        get: function () {\n            return this.m_DistanceTree;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    /// <summary>\n    /// Maximum count of bits.\n    /// </summary>\n    DecompressorHuffmanTree.MAX_BITLEN = 15;\n    return DecompressorHuffmanTree;\n}());\nexport { DecompressorHuffmanTree };\n/* eslint-enable */ \n","/* eslint-disable */\n/// <summary>\n/// Checksum calculator, based on Adler32 algorithm.\n/// </summary>\nvar ChecksumCalculator = /** @class */ (function () {\n    function ChecksumCalculator() {\n    }\n    /// <summary>\n    /// Updates checksum by calculating checksum of the\n    /// given buffer and adding it to current value.\n    /// </summary>\n    /// <param name=\"checksum\">Current checksum.</param>\n    /// <param name=\"buffer\">Data byte array.</param>\n    /// <param name=\"offset\">Offset in the buffer.</param>\n    /// <param name=\"length\">Length of data to be used from the stream.</param>\n    ChecksumCalculator.ChecksumUpdate = function (checksum, buffer, offset, length) {\n        var checkSumUInt = checksum;\n        var s1 = checkSumUInt & 65535;\n        var s2 = checkSumUInt >> this.DEF_CHECKSUM_BIT_OFFSET;\n        while (length > 0) {\n            var steps = Math.min(length, this.DEF_CHECKSUM_ITERATIONSCOUNT);\n            length -= steps;\n            while (--steps >= 0) {\n                s1 = s1 + (buffer[offset++] & 255);\n                s2 = s2 + s1;\n            }\n            s1 %= this.DEF_CHECKSUM_BASE;\n            s2 %= this.DEF_CHECKSUM_BASE;\n        }\n        checkSumUInt = (s2 << this.DEF_CHECKSUM_BIT_OFFSET) | s1;\n        checksum = checkSumUInt;\n    };\n    /// <summary>\n    /// Generates checksum by calculating checksum of the\n    /// given buffer.\n    /// </summary>\n    /// <param name=\"buffer\">Data byte array.</param>\n    /// <param name=\"offset\">Offset in the buffer.</param>\n    /// <param name=\"length\">Length of data to be used from the stream.</param>\n    ChecksumCalculator.ChecksumGenerate = function (buffer, offset, length) {\n        var result = 1;\n        ChecksumCalculator.ChecksumUpdate(result, buffer, offset, length);\n        return result;\n    };\n    /// <summary>\n    /// Bits offset, used in adler checksum calculation.\n    /// </summary>\n    ChecksumCalculator.DEF_CHECKSUM_BIT_OFFSET = 16;\n    /// <summary>\n    /// Lagrest prime, less than 65535\n    /// </summary>\n    ChecksumCalculator.DEF_CHECKSUM_BASE = 65521;\n    /// <summary>\n    /// Count of iteration used in calculated of the adler checksumm.\n    /// </summary>\n    ChecksumCalculator.DEF_CHECKSUM_ITERATIONSCOUNT = 3800;\n    return ChecksumCalculator;\n}());\nexport { ChecksumCalculator };\n/* eslint-enable */ \n","/* eslint-disable */\nimport { DecompressorHuffmanTree } from './decompressor-huffman-tree';\nimport { Utils } from './utils';\nimport { ChecksumCalculator } from './checksum-calculator';\nvar CompressedStreamReader = /** @class */ (function () {\n    function CompressedStreamReader(stream, bNoWrap) {\n        /// <summary>\n        /// Code lengths for the code length alphabet.\n        /// </summary>\n        this.defaultHuffmanDynamicTree = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];\n        /// <summary>\n        /// Mask for compression method to be decoded from 16-bit header.\n        /// </summary>\n        this.DEF_HEADER_METHOD_MASK = 15 << 8;\n        /// <summary>\n        /// Mask for compression info to be decoded from 16-bit header.\n        /// </summary>\n        this.DEF_HEADER_INFO_MASK = 240 << 8;\n        /// <summary>\n        /// Mask for check bits to be decoded from 16-bit header.\n        /// </summary>\n        this.DEF_HEADER_FLAGS_FCHECK = 31;\n        /// <summary>\n        /// Mask for dictionary presence to be decoded from 16-bit header.\n        /// </summary>\n        this.DEF_HEADER_FLAGS_FDICT = 32;\n        /// <summary>\n        /// Mask for compression level to be decoded from 16-bit header.\n        /// </summary>\n        this.DEF_HEADER_FLAGS_FLEVEL = 192;\n        /// <summary>\n        /// Maximum size of the data window.\n        /// </summary>\n        this.DEF_MAX_WINDOW_SIZE = 65535;\n        /// <summary>\n        /// Maximum length of the repeatable block.\n        /// </summary>\n        this.DEF_HUFFMAN_REPEATE_MAX = 258;\n        /// <summary>\n        /// End of the block sign.\n        /// </summary>\n        this.DEF_HUFFMAN_END_BLOCK = 256;\n        /// <summary>\n        /// Minimal length code.\n        /// </summary>\n        this.DEF_HUFFMAN_LENGTH_MINIMUMCODE = 257;\n        /// <summary>\n        /// Maximal length code.\n        /// </summary>\n        this.DEF_HUFFMAN_LENGTH_MAXIMUMCODE = 285;\n        /// <summary>\n        /// Maximal distance code.\n        /// </summary>\n        this.DEF_HUFFMAN_DISTANCE_MAXIMUMCODE = 29;\n        /// <summary>\n        /// Currently calculated checksum,\n        /// based on Adler32 algorithm.\n        /// </summary>\n        this.mCheckSum = 1;\n        /// <summary>\n        /// Currently read 4 bytes.\n        /// </summary>\n        this.tBuffer = 0;\n        /// <summary>\n        /// Count of bits that are in buffer.\n        /// </summary>\n        this.mBufferedBits = 0;\n        /// <summary>\n        /// Temporary buffer.\n        /// </summary>\n        this.mTempBuffer = new Uint8Array(4);\n        /// <summary>\n        /// 32k buffer for unpacked data.\n        /// </summary>\n        this.mBlockBuffer = new Uint8Array(this.DEF_MAX_WINDOW_SIZE);\n        /// <summary>\n        /// No wrap mode.\n        /// </summary>\n        this.mbNoWrap = false;\n        /// <summary>\n        /// Window size, can not be larger than 32k.\n        /// </summary>\n        this.mWindowSize = 0;\n        /// <summary>\n        /// Current position in output stream.\n        /// Current in-block position can be extracted by applying Int16.MaxValue mask.\n        /// </summary>\n        this.mCurrentPosition = 0;\n        /// <summary>\n        /// Data length.\n        /// Current in-block position can be extracted by applying Int16.MaxValue mask.\n        /// </summary>\n        this.mDataLength = 0;\n        /// <summary>\n        /// Specifies wheather next block can to be read.\n        /// Reading can be denied because the header of the last block have been read.\n        /// </summary>\n        this.mbCanReadNextBlock = true;\n        /// <summary>\n        /// Specifies wheather user can read more data from stream.\n        /// </summary>\n        this.mbCanReadMoreData = true;\n        /// <summary>\n        /// Specifies wheather checksum has been read.\n        /// </summary>\n        this.mbCheckSumRead = false;\n        if (stream == null) {\n            throw new DOMException('stream');\n        }\n        if (stream.length === 0) {\n            throw new DOMException('stream - string can not be empty');\n        }\n        DecompressorHuffmanTree.init();\n        this.mInputStream = new Stream(stream);\n        this.mbNoWrap = bNoWrap;\n        if (!this.mbNoWrap) {\n            this.readZLibHeader();\n        }\n        this.decodeBlockHeader();\n    }\n    Object.defineProperty(CompressedStreamReader.prototype, \"mBuffer\", {\n        get: function () {\n            return this.tBuffer;\n        },\n        set: function (value) {\n            this.tBuffer = value;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    /**\n     * Initializes compressor and writes ZLib header if needed.\n     * @param {boolean} noWrap - optional if true, ZLib header and checksum will not be written.\n     */\n    /// <summary>\n    /// Reads specified count of bits without adjusting position.\n    /// </summary>\n    /// <param name=\"count\">Count of bits to be read.</param>\n    /// <returns>Read value.</returns>\n    CompressedStreamReader.prototype.peekBits = function (count) {\n        if (count < 0) {\n            throw new DOMException('count', 'Bits count can not be less than zero.');\n        }\n        if (count > 32) {\n            throw new DOMException('count', 'Count of bits is too large.');\n        }\n        // If buffered data is not enough to give result,\n        // fill buffer.\n        if (this.mBufferedBits < count) {\n            this.fillBuffer();\n        }\n        // If you want to read 4 bytes and there is partial data in\n        // buffer, than you will fail.\n        if (this.mBufferedBits < count) {\n            return -1;\n        }\n        // Create bitmask for reading of count bits\n        var bitMask = ~(4294967295 << count);\n        var result = Utils.bitConverterUintToInt32(this.mBuffer & bitMask);\n        //Debug.WriteLine( /*new string( ' ', 32 - mBufferedBits + (int)( ( 32 - mBufferedBits ) / 8 ) ) + BitsToString( (int)mBuffer, mBufferedBits ) + \" \" + BitsToString( result, count ) +*/ \" \" + result.ToString() );\n        return result;\n    };\n    CompressedStreamReader.prototype.fillBuffer = function () {\n        var length = 4 - (this.mBufferedBits >> 3) -\n            (((this.mBufferedBits & 7) !== 0) ? 1 : 0);\n        if (length === 0) {\n            return;\n        }\n        //TODO: fix this\n        var bytesRead = this.mInputStream.read(this.mTempBuffer, 0, length);\n        for (var i = 0; i < bytesRead; i++) {\n            this.mBuffer = Utils.bitConverterInt32ToUint(this.mBuffer |\n                (Utils.bitConverterInt32ToUint(this.mTempBuffer[i] << this.mBufferedBits)));\n            this.mBufferedBits += 8;\n        }\n        //TODO: fix this\n    };\n    /// <summary>\n    /// Skips specified count of bits.\n    /// </summary>\n    /// <param name=\"count\">Count of bits to be skipped.</param>\n    CompressedStreamReader.prototype.skipBits = function (count) {\n        if (count < 0) {\n            throw new DOMException('count', 'Bits count can not be less than zero.');\n        }\n        if (count === 0) {\n            return;\n        }\n        if (count >= this.mBufferedBits) {\n            count -= this.mBufferedBits;\n            this.mBufferedBits = 0;\n            this.mBuffer = 0;\n            // if something left, skip it.\n            if (count > 0) {\n                // Skip entire bytes.\n                this.mInputStream.position += (count >> 3); //TODO: fix this\n                count &= 7;\n                // Skip bits.\n                if (count > 0) {\n                    this.fillBuffer();\n                    this.mBufferedBits -= count;\n                    this.mBuffer = Utils.bitConverterInt32ToUint(this.mBuffer >>> count);\n                }\n            }\n        }\n        else {\n            this.mBufferedBits -= count;\n            this.mBuffer = Utils.bitConverterInt32ToUint(this.mBuffer >>> count);\n        }\n    };\n    Object.defineProperty(CompressedStreamReader.prototype, \"availableBits\", {\n        get: function () {\n            return this.mBufferedBits;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    /// <summary>\n    /// Reads ZLib header with compression method and flags.\n    /// </summary>\n    CompressedStreamReader.prototype.readZLibHeader = function () {\n        // first 8 bits - compression Method and flags\n        // 8 other - flags\n        var header = this.readInt16();\n        //Debug.WriteLine( BitsToString( header ) );\n        if (header === -1) {\n            throw new DOMException('Header of the stream can not be read.');\n        }\n        if (header % 31 !== 0) {\n            throw new DOMException('Header checksum illegal');\n        }\n        if ((header & this.DEF_HEADER_METHOD_MASK) !== (8 << 8)) {\n            throw new DOMException('Unsupported compression method.');\n        }\n        this.mWindowSize = Math.pow(2, ((header & this.DEF_HEADER_INFO_MASK) >> 12) + 8);\n        if (this.mWindowSize > 65535) {\n            throw new DOMException('Unsupported window size for deflate compression method.');\n        }\n        if ((header & this.DEF_HEADER_FLAGS_FDICT) >> 5 === 1) {\n            // Get dictionary.\n            throw new DOMException('Custom dictionary is not supported at the moment.');\n        }\n    };\n    /// <summary>\n    /// TODO: place correct comment here\n    /// </summary>\n    /// <returns>\n    /// TODO: place correct comment here\n    /// </returns>\n    CompressedStreamReader.prototype.readInt16 = function () {\n        var result = (this.readBits(8) << 8);\n        result |= this.readBits(8);\n        return result;\n    };\n    /// <summary>\n    /// Reads specified count of bits from stream.\n    /// </summary>\n    /// <param name=\"count\">Count of bits to be read.</param>\n    /// <returns>\n    /// TODO: place correct comment here\n    /// </returns>\n    CompressedStreamReader.prototype.readBits = function (count) {\n        var result = this.peekBits(count);\n        if (result === -1) {\n            return -1;\n        }\n        this.mBufferedBits -= count;\n        this.mBuffer = Utils.bitConverterInt32ToUint(this.mBuffer >>> count);\n        return result;\n    };\n    /// <summary>\n    /// Reads and decodes block of data.\n    /// </summary>\n    /// <returns>True if buffer was empty and new data was read, otherwise - False.</returns>\n    CompressedStreamReader.prototype.decodeBlockHeader = function () {\n        if (!this.mbCanReadNextBlock) {\n            return false;\n        }\n        var bFinalBlock = this.readBits(1);\n        if (bFinalBlock === -1) {\n            return false;\n        }\n        var blockType = this.readBits(2);\n        if (blockType === -1) {\n            return false;\n        }\n        this.mbCanReadNextBlock = (bFinalBlock === 0);\n        //      ChecksumReset();\n        switch (blockType) {\n            case 0:\n                // Uncompressed data\n                this.mbReadingUncompressed = true;\n                this.skipToBoundary();\n                var length_1 = this.readInt16Inverted();\n                var lengthComplement = this.readInt16Inverted();\n                if (length_1 !== (lengthComplement ^ 0xffff)) {\n                    throw new DOMException('Wrong block length.');\n                }\n                if (length_1 > 65535) {\n                    throw new DOMException('Uncompressed block length can not be more than 65535.');\n                }\n                this.mUncompressedDataLength = length_1;\n                this.mCurrentLengthTree = null;\n                this.mCurrentDistanceTree = null;\n                break;\n            case 1:\n                // Compressed data with fixed huffman codes.\n                this.mbReadingUncompressed = false;\n                this.mUncompressedDataLength = -1;\n                this.mCurrentLengthTree = DecompressorHuffmanTree.lengthTree;\n                this.mCurrentDistanceTree = DecompressorHuffmanTree.distanceTree;\n                break;\n            case 2:\n                // Compressed data with dynamic huffman codes.\n                this.mbReadingUncompressed = false;\n                this.mUncompressedDataLength = -1;\n                var trees = this.decodeDynamicHeader(this.mCurrentLengthTree, this.mCurrentDistanceTree);\n                this.mCurrentLengthTree = trees.lengthTree;\n                this.mCurrentDistanceTree = trees.distanceTree;\n                break;\n            default:\n                throw new DOMException('Wrong block type.');\n        }\n        return true;\n    };\n    /// <summary>\n    /// Discards left-most partially used byte.\n    /// </summary>\n    CompressedStreamReader.prototype.skipToBoundary = function () {\n        this.mBuffer = Utils.bitConverterInt32ToUint(this.mBuffer >>> (this.mBufferedBits & 7));\n        this.mBufferedBits &= ~7;\n    };\n    /// <summary>\n    /// TODO: place correct comment here\n    /// </summary>\n    /// <returns>\n    /// TODO: place correct comment here\n    /// </returns>\n    CompressedStreamReader.prototype.readInt16Inverted = function () {\n        var result = (this.readBits(8));\n        result |= this.readBits(8) << 8;\n        return result;\n    };\n    /// <summary>\n    /// Reades dynamic huffman codes from block header.\n    /// </summary>\n    /// <param name=\"lengthTree\">Literals/Lengths tree.</param>\n    /// <param name=\"distanceTree\">Distances tree.</param>\n    CompressedStreamReader.prototype.decodeDynamicHeader = function (lengthTree, distanceTree) {\n        var bLastSymbol = 0;\n        var iLengthsCount = this.readBits(5);\n        var iDistancesCount = this.readBits(5);\n        var iCodeLengthsCount = this.readBits(4);\n        if (iLengthsCount < 0 || iDistancesCount < 0 || iCodeLengthsCount < 0) {\n            throw new DOMException('Wrong dynamic huffman codes.');\n        }\n        iLengthsCount += 257;\n        iDistancesCount += 1;\n        var iResultingCodeLengthsCount = iLengthsCount + iDistancesCount;\n        var arrResultingCodeLengths = new Uint8Array(iResultingCodeLengthsCount);\n        var arrDecoderCodeLengths = new Uint8Array(19);\n        iCodeLengthsCount += 4;\n        var iCurrentCode = 0;\n        while (iCurrentCode < iCodeLengthsCount) {\n            var len = this.readBits(3);\n            if (len < 0) {\n                throw new DOMException('Wrong dynamic huffman codes.');\n            }\n            arrDecoderCodeLengths[this.defaultHuffmanDynamicTree[iCurrentCode++]] = len;\n        }\n        var treeInternalDecoder = new DecompressorHuffmanTree(arrDecoderCodeLengths);\n        iCurrentCode = 0;\n        for (;;) {\n            var symbol = void 0;\n            var bNeedBreak = false;\n            symbol = treeInternalDecoder.unpackSymbol(this);\n            while ((symbol & ~15) === 0) {\n                arrResultingCodeLengths[iCurrentCode++] = bLastSymbol = symbol;\n                if (iCurrentCode === iResultingCodeLengthsCount) {\n                    bNeedBreak = true;\n                    break;\n                }\n                symbol = treeInternalDecoder.unpackSymbol(this);\n            }\n            if (bNeedBreak) {\n                break;\n            }\n            if (symbol < 0) {\n                throw new DOMException('Wrong dynamic huffman codes.');\n            }\n            if (symbol >= 17) {\n                bLastSymbol = 0;\n            }\n            else if (iCurrentCode === 0) {\n                throw new DOMException('Wrong dynamic huffman codes.');\n            }\n            var miRepSymbol = symbol - 16;\n            var bits = CompressedStreamReader.DEF_HUFFMAN_DYNTREE_REPEAT_BITS[miRepSymbol];\n            var count = this.readBits(bits);\n            if (count < 0) {\n                throw new DOMException('Wrong dynamic huffman codes.');\n            }\n            count += CompressedStreamReader.DEF_HUFFMAN_DYNTREE_REPEAT_MINIMUMS[miRepSymbol];\n            if (iCurrentCode + count > iResultingCodeLengthsCount) {\n                throw new DOMException('Wrong dynamic huffman codes.');\n            }\n            while (count-- > 0) {\n                arrResultingCodeLengths[iCurrentCode++] = bLastSymbol;\n            }\n            if (iCurrentCode === iResultingCodeLengthsCount) {\n                break;\n            }\n        }\n        var tempArray = new Uint8Array(iLengthsCount);\n        tempArray.set(arrResultingCodeLengths.subarray(0, iLengthsCount), 0);\n        //sourceArray, sourceIndex, destinationArray, destinationIndex, length\n        //Array.copy( arrResultingCodeLengths, 0, tempArray, 0, iLengthsCount );\n        lengthTree = new DecompressorHuffmanTree(tempArray);\n        tempArray = arrResultingCodeLengths.slice(iLengthsCount, iLengthsCount + iDistancesCount);\n        //Array.copy( arrResultingCodeLengths, iLengthsCount, tempArray, 0, iDistancesCount );\n        distanceTree = new DecompressorHuffmanTree(tempArray);\n        return { 'lengthTree': lengthTree, 'distanceTree': distanceTree };\n    };\n    /// <summary>\n    /// Decodes huffman codes.\n    /// </summary>\n    /// <returns>True if some data was read.</returns>\n    CompressedStreamReader.prototype.readHuffman = function () {\n        var free = this.DEF_MAX_WINDOW_SIZE - (this.mDataLength - this.mCurrentPosition);\n        var dataRead = false;\n        //long maxdistance = DEF_MAX_WINDOW_SIZE >> 1;\n        var readdata = {};\n        // DEF_HUFFMAN_REPEATE_MAX - longest repeatable block, we should always reserve space for it because\n        // if we should not, we will have buffer overrun.\n        while (free >= this.DEF_HUFFMAN_REPEATE_MAX) {\n            var symbol = void 0;\n            symbol = this.mCurrentLengthTree.unpackSymbol(this);\n            // Only codes 0..255 are valid independent symbols.\n            while (((symbol) & ~0xff) === 0) {\n                readdata[(this.mDataLength + 1) % this.DEF_MAX_WINDOW_SIZE] = symbol;\n                this.mBlockBuffer[this.mDataLength++ % this.DEF_MAX_WINDOW_SIZE] = symbol;\n                dataRead = true;\n                if (--free < this.DEF_HUFFMAN_REPEATE_MAX) {\n                    return true;\n                }\n                //if( (mDataLength - mCurrentPosition ) < maxdistance ) return true;\n                symbol = this.mCurrentLengthTree.unpackSymbol(this);\n            }\n            if (symbol < this.DEF_HUFFMAN_LENGTH_MINIMUMCODE) {\n                if (symbol < this.DEF_HUFFMAN_END_BLOCK) {\n                    throw new DOMException('Illegal code.');\n                }\n                var numDataRead = dataRead ? 1 : 0;\n                this.mbCanReadMoreData = this.decodeBlockHeader();\n                var numReadMore = (this.mbCanReadMoreData) ? 1 : 0;\n                return (numDataRead | numReadMore) ? true : false;\n            }\n            if (symbol > this.DEF_HUFFMAN_LENGTH_MAXIMUMCODE) {\n                throw new DOMException('Illegal repeat code length.');\n            }\n            var iRepeatLength = CompressedStreamReader.DEF_HUFFMAN_REPEAT_LENGTH_BASE[symbol -\n                this.DEF_HUFFMAN_LENGTH_MINIMUMCODE];\n            var iRepeatExtraBits = CompressedStreamReader.DEF_HUFFMAN_REPEAT_LENGTH_EXTENSION[symbol -\n                this.DEF_HUFFMAN_LENGTH_MINIMUMCODE];\n            if (iRepeatExtraBits > 0) {\n                var extra = this.readBits(iRepeatExtraBits);\n                if (extra < 0) {\n                    throw new DOMException('Wrong data.');\n                }\n                iRepeatLength += extra;\n            }\n            // Unpack repeat distance.\n            symbol = this.mCurrentDistanceTree.unpackSymbol(this);\n            if (symbol < 0 || symbol > CompressedStreamReader.DEF_HUFFMAN_REPEAT_DISTANCE_BASE.length) {\n                throw new DOMException('Wrong distance code.');\n            }\n            var iRepeatDistance = CompressedStreamReader.DEF_HUFFMAN_REPEAT_DISTANCE_BASE[symbol];\n            iRepeatExtraBits = CompressedStreamReader.DEF_HUFFMAN_REPEAT_DISTANCE_EXTENSION[symbol];\n            if (iRepeatExtraBits > 0) {\n                var extra = this.readBits(iRepeatExtraBits);\n                if (extra < 0) {\n                    throw new DOMException('Wrong data.');\n                }\n                iRepeatDistance += extra;\n            }\n            // Copy data in slow repeat mode\n            for (var i = 0; i < iRepeatLength; i++) {\n                this.mBlockBuffer[this.mDataLength % this.DEF_MAX_WINDOW_SIZE] =\n                    this.mBlockBuffer[(this.mDataLength - iRepeatDistance) % this.DEF_MAX_WINDOW_SIZE];\n                this.mDataLength++;\n                free--;\n            }\n            dataRead = true;\n        }\n        return dataRead;\n    };\n    /// <summary>\n    /// Reads data to buffer.\n    /// </summary>\n    /// <param name=\"buffer\">Output buffer for data.</param>\n    /// <param name=\"offset\">Offset in output data.</param>\n    /// <param name=\"length\">Length of the data to be read.</param>\n    /// <returns>Count of bytes actually read.</returns>\n    CompressedStreamReader.prototype.read = function (buffer, offset, length) {\n        if (buffer == null) {\n            throw new DOMException('buffer');\n        }\n        if (offset < 0 || offset > buffer.length - 1) {\n            throw new DOMException('offset', 'Offset does not belong to specified buffer.');\n        }\n        if (length < 0 || length > buffer.length - offset) {\n            throw new DOMException('length', 'Length is illegal.');\n        }\n        var initialLength = length;\n        while (length > 0) {\n            // Read from internal buffer.\n            if (this.mCurrentPosition < this.mDataLength) {\n                // Position in buffer array.\n                var inBlockPosition = (this.mCurrentPosition % this.DEF_MAX_WINDOW_SIZE);\n                // We can not read more than we have in buffer at once,\n                // and we not read more than till the array end.\n                var dataToCopy = Math.min(this.DEF_MAX_WINDOW_SIZE - inBlockPosition, (this.mDataLength - this.mCurrentPosition));\n                // Reading not more, than the rest of the buffer.\n                dataToCopy = Math.min(dataToCopy, length);\n                //sourceArray, sourceIndex, destinationArray, destinationIndex, length\n                // Copy data.\n                //Array.Copy( mBlockBuffer, inBlockPosition, buffer, offset, dataToCopy );\n                //buffer.set(this.mBlockBuffer.slice(inBlockPosition, dataToCopy), offset);\n                Utils.arrayCopy(this.mBlockBuffer, inBlockPosition, buffer, offset, dataToCopy);\n                // Correct position, length,\n                this.mCurrentPosition += dataToCopy;\n                offset += dataToCopy;\n                length -= dataToCopy;\n            }\n            else {\n                if (!this.mbCanReadMoreData) {\n                    break;\n                }\n                var oldDataLength = this.mDataLength;\n                if (!this.mbReadingUncompressed) {\n                    if (!this.readHuffman()) {\n                        break;\n                    }\n                }\n                else {\n                    if (this.mUncompressedDataLength === 0) {\n                        // If there is no more data in stream, just exit.\n                        this.mbCanReadMoreData = this.decodeBlockHeader();\n                        if (!(this.mbCanReadMoreData)) {\n                            break;\n                        }\n                    }\n                    else {\n                        // Position of the data end in block buffer.\n                        var inBlockPosition = (this.mDataLength % this.DEF_MAX_WINDOW_SIZE);\n                        var dataToRead = Math.min(this.mUncompressedDataLength, this.DEF_MAX_WINDOW_SIZE - inBlockPosition);\n                        var dataRead = this.readPackedBytes(this.mBlockBuffer, inBlockPosition, dataToRead);\n                        if (dataToRead !== dataRead) {\n                            throw new DOMException('Not enough data in stream.');\n                        }\n                        this.mUncompressedDataLength -= dataRead;\n                        this.mDataLength += dataRead;\n                    }\n                }\n                if (oldDataLength < this.mDataLength) {\n                    var start = (oldDataLength % this.DEF_MAX_WINDOW_SIZE);\n                    var end = (this.mDataLength % this.DEF_MAX_WINDOW_SIZE);\n                    if (start < end) {\n                        this.checksumUpdate(this.mBlockBuffer, start, end - start);\n                    }\n                    else {\n                        this.checksumUpdate(this.mBlockBuffer, start, this.DEF_MAX_WINDOW_SIZE - start);\n                        if (end > 0) {\n                            this.checksumUpdate(this.mBlockBuffer, 0, end);\n                        }\n                    }\n                }\n            }\n        }\n        if (!this.mbCanReadMoreData && !this.mbCheckSumRead && !this.mbNoWrap) {\n            this.skipToBoundary();\n            var checkSum = this.readInt32();\n            //Debug.Assert( checkSum == mCheckSum, \"\" );\n            if (checkSum !== this.mCheckSum) {\n                throw new DOMException('Checksum check failed.');\n            }\n            this.mbCheckSumRead = true;\n        }\n        return initialLength - length;\n    };\n    /// <summary>\n    /// Reads array of bytes.\n    /// </summary>\n    /// <param name=\"buffer\">Output buffer.</param>\n    /// <param name=\"offset\">Offset in output buffer.</param>\n    /// <param name=\"length\">Length of the data to be read.</param>\n    /// <returns>Count of bytes actually read to the buffer.</returns>\n    CompressedStreamReader.prototype.readPackedBytes = function (buffer, offset, length) {\n        if (buffer == null) {\n            throw new DOMException('buffer');\n        }\n        if (offset < 0 || offset > buffer.length - 1) {\n            throw new DOMException('offset\", \"Offset can not be less than zero or greater than buffer length - 1.');\n        }\n        if (length < 0) {\n            throw new DOMException('length\", \"Length can not be less than zero.');\n        }\n        if (length > buffer.length - offset) {\n            throw new DOMException('length\", \"Length is too large.');\n        }\n        if ((this.mBufferedBits & 7) !== 0) {\n            throw new DOMException('Reading of unalligned data is not supported.');\n        }\n        if (length === 0) {\n            return 0;\n        }\n        var result = 0;\n        while (this.mBufferedBits > 0 && length > 0) {\n            buffer[offset++] = (this.mBuffer);\n            this.mBufferedBits -= 8;\n            this.mBuffer = Utils.bitConverterInt32ToUint(this.mBuffer >>> 8);\n            length--;\n            result++;\n        }\n        if (length > 0) {\n            //TODO: Fix this.\n            result += this.mInputStream.read(buffer, offset, length);\n        }\n        return result;\n    };\n    /// <summary>\n    /// TODO: place correct comment here\n    /// </summary>\n    /// <returns>\n    /// TODO: place correct comment here\n    /// </returns>\n    CompressedStreamReader.prototype.readInt32 = function () {\n        var result = this.readBits(8) << 24;\n        result |= this.readBits(8) << 16;\n        result |= this.readBits(8) << 8;\n        result |= this.readBits(8);\n        return result;\n    };\n    /// <summary>\n    /// Updates checksum by calculating checksum of the\n    /// given buffer and adding it to current value.\n    /// </summary>\n    /// <param name=\"buffer\">Data byte array.</param>\n    /// <param name=\"offset\">Offset in the buffer.</param>\n    /// <param name=\"length\">Length of data to be used from the stream.</param>\n    CompressedStreamReader.prototype.checksumUpdate = function (buffer, offset, length) {\n        ChecksumCalculator.ChecksumUpdate(this.mCheckSum, buffer, offset, length);\n    };\n    CompressedStreamReader.DEF_REVERSE_BITS = new Uint8Array([0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15]);\n    /// <summary>\n    /// Minimum count of repetions.\n    /// </summary>\n    CompressedStreamReader.DEF_HUFFMAN_DYNTREE_REPEAT_MINIMUMS = [3, 3, 11];\n    /// <summary>\n    /// Bits, that responds for different repetion modes.\n    /// </summary>\n    CompressedStreamReader.DEF_HUFFMAN_DYNTREE_REPEAT_BITS = [2, 3, 7];\n    /// <summary>\n    /// Length bases.\n    /// </summary>\n    CompressedStreamReader.DEF_HUFFMAN_REPEAT_LENGTH_BASE = [\n        3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,\n        35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258\n    ];\n    /// <summary>\n    /// Length extended bits count.\n    /// </summary>\n    CompressedStreamReader.DEF_HUFFMAN_REPEAT_LENGTH_EXTENSION = [\n        0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,\n        3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0\n    ];\n    /// <summary>\n    /// Distance bases.\n    /// </summary>\n    CompressedStreamReader.DEF_HUFFMAN_REPEAT_DISTANCE_BASE = [\n        1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,\n        257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,\n        8193, 12289, 16385, 24577\n    ];\n    /// <summary>\n    /// Distance extanded bits count.\n    /// </summary>\n    CompressedStreamReader.DEF_HUFFMAN_REPEAT_DISTANCE_EXTENSION = [\n        0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,\n        7, 7, 8, 8, 9, 9, 10, 10, 11, 11,\n        12, 12, 13, 13\n    ];\n    return CompressedStreamReader;\n}());\nexport { CompressedStreamReader };\nvar Stream = /** @class */ (function () {\n    function Stream(input) {\n        this.position = 0;\n        this.inputStream = new Uint8Array(input.buffer);\n    }\n    Object.defineProperty(Stream.prototype, \"length\", {\n        get: function () {\n            return this.inputStream.buffer.byteLength;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Stream.prototype.read = function (buffer, start, length) {\n        var temp = new Uint8Array(this.inputStream.buffer, this.position + start);\n        var data = temp.subarray(0, length);\n        buffer.set(data, 0);\n        this.position += data.byteLength;\n        return data.byteLength;\n    };\n    Stream.prototype.readByte = function () {\n        return this.inputStream[this.position++];\n    };\n    Stream.prototype.write = function (inputBuffer, offset, count) {\n        Utils.arrayCopy(inputBuffer, 0, this.inputStream, this.position + offset, count);\n        // this.inputStream = new Uint8Array(this.inputStream.buffer, this.position + offset);\n        // this.inputStream.set(inputBuffer, offset);\n        this.position += count;\n    };\n    Stream.prototype.toByteArray = function () {\n        return new Uint8Array(this.inputStream.buffer);\n    };\n    return Stream;\n}());\nexport { Stream };\n/* eslint-enable */ \n"],"names":["Utils","bitReverse","value","reverseBits","bitConverterToInt32","index","bitConverterToInt16","bitConverterToUInt32","uint","Uint32Array","bitConverterToUInt16","Uint16Array","bitConverterUintToInt32","Int32Array","bitConverterInt32ToUint","bitConverterInt32ToInt16","Int16Array","byteToString","str","i","length","String","fromCharCode","byteIntToString","arrayCopy","source","sourceIndex","destination","destinationIndex","dataToCopy","data","Uint8Array","buffer","subarray","set","mergeArray","arrayOne","arrayTwo","mergedArray","encodedString","input","chr1","chr2","chr3","encode2","encode3","encode4","keyStr","count","resultIndex","totalLength","replace","charAt","Error","output","indexOf","huffCodeLengthOrders","CRC32TABLE","ZipArchive","initCrc32Table","this","files","level","Save","isMicrosoftBrowser","navigator","msSaveBlob","Object","defineProperty","prototype","get","enumerable","configurable","undefined","addItem","item","file","ZipArchiveItem","name","push","addDirectory","directoryName","slice","getItem","contains","open","base64String","zipByteArray","DOMException","stream","Stream","lCentralDirEndPosition","findValueFromEnd","position","lCentralDirPosition","ReadInt32","readCentralDirectoryDataAndExtractItems","itemHelper","ZipArchiveItemHelper","readCentralDirectoryData","readData","checkCrc","decompressData","unCompressedStream","save","fileName","zipArchive","Promise","resolve","reject","saveInternal","then","saveAsBlob","blob","skipFileSave","_this","zipData","dirLength","getCompressedData","constructZippedObject","isDirectory","writeZippedContent","destroy","reader_1","FileReader","onload","result","crc32Value","compressedData","compressedSize","uncompressedDataSize","compressionType","compressData","length_1","calculateCrc32Value","readAsArrayBuffer","crc32Table","compressor","CompressedStreamWriter","currentIndex","nextIndex","close","Math","min","subArray","write","zipParts","extFileAttr","date","Date","header","writeHeader","localHeader","centralDir","writeCentralDirectory","zipHeader","getBytes","getModifiedTime","getModifiedDate","localDirLen","cenDirLen","getArrayBuffer","shift","writeFooter","Blob","type","offset","externalFileAttribute","centralLength","localLength","a","j","charCodeAt","bytes","modTime","getHours","getMinutes","getSeconds","modiDate","getFullYear","getMonth","getDate","k","maxCount","lStreamSize","inputStream","byteLength","arrBuffer","lLastPos","max","lCurrentPosition","read","uiCurValue","bFound","readByte","ReadInt16","ReadUInt16","headerSignature","crc32","options","compressionMethod","originalSize","iFileNameLength","iExtraFieldLenth","iCommentLength","externalAttributes","localHeaderOffset","m_strItemName","readLocalHeader","readCompressedData","decompressDataOld","decompressedData","reader","CompressedStreamReader","compressedStream","iReadBytes","toByteArray","iNameLength","iExtraLength","dataStream","iBytesLeft","iBytesToRead","itemName","decompressedStream","ARR_LITERAL_CODES","ARR_LITERAL_LENGTHS","ARR_DISTANCE_CODES","ARR_DISTANCE_LENGTHS","noWrap","pendingBuffer","pendingBufLength","pendingBufCache","pendingBufBitsInCache","bufferPosition","extraBits","currentHash","matchStart","matchLength","matchPrevAvail","blockStart","stringStart","lookAhead","totalBytesIn","inputOffset","inputEnd","windowSize","windowMask","hashSize","hashMask","hashShift","floor","maxDist","checkSum","isHuffmanTreeInitiated","initHuffmanTree","treeLiteral","CompressorHuffmanTree","treeDistances","treeCodeLengths","arrDistances","arrLiterals","dataWindow","hashHead","hashPrevious","writeZLibHeader","compressedString","apply","end","encode","Encoding","inputBuffer","ChecksumCalculator","checksumUpdate","pendingBufferFlush","headerDate","pendingBufferWriteShortBytes","s","finish","success","fillWindow","canFlush","compressSlow","flush","lookAheadCompleted","slideWindow","prevMatch","prevLen","discardMatch","matchPreviousBest","matchPreviousAvailable","huffmanIsFull","insertString","findLongestMatch","huffmanTallyLit","huffmanTallyDist","huffmanFlushBlock","len","lastBlock","more","updateHash","m","match","hash","curMatch","chainLen","niceLen","scan","bestEnd","bestLength","limit","stringEnd","scanEnd1","scanEnd","literal","codeFrequencies","dist","lc","huffmanLengthCode","dc","huffmanDistanceCode","stored","storedOffset","storedLength","buildTree","calculateBLFreq","blTreeCodes","codeLengths","opt_len","getEncodedLength","static_len","huffmanFlushStoredBlock","pendingBufferWriteBits","setStaticCodes","huffmanCompressBlock","huffmanReset","huffmanSendAllTrees","pendingBufferAlignToByte","pendingBufferWriteShort","pendingBufferWriteByteBlock","code","distance","buildCodes","treeLength","rank","writeTree","reset","literalLen","writeCodeToStream","bits","b","pendingBufferFlushBits","isClose","array","writer","elementCount","minCodes","maxLength","codeMinCount","codeFrequency","lengthCount","codeCount","codeLength","codes","lengths","temp","lengthTemp","nextCode","bitsCount","blTree","minCount","curLen","nextLen","maxRepeatCount","minRepeatCount","currentRepeatCount","currentCodeLength","codesCount","arrTree","n","freq","pos","pPos","nodesCount","child","values","node","iIndex","constructHuffmanTree","buildLength","first","last","lastVal","path","second","minDepth","numNodes","numLeafs","overflow","calculateOptimalCodeLength","iIncreasableLength","recreateTree","nodePtr","childPtr","childIndex","bitLength","checksum","checksum_uint","s1","s2","checkSumBitOffset","steps","checksumIterationCount","checksumBase","DecompressorHuffmanTree","init","m_LengthTree","m_DistanceTree","prepareData","blCount","treeSize","MAX_BITLEN","treeFromData","tree","pointer","revcode","subTree","treeLen","m_Tree","unpackSymbol","lookahead","symbol","peekBits","skipBits","subtree","bitlen","availableBits","ChecksumUpdate","checkSumUInt","DEF_CHECKSUM_BIT_OFFSET","DEF_CHECKSUM_ITERATIONSCOUNT","DEF_CHECKSUM_BASE","ChecksumGenerate","bNoWrap","defaultHuffmanDynamicTree","DEF_HEADER_METHOD_MASK","DEF_HEADER_INFO_MASK","DEF_HEADER_FLAGS_FCHECK","DEF_HEADER_FLAGS_FDICT","DEF_HEADER_FLAGS_FLEVEL","DEF_MAX_WINDOW_SIZE","DEF_HUFFMAN_REPEATE_MAX","DEF_HUFFMAN_END_BLOCK","DEF_HUFFMAN_LENGTH_MINIMUMCODE","DEF_HUFFMAN_LENGTH_MAXIMUMCODE","DEF_HUFFMAN_DISTANCE_MAXIMUMCODE","mCheckSum","tBuffer","mBufferedBits","mTempBuffer","mBlockBuffer","mbNoWrap","mWindowSize","mCurrentPosition","mDataLength","mbCanReadNextBlock","mbCanReadMoreData","mbCheckSumRead","mInputStream","readZLibHeader","decodeBlockHeader","fillBuffer","bitMask","mBuffer","bytesRead","readInt16","pow","readBits","bFinalBlock","blockType","mbReadingUncompressed","skipToBoundary","readInt16Inverted","mUncompressedDataLength","mCurrentLengthTree","mCurrentDistanceTree","lengthTree","distanceTree","trees","decodeDynamicHeader","bLastSymbol","iLengthsCount","iDistancesCount","iCodeLengthsCount","iResultingCodeLengthsCount","arrResultingCodeLengths","arrDecoderCodeLengths","iCurrentCode","treeInternalDecoder","bNeedBreak","miRepSymbol","DEF_HUFFMAN_DYNTREE_REPEAT_BITS","DEF_HUFFMAN_DYNTREE_REPEAT_MINIMUMS","tempArray","readHuffman","free","dataRead","readdata","numDataRead","iRepeatLength","DEF_HUFFMAN_REPEAT_LENGTH_BASE","iRepeatExtraBits","DEF_HUFFMAN_REPEAT_LENGTH_EXTENSION","extra","DEF_HUFFMAN_REPEAT_DISTANCE_BASE","iRepeatDistance","DEF_HUFFMAN_REPEAT_DISTANCE_EXTENSION","initialLength","inBlockPosition","oldDataLength","dataToRead","readPackedBytes","start","readInt32","DEF_REVERSE_BITS"],"mappings":"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"}