Remove an unnecessary 'use strict'.

.gitignore

@@ -1,2 +1,2 @@
+lib
 node_modules
-package-lock.json

.npmignore

@@ -0,0 +1,6 @@
+.git
+.gitignore
+.npmignore
+.travis.yml
+node_modules
+spec

.travis.yml

@@ -1,19 +1,12 @@
-sudo: false
 language: node_js
 
 node_js:
   - "0.8"
   - "0.10"
   - "0.12"
-  - "4"
-  - "5"
-  - "6"
-  - "7"
-  - "8"
-  - "9"
-  - "10"
-  - "11"
-  - "12"
+  - "iojs"
 
 before_install:
-  - '[ "${TRAVIS_NODE_VERSION}" = "0.8" ] && npm install -g npm@~1.4.0 || true'
+  - '[ "${TRAVIS_NODE_VERSION}" != "0.8" ] || npm install -g npm@~1.4.0'
+
+script: make test

CHANGELOG.md

@@ -1,38 +1,14 @@
-### 0.1.7 / 2019-06-10
-
-- Use the `Buffer.alloc()` and `Buffer.from()` functions instead of the unsafe
-  `Buffer()` constructor
-
-### 0.1.6 / 2017-09-10
-
-- Use `9` instead of `8` as the `windowBits` parameter to zlib, to deal with
-  restrictions introduced in zlib v1.2.9
-
-### 0.1.5 / 2016-02-24
-
-- Catch errors thrown by `close()` on zlib streams
-
-### 0.1.4 / 2015-11-06
-
-- The server does not send `server_max_window_bits` if the client does not ask
-  for it; this works around an issue in Firefox.
-
-### 0.1.3 / 2015-04-10
-
-- Fix a race condition causing some fragments of deflate output to be dropped
-- Make sure to emit minimal output on all Node versions
-
 ### 0.1.2 / 2014-12-18
 
-- Don't allow configure() to be called with unrecognized options
+* Don't allow configure() to be called with unrecognized options
 
 ### 0.1.1 / 2014-12-15
 
-- Fix race condition when using context takeover, where adjacent messages have
+* Fix race condition when using context takeover, where adjacent messages have
   data listeners bound at the same time and end up duplicating output
-- Use `DeflateRaw.flush()` correctly on v0.10 so that optimal compression is
+* Use `DeflateRaw.flush()` correctly on v0.10 so that optimal compression is
   achieved
 
 ### 0.1.0 / 2014-12-13
 
-- Initial release
+* Initial release

CODE_OF_CONDUCT.md

