diff --git a/lib/deflate.js b/lib/deflate.js
index 6befbbf..ce29e7d 100644
--- a/lib/deflate.js
+++ b/lib/deflate.js
@@ -65,6 +65,23 @@ function sliceBuf(buf, size) {
  * - `chunkSize` - size of generated data chunks (16K by default)
  * - `raw` (boolean) - do raw deflate
  * - `gzip` (boolean) - create gzip wrapper
+ *
+ * ##### Example:
+ *
+ * ```javascript
+ * var pako = require('pako')
+ *   , chunk1 = Uint8Array([1,2,3,4,5,6,7,8,9])
+ *   , chunk2 = Uint8Array([10,11,12,13,14,15,16,17,18,19]);
+ *
+ * var deflate = new pako.Deflate({ level: 3});
+ *
+ * deflate.push(chunk1, false);
+ * deflate.push(chunk2, true);  // true -> last chunk
+ *
+ * if (deflate.err) { throw new Error(deflate.err); }
+ *
+ * console.log(deflate.result);
+ * ```
  **/
 var Deflate = function(options) {
 
@@ -118,6 +135,20 @@ var Deflate = function(options) {
  * [[Deflate#onEnd]].
  *
  * On fail call [[Deflate#onEnd]] with error code and return false.
+ *
+ * We strongly recommend to use `Uint8Array` on input for best speed (output
+ * format is detected automatically). Also, don't skip last param and always
+ * use the same type in your code (boolean or number). That will improve JS speed.
+ *
+ * For regular `Array`-s make sure all elements are [0..255].
+ *
+ * ##### Example
+ *
+ * ```javascript
+ * push(chunk, false); // push one of data chunks
+ * ...
+ * push(chunk, true);  // push last chunk
+ * ```
  **/
 Deflate.prototype.push = function(data, mode) {
   var strm = this.strm;
@@ -182,9 +213,9 @@ Deflate.prototype.onData = function(chunk) {
  * - status (Number): deflate status. 0 (Z_OK) on success,
  *   other if not.
  *
- * Called once after you tell deflate that input stream complete.
- * By default - join collected chunks, free memory and fill
- * `results` / `err` properties.
+ * Called once after you tell deflate that input stream complete
+ * or error happenned. By default - join collected chunks,
+ * free memory and fill `results` / `err` properties.
  **/
 Deflate.prototype.onEnd = function(status) {
   // On success - join
@@ -195,7 +226,6 @@ Deflate.prototype.onEnd = function(status) {
   this.err = status;
   // TODO: detect message by status, if not set in zstream
   this.msg = this.strm.msg || msg[status];
-  this.ended = true;
 };
 
 
@@ -215,6 +245,15 @@ Deflate.prototype.onEnd = function(status) {
  *
  * [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)
  * for more information on these.
+ *
+ * ##### Example:
+ *
+ * ```javascript
+ * var pako = require('pako')
+ *   , data = Uint8Array([1,2,3,4,5,6,7,8,9]);
+ *
+ * console.log(pako.deflate(data));
+ * ```
  **/
 function deflate(input, options) {
   var deflator = new Deflate(options);
diff --git a/lib/inflate.js b/lib/inflate.js
index 0907cc9..5c351ae 100644
--- a/lib/inflate.js
+++ b/lib/inflate.js
@@ -1,73 +1,269 @@
 'use strict';
 
-//var z_inflate = require('./zlib/inflate');
+
+var zlib_inflate = require('./zlib/inflate.js');
 var utils = require('./zlib/utils');
+var c = require('./zlib/constants');
+var msg = require('./zlib/messages');
+var zstream = require('./zlib/zstream');
 
+// return sliced buffer, trying to avoid new objects creation and mem copy
+function sliceBuf(buf, size) {
+  if (buf.length === size) { return buf; }
 
-var Inflate = function(/*options*/) {
-
-};
-
-
-Inflate.prototype.push = function(/*data_in*/) {
-
-};
-
-Inflate.prototype.finish = function() {
-
-};
-
-Inflate.prototype.onData = function(/*data_out*/) {
-
-};
-
-Inflate.prototype.onEnd = function(/*error*/) {
-
-};
-
-function inflate (input, options) {
-  var result;
-  var chains = [];
-  var inflator = new Inflate(options);
-
-  inflator.onData = function(data_out) {
-    chains.push(data_out);
-  };
-
-  inflator.onEnd = function(error) {
-    var i, l, len, pos, chain;
-
-    if (error) { throw error; }
-
-    // calculate data length
-    len = 0;
-    for (i=0, l=chains.length; i<l; i++) {
-      len += chains[i].length;
-    }
-
-    // join chains
-    result = utils.arrayCreate(len);
-    pos = 0;
-
-    for (i=0, l=chains.length; i<l; i++) {
-      chain = chains[i];
-      len = chain.length;
-      utils.arraySet(result, chain, 0, len, pos);
-      pos += len;
-    }
-  };
-
-  inflator.push(input);
-
-  return result;
+  return utils.typedOk() ? buf.subarray(0, size) : buf.slice(0, size);
 }
 
-function inflateRaw (input, options) {
+/**
+ * class Inflate
+ *
+ * Generic JS-style wrapper for zlib calls. If you don't need
+ * streaming behaviour - use more simple functions: [[inflate]]
+ * and [[inflateRaw]].
+ **/
+
+/* internal
+ * inflate.chunks -> Array
+ *
+ * Chunks of output data, if [[Inflate#onData]] not overriden.
+ **/
+
+/**
+ * Inflate.result -> Uint8Array|Array
+ *
+ * Uncompressed result, generated by default [[Inflate#onData]]
+ * and [[Inflate#onEnd]] handlers. Filled after you push last chunk
+ * (call [[Inflate#push]] with `Z_FINISH` / `true` param).
+ **/
+
+/**
+ * Inflate.err -> Number
+ *
+ * Error code after inflate finished. 0 (Z_OK) on success.
+ * Should be checked if broken data possible.
+ **/
+
+
+/**
+ * new Inflate(options)
+ * - options (Object): zlib inflate options.
+ *
+ * Creates new inflator instance with specified params. Supported options:
+ *
+ * - `windowBits`
+ *
+ * [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)
+ * for more information on these.
+ *
+ * Additional options, for internal needs:
+ *
+ * - `chunkSize` - size of generated data chunks (16K by default)
+ * - `raw` (boolean) - do raw inflate
+ *
+ * ##### Example:
+ *
+ * ```javascript
+ * var pako = require('pako')
+ *   , chunk1 = Uint8Array([1,2,3,4,5,6,7,8,9])
+ *   , chunk2 = Uint8Array([10,11,12,13,14,15,16,17,18,19]);
+ *
+ * var inflate = new pako.Inflate({ level: 3});
+ *
+ * inflate.push(chunk1, false);
+ * inflate.push(chunk2, true);  // true -> last chunk
+ *
+ * if (inflate.err) { throw new Error(inflate.err); }
+ *
+ * console.log(inflate.result);
+ * ```
+ **/
+var Inflate = function(options) {
+
+  this.options = utils.assign({
+    chunkSize: 16384,
+    windowBits: 15 + 32
+  }, options || {});
+
+  var opt = this.options;
+
+  if (opt.raw && (opt.windowBits > 0)) {
+    opt.windowBits = -opt.windowBits;
+  }
+
+  this.ended = false; // used to avoid multiple onEnd() calls
+  this.chunks = [];   // chunks of compressed data
+
+  this.strm = new zstream();
+
+  var status = zlib_inflate.inflateInit2(
+    this.strm,
+    opt.windowBits
+  );
+
+  if (status !== c.Z_OK) {
+    throw new Error(msg[status]);
+  }
+};
+
+/**
+ * Inflate#push(data[, mode]) -> Boolean
+ * - data (Uint8Array|Array): input data
+ * - mode (Number|Boolean): 0..6 for corresponding Z_NO_FLUSH..Z_TREE modes.
+ *   See constants. Skipped or `false` means Z_NO_FLUSH, `true` meansh Z_FINISH.
+ *
+ * Sends input data to inflate pipe, generating [[Inflate#onData]] calls with
+ * new output chunks. Returns `true` on success. The last data block must have
+ * mode Z_FINISH (or `true`). That flush internal pending buffers and call
+ * [[Inflate#onEnd]].
+ *
+ * On fail call [[Inflate#onEnd]] with error code and return false.
+ *
+ * We strongly recommend to use `Uint8Array` on input for best speed (output
+ * format is detected automatically). Also, don't skip last param and always
+ * use the same type in your code (boolean or number). That will improve JS speed.
+ *
+ * For regular `Array`-s make sure all elements are [0..255].
+ *
+ * ##### Example
+ *
+ * ```javascript
+ * push(chunk, false); // push one of data chunks
+ * ...
+ * push(chunk, true);  // push last chunk
+ * ```
+ **/
+Inflate.prototype.push = function(data, mode) {
+  var strm = this.strm;
+  var chunkSize = this.options.chunkSize;
+  var status, _mode;
+
+  if (this.ended) { return false; }
+
+  _mode = (mode === ~~mode) ? mode : ((mode === true) ? c.Z_FINISH : c.Z_NO_FLUSH);
+
+  strm.next_in = data;
+  strm.next_in_index = 0;
+  strm.avail_in = strm.next_in.length;
+  strm.next_out = utils.arrayCreate(chunkSize);
+
+  do {
+    strm.avail_out = this.options.chunkSize;
+    strm.next_out_index = 0;
+    status = zlib_inflate.inflate(strm, _mode);    /* no bad return value */
+
+    if (status !== c.Z_STREAM_END && status !== c.Z_OK) {
+      this.onEnd(status);
+      this.ended = true;
+      return false;
+    }
+    if(strm.next_out_index) {
+      this.onData(sliceBuf(strm.next_out, strm.next_out_index));
+      // Allocate buffer for next chunk, if not last
+      if (strm.avail_in > 0 || strm.avail_out === 0) {
+        strm.next_out = utils.arrayCreate(this.options.chunkSize);
+      }
+    }
+  } while (strm.avail_in > 0 || strm.avail_out === 0);
+
+  // Finalize on the last chunk.
+  if (_mode === c.Z_FINISH) {
+    status = zlib_inflate.inflateEnd(this.strm);
+    this.onEnd(status);
+    this.ended = true;
+    return status === c.Z_OK;
+  }
+
+  return true;
+};
+
+
+/**
+ * Inflate#onData(chunk) -> Void
+ * - chunk (Uint8Array|Array): ouput data. Type of array depends
+ *   on js engine support.
+ *
+ * By default, stores data blocks in `chunks[]` property and glue
+ * those in `onEnd`. Override this handler, if you need another behaviour.
+ **/
+Inflate.prototype.onData = function(chunk) {
+  this.chunks.push(chunk);
+};
+
+
+/**
+ * Inflate#onEnd(status) -> Void
+ * - status (Number): inflate status. 0 (Z_OK) on success,
+ *   other if not.
+ *
+ * Called once after you tell inflate that input stream complete
+ * or error happenned. By default - join collected chunks,
+ * free memory and fill `results` / `err` properties.
+ **/
+Inflate.prototype.onEnd = function(status) {
+  // On success - join
+  if (status === c.Z_OK) {
+    this.result = utils.flattenChunks(this.chunks);
+  }
+  this.chunks = [];
+  this.err = status;
+  // TODO: detect message by status, if not set in zstream
+  this.msg = this.strm.msg || msg[status];
+};
+
+
+/**
+ * inflate(data[, options]) -> Uint8Array|Array
+ * - data (Uint8Array|Array): input data to compress.
+ * - options (Object): zlib inflate options.
+ *
+ * Decompress `data` with inflate alrorythm and `options`.
+ *
+ * Supported options are:
+ *
+ * - windowBits
+ *
+ * [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)
+ * for more information on these.
+ *
+ * ##### Example:
+ *
+ * ```javascript
+ * var pako = require('pako')
+ *   , in = Uint8Array([1,2,3,4,5,6,7,8,9])
+ *   , out;
+ *
+ * out = pako.inflate(data);
+ * if (out.err) { throw new Error(out.err); }
+ * console.log(pako.inflate(out.result));
+ * ```
+ **/
+function inflate(input, options) {
+  var inflator = new Inflate(options);
+
+  inflator.push(input, true);
+
+  // That will never happens, if you don't cheat with options :)
+  if (inflator.err) { throw msg[inflator.err]; }
+
+  return inflator.result;
+}
+
+
+/**
+ * inflateRaw(data[, options]) -> Uint8Array|Array
+ * - data (Uint8Array|Array): input data to compress.
+ * - options (Object): zlib inflate options.
+ *
+ * The same as [[inflate]], but creates raw data, without wrapper
+ * (header and adler32 crc).
+ **/
+function inflateRaw(input, options) {
   options = options || {};
   options.raw = true;
   return inflate(input, options);
 }
 
+
 exports.Inflate = Inflate;
 exports.inflate = inflate;
-exports.inflateRaw = inflateRaw;
\ No newline at end of file
+exports.inflateRaw = inflateRaw;