A easy way to load in wasm-flate and use it's methods

wasm-flate-fetch-browser.js

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 = new Uint8Array(wasm.memory.buffer)
                                    }
                                    return cachegetNodeBufferMemory;
                                }

                                function passStringToWasm(arg) {

                                    const size = arg.length;
                                    const ptr = wasm.__wbindgen_malloc(size);
                                    var enc = new TextEncoder();
                                    var y = enc.encode(arg)
                                    getNodeBufferMemory().set(y, ptr)
                                    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) {
                                    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)
                                    const ret = wasm.deflate_encode(retptr, v, 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;
                                };

                                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("Y2AAAgA="));
                                // console.log(deflate_decode("S0ksy0wBAA=="));
                            });
                    });
            });
    });

I think wasm-flate functions should be declared with var or let for this file to work :
let deflate_encode = function(base_raw) {...};