wao 0.9.2 → 0.10.1

package/cjs/waosm-node/waosm_bg.js

@@ -0,0 +1,193 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Decompressor = exports.Compressor = void 0;
+exports.__wbg_buffer_609cc3eee51ed158 = __wbg_buffer_609cc3eee51ed158;
+exports.__wbg_length_a446193dc22c12f8 = __wbg_length_a446193dc22c12f8;
+exports.__wbg_newwithbyteoffsetandlength_d97e637ebe145a9a = __wbg_newwithbyteoffsetandlength_d97e637ebe145a9a;
+exports.__wbg_newwithlength_a381634e90c276d4 = __wbg_newwithlength_a381634e90c276d4;
+exports.__wbg_set_65595bdd868b3009 = __wbg_set_65595bdd868b3009;
+exports.__wbg_set_wasm = __wbg_set_wasm;
+exports.__wbindgen_memory = __wbindgen_memory;
+exports.__wbindgen_object_drop_ref = __wbindgen_object_drop_ref;
+exports.__wbindgen_throw = __wbindgen_throw;
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+var wasm;
+function __wbg_set_wasm(val) {
+  wasm = val;
+}
+var heap = new Array(128).fill(undefined);
+heap.push(undefined, null, true, false);
+function getObject(idx) {
+  return heap[idx];
+}
+var heap_next = heap.length;
+function addHeapObject(obj) {
+  if (heap_next === heap.length) heap.push(heap.length + 1);
+  var idx = heap_next;
+  heap_next = heap[idx];
+  heap[idx] = obj;
+  return idx;
+}
+function dropObject(idx) {
+  if (idx < 132) return;
+  heap[idx] = heap_next;
+  heap_next = idx;
+}
+function takeObject(idx) {
+  var ret = getObject(idx);
+  dropObject(idx);
+  return ret;
+}
+var lTextDecoder = typeof TextDecoder === 'undefined' ? (0, module.require)('util').TextDecoder : TextDecoder;
+var cachedTextDecoder = new lTextDecoder('utf-8', {
+  ignoreBOM: true,
+  fatal: true
+});
+cachedTextDecoder.decode();
+var cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+  if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+    cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+  }
+  return cachedUint8ArrayMemory0;
+}
+function getStringFromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+var WASM_VECTOR_LEN = 0;
+function passArray8ToWasm0(arg, malloc) {
+  var ptr = malloc(arg.length * 1, 1) >>> 0;
+  getUint8ArrayMemory0().set(arg, ptr / 1);
+  WASM_VECTOR_LEN = arg.length;
+  return ptr;
+}
+var CompressorFinalization = typeof FinalizationRegistry === 'undefined' ? {
+  register: function register() {},
+  unregister: function unregister() {}
+} : new FinalizationRegistry(function (ptr) {
+  return wasm.__wbg_compressor_free(ptr >>> 0, 1);
+});
+var Compressor = exports.Compressor = /*#__PURE__*/function () {
+  function Compressor() {
+    _classCallCheck(this, Compressor);
+    var ret = wasm.compressor_new();
+    this.__wbg_ptr = ret >>> 0;
+    CompressorFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+  /**
+   * @param {Uint8Array} data
+   * @returns {Uint8Array}
+   */
+  return _createClass(Compressor, [{
+    key: "__destroy_into_raw",
+    value: function __destroy_into_raw() {
+      var ptr = this.__wbg_ptr;
+      this.__wbg_ptr = 0;
+      CompressorFinalization.unregister(this);
+      return ptr;
+    }
+  }, {
+    key: "free",
+    value: function free() {
+      var ptr = this.__destroy_into_raw();
+      wasm.__wbg_compressor_free(ptr, 0);
+    }
+  }, {
+    key: "compress",
+    value: function compress(data) {
+      var ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+      var len0 = WASM_VECTOR_LEN;
+      var ret = wasm.compressor_compress(this.__wbg_ptr, ptr0, len0);
+      return takeObject(ret);
+    }
+  }]);
+}();
+var DecompressorFinalization = typeof FinalizationRegistry === 'undefined' ? {
+  register: function register() {},
+  unregister: function unregister() {}
+} : new FinalizationRegistry(function (ptr) {
+  return wasm.__wbg_decompressor_free(ptr >>> 0, 1);
+});
+var Decompressor = exports.Decompressor = /*#__PURE__*/function () {
+  function Decompressor() {
+    _classCallCheck(this, Decompressor);
+    var ret = wasm.compressor_new();
+    this.__wbg_ptr = ret >>> 0;
+    DecompressorFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+  /**
+   * @param {Uint8Array} data
+   * @returns {Uint8Array}
+   */
+  return _createClass(Decompressor, [{
+    key: "__destroy_into_raw",
+    value: function __destroy_into_raw() {
+      var ptr = this.__wbg_ptr;
+      this.__wbg_ptr = 0;
+      DecompressorFinalization.unregister(this);
+      return ptr;
+    }
+  }, {
+    key: "free",
+    value: function free() {
+      var ptr = this.__destroy_into_raw();
+      wasm.__wbg_decompressor_free(ptr, 0);
+    }
+  }, {
+    key: "decompress",
+    value: function decompress(data) {
+      var ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+      var len0 = WASM_VECTOR_LEN;
+      var ret = wasm.decompressor_decompress(this.__wbg_ptr, ptr0, len0);
+      return takeObject(ret);
+    }
+  }]);
+}();
+function __wbg_buffer_609cc3eee51ed158(arg0) {
+  var ret = getObject(arg0).buffer;
+  return addHeapObject(ret);
+}
+;
+function __wbg_length_a446193dc22c12f8(arg0) {
+  var ret = getObject(arg0).length;
+  return ret;
+}
+;
+function __wbg_newwithbyteoffsetandlength_d97e637ebe145a9a(arg0, arg1, arg2) {
+  var ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
+  return addHeapObject(ret);
+}
+;
+function __wbg_newwithlength_a381634e90c276d4(arg0) {
+  var ret = new Uint8Array(arg0 >>> 0);
+  return addHeapObject(ret);
+}
+;
+function __wbg_set_65595bdd868b3009(arg0, arg1, arg2) {
+  getObject(arg0).set(getObject(arg1), arg2 >>> 0);
+}
+;
+function __wbindgen_memory() {
+  var ret = wasm.memory;
+  return addHeapObject(ret);
+}
+;
+function __wbindgen_object_drop_ref(arg0) {
+  takeObject(arg0);
+}
+;
+function __wbindgen_throw(arg0, arg1) {
+  throw new Error(getStringFromWasm0(arg0, arg1));
+}
+;

package/cjs/waosm-node.js

@@ -0,0 +1,28 @@
+"use strict";
+
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _waosm_bg = _interopRequireWildcard(require("./waosm-node/waosm_bg.js"));
+var wasmBindings = _waosm_bg;
+Object.keys(_waosm_bg).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _waosm_bg[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _waosm_bg[key];
+    }
+  });
+});
+var _fs = require("fs");
+var _path = require("path");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
+var wasm = (0, _fs.readFileSync)((0, _path.resolve)(import.meta.dirname, "./waosm-node/waosm_bg.wasm"));
+var wasmModule = new WebAssembly.Module(wasm);
+var wasmInstance = new WebAssembly.Instance(wasmModule, {
+  "./waosm_bg.js": wasmBindings
+});
+(0, _waosm_bg.__wbg_set_wasm)(wasmInstance.exports);

