node get wasm flate and use

wasm-flate-fetch-node.js

const fetch = require("node-fetch");
const { TextDecoder } = require(String.raw `util`);

let wasm;
let WASM_VECTOR_LEN = 0;
var path = "https://unpkg.com/[email protected]/dist/9eae6f5a6ee0cd2a3640.module.wasm"
fetch(path)
    .then(function(response) {
        response.arrayBuffer()
            .then(function(buffer) {
                WebAssembly.compile(buffer)
                    .then(function(obj) {
                        WebAssembly.instantiate(obj)
                            .then(function(skee) {
                                wasm = skee.exports;


                                let cachegetNodeBufferMemory = null;

                                function getNodeBufferMemory() {
                                    if (cachegetNodeBufferMemory === null || cachegetNodeBufferMemory.buffer !== wasm.memory.buffer) {
                                        cachegetNodeBufferMemory = Buffer.from(wasm.memory.buffer);

                                        // console.log(cachegetNodeBufferMemory)
                                    }
                                    return cachegetNodeBufferMemory;
                                }

                                function passStringToWasm(arg) {

                                    const size = Buffer.byteLength(arg);
                                    const ptr = wasm.__wbindgen_malloc(size);

                                    console.log(arg, ptr, size, getNodeBufferMemory().length)
                                    
                                    getNodeBufferMemory().write(arg, ptr, size);

                                    console.log(arg, ptr, size, getNodeBufferMemory().length)
                                    
                                    WASM_VECTOR_LEN = size;
                                    return ptr;
                                }

                                let cachegetInt32Memory = null;

                                function getInt32Memory() {
                                    if (cachegetInt32Memory === null || cachegetInt32Memory.buffer !== wasm.memory.buffer) {
                                        cachegetInt32Memory = new Int32Array(wasm.memory.buffer);
                                    }
                                    return cachegetInt32Memory;
                                }

                                let cachedTextDecoder = new TextDecoder('utf-8');

                                let cachegetUint8Memory = null;

                                function getUint8Memory() {
                                    if (cachegetUint8Memory === null || cachegetUint8Memory.buffer !== wasm.memory.buffer) {
                                        cachegetUint8Memory = new Uint8Array(wasm.memory.buffer);
                                    }
                                    return cachegetUint8Memory;
                                }

                                function getStringFromWasm(ptr, len) {
                                    console.log(ptr, len, getUint8Memory().subarray(ptr, ptr + len))
                                    return cachedTextDecoder.decode(getUint8Memory().subarray(ptr, ptr + len));
                                }
                                /**
                                 * @param {string} base_compressed
                                 * @returns {string}
                                 */
                                zlib_decode = function(base_compressed) {
                                    const retptr = 8;
                                    const ret = wasm.zlib_decode(retptr, passStringToWasm(base_compressed), WASM_VECTOR_LEN);
                                    const memi32 = getInt32Memory();
                                    const v0 = getStringFromWasm(memi32[retptr / 4 + 0], memi32[retptr / 4 + 1]).slice();
                                    wasm.__wbindgen_free(memi32[retptr / 4 + 0], memi32[retptr / 4 + 1] * 1);
                                    return v0;
                                };

                                /**
                                 * @param {string} base_raw
                                 * @returns {string}
                                 */
                                zlib_encode = function(base_raw) {
                                    const retptr = 8;
                                    const ret = wasm.zlib_encode(retptr, passStringToWasm(base_raw), WASM_VECTOR_LEN);
                                    const memi32 = getInt32Memory();
                                    const v0 = getStringFromWasm(memi32[retptr / 4 + 0], memi32[retptr / 4 + 1]).slice();
                                    wasm.__wbindgen_free(memi32[retptr / 4 + 0], memi32[retptr / 4 + 1] * 1);
                                    return v0;
                                };

                                /**
                                 * @param {string} base_compressed
                                 * @returns {string}
                                 */
                                gzip_decode = function(base_compressed) {
                                    const retptr = 8;
                                    const ret = wasm.gzip_decode(retptr, passStringToWasm(base_compressed), WASM_VECTOR_LEN);
                                    const memi32 = getInt32Memory();
                                    const v0 = getStringFromWasm(memi32[retptr / 4 + 0], memi32[retptr / 4 + 1]).slice();
                                    wasm.__wbindgen_free(memi32[retptr / 4 + 0], memi32[retptr / 4 + 1] * 1);
                                    return v0;
                                };

                                /**
                                 * @param {string} base_raw
                                 * @returns {string}
                                 */
                                gzip_encode = function(base_raw) {
                                    const retptr = 8;
                                    const ret = wasm.gzip_encode(retptr, passStringToWasm(base_raw), WASM_VECTOR_LEN);
                                    const memi32 = getInt32Memory();
                                    const v0 = getStringFromWasm(memi32[retptr / 4 + 0], memi32[retptr / 4 + 1]).slice();
                                    wasm.__wbindgen_free(memi32[retptr / 4 + 0], memi32[retptr / 4 + 1] * 1);
                                    return v0;
                                };

                                /**
                                 * @param {string} base_compressed
                                 * @returns {string}
                                 */
                                deflate_decode = function(base_compressed) {
                                    const retptr = 8;
                                    const ret = wasm.deflate_decode(retptr, passStringToWasm(base_compressed), WASM_VECTOR_LEN);
                                    const memi32 = getInt32Memory();
                                    const v0 = getStringFromWasm(memi32[retptr / 4 + 0], memi32[retptr / 4 + 1]).slice();
                                    wasm.__wbindgen_free(memi32[retptr / 4 + 0], memi32[retptr / 4 + 1] * 1);
                                    return v0;
                                };

                                /**
                                 * @param {string} base_raw
                                 * @returns {string}
                                 */
                                deflate_encode = function(base_raw) {
                                    const retptr = 8;
                                    var v = passStringToWasm(base_raw)
                                    console.log(retptr, v, WASM_VECTOR_LEN)
                                    const ret = wasm.deflate_encode(retptr, v, WASM_VECTOR_LEN);
                                    const memi32 = getInt32Memory();

                                    console.log(memi32.length)
                                    const v0 = getStringFromWasm(memi32[retptr / 4 + 0], memi32[retptr / 4 + 1]).slice();
                                    wasm.__wbindgen_free(memi32[retptr / 4 + 0], memi32[retptr / 4 + 1] * 1);
                                    return v0;
                                };

                                function passArray8ToWasm(arg) {
                                    const ptr = wasm.__wbindgen_malloc(arg.length * 1);
                                    getUint8Memory().set(arg, ptr / 1);
                                    WASM_VECTOR_LEN = arg.length;
                                    return ptr;
                                }

                                function getArrayU8FromWasm(ptr, len) {
                                    return getUint8Memory().subarray(ptr / 1, ptr / 1 + len);
                                }
                                /**
                                 * @param {Uint8Array} base_compressed
                                 * @returns {Uint8Array}
                                 */
                                zlib_decode_raw = function(base_compressed) {
                                    const retptr = 8;
                                    const ret = wasm.zlib_decode_raw(retptr, passArray8ToWasm(base_compressed), WASM_VECTOR_LEN);
                                    const memi32 = getInt32Memory();
                                    const v0 = getArrayU8FromWasm(memi32[retptr / 4 + 0], memi32[retptr / 4 + 1]).slice();
                                    wasm.__wbindgen_free(memi32[retptr / 4 + 0], memi32[retptr / 4 + 1] * 1);
                                    return v0;
                                };

                                /**
                                 * @param {Uint8Array} base_raw
                                 * @returns {Uint8Array}
                                 */
                                zlib_encode_raw = function(base_raw) {
                                    const retptr = 8;
                                    const ret = wasm.zlib_encode_raw(retptr, passArray8ToWasm(base_raw), WASM_VECTOR_LEN);
                                    const memi32 = getInt32Memory();
                                    const v0 = getArrayU8FromWasm(memi32[retptr / 4 + 0], memi32[retptr / 4 + 1]).slice();
                                    wasm.__wbindgen_free(memi32[retptr / 4 + 0], memi32[retptr / 4 + 1] * 1);
                                    return v0;
                                };

                                /**
                                 * @param {Uint8Array} base_compressed
                                 * @returns {Uint8Array}
                                 */
                                gzip_decode_raw = function(base_compressed) {
                                    const retptr = 8;
                                    const ret = wasm.gzip_decode_raw(retptr, passArray8ToWasm(base_compressed), WASM_VECTOR_LEN);
                                    const memi32 = getInt32Memory();
                                    const v0 = getArrayU8FromWasm(memi32[retptr / 4 + 0], memi32[retptr / 4 + 1]).slice();
                                    wasm.__wbindgen_free(memi32[retptr / 4 + 0], memi32[retptr / 4 + 1] * 1);
                                    return v0;
                                };

                                /**
                                 * @param {Uint8Array} base_raw
                                 * @returns {Uint8Array}
                                 */
                                gzip_encode_raw = function(base_raw) {
                                    const retptr = 8;
                                    const ret = wasm.gzip_encode_raw(retptr, passArray8ToWasm(base_raw), WASM_VECTOR_LEN);
                                    const memi32 = getInt32Memory();
                                    const v0 = getArrayU8FromWasm(memi32[retptr / 4 + 0], memi32[retptr / 4 + 1]).slice();
                                    wasm.__wbindgen_free(memi32[retptr / 4 + 0], memi32[retptr / 4 + 1] * 1);
                                    return v0;
                                };

                                /**
                                 * @param {Uint8Array} base_compressed
                                 * @returns {Uint8Array}
                                 */
                                deflate_decode_raw = function(base_compressed) {
                                    const retptr = 8;
                                    const ret = wasm.deflate_decode_raw(retptr, passArray8ToWasm(base_compressed), WASM_VECTOR_LEN);
                                    const memi32 = getInt32Memory();
                                    const v0 = getArrayU8FromWasm(memi32[retptr / 4 + 0], memi32[retptr / 4 + 1]).slice();
                                    wasm.__wbindgen_free(memi32[retptr / 4 + 0], memi32[retptr / 4 + 1] * 1);
                                    return v0;
                                };

                                /**
                                 * @param {Uint8Array} base_raw
                                 * @returns {Uint8Array}
                                 */
                                deflate_encode_raw = function(base_raw) {
                                    const retptr = 8;
                                    const ret = wasm.deflate_encode_raw(retptr, passArray8ToWasm(base_raw), WASM_VECTOR_LEN);
                                    const memi32 = getInt32Memory();
                                    const v0 = getArrayU8FromWasm(memi32[retptr / 4 + 0], memi32[retptr / 4 + 1]).slice();
                                    wasm.__wbindgen_free(memi32[retptr / 4 + 0], memi32[retptr / 4 + 1] * 1);
                                    return v0;
                                };


                                console.log(deflate_encode("david"));
                                // console.log(deflate_decode("S0ksy0wBAA=="));
                                // console.log(deflate_decode("Y2AAAgA="));
                            });
                    });
            });
    });