Import zlib-wasm

example/zlib-wasm/LICENSE

+MIT License
+
+Copyright (c) 2017 ukyo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

example/zlib-wasm/README.md

+# zlib-wasm-without-emscripten-sample
+
+A zlib WebAssembly binary build sample with [dcodeIO/webassembly](https://github.com/dcodeIO/webassembly).
+
+## Initialize and Build code
+
+```
+$ git clone https://github.com/ukyo/zlib-wasm-without-emscripten-sample.git
+$ cd zlib-wasm-without-emsripten-sample
+$ npm install
+$ npm run build
+``` 
+
+## Example
+
+```js
+const myZlib = await require("./src/index").initialize();
+const deflated = myZlib.deflate(buffer);
+console.log(myZlib.inflate(deflated).equals(buffer));
+```
+
+## Benchmark
+
+* NodeJS: v8.9.1
+* OS: MacBook Pro
+* CPU: Intel Core i5 2.4GHz 
+* Memory: 16GB
+
+```
+$ npm run bench
+
+## lorem_1mb.txt size: 1000205
+wasm x 9.61 ops/sec ±4.48% (27 runs sampled)
+pako x 8.70 ops/sec ±2.26% (25 runs sampled)
+native x 15.21 ops/sec ±3.15% (41 runs sampled)
+Deflate: Fastest is native
+## deflated lorem_1mb.txt size: 257012
+wasm x 120 ops/sec ±10.26% (60 runs sampled)
+pako x 106 ops/sec ±8.56% (67 runs sampled)
+native x 211 ops/sec ±2.68% (74 runs sampled)
+Inflate: Fastest is native
+```

example/zlib-wasm/index.js

+"use strict";
+
+const fs = require("fs");
+const buff = fs.readFileSync("build/zlib-sample.wasm");
+let ret;
+
+module.exports.initialize = async () => {
+  if (ret) return ret;
+
+  const COMPRESSION_LEVEL = 6;
+  const NO_ZLIB_HEADER = -1;
+  const CHUNK_SIZE = 32 * 1024;
+  const map = {};
+  const memory = new WebAssembly.Memory({
+    initial: 1,
+    maximum: 1024, // 64MB
+  });
+  const env = {
+    memory,
+    writeToJs(ptr, size) {
+      const o = map[ptr];
+      o.onData(new Uint8Array(memory.buffer, dstPtr, size));
+    },
+    _abort: errno => { console.error(`Error: ${errno}`) },
+    _grow: () => { },
+  };
+
+  const module = await WebAssembly.compile(buff);
+  const ins = await WebAssembly.instantiate(module, { env });
+
+  const srcPtr = ins.exports._malloc(CHUNK_SIZE);
+  const dstPtr = ins.exports._malloc(CHUNK_SIZE);
+
+  class RawDef {
+    constructor() {
+      this.zstreamPtr = ins.exports._createDeflateContext(COMPRESSION_LEVEL, NO_ZLIB_HEADER);
+      map[this.zstreamPtr] = this;
+      this.offset = 0;
+      this.buff = new Uint8Array(CHUNK_SIZE);
+    }
+
+    deflate(chunk, flush) {
+      const src = new Uint8Array(memory.buffer, srcPtr, chunk.length);
+      src.set(chunk);
+      ins.exports._deflate(this.zstreamPtr, srcPtr, dstPtr, chunk.length, CHUNK_SIZE, flush);
+    }
+
+    onData(chunk) {
+      if (this.buff.length < this.offset + chunk.length) {
+        const buff = this.buff;
+        this.buff = new Uint8Array(this.buff.length * 2);
+        this.buff.set(buff);
+      }
+      this.buff.set(chunk, this.offset);
+      this.offset += chunk.length;
+    }
+
+    destroy() {
+      ins.exports._freeDeflateContext(this.zstreamPtr);
+      delete map[this.zstreamPtr];
+      this.buff = null;
+    }
+
+    getBuffer() {
+      return new Buffer(this.buff.buffer, 0, this.offset);
+    }
+  }
+
+  class RawInf {
+    constructor() {
+      this.zstreamPtr = ins.exports._createInflateContext(NO_ZLIB_HEADER);
+      map[this.zstreamPtr] = this;
+      this.offset = 0;
+      this.buff = new Uint8Array(CHUNK_SIZE);
+    }
+
+    inflate(chunk) {
+      const src = new Uint8Array(memory.buffer, srcPtr, chunk.length);
+      src.set(chunk);
+      ins.exports._inflate(this.zstreamPtr, srcPtr, dstPtr, chunk.length, CHUNK_SIZE);
+    }
+
+    onData(chunk) {
+      if (this.buff.length < this.offset + chunk.length) {
+        const buff = this.buff;
+        this.buff = new Uint8Array(this.buff.length * 2);
+        this.buff.set(buff);
+      }
+      this.buff.set(chunk, this.offset);
+      this.offset += chunk.length;
+    }
+
+    destroy() {
+      ins.exports._freeInflateContext(this.zstreamPtr);
+      delete map[this.zstreamPtr];
+      this.buff = null;
+    }
+
+    getBuffer() {
+      return new Buffer(this.buff.buffer, 0, this.offset);
+    }
+  }
+  
+  ret = {
+    inflate(rawDeflateBuffer) {
+      const rawInf = new RawInf();
+      for (let offset = 0; offset < rawDeflateBuffer.length; offset += CHUNK_SIZE) {
+        const end = Math.min(offset + CHUNK_SIZE, rawDeflateBuffer.length);
+        const chunk = rawDeflateBuffer.subarray(offset, end);
+        rawInf.inflate(chunk);
+      }
+      const ret = rawInf.getBuffer();
+      rawInf.destroy();
+      return ret;
+    },
+    deflate(rawInflateBuffer) {
+      const rawDef = new RawDef();
+      for (let offset = 0; offset < rawInflateBuffer.length; offset += CHUNK_SIZE) {
+        const end = Math.min(offset + CHUNK_SIZE, rawInflateBuffer.length);
+        const chunk = rawInflateBuffer.subarray(offset, end);
+        rawDef.deflate(chunk, rawInflateBuffer.length <= offset + CHUNK_SIZE);
+      }
+      const ret = rawDef.getBuffer();
+      rawDef.destroy();
+      return ret;
+    },
+  }
+
+  return ret;
+};