package/esm/ao.js

@@ -369,7 +369,6 @@ class AO {
         data: jsonToStr(data),
       })
     } catch (e) {
-      console.log(e)
       err = e
     }
     const p = pid ? this.p(pid) : null
@@ -405,8 +404,7 @@ class AO {
         }
       }
     }
-    const checkOut = async (get, _txs, _txmap) => {
-      let out = null
+    const checkOut = async (get, _txs, _txmap, out) => {
       for (let v of _txs) {
         if (isNil(_txmap[v.id].res)) {
           const res = await this.result({ process: pid, message: v.id })
@@ -414,8 +412,9 @@ class AO {
         }
         if (!isNil(_txmap[v.id].res) && _txmap[v.id].out !== true) {
           _txmap[v.id].out = true
-          out = getTagVal(get, _txmap[v.id].res, v.from)
-          if (out) break
+          const _out = getTagVal(get, _txmap[v.id].res, v.from)
+          out = mergeOut(out, _out, get)
+          if (isOutComplete(out, get)) break
         }
       }
       return out
@@ -455,14 +454,15 @@ class AO {
         await wait(1000)
         await getNewTxs(pid, _txs, _txmap)
       } while (Date.now() - start < timeout)
+
       if (!checked) {
         err = "something went wrong!"
       } else {
-        out = mergeOut(out, await checkOut(get, _txs, _txmap), get)
+        out = mergeOut(out, await checkOut(get, _txs, _txmap, out), get)
         if (!isOutComplete(out, get) && !isNil(get)) {
           while (Date.now() - start < timeout) {
             await getNewTxs(pid, _txs, _txmap)
-            out = mergeOut(out, await checkOut(get, _txs, _txmap), get)
+            out = mergeOut(out, await checkOut(get, _txs, _txmap, out), get)
             if (isOutComplete(out, get)) break
             await wait(1000)
           }

package/esm/aoconnect-base.js

@@ -221,7 +221,7 @@ export default ({ AR, scheduler, mu, su, cu, acc, AoLoader, ArMem } = {}) => {
 
     const assign = async opt => {
       const p = await mem.get("env", opt.process)
-      if (!p) return null
+      if (!p || !opt.process) return null
       let _opt = await mem.get("msgs", opt.message)
       let hash = genHashChain(p.hash, opt.message)
       p.hash = hash

package/esm/armem-base.js

@@ -1,12 +1,25 @@
 import _Arweave from "arweave"
 const Arweave = _Arweave.default ?? _Arweave
-
-import { last } from "ramda"
+import { compress, decompress } from "./compress.js"
+import { last, assoc, is } from "ramda"
 import { buildTags, tags } from "./utils.js"
 
 export default class ArMemBase {
-  constructor({ MU_URL, CU_URL, SU_URL, GATEWAY_URL, scheduler, cache } = {}) {
+  constructor({
+    MU_URL,
+    CU_URL,
+    SU_URL,
+    GATEWAY_URL,
+    scheduler,
+    cache,
+    init,
+    Compressor,
+    Decompressor,
+  } = {}) {
     this.__type__ = "mem"
+    this._init = init
+    this.Compressor = Compressor
+    this.Decompressor = Decompressor
     this.isInit = false
     this.keyInit = false
     this.keys = {}
@@ -34,7 +47,22 @@ export default class ArMemBase {
     } else {
       this[key] ??= {}
       this[key][field] = val
-      if (this.db) await this.db.put(`${key}.${field}`, this[key][field])
+      if (this.db) {
+        if (key === "env") {
+          let memory = val.memory
+          try {
+            memory = Array.from(this.compressor.compress(val.memory))
+          } catch (e) {
+            memory = compress(val.memory)
+          }
+          await this.db.put(
+            `${key}.${field}`,
+            assoc("memory", memory, this[key][field]),
+          )
+        } else {
+          await this.db.put(`${key}.${field}`, this[key][field])
+        }
+      }
     }
   }
   initSync() {
@@ -118,6 +146,9 @@ export default class ArMemBase {
   async init() {
     if (this.isInit) return
     this.isInit = true
+    if (typeof this._init === "function") await this._init()
+    this.compressor = new this.Compressor()
+    this.decompressor = new this.Decompressor()
     if (this.db) {
       for (const v of ["height", "blocks"]) this[v] = await this.get(v)
       for (const v of [
@@ -136,7 +167,21 @@ export default class ArMemBase {
         for (const v2 of items || []) {
           const key = v2.split(".")[0]
           const field = v2.split(".")[1]
-          if (key === v) this[v][field] = await this.db.get(v2)
+          if (key === v) {
+            if (key.match(/^env/)) {
+              let v3 = await this.db.get(v2)
+              if (is(Array, v3.memory)) {
+                try {
+                  v3.memory = this.decompressor.decompress(v3.memory)
+                } catch (e) {
+                  v3.memory = decompress(v3.memory)
+                }
+              }
+              this[v][field] = v3
+            } else {
+              this[v][field] = await this.db.get(v2)
+            }
+          }
         }
       }
     } else {
@@ -163,9 +208,7 @@ export default class ArMemBase {
           format = tags(tx.tags)["Module-Format"]
         }
       }
-    } else {
-      format = _wasm.format
-    }
+    } else format = _wasm.format
     format ??= "wasm64-unknown-emscripten-draft_2024_02_15"
     return { format, mod, wasm }
   }

package/esm/armem-web.js

@@ -1,10 +1,11 @@
 import wdb from "./lua/weavedb-lite.js"
 import Base from "./armem-base.js"
 import db from "./lfdb.js"
+import init, { Compressor, Decompressor } from "./waosm/waosm.js"
 
 export default class ArMem extends Base {
   constructor(args = {}) {
-    super(args)
+    super({ ...args, init, Compressor, Decompressor })
     this.db = db(this)
     this.initSync()
   }

package/esm/armem.js

@@ -5,11 +5,12 @@ import { open } from "lmdb"
 import { readFileSync } from "fs"
 import { resolve } from "path"
 import Base from "./armem-base.js"
+import { Compressor, Decompressor } from "./waosm-node.js"
 
 export default class ArMem extends Base {
   constructor(args = {}) {
     const { cache } = args
-    super(args)
+    super({ ...args, Compressor, Decompressor })
     if (cache) this.db = open({ path: cache, compression: true })
     this.initSync()
   }

package/esm/build.js

@@ -0,0 +1,7 @@
+import fs from "fs"
+
+const wasmBytes = fs.readFileSync("./waosm/waosm_bg.wasm")
+const wasmB64 = wasmBytes.toString("base64")
+
+const exports = `export const wasmB64 = "${wasmB64}";`
+fs.writeFileSync("./waosm/waosm_b64.js", exports)

package/esm/compress.js

@@ -0,0 +1,113 @@
+function toBase256(n) {
+  let result = []
+  while (n > 0) {
+    result.unshift(n % 256)
+    n = Math.floor(n / 256)
+  }
+  return [result.length, ...result]
+}
+
+const _comp = (arr, _arr, mode) => {
+  let _nums = null
+  let _elms = null
+  let len = _arr.length
+  let flag = 0
+  if (mode === 1 && _arr[0] !== 0) {
+    flag += 100
+    _elms = [_arr[0]]
+  } else if (mode === 2) {
+    flag += 200
+    _elms = _arr
+  }
+  if (len < 10) flag += len
+  else if (len !== 10) {
+    const [elm, ...nums] = toBase256(len)
+    _nums = nums
+    flag += elm * 10
+    if (_nums[0] < 10) flag += _nums.shift()
+  }
+  arr.push(flag)
+  if (_nums) for (const n of _nums) arr.push(n)
+  if (_elms) for (const n of _elms) arr.push(n)
+}
+
+export const compress = d => {
+  let _arr = []
+  let mode = 1
+  let prev = null
+  let max = 0
+  let arr = []
+  for (const v of d) {
+    if (prev === null) _arr.push(v)
+    else if (_arr.length === 1) {
+      mode = prev !== v ? 2 : 1
+      _arr.push(v)
+    } else {
+      if (prev !== v && mode === 1) {
+        _comp(arr, _arr, mode)
+        _arr = [v]
+        mode = 2
+      } else if (prev === v && mode === 2) {
+        const last = _arr.pop()
+        _comp(arr, _arr, mode)
+        _arr = [last, v]
+        mode = 1
+      } else {
+        _arr.push(v)
+      }
+    }
+    prev = v
+  }
+  if (_arr.length > 0) _comp(arr, _arr, mode)
+  return arr
+}
+
+export const decompress = d => {
+  let arr = []
+  let flag = null
+  let elm = 0
+  let sum = 0
+  let nums = []
+  let first = null
+  let second = null
+  let third = null
+  for (let v of d) {
+    if (flag === null) {
+      flag = v
+      first = Math.floor(flag / 100)
+      second = Math.floor((flag - first * 100) / 10)
+      third = flag - first * 100 - second * 10
+      nums = []
+      if (second === 0) {
+        nums.push(third === 0 ? 10 : third)
+        elm = 0
+      } else if (third !== 0) {
+        nums.push(third)
+        elm = second - 1
+      } else elm = second
+      console.log(flag, first, second, third, elm, nums)
+    } else if (sum === 0) {
+      elm -= 1
+      nums.push(v)
+    }
+    if (sum > 0) {
+      if (first === 2) arr.push(v)
+      else if (first === 1) for (let i = 0; i < to10(nums); i++) arr.push(v)
+      sum -= 1
+      if (sum === 0) flag = null
+    } else if (elm === 0) {
+      if (first === 0) {
+        for (let i = 0; i < to10(nums); i++) arr.push(0)
+        flag = null
+      } else if (first === 2) sum = to10(nums)
+      else sum = 1
+    }
+  }
+  return new Uint8Array(arr)
+}
+
+function to10(arr) {
+  let num = 0
+  for (let i = 0; i < arr.length; i++) num = num * 256 + arr[i]
+  return num
+}

package/esm/lfdb.js

@@ -4,6 +4,7 @@ import { is, keys } from "ramda"
 export default _this => {
   return {
     put: async (key, val) => {
+      console.log(key, val)
       let _val = null
       if (typeof val === "object" && !is(Array, val)) {
         _val = {}
@@ -48,9 +49,7 @@ export default _this => {
       _this.keys[key] = true
       await lf.setItem("keys", keys(_this.keys))
     },
-    get: async key => {
-      return await lf.getItem(key)
-    },
+    get: async key => await lf.getItem(key),
     getKeys: async ({ start, end }) => {
       if (!_this.keyInit) {
         const _keys = (await lf.getItem("keys")) ?? []

package/esm/waosm/README.md

@@ -0,0 +1,79 @@
+# Waosm Compressor
+
+Waosm is a lightweight new compression algorithm to efficiently compress Wasm memory.
+
+It is implemented in Rust and compiled to Wasm for better performance in browsers.
+
+```bash
+yarn build
+```
+
+Using Waosm in nodejs.
+
+```js
+import init, { Compressor, Decompressor } from "../src/waosm-node.js"
+
+const main = async ()=>{
+  await init()
+  const compressor = new Compressor()
+  const decompressor = new Decompressor()
+  const memory = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 0])
+  console.log(memory)
+  const compressed = compressor.compress(memory)
+  console.log(compressed)
+  const decompressed = decompressor.decompress(compressed)
+  console.log(decompressed)
+}
+main()
+```
+
+## How Compression Works
+
+Waosm Compression is a simple LRF variant that sequentially processes 8-bit integers. It is specifically optimized for zero-padded Wasm memory, achieving a 99% compression rate for largely idle WebAssembly memory. This enables efficient handling of large WebAssembly modules in browser environments.
+
+The algorithm packs integers into chunks with 3 parts.
+
+- flag
+- 256-base number to tell the number of element in the current chunk
+- actuall 8-bit intergers
+
+### Flag
+
+A flag is a 1 byte (8 bits) integer, which ranges from 0 to 255. So there are 3 digits.
+
+- 1st digit: `mode`
+  - `0`: a sequence of 0s
+  - `1`: a sequence of a single repeating 8 bit integer
+  - `2`: a sequence of multiple unique 8 bit integer
+- 2nd digit:
+  - `0`: the 3rd digit is the number of elements, no 256-base number required in this case
+  - `1-9`: the number of integers to represent the 256-base number
+- 3rd digit:
+    - if the 2nd digit is `0`, the 3rd digit represents the number of the elements, `0` represents `10`
+	- otherwise, the 3rd digit represents the first integer in the 256-base number representation
+	
+### 256-Base Number
+
+This part tells how many 8-bit integers are in the current chunk. For instance,
+- `2, 200` = (256 ** 1 * 2) + 200 = 712
+- `5, 50, 200` = (256 ** 2 * 5) + (256 ** 1 * 50) + 200 = 340680
+
+Note that for space efficiency, the first integer is in the flag in some cases.
+
+### 8 Bit Elements
+
+- `Mode 0`: no need for this part since we know it's a sequence of 0
+- `Mode 1`: 1 integer to tell which integer of a sequence this chunk is
+- `Mode 2`: the entire integers are required
+
+## Examples
+
+`[ 1, 2, 3, 4, 5, 5, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]` (28 bytes)
+
+- `204` | `-` | `1, 2, 3, 4`
+- `103` | `-` | `5`
+- `204` | `-` | `6, 7, 8, 9`
+- `010` | `17` | `-`
+
+It becomes `[204, 1, 2, 3, 4, 103, 5, 204, 6, 7, 8, 9, 10, 17]` (14 bytes - 50% compression rate).
+

package/esm/waosm/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "waosm",
+  "version": "0.1.0",
+  "files": [
+    "waosm_bg.wasm",
+    "waosm.js",
+    "waosm.d.ts"
+  ],
+  "module": "waosm.js",
+  "types": "waosm.d.ts",
+  "sideEffects": [
+    "./snippets/*"
+  ]
+}

package/esm/waosm/waosm.d.ts

@@ -0,0 +1,46 @@
+/* tslint:disable */
+/* eslint-disable */
+export class Compressor {
+  free(): void;
+  constructor();
+  compress(data: Uint8Array): Uint8Array;
+}
+export class Decompressor {
+  free(): void;
+  constructor();
+  decompress(data: Uint8Array): Uint8Array;
+}
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+  readonly memory: WebAssembly.Memory;
+  readonly __wbg_compressor_free: (a: number, b: number) => void;
+  readonly compressor_new: () => number;
+  readonly compressor_compress: (a: number, b: number, c: number) => number;
+  readonly decompressor_decompress: (a: number, b: number, c: number) => number;
+  readonly __wbg_decompressor_free: (a: number, b: number) => void;
+  readonly decompressor_new: () => number;
+  readonly __wbindgen_malloc: (a: number, b: number) => number;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+/**
+* Instantiates the given `module`, which can either be bytes or
+* a precompiled `WebAssembly.Module`.
+*
+* @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+*
+* @returns {InitOutput}
+*/
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+* If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+* for everything else, calls `WebAssembly.instantiate` directly.
+*
+* @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+*
+* @returns {Promise<InitOutput>}
+*/
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;