@mtkruto/node 0.0.6

package/script/deps/raw.githubusercontent.com/MTKruto/compress/master/gzip/gzip.js

@@ -0,0 +1,271 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkTail = exports.checkHeader = exports.gunzip = exports.gzip = exports.getHeader = exports.putLong = exports.DEFAULT_LEVEL = void 0;
+const dntShim = __importStar(require("../../../../../../_dnt.shims.js"));
+const mod_js_1 = require("../../../../../deno.land/x/crc32@v0.2.0/mod.js");
+/** very fast */
+const mod_js_2 = require("../zlib/mod.js");
+/** slow */
+// import { deflateRaw, inflateRaw } from "../deflate/mod.ts";
+// magic numbers marking this file as GZIP
+const ID1 = 0x1F;
+const ID2 = 0x8B;
+const compressionMethods = {
+    "deflate": 8,
+};
+const possibleFlags = {
+    "FTEXT": 0x01,
+    "FHCRC": 0x02,
+    "FEXTRA": 0x04,
+    "FNAME": 0x08,
+    "FCOMMENT": 0x10,
+};
+// const osMap = {
+//   "fat": 0, // FAT file system (DOS, OS/2, NT) + PKZIPW 2.50 VFAT, NTFS
+//   "amiga": 1, // Amiga
+//   "vmz": 2, // VMS (VAX or Alpha AXP)
+//   "unix": 3, // Unix
+//   "vm/cms": 4, // VM/CMS
+//   "atari": 5, // Atari
+//   "hpfs": 6, // HPFS file system (OS/2, NT 3.x)
+//   "macintosh": 7, // Macintosh
+//   "z-system": 8, // Z-System
+//   "cplm": 9, // CP/M
+//   "tops-20": 10, // TOPS-20
+//   "ntfs": 11, // NTFS file system (NT)
+//   "qdos": 12, // SMS/QDOS
+//   "acorn": 13, // Acorn RISC OS
+//   "vfat": 14, // VFAT file system (Win95, NT)
+//   "vms": 15, // MVS (code also taken for PRIMOS)
+//   "beos": 16, // BeOS (BeBox or PowerMac)
+//   "tandem": 17, // Tandem/NSK
+//   "theos": 18, // THEOS
+// };
+const os = {
+    "darwin": 3,
+    "linux": 3,
+    "windows": 0,
+};
+// @ts-ignore
+const osCode = os[dntShim.dntGlobalThis["Deno"]?.build?.os] ?? 255;
+exports.DEFAULT_LEVEL = 6;
+function putByte(n, arr) {
+    arr.push(n & 0xFF);
+}
+// LSB first
+function putShort(n, arr) {
+    arr.push(n & 0xFF);
+    arr.push(n >>> 8);
+}
+// LSB first
+function putLong(n, arr) {
+    putShort(n & 0xffff, arr);
+    putShort(n >>> 16, arr);
+}
+exports.putLong = putLong;
+function putString(s, arr) {
+    for (let i = 0, len = s.length; i < len; i += 1) {
+        putByte(s.charCodeAt(i), arr);
+    }
+}
+function readByte(arr) {
+    return arr.shift();
+}
+function readShort(arr) {
+    return arr.shift() | (arr.shift() << 8);
+}
+function readLong(arr) {
+    const n1 = readShort(arr);
+    let n2 = readShort(arr);
+    // JavaScript can't handle bits in the position 32
+    // we'll emulate this by removing the left-most bit (if it exists)
+    // and add it back in via multiplication, which does work
+    if (n2 > 32768) {
+        n2 -= 32768;
+        return ((n2 << 16) | n1) + 32768 * Math.pow(2, 16);
+    }
+    return (n2 << 16) | n1;
+}
+function readString(arr) {
+    const charArr = [];
+    // turn all bytes into chars until the terminating null
+    while (arr[0] !== 0) {
+        charArr.push(String.fromCharCode(arr.shift()));
+    }
+    // throw away terminating null
+    arr.shift();
+    // join all characters into a cohesive string
+    return charArr.join("");
+}
+function readBytes(arr, n) {
+    const ret = [];
+    for (let i = 0; i < n; i += 1) {
+        ret.push(arr.shift());
+    }
+    return ret;
+}
+function getHeader(options = {}) {
+    let flags = 0;
+    const level = options.level ?? exports.DEFAULT_LEVEL;
+    const out = [];
+    putByte(ID1, out);
+    putByte(ID2, out);
+    putByte(compressionMethods["deflate"], out);
+    if (options.name) {
+        flags |= possibleFlags["FNAME"];
+    }
+    putByte(flags, out);
+    putLong(options.timestamp ?? Math.floor(Date.now() / 1000), out);
+    // put deflate args (extra flags)
+    if (level === 1) {
+        // fastest algorithm
+        putByte(4, out);
+    }
+    else if (level === 9) {
+        // maximum compression (fastest algorithm)
+        putByte(2, out);
+    }
+    else {
+        putByte(0, out);
+    }
+    // OS identifier
+    putByte(osCode, out);
+    if (options.name) {
+        // ignore the directory part
+        putString(options.name.substring(options.name.lastIndexOf("/") + 1), out);
+        // terminating null
+        putByte(0, out);
+    }
+    return new Uint8Array(out);
+}
+exports.getHeader = getHeader;
+function gzip(bytes, options = {}) {
+    let flags = 0;
+    const level = options.level ?? exports.DEFAULT_LEVEL;
+    const out = [];
+    putByte(ID1, out);
+    putByte(ID2, out);
+    putByte(compressionMethods["deflate"], out);
+    if (options.name) {
+        flags |= possibleFlags["FNAME"];
+    }
+    putByte(flags, out);
+    putLong(options.timestamp ?? Math.floor(Date.now() / 1000), out);
+    // put deflate args (extra flags)
+    if (level === 1) {
+        // fastest algorithm
+        putByte(4, out);
+    }
+    else if (level === 9) {
+        // maximum compression (fastest algorithm)
+        putByte(2, out);
+    }
+    else {
+        putByte(0, out);
+    }
+    // OS identifier
+    putByte(osCode, out);
+    if (options.name) {
+        // ignore the directory part
+        putString(options.name.substring(options.name.lastIndexOf("/") + 1), out);
+        // terminating null
+        putByte(0, out);
+    }
+    (0, mod_js_2.deflateRaw)(bytes).forEach(function (byte) {
+        putByte(byte, out);
+    });
+    // import { deflateRaw, inflateRaw } from "../deflate/mod.ts";
+    // deflateRaw(bytes, level).forEach(function (byte) {
+    //   putByte(byte, out);
+    // });
+    putLong(parseInt((0, mod_js_1.crc32)(bytes), 16), out);
+    putLong(bytes.length, out);
+    return new Uint8Array(out);
+}
+exports.gzip = gzip;
+function gunzip(bytes) {
+    const arr = Array.from(bytes);
+    checkHeader(arr);
+    // give deflate everything but the last 8 bytes
+    // the last 8 bytes are for the CRC32 checksum and filesize
+    const res = (0, mod_js_2.inflateRaw)(new Uint8Array(arr.splice(0, arr.length - 8)));
+    // if (flags & possibleFlags["FTEXT"]) {
+    //   res = Array.prototype.map.call(res, function (byte) {
+    //     return String.fromCharCode(byte);
+    //   }).join("");
+    // }
+    const crc = readLong(arr) >>> 0;
+    if (crc !== parseInt((0, mod_js_1.crc32)(res), 16)) {
+        throw "Checksum does not match";
+    }
+    const size = readLong(arr);
+    if (size !== res.length) {
+        throw "Size of decompressed file not correct";
+    }
+    return res;
+}
+exports.gunzip = gunzip;
+function checkHeader(arr) {
+    // check the first two bytes for the magic numbers
+    if (readByte(arr) !== ID1 || readByte(arr) !== ID2) {
+        throw "Not a GZIP file";
+    }
+    if (readByte(arr) !== 8) {
+        throw "Unsupported compression method";
+    }
+    const flags = readByte(arr);
+    readLong(arr); // mtime
+    readByte(arr); // xFlags
+    readByte(arr); // os, throw away
+    // just throw away the bytes for now
+    if (flags & possibleFlags["FEXTRA"]) {
+        const t = readShort(arr);
+        readBytes(arr, t);
+    }
+    // just throw away for now
+    if (flags & possibleFlags["FNAME"]) {
+        readString(arr);
+    }
+    // just throw away for now
+    if (flags & possibleFlags["FCOMMENT"]) {
+        readString(arr);
+    }
+    // just throw away for now
+    if (flags & possibleFlags["FHCRC"]) {
+        readShort(arr);
+    }
+}
+exports.checkHeader = checkHeader;
+function checkTail(arr) {
+    const tail = arr.splice(arr.length - 8);
+    const crc32 = readLong(tail) >>> 0;
+    const size = readLong(tail);
+    return {
+        crc32,
+        size,
+    };
+}
+exports.checkTail = checkTail;

