@mtkruto/node 0.0.6

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

@@ -0,0 +1,239 @@
+import * as dntShim from "../../../../../../_dnt.shims.js";
+import { crc32 } from "../../../../../deno.land/x/crc32@v0.2.0/mod.js";
+/** very fast */
+import { deflateRaw, inflateRaw } from "../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;
+export const 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
+export function putLong(n, arr) {
+    putShort(n & 0xffff, arr);
+    putShort(n >>> 16, arr);
+}
+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;
+}
+export function getHeader(options = {}) {
+    let flags = 0;
+    const level = options.level ?? 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);
+}
+export function gzip(bytes, options = {}) {
+    let flags = 0;
+    const level = options.level ?? 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);
+    }
+    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(crc32(bytes), 16), out);
+    putLong(bytes.length, out);
+    return new Uint8Array(out);
+}
+export 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 = 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(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;
+}
+export 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);
+    }
+}
+export function checkTail(arr) {
+    const tail = arr.splice(arr.length - 8);
+    const crc32 = readLong(tail) >>> 0;
+    const size = readLong(tail);
+    return {
+        crc32,
+        size,
+    };
+}

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

@@ -0,0 +1,10 @@
+export 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;
+}

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

@@ -0,0 +1,139 @@
+// from https://github.com/nodeca/pako
+import * as zlibDeflate from "./zlib/deflate.js";
+import { concatUint8Array } from "../utils/uint8.js";
+import { message as msg } from "./zlib/messages.js";
+import ZStream from "./zlib/zstream.js";
+import STATUS from "./zlib/status.js";
+export 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.Z_DEFAULT_COMPRESSION,
+            method: STATUS.Z_DEFLATED,
+            chunkSize: 16384,
+            windowBits: 15,
+            memLevel: 8,
+            strategy: STATUS.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();
+        this.strm.avail_out = 0;
+        let status = zlibDeflate.deflateInit2(this.strm, opt.level, opt.method, opt.windowBits, opt.memLevel, opt.strategy);
+        if (status !== STATUS.Z_OK) {
+            throw new Error(msg[status]);
+        }
+        if (opt.header) {
+            zlibDeflate.deflateSetHeader(this.strm, opt.header);
+        }
+        if (opt.dictionary) {
+            status = zlibDeflate.deflateSetDictionary(this.strm, opt.dictionary);
+            if (status !== STATUS.Z_OK) {
+                throw new Error(msg[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.Z_FINISH : STATUS.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.Z_STREAM_END && status !== STATUS.Z_OK) {
+                this.ended = true;
+                throw new Error(this.strm.msg);
+            }
+            if (strm.avail_out === 0 ||
+                (strm.avail_in === 0 &&
+                    (_mode === STATUS.Z_FINISH || _mode === STATUS.Z_SYNC_FLUSH))) {
+                chunks.push(strm.output.subarray(0, strm.next_out));
+            }
+        } while ((strm.avail_in > 0 || strm.avail_out === 0) &&
+            status !== STATUS.Z_STREAM_END);
+        // Finalize on the last chunk.
+        if (_mode === STATUS.Z_FINISH) {
+            status = zlibDeflate.deflateEnd(this.strm);
+            this.ended = true;
+            if (status !== STATUS.Z_OK)
+                throw new Error(this.strm.msg);
+        }
+        // callback interim results if Z_SYNC_FLUSH.
+        if (_mode === STATUS.Z_SYNC_FLUSH) {
+            strm.avail_out = 0;
+        }
+        return concatUint8Array(chunks);
+    }
+}
+export 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 || msg[deflator.err];
+    return result;
+}
+export function deflateRaw(input, options = {}) {
+    options.raw = true;
+    return deflate(input, options);
+}
+export function gzip(input, options = {}) {
+    options.gzip = true;
+    return deflate(input, options);
+}

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