@@ -1,4 +0,0 @@
-# Code of Conduct
-
-All projects under the [Faye](https://github.com/faye) umbrella are covered by
-the [Code of Conduct](https://github.com/faye/code-of-conduct).

LICENSE.md

@@ -1,12 +0,0 @@
-Copyright 2014-2019 James Coglan
-
-Licensed under the Apache License, Version 2.0 (the "License"); you may not use
-this file except in compliance with the License. You may obtain a copy of the
-License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software distributed
-under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-CONDITIONS OF ANY KIND, either express or implied. See the License for the
-specific language governing permissions and limitations under the License.

Makefile

@@ -0,0 +1,19 @@
+SHELL := /bin/bash
+PATH  := node_modules/.bin:$(PATH)
+
+source_files := $(shell find src -name '*.js')
+target_files := $(source_files:src/%.js=lib/%.js)
+
+.PHONY: all clean test
+
+all: $(target_files)
+
+lib/%.js: src/%.js
+	mkdir -p $(dir $@)
+	babel $< --out-file $@ --source-maps true
+
+clean:
+	rm -rf lib
+
+test: all
+	jstest spec/runner.js

README.md

@@ -11,7 +11,7 @@ WebSocket protocol extension as a plugin for
 $ npm install permessage-deflate
 ```
 
-## Usage
+## Usage
 
 Add the plugin to your extensions:
 
@@ -45,25 +45,48 @@ the peer, and those that are negotiated as part of the protocol. The settings
 only affecting the compressor are described fully in the [zlib
 documentation](http://nodejs.org/api/zlib.html#zlib_options):
 
-- `level`: sets the compression level, can be an integer from `0` to `9`, or one
+* `level`: sets the compression level, can be an integer from `0` to `9`, or one
   of the constants `zlib.Z_NO_COMPRESSION`, `zlib.Z_BEST_SPEED`,
   `zlib.Z_BEST_COMPRESSION`, or `zlib.Z_DEFAULT_COMPRESSION`
-- `memLevel`: sets how much memory the compressor allocates, can be an integer
+* `memLevel`: sets how much memory the compressor allocates, can be an integer
   from `1` to `9`, or one of the constants `zlib.Z_MIN_MEMLEVEL`,
   `zlib.Z_MAX_MEMLEVEL`, or `zlib.Z_DEFAULT_MEMLEVEL`
-- `strategy`: can be one of the constants `zlib.Z_FILTERED`,
+* `strategy`: can be one of the constants `zlib.Z_FILTERED`,
   `zlib.Z_HUFFMAN_ONLY`, `zlib.Z_RLE`, `zlib.Z_FIXED`, or
   `zlib.Z_DEFAULT_STRATEGY`
 
 The other options relate to settings that are negotiated via the protocol and
 can be used to set the local session's behaviour and control that of the peer:
 
-- `noContextTakeover`: if `true`, stops the session reusing a deflate context
+* `noContextTakeover`: if `true`, stops the session reusing a deflate context
   between messages
-- `requestNoContextTakeover`: if `true`, makes the session tell the other peer
+* `requestNoContextTakeover`: if `true`, makes the session tell the other peer
   not to reuse a deflate context between messages
-- `maxWindowBits`: an integer from `8` to `15` inclusive that sets the maximum
+* `maxWindowBits`: an integer from `8` to `15` inclusive that sets the maximum
   size of the session's sliding window; a lower window size will be used if
   requested by the peer
-- `requestMaxWindowBits`: an integer from `8` to `15` inclusive to ask the other
+* `requestMaxWindowBits`: an integer from `8` to `15` inclusive to ask the other
   peer to use to set its maximum sliding window size, if supported
+
+## License
+
+(The MIT License)
+
+Copyright (c) 2014-2015 James Coglan
+
+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.

examples/roundtrip.js

@@ -1,52 +0,0 @@
-var fs      = require('fs'),
-    deflate = require('..');
-
-var records = fs.readFileSync(__dirname + '/bad.out.log', 'utf8')
-              .replace(/\s*$/g, '')
-              .split(/\n/)
-              .map(JSON.parse);
-
-var client     = deflate.createClientSession(),
-    offer      = client.generateOffer(),
-    server     = deflate.createServerSession([offer]),
-    response   = server.generateResponse(),
-    compressed = [],
-    size       = [0, 0];
-
-client.activate(response);
-
-function compress(index) {
-  var record = records[index];
-  if (!record) {
-    console.log(size, size[0] / size[1]);
-    return decompress(0);
-  }
-
-  var message = {data: new Buffer(record[3], 'base64')};
-  size[0] += message.data.length;
-
-  server.processOutgoingMessage(message, function(error, message) {
-    compressed[index] = message;
-    size[1] += message.data.length;
-    compress(index + 1);
-  });
-}
-
-function decompress(index) {
-  var record = records[index];
-  if (!record) return;
-
-  var payload = record[3],
-      message = compressed[index];
-
-  client.processIncomingMessage(message, function(error, message) {
-    var output = message.data.toString('base64');
-    if (output !== payload) {
-      console.error('Failed on', record, message);
-      process.exit(1);
-    }
-    decompress(index + 1);
-  });
-}
-
-compress(0);

lib/client_session.js

@@ -1,77 +0,0 @@
-'use strict';
-
-var util    = require('util'),
-    common  = require('./common'),
-    Session = require('./session');
-
-var ClientSession = function(options) {
-  Session.call(this, options);
-};
-util.inherits(ClientSession, Session);
-
-ClientSession.validParams = function(params) {
-  if (!common.validParams(params)) return false;
-
-  if (params.hasOwnProperty('client_max_window_bits')) {
-    if (common.VALID_WINDOW_BITS.indexOf(params.client_max_window_bits) < 0)
-      return false;
-  }
-  return true;
-};
-
-ClientSession.prototype.generateOffer = function() {
-  var offer = {};
-
-  if (this._acceptNoContextTakeover)
-    offer.client_no_context_takeover = true;
-
-  if (this._acceptMaxWindowBits !== undefined) {
-    if (common.VALID_WINDOW_BITS.indexOf(this._acceptMaxWindowBits) < 0) {
-      throw new Error('Invalid value for maxWindowBits');
-    }
-    offer.client_max_window_bits = this._acceptMaxWindowBits;
-  } else {
-    offer.client_max_window_bits = true;
-  }
-
-  if (this._requestNoContextTakeover)
-    offer.server_no_context_takeover = true;
-
-  if (this._requestMaxWindowBits !== undefined) {
-    if (common.VALID_WINDOW_BITS.indexOf(this._requestMaxWindowBits) < 0) {
-      throw new Error('Invalid value for requestMaxWindowBits');
-    }
-    offer.server_max_window_bits = this._requestMaxWindowBits;
-  }
-
-  return offer;
-};
-
-ClientSession.prototype.activate = function(params) {
-  if (!ClientSession.validParams(params)) return false;
-
-  if (this._acceptMaxWindowBits && params.client_max_window_bits) {
-    if (params.client_max_window_bits > this._acceptMaxWindowBits) return false;
-  }
-
-  if (this._requestNoContextTakeover && !params.server_no_context_takeover)
-    return false;
-
-  if (this._requestMaxWindowBits) {
-    if (!params.server_max_window_bits) return false;
-    if (params.server_max_window_bits > this._requestMaxWindowBits) return false;
-  }
-
-  this._ownContextTakeover = !(this._acceptNoContextTakeover || params.client_no_context_takeover);
-  this._ownWindowBits = Math.min(
-    this._acceptMaxWindowBits || common.MAX_WINDOW_BITS,
-    params.client_max_window_bits || common.MAX_WINDOW_BITS
-  );
-
-  this._peerContextTakeover = !params.server_no_context_takeover;
-  this._peerWindowBits = params.server_max_window_bits || common.MAX_WINDOW_BITS;
-
-  return true;
-};
-
-module.exports = ClientSession;

lib/common.js

@@ -1,50 +0,0 @@
-'use strict';
-
-var Buffer = require('safe-buffer').Buffer;
-
-var common = {
-  VALID_PARAMS: [
-    'server_no_context_takeover',
-    'client_no_context_takeover',
-    'server_max_window_bits',
-    'client_max_window_bits'
-  ],
-
-  MIN_WINDOW_BITS:   9,
-  MAX_WINDOW_BITS:   15,
-  VALID_WINDOW_BITS: [8, 9, 10, 11, 12, 13, 14, 15],
-
-  fetch: function(options, key, _default) {
-    if (options.hasOwnProperty(key))
-      return options[key];
-    else
-      return _default;
-  },
-
-  validateOptions: function(options, validKeys) {
-    for (var key in options) {
-      if (validKeys.indexOf(key) < 0)
-        throw new Error('Unrecognized option: ' + key);
-    }
-  },
-
-  validParams: function(params) {
-    var keys = Object.keys(params), i = keys.length;
-    while (i--) {
-      if (this.VALID_PARAMS.indexOf(keys[i]) < 0) return false;
-      if (params[keys[i]] instanceof Array) return false;
-    }
-    if (params.hasOwnProperty('server_no_context_takeover')) {
-      if (params.server_no_context_takeover !== true) return false;
-    }
-    if (params.hasOwnProperty('client_no_context_takeover')) {
-      if (params.client_no_context_takeover !== true) return false;
-    }
-    if (params.hasOwnProperty('server_max_window_bits')) {
-      if (this.VALID_WINDOW_BITS.indexOf(params.server_max_window_bits) < 0) return false;
-    }
-    return true;
-  }
-};
-
-module.exports = common;

lib/permessage_deflate.js

@@ -1,45 +0,0 @@
-'use strict';
-
-var ClientSession = require('./client_session'),
-    ServerSession = require('./server_session'),
-    common        = require('./common');
-
-var VALID_OPTIONS = [
-  'level',
-  'memLevel',
-  'strategy',
-  'noContextTakeover',
-  'maxWindowBits',
-  'requestNoContextTakeover',
-  'requestMaxWindowBits',
-  'zlib'
-];
-
-var PermessageDeflate = {
-  configure: function(options) {
-    common.validateOptions(options, VALID_OPTIONS);
-    var opts = this._options || {};
-    for (var key in opts) options[key] = opts[key];
-    return Object.create(this, {_options: {value: options}});
-  },
-
-  createClientSession: function() {
-    return new ClientSession(this._options || {});
-  },
-
-  createServerSession: function(offers) {
-    for (var i = 0, n = offers.length; i < n; i++) {
-      if (ServerSession.validParams(offers[i]))
-        return new ServerSession(this._options || {}, offers[i]);
-    }
-    return null;
-  },
-
-  name: 'permessage-deflate',
-  type: 'permessage',
-  rsv1: true,
-  rsv2: false,
-  rsv3: false
-};
-
-module.exports = PermessageDeflate;

lib/server_session.js

@@ -1,66 +0,0 @@
-'use strict';
-
-var util    = require('util'),
-    common  = require('./common'),
-    Session = require('./session');
-
-var ServerSession = function(options, params) {
-  Session.call(this, options);
-  this._params = params;
-};
-util.inherits(ServerSession, Session);
-
-ServerSession.validParams = function(params) {
-  if (!common.validParams(params)) return false;
-
-  if (params.hasOwnProperty('client_max_window_bits')) {
-    if ([true].concat(common.VALID_WINDOW_BITS).indexOf(params.client_max_window_bits) < 0)
-      return false;
-  }
-  return true;
-};
-
-ServerSession.prototype.generateResponse = function() {
-  var response = {};
-
-  // https://tools.ietf.org/html/rfc7692#section-7.1.1.1
-
-  this._ownContextTakeover = !this._acceptNoContextTakeover &&
-                             !this._params.server_no_context_takeover;
-
-  if (!this._ownContextTakeover) response.server_no_context_takeover = true;
-
-  // https://tools.ietf.org/html/rfc7692#section-7.1.1.2
-
-  this._peerContextTakeover = !this._requestNoContextTakeover &&
-                              !this._params.client_no_context_takeover;
-
-  if (!this._peerContextTakeover) response.client_no_context_takeover = true;
-
-  // https://tools.ietf.org/html/rfc7692#section-7.1.2.1
-
-  this._ownWindowBits = Math.min(this._acceptMaxWindowBits || common.MAX_WINDOW_BITS,
-                                 this._params.server_max_window_bits || common.MAX_WINDOW_BITS);
-
-  // In violation of the spec, Firefox closes the connection if it does not
-  // send server_max_window_bits but the server includes this in its response
-  if (this._ownWindowBits < common.MAX_WINDOW_BITS && this._params.server_max_window_bits)
-    response.server_max_window_bits = this._ownWindowBits;
-
-  // https://tools.ietf.org/html/rfc7692#section-7.1.2.2
-
-  var clientMax = this._params.client_max_window_bits, requestMax;
-  if (clientMax) {
-    if (clientMax === true) clientMax = common.MAX_WINDOW_BITS;
-    this._peerWindowBits = Math.min(this._requestMaxWindowBits || common.MAX_WINDOW_BITS, clientMax);
-  } else {
-    this._peerWindowBits = common.MAX_WINDOW_BITS;
-  }
-
-  if (this._peerWindowBits < common.MAX_WINDOW_BITS)
-    response.client_max_window_bits = this._peerWindowBits;
-
-  return response;
-};
-
-module.exports = ServerSession;

lib/session.js

@@ -1,175 +0,0 @@
-'use strict';
-
-var Buffer = require('safe-buffer').Buffer,
-    zlib   = require('zlib'),
-    common = require('./common');
-
-var Session = function(options) {
-  this._level    = common.fetch(options, 'level',    zlib.Z_DEFAULT_COMPRESSION);
-  this._memLevel = common.fetch(options, 'memLevel', zlib.Z_DEFAULT_MEMLEVEL);
-  this._strategy = common.fetch(options, 'strategy', zlib.Z_DEFAULT_STRATEGY);
-
-  this._acceptNoContextTakeover  = common.fetch(options, 'noContextTakeover', false);
-  this._acceptMaxWindowBits      = common.fetch(options, 'maxWindowBits', undefined);
-  this._requestNoContextTakeover = common.fetch(options, 'requestNoContextTakeover', false);
-  this._requestMaxWindowBits     = common.fetch(options, 'requestMaxWindowBits', undefined);
-
-  this._queueIn  = [];
-  this._queueOut = [];
-
-  this._zlib = common.fetch(options, 'zlib', zlib);
-};
-
-Session.prototype.processIncomingMessage = function(message, callback) {
-  if (!message.rsv1) return callback(null, message);
-  if (this._lockIn) return this._queueIn.push([message, callback]);
-
-  var inflate = this._getInflate(),
-      chunks  = [],
-      length  = 0,
-      self    = this;
-
-  if (this._inflate) this._lockIn = true;
-
-  var return_ = function(error, message) {
-    return_ = function() {};
-
-    inflate.removeListener('data', onData);
-    inflate.removeListener('error', onError);
-    if (!self._inflate) self._close(inflate);
-
-    self._lockIn = false;
-    var next = self._queueIn.shift();
-    if (next) self.processIncomingMessage.apply(self, next);
-
-    callback(error, message);
-  };
-
-  var onData = function(data) {
-    chunks.push(data);
-    length += data.length;
-  };
-
-  var onError = function(error) {
-    return_(error, null);
-  };
-
-  inflate.on('data', onData);
-  inflate.on('error', onError);
-
-  inflate.write(message.data);
-  inflate.write(Buffer.from([0x00, 0x00, 0xff, 0xff]));
-
-  inflate.flush(function() {
-    message.data = Buffer.concat(chunks, length);
-    return_(null, message);
-  });
-};
-
-Session.prototype.processOutgoingMessage = function(message, callback) {
-  if (this._lockOut) return this._queueOut.push([message, callback]);
-
-  var deflate = this._getDeflate(),
-      chunks  = [],
-      length  = 0,
-      self    = this;
-
-  if (this._deflate) this._lockOut = true;
-
-  var return_ = function(error, message) {
-    return_ = function() {};
-
-    deflate.removeListener('data', onData);
-    deflate.removeListener('error', onError);
-    if (!self._deflate) self._close(deflate);
-
-    self._lockOut = false;
-    var next = self._queueOut.shift();
-    if (next) self.processOutgoingMessage.apply(self, next);
-
-    callback(error, message);
-  };
-
-  var onData = function(data) {
-    chunks.push(data);
-    length += data.length;
-  };
-
-  var onError = function(error) {
-    return_(error, null);
-  };
-
-  deflate.on('data', onData);
-  deflate.on('error', onError);
-  deflate.write(message.data);
-
-  var onFlush = function() {
-    var data = Buffer.concat(chunks, length);
-    message.data = data.slice(0, data.length - 4);
-    message.rsv1 = true;
-    return_(null, message);
-  };
-
-  if (deflate.params !== undefined)
-    deflate.flush(zlib.Z_SYNC_FLUSH, onFlush);
-  else
-    deflate.flush(onFlush);
-};
-
-Session.prototype.close = function() {
-  this._close(this._inflate);
-  this._inflate = null;
-
-  this._close(this._deflate);
-  this._deflate = null;
-};
-
-Session.prototype._getInflate = function() {
-  if (this._inflate) return this._inflate;
-
-  var windowBits = Math.max(this._peerWindowBits, common.MIN_WINDOW_BITS),
-      inflate    = this._zlib.createInflateRaw({windowBits: windowBits});
-
-  if (this._peerContextTakeover) this._inflate = inflate;
-  return inflate;
-};
-
-Session.prototype._getDeflate = function() {
-  if (this._deflate) return this._deflate;
-
-  var windowBits = Math.max(this._ownWindowBits, common.MIN_WINDOW_BITS);
-
-  var deflate = this._zlib.createDeflateRaw({
-    windowBits: windowBits,
-    level:      this._level,
-    memLevel:   this._memLevel,
-    strategy:   this._strategy
-  });
-
-  var flush = deflate.flush;
-
-  // This monkey-patch is needed to make Node 0.10 produce optimal output.
-  // Without this it uses Z_FULL_FLUSH and effectively drops all its context
-  // state on every flush.
-
-  if (deflate._flushFlag !== undefined && deflate.params === undefined)
-    deflate.flush = function(callback) {
-      var ws = this._writableState;
-      if (ws.ended || ws.ending || ws.needDrain) {
-        flush.call(this, callback);
-      } else {
-        this._flushFlag = zlib.Z_SYNC_FLUSH;
-        this.write(Buffer.alloc(0), '', callback);
-      }
-    };
-
-  if (this._ownContextTakeover) this._deflate = deflate;
-  return deflate;
-};
-
-Session.prototype._close = function(codec) {
-  if (!codec || !codec.close) return;
-  try { codec.close() } catch (error) {}
-};
-
-module.exports = Session;

package.json

@@ -1,34 +1,18 @@
-{
-          "name": "permessage-deflate",
-          "description": "Per-message DEFLATE compression extension for WebSocket connections",
-          "homepage": "https://github.com/faye/permessage-deflate-node",
-          "author": "James Coglan <jcoglan@gmail.com> (http://jcoglan.com/)",
-          "keywords": [
-                    "websocket",
-                    "compression",
-                    "deflate"
-          ],
-          "license": "Apache-2.0",
-          "version": "0.1.7",
-          "engines": {
-                    "node": ">=0.8.0"
-          },
-          "files": [
-                    "lib"
-          ],
-          "main": "./lib/permessage_deflate",
-          "dependencies": {
-                    "safe-buffer": "*"
-          },
-          "devDependencies": {
-                    "jstest": "*"
-          },
-          "scripts": {
-                    "test": "jstest spec/runner.js"
-          },
-          "repository": {
-                    "type": "git",
-                    "url": "git://github.com/faye/permessage-deflate-node.git"
-          },
-          "bugs": "https://github.com/faye/permessage-deflate-node/issues"
+{ "name"            : "permessage-deflate"
+, "description"     : "Per-message DEFLATE compression extension for WebSocket connections"
+, "homepage"        : "http://github.com/faye/permessage-deflate-node"
+, "author"          : "James Coglan <jcoglan@gmail.com> (http://jcoglan.com/)"
+, "keywords"        : ["websocket", "compression", "deflate"]
+, "license"         : "MIT"
+
+, "version"         : "0.1.3"
+, "engines"         : {"node": ">=0.6.0"}
+, "main"            : "./lib/permessage_deflate"
+, "devDependencies" : {"babel": "", "jstest": ""}
+
+, "repository"      : { "type"  : "git"
+                      , "url"   : "git://github.com/faye/permessage-deflate-node.git"
+                      }
+
+, "bugs"            : "http://github.com/faye/permessage-deflate-node/issues"
 }

spec/client_session_spec.js

@@ -1,18 +1,17 @@
 var PermessageDeflate = require('../lib/permessage_deflate'),
-    _zlib = require('zlib'),
+    zlib = require('zlib'),
     test = require('jstest').Test
 
 test.describe("ClientSession", function() { with(this) {
   before(function() { with(this) {
+    this.ext      = PermessageDeflate.configure(options)
+    this.session  = ext.createClientSession()
+
     this.deflate  = zlibMock()
     this.inflate  = zlibMock()
-    this.level    = _zlib.Z_DEFAULT_LEVEL
-    this.memLevel = _zlib.Z_DEFAULT_MEMLEVEL
-    this.strategy = _zlib.Z_DEFAULT_STRATEGY
-
-    this.ext      = PermessageDeflate.configure(options)
-    this.zlib     = {}
-    this.session  = ext.configure({zlib: zlib}).createClientSession()
+    this.level    = zlib.Z_DEFAULT_LEVEL
+    this.memLevel = zlib.Z_DEFAULT_MEMLEVEL
+    this.strategy = zlib.Z_DEFAULT_STRATEGY
 
     this.message  = {data: "hello", rsv1: true}
   }})
@@ -91,12 +90,6 @@ test.describe("ClientSession", function() { with(this) {
         processIncomingMessage()
         processIncomingMessage()
       }})
-
-      it("catches errors thrown by zlib", function() { with(this) {
-        activate()
-        stub(zlib, "createInflateRaw").returning(inflate)
-        assertNothingThrown(function() { processIncomingMessage() })
-      }})
     }})
 
     describe("when the response includes client_no_context_takeover", function() { with(this) {
@@ -113,12 +106,6 @@ test.describe("ClientSession", function() { with(this) {
         processOutgoingMessage()
         processOutgoingMessage()
       }})
-
-      it("catches errors thrown by zlib", function() { with(this) {
-        activate()
-        stub(zlib, "createDeflateRaw").returning(deflate)
-        assertNothingThrown(function() { processOutgoingMessage() })
-      }})
     }})
 
     describe("when the response includes server_max_window_bits", function() { with(this) {
@@ -128,9 +115,9 @@ test.describe("ClientSession", function() { with(this) {
         assertEqual( true, activate() )
       }})
 
-      it("uses context takeover and 9 window bits for inflating incoming messages", function() { with(this) {
+      it("uses context takeover and 8 window bits for inflating incoming messages", function() { with(this) {
         activate()
-        expect(zlib, "createInflateRaw").given({windowBits: 9}).exactly(1).returning(inflate)
+        expect(zlib, "createInflateRaw").given({windowBits: 8}).exactly(1).returning(inflate)
         processIncomingMessage()
         processIncomingMessage()
       }})
@@ -151,9 +138,9 @@ test.describe("ClientSession", function() { with(this) {
         assertEqual( true, activate() )
       }})
 
-      it("uses context takeover and 9 window bits for deflating outgoing messages", function() { with(this) {
+      it("uses context takeover and 8 window bits for deflating outgoing messages", function() { with(this) {
         activate()
-        expect(zlib, "createDeflateRaw").given({windowBits: 9, level: level, memLevel: memLevel, strategy: strategy}).exactly(1).returning(deflate)
+        expect(zlib, "createDeflateRaw").given({windowBits: 8, level: level, memLevel: memLevel, strategy: strategy}).exactly(1).returning(deflate)
         processOutgoingMessage()
         processOutgoingMessage()
       }})
@@ -225,9 +212,9 @@ test.describe("ClientSession", function() { with(this) {
         assertEqual( true, activate() )
       }})
 
-      it("uses context takeover and 9 window bits for deflating outgoing messages", function() { with(this) {
+      it("uses context takeover and 8 window bits for deflating outgoing messages", function() { with(this) {
         activate()
-        expect(zlib, "createDeflateRaw").given({windowBits: 9, level: level, memLevel: memLevel, strategy: strategy}).exactly(1).returning(deflate)
+        expect(zlib, "createDeflateRaw").given({windowBits: 8, level: level, memLevel: memLevel, strategy: strategy}).exactly(1).returning(deflate)
         processOutgoingMessage()
         processOutgoingMessage()
       }})
@@ -318,11 +305,11 @@ test.describe("ClientSession", function() { with(this) {
   }})
 
   describe("with level", function() { with(this) {
-    define("options", {level: _zlib.Z_BEST_SPEED})
+    define("options", {level: zlib.Z_BEST_SPEED})
 
     it("sets the level of the deflate stream", function() { with(this) {
       activate()
-      expect(zlib, "createDeflateRaw").given({windowBits: 15, level: _zlib.Z_BEST_SPEED, memLevel: memLevel, strategy: strategy}).returns(deflate)
+      expect(zlib, "createDeflateRaw").given({windowBits: 15, level: zlib.Z_BEST_SPEED, memLevel: memLevel, strategy: strategy}).returns(deflate)
       processOutgoingMessage()
     }})
   }})
@@ -332,17 +319,17 @@ test.describe("ClientSession", function() { with(this) {
 
     it("sets the memLevel of the deflate stream", function() { with(this) {
       activate()
-      expect(zlib, "createDeflateRaw").given({windowBits: 15, level: _zlib.Z_DEFAULT_LEVEL, memLevel: 5, strategy: strategy}).returns(deflate)
+      expect(zlib, "createDeflateRaw").given({windowBits: 15, level: zlib.Z_DEFAULT_LEVEL, memLevel: 5, strategy: strategy}).returns(deflate)
       processOutgoingMessage()
     }})
   }})
 
   describe("with strategy", function() { with(this) {
-    define("options", {strategy: _zlib.Z_FILTERED})
+    define("options", {strategy: zlib.Z_FILTERED})
 
     it("sets the strategy of the deflate stream", function() { with(this) {
       activate()
-      expect(zlib, "createDeflateRaw").given({windowBits: 15, level: _zlib.Z_DEFAULT_LEVEL, memLevel: memLevel, strategy: _zlib.Z_FILTERED}).returns(deflate)
+      expect(zlib, "createDeflateRaw").given({windowBits: 15, level: zlib.Z_DEFAULT_LEVEL, memLevel: memLevel, strategy: zlib.Z_FILTERED}).returns(deflate)
       processOutgoingMessage()
     }})
   }})

spec/runner.js

@@ -1,2 +1,4 @@
+require('babel/polyfill');
+
 require('./client_session_spec')
 require('./server_session_spec')

spec/server_session_spec.js

@@ -1,18 +1,17 @@
 var PermessageDeflate = require('../lib/permessage_deflate'),
-    _zlib = require('zlib'),
+    zlib = require('zlib'),
     test = require('jstest').Test
 
-test.describe("ServerSession", function() { with(this) {
+test.describe("ClientSession", function() { with(this) {
   before(function() { with(this) {
+    this.ext      = PermessageDeflate.configure(options)
+    this.session  = ext.createServerSession([offer])
+
     this.deflate  = zlibMock()
     this.inflate  = zlibMock()
-    this.level    = _zlib.Z_DEFAULT_LEVEL
-    this.memLevel = _zlib.Z_DEFAULT_MEMLEVEL
-    this.strategy = _zlib.Z_DEFAULT_STRATEGY
-
-    this.ext      = PermessageDeflate.configure(options)
-    this.zlib     = {}
-    this.session  = ext.configure({zlib: zlib}).createServerSession([offer])
+    this.level    = zlib.Z_DEFAULT_LEVEL
+    this.memLevel = zlib.Z_DEFAULT_MEMLEVEL
+    this.strategy = zlib.Z_DEFAULT_STRATEGY
 
     this.message  = {data: "hello", rsv1: true}
   }})
@@ -82,12 +81,6 @@ test.describe("ServerSession", function() { with(this) {
         processOutgoingMessage()
         processOutgoingMessage()
       }})
-
-      it("catches errors thrown by zlib", function() { with(this) {
-        response()
-        stub(zlib, "createDeflateRaw").returning(deflate)
-        assertNothingThrown(function() { processOutgoingMessage() })
-      }})
     }})
 
     describe("when the offer includes client_no_context_takeover", function() { with(this) {
@@ -104,12 +97,6 @@ test.describe("ServerSession", function() { with(this) {
         processIncomingMessage()
         processIncomingMessage()
       }})
-
-      it("catches errors thrown by zlib", function() { with(this) {
-        response()
-        stub(zlib, "createInflateRaw").returning(inflate)
-        assertNothingThrown(function() { processIncomingMessage() })
-      }})
     }})
 
     describe("when the offer includes server_max_window_bits", function() { with(this) {
@@ -196,8 +183,8 @@ test.describe("ServerSession", function() { with(this) {
     define("options", {maxWindowBits: 12})
 
     describe("with an empty offer", function() { with(this) {
-      it("does not include server_max_window_bits in the response", function() { with(this) {
-        assertEqual( {}, response() )
+      it("includes server_max_window_bits in the response", function() { with(this) {
+        assertEqual( {server_max_window_bits: 12}, response() )
       }})
 
       it("uses context takeover and 12 window bits for deflating outgoing messages", function() { with(this) {
@@ -320,11 +307,11 @@ test.describe("ServerSession", function() { with(this) {
   }})
 
   describe("with level", function() { with(this) {
-    define("options", {level: _zlib.Z_BEST_SPEED})
+    define("options", {level: zlib.Z_BEST_SPEED})
 
     it("sets the level of the deflate stream", function() { with(this) {
       response()
-      expect(zlib, "createDeflateRaw").given({windowBits: 15, level: _zlib.Z_BEST_SPEED, memLevel: memLevel, strategy: strategy}).returns(deflate)
+      expect(zlib, "createDeflateRaw").given({windowBits: 15, level: zlib.Z_BEST_SPEED, memLevel: memLevel, strategy: strategy}).returns(deflate)
       processOutgoingMessage()
     }})
   }})
@@ -334,17 +321,17 @@ test.describe("ServerSession", function() { with(this) {
 
     it("sets the memLevel of the deflate stream", function() { with(this) {
       response()
-      expect(zlib, "createDeflateRaw").given({windowBits: 15, level: _zlib.Z_DEFAULT_LEVEL, memLevel: 5, strategy: strategy}).returns(deflate)
+      expect(zlib, "createDeflateRaw").given({windowBits: 15, level: zlib.Z_DEFAULT_LEVEL, memLevel: 5, strategy: strategy}).returns(deflate)
       processOutgoingMessage()
     }})
   }})
 
   describe("with strategy", function() { with(this) {
-    define("options", {strategy: _zlib.Z_FILTERED})
+    define("options", {strategy: zlib.Z_FILTERED})
 
     it("sets the strategy of the deflate stream", function() { with(this) {
       response()
-      expect(zlib, "createDeflateRaw").given({windowBits: 15, level: _zlib.Z_DEFAULT_LEVEL, memLevel: memLevel, strategy: _zlib.Z_FILTERED}).returns(deflate)
+      expect(zlib, "createDeflateRaw").given({windowBits: 15, level: zlib.Z_DEFAULT_LEVEL, memLevel: memLevel, strategy: zlib.Z_FILTERED}).returns(deflate)
       processOutgoingMessage()
     }})
   }})

src/client_session.js

@@ -0,0 +1,69 @@
+import Session from './session';
+import * as common from './common';
+
+export default class ClientSession extends Session {
+  static validParams(params) {
+    if (!common.validParams(params)) return false;
+
+    if (params.hasOwnProperty('client_max_window_bits')) {
+      if (common.VALID_WINDOW_BITS.indexOf(params.client_max_window_bits) < 0)
+        return false;
+    }
+    return true;
+  }
+
+  generateOffer() {
+    let offer = {};
+
+    if (this._acceptNoContextTakeover)
+      offer.client_no_context_takeover = true;
+
+    if (this._acceptMaxWindowBits !== undefined) {
+      if (common.VALID_WINDOW_BITS.indexOf(this._acceptMaxWindowBits) < 0) {
+        throw new Error('Invalid value for maxWindowBits');
+      }
+      offer.client_max_window_bits = this._acceptMaxWindowBits;
+    } else {
+      offer.client_max_window_bits = true;
+    }
+
+    if (this._requestNoContextTakeover)
+      offer.server_no_context_takeover = true;
+
+    if (this._requestMaxWindowBits !== undefined) {
+      if (common.VALID_WINDOW_BITS.indexOf(this._requestMaxWindowBits) < 0) {
+        throw new Error('Invalid valud for requestMaxWindowBits');
+      }
+      offer.server_max_window_bits = this._requestMaxWindowBits;
+    }
+
+    return offer;
+  }
+
+  activate(params) {
+    if (!ClientSession.validParams(params)) return false;
+
+    if (this._acceptMaxWindowBits && params.client_max_window_bits) {
+      if (params.client_max_window_bits > this._acceptMaxWindowBits) return false;
+    }
+
+    if (this._requestNoContextTakeover && !params.server_no_context_takeover)
+      return false;
+
+    if (this._requestMaxWindowBits) {
+      if (!params.server_max_window_bits) return false;
+      if (params.server_max_window_bits > this._requestMaxWindowBits) return false;
+    }
+
+    this._ownContextTakeover = !(this._acceptNoContextTakeover || params.client_no_context_takeover);
+    this._ownWindowBits = Math.min(
+      this._acceptMaxWindowBits || common.DEFAULT_MAX_WINDOW_BITS,
+      params.client_max_window_bits || common.DEFAULT_MAX_WINDOW_BITS
+    );
+
+    this._peerContextTakeover = !params.server_no_context_takeover;
+    this._peerWindowBits = params.server_max_window_bits || common.DEFAULT_MAX_WINDOW_BITS;
+
+    return true;
+  }
+}

src/common.js

@@ -0,0 +1,44 @@
+const  VALID_PARAMS = [
+  'server_no_context_takeover',
+  'client_no_context_takeover',
+  'server_max_window_bits',
+  'client_max_window_bits'
+];
+
+export const DEFAULT_MAX_WINDOW_BITS = 15;
+export const VALID_WINDOW_BITS = [8, 9, 10, 11, 12, 13, 14, 15];
+
+export function concat(buffers, length) {
+  let buffer = new Buffer(length),
+      offset = 0;
+
+  for (let buf of buffers) {
+    buf.copy(buffer, offset);
+    offset += buf.length;
+  }
+  return buffer;
+}
+
+export function validateOptions(options, validKeys) {
+  for (let key in options) {
+    if (validKeys.indexOf(key) < 0)
+      throw new Error(`Unrecognized option: ${key}`);
+  }
+}
+
+export function validParams(params) {
+  for (let key of Object.keys(params)) {
+    if (VALID_PARAMS.indexOf(key) < 0) return false;
+    if (params[key] instanceof Array) return false;
+  }
+  if (params.hasOwnProperty('server_no_context_takeover')) {
+    if (params.server_no_context_takeover !== true) return false;
+  }
+  if (params.hasOwnProperty('client_no_context_takeover')) {
+    if (params.client_no_context_takeover !== true) return false;
+  }
+  if (params.hasOwnProperty('server_max_window_bits')) {
+    if (this.VALID_WINDOW_BITS.indexOf(params.server_max_window_bits) < 0) return false;
+  }
+  return true;
+}

src/permessage_deflate.js

@@ -0,0 +1,42 @@
+import ClientSession from './client_session';
+import ServerSession from './server_session';
+import { validateOptions } from './common';
+
+const VALID_OPTIONS = [
+  'level',
+  'memLevel',
+  'strategy',
+  'noContextTakeover',
+  'maxWindowBits',
+  'requestNoContextTakeover',
+  'requestMaxWindowBits'
+];
+
+const PermessageDeflate = {
+  configure(options) {
+    validateOptions(options, VALID_OPTIONS);
+    let opts = this._options || {};
+    for (let key in opts) options[key] = opts[key];
+    return Object.create(this, {_options: {value: options}});
+  },
+
+  createClientSession() {
+    return new ClientSession(this._options || {});
+  },
+
+  createServerSession(offers) {
+    for (let offer of offers) {
+      if (ServerSession.validParams(offer))
+        return new ServerSession(this._options || {}, offer);
+    }
+    return null;
+  },
+
+  name: 'permessage-deflate',
+  type: 'permessage',
+  rsv1: true,
+  rsv2: false,
+  rsv3: false
+};
+
+export default PermessageDeflate;

src/server_session.js

@@ -0,0 +1,58 @@
+import Session from './session';
+import * as common from './common';
+
+export default class ServerSession extends Session {
+  constructor(options, params) {
+    super(options);
+    this._params = params;
+  }
+
+  static validParams(params) {
+    if (!common.validParams(params)) return false;
+
+    if (params.hasOwnProperty('client_max_window_bits')) {
+      if ([true].concat(common.VALID_WINDOW_BITS).indexOf(params.client_max_window_bits) < 0)
+        return false;
+    }
+    return true;
+  }
+
+  generateResponse() {
+    let params = {};
+
+    // https://tools.ietf.org/html/draft-ietf-hybi-permessage-compression#section-8.1.1.1
+    if (this._acceptNoContextTakeover || this._params.server_no_context_takeover)
+      params.server_no_context_takeover = true;
+
+    // https://tools.ietf.org/html/draft-ietf-hybi-permessage-compression#section-8.1.1.2
+    if (this._requestNoContextTakeover || this._params.client_no_context_takeover)
+      params.client_no_context_takeover = true;
+
+    // https://tools.ietf.org/html/draft-ietf-hybi-permessage-compression#section-8.1.2.1
+    let acceptMax, serverMax;
+    if (this._acceptMaxWindowBits || this._params.server_max_window_bits) {
+      acceptMax = this._acceptMaxWindowBits || common.DEFAULT_MAX_WINDOW_BITS;
+      serverMax = this._params.server_max_window_bits || common.DEFAULT_MAX_WINDOW_BITS;
+      params.server_max_window_bits = Math.min(acceptMax, serverMax);
+    }
+
+    // https://tools.ietf.org/html/draft-ietf-hybi-permessage-compression#section-8.1.2.2
+    let clientMax = this._params.client_max_window_bits, requestMax;
+    if (clientMax) {
+      if (clientMax === true) {
+        if (this._requestMaxWindowBits) params.client_max_window_bits = this._requestMaxWindowBits;
+      } else {
+        requestMax = this._requestMaxWindowBits || common.DEFAULT_MAX_WINDOW_BITS;
+        params.client_max_window_bits = Math.min(requestMax, clientMax);
+      }
+    }
+
+    this._ownContextTakeover = !params.server_no_context_takeover;
+    this._ownWindowBits = params.server_max_window_bits || common.DEFAULT_MAX_WINDOW_BITS;
+
+    this._peerContextTakeover = !params.client_no_context_takeover;
+    this._peerWindowBits = params.client_max_window_bits || common.DEFAULT_MAX_WINDOW_BITS;
+
+    return params;
+  }
+}

src/session.js

@@ -0,0 +1,156 @@
+import zlib from 'zlib';
+import { concat } from './common';
+
+export default class Session {
+  constructor({ level    = zlib.Z_DEFAULT_LEVEL,
+                memLevel = zlib.Z_DEFAULT_MEMLEVEL,
+                strategy = zlib.Z_DEFAULT_STRATEGY,
+
+                noContextTakeover = false,
+                maxWindowBits,
+                requestNoContextTakeover = false,
+                requestMaxWindowBits }) {
+
+    this._level    = level;
+    this._memLevel = memLevel;
+    this._strategy = strategy;
+
+    this._acceptNoContextTakeover  = noContextTakeover;
+    this._acceptMaxWindowBits      = maxWindowBits;
+    this._requestNoContextTakeover = requestNoContextTakeover;
+    this._requestMaxWindowBits     = requestMaxWindowBits;
+
+    this._queueIn  = [];
+    this._queueOut = [];
+  }
+
+  processIncomingMessage(message, callback) {
+    if (!message.rsv1) return callback(null, message);
+    if (this._lockIn) return this._queueIn.push([message, callback]);
+
+    let [inflate, chunks, length] = [this._getInflate(), [], 0];
+    if (this._inflate) this._lockIn = true;
+
+    let return_ = (error, message) => {
+      return_ = () => {};
+
+      inflate.removeListener('data', onData);
+      inflate.removeListener('error', onError);
+      if (!this._inflate && inflate.close) inflate.close();
+
+      this._lockIn = false;
+      let next = this._queueIn.shift();
+      if (next) this.processIncomingMessage.apply(this, next);
+
+      callback(error, message);
+    };
+
+    let onData = (data) => {
+      chunks.push(data);
+      length += data.length;
+    };
+
+    let onError = (error) => return_(error, null);
+
+    inflate.on('data', onData);
+    inflate.on('error', onError);
+
+    inflate.write(message.data);
+    inflate.write(new Buffer([0x00, 0x00, 0xff, 0xff]));
+
+    inflate.flush(() => {
+      message.data = concat(chunks, length);
+      return_(null, message);
+    });
+  }
+
+  processOutgoingMessage(message, callback) {
+    if (this._lockOut) return this._queueOut.push([message, callback]);
+
+    let [deflate, chunks, length] = [this._getDeflate(), [], 0];
+    if (this._deflate) this._lockOut = true;
+
+    let return_ = (error, message) => {
+      return_ = () => {};
+
+      deflate.removeListener('data', onData);
+      deflate.removeListener('error', onError);
+      if (!this._deflate && deflate.close) deflate.close();
+
+      this._lockOut = false;
+      let next = this._queueOut.shift();
+      if (next) this.processOutgoingMessage.apply(this, next);
+
+      callback(error, message);
+    };
+
+    let onData = (data) => {
+      chunks.push(data);
+      length += data.length;
+    };
+
+    let onError = (error) => return_(error, null);
+
+    deflate.on('data', onData);
+    deflate.on('error', onError);
+    deflate.write(message.data);
+
+    let onFlush = () => {
+      let data = concat(chunks, length);
+      message.data = data.slice(0, data.length - 4);
+      message.rsv1 = true;
+      return_(null, message);
+    };
+
+    if (deflate.params !== undefined)
+      deflate.flush(zlib.Z_SYNC_FLUSH, onFlush);
+    else
+      deflate.flush(onFlush);
+  }
+
+  close() {
+    if (this._inflate && this._inflate.close) this._inflate.close();
+    this._inflate = null;
+
+    if (this._deflate && this._deflate.close) this._deflate.close();
+    this._deflate = null;
+  }
+
+  _getInflate() {
+    if (this._inflate) return this._inflate;
+    let inflate = zlib.createInflateRaw({windowBits: this._peerWindowBits});
+    if (this._peerContextTakeover) this._inflate = inflate;
+    return inflate;
+  }
+
+  _getDeflate() {
+    if (this._deflate) return this._deflate;
+
+    let deflate = zlib.createDeflateRaw({
+      windowBits: this._ownWindowBits,
+      level:      this._level,
+      memLevel:   this._memLevel,
+      strategy:   this._strategy
+    });
+
+    let flush = deflate.flush;
+
+    // This monkey-patch is needed to make Node 0.10 produce optimal output.
+    // Without this it uses Z_FULL_FLUSH and effectively drops all its context
+    // state on every flush.
+
+    if (deflate._flushFlag !== undefined && deflate.params === undefined)
+      deflate.flush = function(callback) {
+        let ws = this._writableState;
+        if (ws.ended || ws.ending || ws.needDrain) {
+          flush.call(this, callback);
+        } else {
+          this._flushFlag = zlib.Z_SYNC_FLUSH;
+          this.write(new Buffer(0), '', callback);
+        }
+      };
+
+    if (this._ownContextTakeover) this._deflate = deflate;
+    return deflate;
+  }
+}