package/script/deps/raw.githubusercontent.com/MTKruto/compress/master/utils/uint8.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.concatUint8Array = void 0;
+function concatUint8Array(arr) {
+    const length = arr.reduce((pre, next) => pre + next.length, 0);
+    const result = new Uint8Array(length);
+    let offset = 0;
+    for (const v of arr) {
+        result.set(v, offset);
+        offset += v.length;
+    }
+    return result;
+}
+exports.concatUint8Array = concatUint8Array;

package/script/deps/raw.githubusercontent.com/MTKruto/compress/master/zlib/deflate.js

@@ -0,0 +1,172 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gzip = exports.deflateRaw = exports.deflate = exports.Deflate = void 0;
+// from https://github.com/nodeca/pako
+const zlibDeflate = __importStar(require("./zlib/deflate.js"));
+const uint8_js_1 = require("../utils/uint8.js");
+const messages_js_1 = require("./zlib/messages.js");
+const zstream_js_1 = __importDefault(require("./zlib/zstream.js"));
+const status_js_1 = __importDefault(require("./zlib/status.js"));
+class Deflate {
+    constructor(options = {}) {
+        Object.defineProperty(this, "err", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        }); // error code, if happens (0 = Z_OK)
+        Object.defineProperty(this, "msg", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ""
+        }); // error message
+        Object.defineProperty(this, "ended", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        }); // used to avoid multiple onEnd() calls
+        Object.defineProperty(this, "strm", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_dict_set", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.options = Object.assign({
+            level: status_js_1.default.Z_DEFAULT_COMPRESSION,
+            method: status_js_1.default.Z_DEFLATED,
+            chunkSize: 16384,
+            windowBits: 15,
+            memLevel: 8,
+            strategy: status_js_1.default.Z_DEFAULT_STRATEGY,
+            to: "",
+        }, options);
+        const opt = this.options;
+        if (opt.raw && (opt.windowBits > 0)) {
+            opt.windowBits = -opt.windowBits;
+        }
+        else if (opt.gzip && (opt.windowBits > 0) && (opt.windowBits < 16)) {
+            opt.windowBits += 16;
+        }
+        this.strm = new zstream_js_1.default();
+        this.strm.avail_out = 0;
+        let status = zlibDeflate.deflateInit2(this.strm, opt.level, opt.method, opt.windowBits, opt.memLevel, opt.strategy);
+        if (status !== status_js_1.default.Z_OK) {
+            throw new Error(messages_js_1.message[status]);
+        }
+        if (opt.header) {
+            zlibDeflate.deflateSetHeader(this.strm, opt.header);
+        }
+        if (opt.dictionary) {
+            status = zlibDeflate.deflateSetDictionary(this.strm, opt.dictionary);
+            if (status !== status_js_1.default.Z_OK) {
+                throw new Error(messages_js_1.message[status]);
+            }
+            this._dict_set = true;
+        }
+    }
+    push(data, mode) {
+        const strm = this.strm;
+        const chunkSize = this.options.chunkSize;
+        const chunks = [];
+        let status;
+        if (this.ended) {
+            throw new Error("can not call after ended");
+        }
+        const _mode = mode === ~~mode
+            ? mode
+            : (mode === true ? status_js_1.default.Z_FINISH : status_js_1.default.Z_NO_FLUSH);
+        strm.input = data;
+        strm.next_in = 0;
+        strm.avail_in = strm.input.length;
+        do {
+            if (strm.avail_out === 0) {
+                strm.output = new Uint8Array(chunkSize);
+                strm.next_out = 0;
+                strm.avail_out = chunkSize;
+            }
+            status = zlibDeflate.deflate(strm, _mode); /* no bad return value */
+            if (status !== status_js_1.default.Z_STREAM_END && status !== status_js_1.default.Z_OK) {
+                this.ended = true;
+                throw new Error(this.strm.msg);
+            }
+            if (strm.avail_out === 0 ||
+                (strm.avail_in === 0 &&
+                    (_mode === status_js_1.default.Z_FINISH || _mode === status_js_1.default.Z_SYNC_FLUSH))) {
+                chunks.push(strm.output.subarray(0, strm.next_out));
+            }
+        } while ((strm.avail_in > 0 || strm.avail_out === 0) &&
+            status !== status_js_1.default.Z_STREAM_END);
+        // Finalize on the last chunk.
+        if (_mode === status_js_1.default.Z_FINISH) {
+            status = zlibDeflate.deflateEnd(this.strm);
+            this.ended = true;
+            if (status !== status_js_1.default.Z_OK)
+                throw new Error(this.strm.msg);
+        }
+        // callback interim results if Z_SYNC_FLUSH.
+        if (_mode === status_js_1.default.Z_SYNC_FLUSH) {
+            strm.avail_out = 0;
+        }
+        return (0, uint8_js_1.concatUint8Array)(chunks);
+    }
+}
+exports.Deflate = Deflate;
+function deflate(input, options = {}) {
+    const deflator = new Deflate(options);
+    const result = deflator.push(input, true);
+    // That will never happens, if you don't cheat with options :)
+    if (deflator.err)
+        throw deflator.msg || messages_js_1.message[deflator.err];
+    return result;
+}
+exports.deflate = deflate;
+function deflateRaw(input, options = {}) {
+    options.raw = true;
+    return deflate(input, options);
+}
+exports.deflateRaw = deflateRaw;
+function gzip(input, options = {}) {
+    options.gzip = true;
+    return deflate(input, options);
+}
+exports.gzip = gzip;