@@ -0,0 +1,176 @@
+// from https://github.com/nodeca/pako
+import { concatUint8Array } from "../utils/uint8.js";
+import * as zlibInflate from "./zlib/inflate.js";
+import STATUS from "./zlib/status.js";
+import { message as msg } from "./zlib/messages.js";
+import ZStream from "./zlib/zstream.js";
+import GZheader from "./zlib/gzheader.js";
+export 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();
+        this.strm.avail_out = 0;
+        var status = zlibInflate.inflateInit2(this.strm, opt.windowBits);
+        if (status !== STATUS.Z_OK) {
+            throw new Error(msg[status]);
+        }
+        this.header = new GZheader();
+        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.Z_OK) {
+                    throw new Error(msg[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.Z_FINISH : STATUS.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.Z_NO_FLUSH); /* no bad return value */
+            if (status === STATUS.Z_NEED_DICT && dictionary) {
+                status = zlibInflate.inflateSetDictionary(this.strm, dictionary);
+            }
+            if (status === STATUS.Z_BUF_ERROR && allowBufError === true) {
+                status = STATUS.Z_OK;
+                allowBufError = false;
+            }
+            if (status !== STATUS.Z_STREAM_END && status !== STATUS.Z_OK) {
+                this.ended = true;
+                throw new Error(this.strm.msg);
+            }
+            if (strm.next_out) {
+                if (strm.avail_out === 0 || status === STATUS.Z_STREAM_END ||
+                    (strm.avail_in === 0 &&
+                        (_mode === STATUS.Z_FINISH || _mode === STATUS.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.Z_STREAM_END);
+        if (status === STATUS.Z_STREAM_END) {
+            _mode = STATUS.Z_FINISH;
+        }
+        // Finalize on the last chunk.
+        if (_mode === STATUS.Z_FINISH) {
+            status = zlibInflate.inflateEnd(this.strm);
+            this.ended = true;
+            if (status !== STATUS.Z_OK)
+                throw new Error(this.strm.msg);
+        }
+        // callback interim results if Z_SYNC_FLUSH.
+        if (_mode === STATUS.Z_SYNC_FLUSH) {
+            strm.avail_out = 0;
+        }
+        return concatUint8Array(chunks);
+    }
+}
+export 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 || msg[inflator.err];
+    return result;
+}
+export function inflateRaw(input, options = {}) {
+    options.raw = true;
+    return inflate(input, options);
+}
+export const gunzip = inflate;

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

@@ -0,0 +1,2 @@
+export * from "./deflate.js";
+export * from "./inflate.js";

package/esm/deps/raw.githubusercontent.com/MTKruto/compress/master/zlib/zlib/adler32.js

@@ -0,0 +1,19 @@
+export default function adler32(adler, buf, len, pos) {
+    let s1 = (adler & 0xffff) | 0;
+    let s2 = ((adler >>> 16) & 0xffff) | 0;
+    let n = 0;
+    while (len !== 0) {
+        // Set limit ~ twice less than 5552, to keep
+        // s2 in 31-bits, because we force signed ints.
+        // in other case %= will fail.
+        n = len > 2000 ? 2000 : len;
+        len -= n;
+        do {
+            s1 = (s1 + buf[pos++]) | 0;
+            s2 = (s2 + s1) | 0;
+        } while (--n);
+        s1 %= 65521;
+        s2 %= 65521;
+    }
+    return (s1 | (s2 << 16)) | 0;
+}

package/esm/deps/raw.githubusercontent.com/MTKruto/compress/master/zlib/zlib/crc32.js

@@ -0,0 +1,25 @@
+export function makeTable() {
+    let c;
+    const table = [];
+    const m = 0xEDB88320;
+    for (let n = 0; n < 256; n++) {
+        c = n;
+        for (let k = 0; k < 8; k++) {
+            c = ((c & 1) ? (m ^ (c >>> 1)) : (c >>> 1));
+        }
+        table[n] = c;
+    }
+    return table;
+}
+// Create table on load. Just 255 signed longs. Not a problem.
+const crcTable = makeTable();
+export function crc32(crc, buf, len, pos) {
+    let t = crcTable;
+    let end = pos + len;
+    let f = 0xFF;
+    crc ^= -1;
+    for (let i = pos; i < end; i++) {
+        crc = (crc >>> 8) ^ t[(crc ^ buf[i]) & f];
+    }
+    return (crc ^ (-1)); // >>> 0;
+}