package/script/deps/raw.githubusercontent.com/MTKruto/compress/master/zlib/inflate.js

@@ -0,0 +1,208 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gunzip = exports.inflateRaw = exports.inflate = exports.Inflate = void 0;
+// from https://github.com/nodeca/pako
+const uint8_js_1 = require("../utils/uint8.js");
+const zlibInflate = __importStar(require("./zlib/inflate.js"));
+const status_js_1 = __importDefault(require("./zlib/status.js"));
+const messages_js_1 = require("./zlib/messages.js");
+const zstream_js_1 = __importDefault(require("./zlib/zstream.js"));
+const gzheader_js_1 = __importDefault(require("./zlib/gzheader.js"));
+class Inflate {
+    constructor(options) {
+        Object.defineProperty(this, "err", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        }); // error code, if happens (0 = Z_OK)
+        Object.defineProperty(this, "msg", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ""
+        }); // error message
+        Object.defineProperty(this, "ended", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        }); // used to avoid multiple onEnd() calls
+        Object.defineProperty(this, "strm", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "header", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.options = {
+            chunkSize: 16384,
+            windowBits: 0,
+            to: "",
+            ...options,
+        };
+        const opt = this.options;
+        // Force window size for `raw` data, if not set directly,
+        // because we have no header for autodetect.
+        if (opt.raw && (opt.windowBits >= 0) && (opt.windowBits < 16)) {
+            opt.windowBits = -opt.windowBits;
+            if (opt.windowBits === 0)
+                opt.windowBits = -15;
+        }
+        // If `windowBits` not defined (and mode not raw) - set autodetect flag for gzip/deflate
+        if ((opt.windowBits >= 0) && (opt.windowBits < 16) &&
+            !(options && options.windowBits)) {
+            opt.windowBits += 32;
+        }
+        // Gzip header has no info about windows size, we can do autodetect only
+        // for deflate. So, if window size not set, force it to max when gzip possible
+        if ((opt.windowBits > 15) && (opt.windowBits < 48)) {
+            // bit 3 (16) -> gzipped data
+            // bit 4 (32) -> autodetect gzip/deflate
+            if ((opt.windowBits & 15) === 0) {
+                opt.windowBits |= 15;
+            }
+        }
+        this.strm = new zstream_js_1.default();
+        this.strm.avail_out = 0;
+        var status = zlibInflate.inflateInit2(this.strm, opt.windowBits);
+        if (status !== status_js_1.default.Z_OK) {
+            throw new Error(messages_js_1.message[status]);
+        }
+        this.header = new gzheader_js_1.default();
+        zlibInflate.inflateGetHeader(this.strm, this.header);
+        // Setup dictionary
+        if (opt.dictionary) {
+            if (opt.raw) { //In raw mode we need to set the dictionary early
+                status = zlibInflate.inflateSetDictionary(this.strm, opt.dictionary);
+                if (status !== status_js_1.default.Z_OK) {
+                    throw new Error(messages_js_1.message[status]);
+                }
+            }
+        }
+    }
+    push(data, mode) {
+        const strm = this.strm;
+        const chunkSize = this.options.chunkSize;
+        const dictionary = this.options.dictionary;
+        const chunks = [];
+        let status;
+        // Flag to properly process Z_BUF_ERROR on testing inflate call
+        // when we check that all output data was flushed.
+        var allowBufError = false;
+        if (this.ended) {
+            throw new Error("can not call after ended");
+        }
+        let _mode = (mode === ~~mode)
+            ? mode
+            : ((mode === true) ? status_js_1.default.Z_FINISH : status_js_1.default.Z_NO_FLUSH);
+        strm.input = data;
+        strm.next_in = 0;
+        strm.avail_in = strm.input.length;
+        do {
+            if (strm.avail_out === 0) {
+                strm.output = new Uint8Array(chunkSize);
+                strm.next_out = 0;
+                strm.avail_out = chunkSize;
+            }
+            status = zlibInflate.inflate(strm, status_js_1.default.Z_NO_FLUSH); /* no bad return value */
+            if (status === status_js_1.default.Z_NEED_DICT && dictionary) {
+                status = zlibInflate.inflateSetDictionary(this.strm, dictionary);
+            }
+            if (status === status_js_1.default.Z_BUF_ERROR && allowBufError === true) {
+                status = status_js_1.default.Z_OK;
+                allowBufError = false;
+            }
+            if (status !== status_js_1.default.Z_STREAM_END && status !== status_js_1.default.Z_OK) {
+                this.ended = true;
+                throw new Error(this.strm.msg);
+            }
+            if (strm.next_out) {
+                if (strm.avail_out === 0 || status === status_js_1.default.Z_STREAM_END ||
+                    (strm.avail_in === 0 &&
+                        (_mode === status_js_1.default.Z_FINISH || _mode === status_js_1.default.Z_SYNC_FLUSH))) {
+                    chunks.push(strm.output.subarray(0, strm.next_out));
+                }
+            }
+            // When no more input data, we should check that internal inflate buffers
+            // are flushed. The only way to do it when avail_out = 0 - run one more
+            // inflate pass. But if output data not exists, inflate return Z_BUF_ERROR.
+            // Here we set flag to process this error properly.
+            //
+            // NOTE. Deflate does not return error in this case and does not needs such
+            // logic.
+            if (strm.avail_in === 0 && strm.avail_out === 0) {
+                allowBufError = true;
+            }
+        } while ((strm.avail_in > 0 || strm.avail_out === 0) &&
+            status !== status_js_1.default.Z_STREAM_END);
+        if (status === status_js_1.default.Z_STREAM_END) {
+            _mode = status_js_1.default.Z_FINISH;
+        }
+        // Finalize on the last chunk.
+        if (_mode === status_js_1.default.Z_FINISH) {
+            status = zlibInflate.inflateEnd(this.strm);
+            this.ended = true;
+            if (status !== status_js_1.default.Z_OK)
+                throw new Error(this.strm.msg);
+        }
+        // callback interim results if Z_SYNC_FLUSH.
+        if (_mode === status_js_1.default.Z_SYNC_FLUSH) {
+            strm.avail_out = 0;
+        }
+        return (0, uint8_js_1.concatUint8Array)(chunks);
+    }
+}
+exports.Inflate = Inflate;
+function inflate(input, options = {}) {
+    const inflator = new Inflate(options);
+    const result = inflator.push(input, true);
+    // That will never happens, if you don't cheat with options :)
+    if (inflator.err)
+        throw inflator.msg || messages_js_1.message[inflator.err];
+    return result;
+}
+exports.inflate = inflate;
+function inflateRaw(input, options = {}) {
+    options.raw = true;
+    return inflate(input, options);
+}
+exports.inflateRaw = inflateRaw;
+exports.gunzip = inflate;

package/script/deps/raw.githubusercontent.com/MTKruto/compress/master/zlib/mod.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./deflate.js"), exports);
+__exportStar(require("./inflate.js"), exports);