waves_lib 0.1.0

data/js/node_modules/@protobufjs/base64/index.js

@@ -0,0 +1,139 @@
+"use strict";
+
+/**
+ * A minimal base64 implementation for number arrays.
+ * @memberof util
+ * @namespace
+ */
+var base64 = exports;
+
+/**
+ * Calculates the byte length of a base64 encoded string.
+ * @param {string} string Base64 encoded string
+ * @returns {number} Byte length
+ */
+base64.length = function length(string) {
+    var p = string.length;
+    if (!p)
+        return 0;
+    var n = 0;
+    while (--p % 4 > 1 && string.charAt(p) === "=")
+        ++n;
+    return Math.ceil(string.length * 3) / 4 - n;
+};
+
+// Base64 encoding table
+var b64 = new Array(64);
+
+// Base64 decoding table
+var s64 = new Array(123);
+
+// 65..90, 97..122, 48..57, 43, 47
+for (var i = 0; i < 64;)
+    s64[b64[i] = i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i - 59 | 43] = i++;
+
+/**
+ * Encodes a buffer to a base64 encoded string.
+ * @param {Uint8Array} buffer Source buffer
+ * @param {number} start Source start
+ * @param {number} end Source end
+ * @returns {string} Base64 encoded string
+ */
+base64.encode = function encode(buffer, start, end) {
+    var parts = null,
+        chunk = [];
+    var i = 0, // output index
+        j = 0, // goto index
+        t;     // temporary
+    while (start < end) {
+        var b = buffer[start++];
+        switch (j) {
+            case 0:
+                chunk[i++] = b64[b >> 2];
+                t = (b & 3) << 4;
+                j = 1;
+                break;
+            case 1:
+                chunk[i++] = b64[t | b >> 4];
+                t = (b & 15) << 2;
+                j = 2;
+                break;
+            case 2:
+                chunk[i++] = b64[t | b >> 6];
+                chunk[i++] = b64[b & 63];
+                j = 0;
+                break;
+        }
+        if (i > 8191) {
+            (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));
+            i = 0;
+        }
+    }
+    if (j) {
+        chunk[i++] = b64[t];
+        chunk[i++] = 61;
+        if (j === 1)
+            chunk[i++] = 61;
+    }
+    if (parts) {
+        if (i)
+            parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));
+        return parts.join("");
+    }
+    return String.fromCharCode.apply(String, chunk.slice(0, i));
+};
+
+var invalidEncoding = "invalid encoding";
+
+/**
+ * Decodes a base64 encoded string to a buffer.
+ * @param {string} string Source string
+ * @param {Uint8Array} buffer Destination buffer
+ * @param {number} offset Destination offset
+ * @returns {number} Number of bytes written
+ * @throws {Error} If encoding is invalid
+ */
+base64.decode = function decode(string, buffer, offset) {
+    var start = offset;
+    var j = 0, // goto index
+        t;     // temporary
+    for (var i = 0; i < string.length;) {
+        var c = string.charCodeAt(i++);
+        if (c === 61 && j > 1)
+            break;
+        if ((c = s64[c]) === undefined)
+            throw Error(invalidEncoding);
+        switch (j) {
+            case 0:
+                t = c;
+                j = 1;
+                break;
+            case 1:
+                buffer[offset++] = t << 2 | (c & 48) >> 4;
+                t = c;
+                j = 2;
+                break;
+            case 2:
+                buffer[offset++] = (t & 15) << 4 | (c & 60) >> 2;
+                t = c;
+                j = 3;
+                break;
+            case 3:
+                buffer[offset++] = (t & 3) << 6 | c;
+                j = 0;
+                break;
+        }
+    }
+    if (j === 1)
+        throw Error(invalidEncoding);
+    return offset - start;
+};
+
+/**
+ * Tests if the specified string appears to be base64 encoded.
+ * @param {string} string String to test
+ * @returns {boolean} `true` if probably base64 encoded, otherwise false
+ */
+base64.test = function test(string) {
+    return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(string);
+};

data/js/node_modules/@protobufjs/base64/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@protobufjs/base64",
+  "description": "A minimal base64 implementation for number arrays.",
+  "version": "1.1.2",
+  "author": "Daniel Wirtz <dcode+protobufjs@dcode.io>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dcodeIO/protobuf.js.git"
+  },
+  "license": "BSD-3-Clause",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "devDependencies": {
+    "istanbul": "^0.4.5",
+    "tape": "^4.6.3"
+  },
+  "scripts": {
+    "test": "tape tests/*.js",
+    "coverage": "istanbul cover node_modules/tape/bin/tape tests/*.js"
+  }
+}

data/js/node_modules/@protobufjs/base64/tests/index.js

@@ -0,0 +1,46 @@
+var tape = require("tape");
+
+var base64 = require("..");
+
+var strings = {
+    "": "",
+    "a": "YQ==",
+    "ab": "YWI=",
+    "abcdefg": "YWJjZGVmZw==",
+    "abcdefgh": "YWJjZGVmZ2g=",
+    "abcdefghi": "YWJjZGVmZ2hp"
+};
+
+tape.test("base64", function(test) {
+
+    Object.keys(strings).forEach(function(str) {
+        var enc = strings[str];
+
+        test.equal(base64.test(enc), true, "should detect '" + enc + "' to be base64 encoded");
+
+        var len = base64.length(enc);
+        test.equal(len, str.length, "should calculate '" + enc + "' as " + str.length + " bytes");
+
+        var buf = new Array(len);
+        var len2 = base64.decode(enc, buf, 0);
+        test.equal(len2, len, "should decode '" + enc + "' to " + len + " bytes");
+
+        test.equal(String.fromCharCode.apply(String, buf), str, "should decode '" + enc + "' to '" + str + "'");
+
+        var enc2 = base64.encode(buf, 0, buf.length);
+        test.equal(enc2, enc, "should encode '" + str + "' to '" + enc + "'");
+
+    });
+
+    test.throws(function() {
+        var buf = new Array(10);
+        base64.decode("YQ!", buf, 0);
+    }, Error, "should throw if encoding is invalid");
+
+    test.throws(function() {
+        var buf = new Array(10);
+        base64.decode("Y", buf, 0);
+    }, Error, "should throw if string is truncated");
+
+    test.end();
+});

data/js/node_modules/@protobufjs/codegen/LICENSE

@@ -0,0 +1,26 @@
+Copyright (c) 2016, Daniel Wirtz  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+* Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer in the
+  documentation and/or other materials provided with the distribution.
+* Neither the name of its author, nor the names of its contributors
+  may be used to endorse or promote products derived from this software
+  without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/js/node_modules/@protobufjs/codegen/README.md

@@ -0,0 +1,49 @@
+@protobufjs/codegen
+===================
+[![npm](https://img.shields.io/npm/v/@protobufjs/codegen.svg)](https://www.npmjs.com/package/@protobufjs/codegen)
+
+A minimalistic code generation utility.
+
+API
+---
+
+* **codegen([functionParams: `string[]`], [functionName: string]): `Codegen`**<br />
+  Begins generating a function.
+
+* **codegen.verbose = `false`**<br />
+  When set to true, codegen will log generated code to console. Useful for debugging.
+
+Invoking **codegen** returns an appender function that appends code to the function's body and returns itself:
+
+* **Codegen(formatString: `string`, [...formatParams: `any`]): Codegen**<br />
+  Appends code to the function's body. The format string can contain placeholders specifying the types of inserted format parameters:
+
+  * `%d`: Number (integer or floating point value)
+  * `%f`: Floating point value
+  * `%i`: Integer value
+  * `%j`: JSON.stringify'ed value
+  * `%s`: String value
+  * `%%`: Percent sign<br />
+
+* **Codegen([scope: `Object.<string,*>`]): `Function`**<br />
+  Finishes the function and returns it.
+
+* **Codegen.toString([functionNameOverride: `string`]): `string`**<br />
+  Returns the function as a string.
+
+Example
+-------
+
+```js
+var codegen = require("@protobufjs/codegen");
+
+var add = codegen(["a", "b"], "add") // A function with parameters "a" and "b" named "add"
+  ("// awesome comment")             // adds the line to the function's body
+  ("return a + b - c + %d", 1)       // replaces %d with 1 and adds the line to the body
+  ({ c: 1 });                        // adds "c" with a value of 1 to the function's scope
+
+console.log(add.toString()); // function add(a, b) { return a + b - c + 1 }
+console.log(add(1, 2));      // calculates 1 + 2 - 1 + 1 = 3
+```
+
+**License:** [BSD 3-Clause License](https://opensource.org/licenses/BSD-3-Clause)

data/js/node_modules/@protobufjs/codegen/index.d.ts

@@ -0,0 +1,31 @@
+export = codegen;
+
+/**
+ * Appends code to the function's body.
+ * @param [formatStringOrScope] Format string or, to finish the function, an object of additional scope variables, if any
+ * @param [formatParams] Format parameters
+ * @returns Itself or the generated function if finished
+ * @throws {Error} If format parameter counts do not match
+ */
+type Codegen = (formatStringOrScope?: (string|{ [k: string]: any }), ...formatParams: any[]) => (Codegen|Function);
+
+/**
+ * Begins generating a function.
+ * @param functionParams Function parameter names
+ * @param [functionName] Function name if not anonymous
+ * @returns Appender that appends code to the function's body
+ */
+declare function codegen(functionParams: string[], functionName?: string): Codegen;
+
+/**
+ * Begins generating a function.
+ * @param [functionName] Function name if not anonymous
+ * @returns Appender that appends code to the function's body
+ */
+declare function codegen(functionName?: string): Codegen;
+
+declare namespace codegen {
+
+    /** When set to `true`, codegen will log generated code to console. Useful for debugging. */
+    let verbose: boolean;
+}

data/js/node_modules/@protobufjs/codegen/index.js

@@ -0,0 +1,99 @@
+"use strict";
+module.exports = codegen;
+
+/**
+ * Begins generating a function.
+ * @memberof util
+ * @param {string[]} functionParams Function parameter names
+ * @param {string} [functionName] Function name if not anonymous
+ * @returns {Codegen} Appender that appends code to the function's body
+ */
+function codegen(functionParams, functionName) {
+
+    /* istanbul ignore if */
+    if (typeof functionParams === "string") {
+        functionName = functionParams;
+        functionParams = undefined;
+    }
+
+    var body = [];
+
+    /**
+     * Appends code to the function's body or finishes generation.
+     * @typedef Codegen
+     * @type {function}
+     * @param {string|Object.<string,*>} [formatStringOrScope] Format string or, to finish the function, an object of additional scope variables, if any
+     * @param {...*} [formatParams] Format parameters
+     * @returns {Codegen|Function} Itself or the generated function if finished
+     * @throws {Error} If format parameter counts do not match
+     */
+
+    function Codegen(formatStringOrScope) {
+        // note that explicit array handling below makes this ~50% faster
+
+        // finish the function
+        if (typeof formatStringOrScope !== "string") {
+            var source = toString();
+            if (codegen.verbose)
+                console.log("codegen: " + source); // eslint-disable-line no-console
+            source = "return " + source;
+            if (formatStringOrScope) {
+                var scopeKeys   = Object.keys(formatStringOrScope),
+                    scopeParams = new Array(scopeKeys.length + 1),
+                    scopeValues = new Array(scopeKeys.length),
+                    scopeOffset = 0;
+                while (scopeOffset < scopeKeys.length) {
+                    scopeParams[scopeOffset] = scopeKeys[scopeOffset];
+                    scopeValues[scopeOffset] = formatStringOrScope[scopeKeys[scopeOffset++]];
+                }
+                scopeParams[scopeOffset] = source;
+                return Function.apply(null, scopeParams).apply(null, scopeValues); // eslint-disable-line no-new-func
+            }
+            return Function(source)(); // eslint-disable-line no-new-func
+        }
+
+        // otherwise append to body
+        var formatParams = new Array(arguments.length - 1),
+            formatOffset = 0;
+        while (formatOffset < formatParams.length)
+            formatParams[formatOffset] = arguments[++formatOffset];
+        formatOffset = 0;
+        formatStringOrScope = formatStringOrScope.replace(/%([%dfijs])/g, function replace($0, $1) {
+            var value = formatParams[formatOffset++];
+            switch ($1) {
+                case "d": case "f": return String(Number(value));
+                case "i": return String(Math.floor(value));
+                case "j": return JSON.stringify(value);
+                case "s": return String(value);
+            }
+            return "%";
+        });
+        if (formatOffset !== formatParams.length)
+            throw Error("parameter count mismatch");
+        body.push(formatStringOrScope);
+        return Codegen;
+    }
+
+    function toString(functionNameOverride) {
+        return "function " + (functionNameOverride || functionName || "") + "(" + (functionParams && functionParams.join(",") || "") + "){\n  " + body.join("\n  ") + "\n}";
+    }
+
+    Codegen.toString = toString;
+    return Codegen;
+}
+
+/**
+ * Begins generating a function.
+ * @memberof util
+ * @function codegen
+ * @param {string} [functionName] Function name if not anonymous
+ * @returns {Codegen} Appender that appends code to the function's body
+ * @variation 2
+ */
+
+/**
+ * When set to `true`, codegen will log generated code to console. Useful for debugging.
+ * @name util.codegen.verbose
+ * @type {boolean}
+ */
+codegen.verbose = false;

data/js/node_modules/@protobufjs/codegen/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "@protobufjs/codegen",
+  "description": "A minimalistic code generation utility.",
+  "version": "2.0.4",
+  "author": "Daniel Wirtz <dcode+protobufjs@dcode.io>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dcodeIO/protobuf.js.git"
+  },
+  "license": "BSD-3-Clause",
+  "main": "index.js",
+  "types": "index.d.ts"
+}

data/js/node_modules/@protobufjs/codegen/tests/index.js

@@ -0,0 +1,13 @@
+var codegen = require("..");
+
+// new require("benchmark").Suite().add("add", function() {
+
+var add = codegen(["a", "b"], "add")
+  ("// awesome comment")
+  ("return a + b - c + %d", 1)
+  ({ c: 1 });
+
+if (add(1, 2) !== 3)
+  throw Error("failed");
+
+// }).on("cycle", function(event) { process.stdout.write(String(event.target) + "\n"); }).run();

data/js/node_modules/@protobufjs/eventemitter/LICENSE

@@ -0,0 +1,26 @@
+Copyright (c) 2016, Daniel Wirtz  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+* Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer in the
+  documentation and/or other materials provided with the distribution.
+* Neither the name of its author, nor the names of its contributors
+  may be used to endorse or promote products derived from this software
+  without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/js/node_modules/@protobufjs/eventemitter/README.md

@@ -0,0 +1,22 @@
+@protobufjs/eventemitter
+========================
+[![npm](https://img.shields.io/npm/v/@protobufjs/eventemitter.svg)](https://www.npmjs.com/package/@protobufjs/eventemitter)
+
+A minimal event emitter.
+
+API
+---
+
+* **new EventEmitter()**<br />
+  Constructs a new event emitter instance.
+
+* **EventEmitter#on(evt: `string`, fn: `function`, [ctx: `Object`]): `EventEmitter`**<br />
+  Registers an event listener.
+
+* **EventEmitter#off([evt: `string`], [fn: `function`]): `EventEmitter`**<br />
+  Removes an event listener or any matching listeners if arguments are omitted.
+
+* **EventEmitter#emit(evt: `string`, ...args: `*`): `EventEmitter`**<br />
+  Emits an event by calling its listeners with the specified arguments.
+
+**License:** [BSD 3-Clause License](https://opensource.org/licenses/BSD-3-Clause)

data/js/node_modules/@protobufjs/eventemitter/index.d.ts

@@ -0,0 +1,43 @@
+export = EventEmitter;
+
+/**
+ * Constructs a new event emitter instance.
+ * @classdesc A minimal event emitter.
+ * @memberof util
+ * @constructor
+ */
+declare class EventEmitter {
+
+    /**
+     * Constructs a new event emitter instance.
+     * @classdesc A minimal event emitter.
+     * @memberof util
+     * @constructor
+     */
+    constructor();
+
+    /**
+     * Registers an event listener.
+     * @param {string} evt Event name
+     * @param {function} fn Listener
+     * @param {*} [ctx] Listener context
+     * @returns {util.EventEmitter} `this`
+     */
+    on(evt: string, fn: () => any, ctx?: any): EventEmitter;
+
+    /**
+     * Removes an event listener or any matching listeners if arguments are omitted.
+     * @param {string} [evt] Event name. Removes all listeners if omitted.
+     * @param {function} [fn] Listener to remove. Removes all listeners of `evt` if omitted.
+     * @returns {util.EventEmitter} `this`
+     */
+    off(evt?: string, fn?: () => any): EventEmitter;
+
+    /**
+     * Emits an event by calling its listeners with the specified arguments.
+     * @param {string} evt Event name
+     * @param {...*} args Arguments
+     * @returns {util.EventEmitter} `this`
+     */
+    emit(evt: string, ...args: any[]): EventEmitter;
+}

data/js/node_modules/@protobufjs/eventemitter/index.js

@@ -0,0 +1,76 @@
+"use strict";
+module.exports = EventEmitter;
+
+/**
+ * Constructs a new event emitter instance.
+ * @classdesc A minimal event emitter.
+ * @memberof util
+ * @constructor
+ */
+function EventEmitter() {
+
+    /**
+     * Registered listeners.
+     * @type {Object.<string,*>}
+     * @private
+     */
+    this._listeners = {};
+}
+
+/**
+ * Registers an event listener.
+ * @param {string} evt Event name
+ * @param {function} fn Listener
+ * @param {*} [ctx] Listener context
+ * @returns {util.EventEmitter} `this`
+ */
+EventEmitter.prototype.on = function on(evt, fn, ctx) {
+    (this._listeners[evt] || (this._listeners[evt] = [])).push({
+        fn  : fn,
+        ctx : ctx || this
+    });
+    return this;
+};
+
+/**
+ * Removes an event listener or any matching listeners if arguments are omitted.
+ * @param {string} [evt] Event name. Removes all listeners if omitted.
+ * @param {function} [fn] Listener to remove. Removes all listeners of `evt` if omitted.
+ * @returns {util.EventEmitter} `this`
+ */
+EventEmitter.prototype.off = function off(evt, fn) {
+    if (evt === undefined)
+        this._listeners = {};
+    else {
+        if (fn === undefined)
+            this._listeners[evt] = [];
+        else {
+            var listeners = this._listeners[evt];
+            for (var i = 0; i < listeners.length;)
+                if (listeners[i].fn === fn)
+                    listeners.splice(i, 1);
+                else
+                    ++i;
+        }
+    }
+    return this;
+};
+
+/**
+ * Emits an event by calling its listeners with the specified arguments.
+ * @param {string} evt Event name
+ * @param {...*} args Arguments
+ * @returns {util.EventEmitter} `this`
+ */
+EventEmitter.prototype.emit = function emit(evt) {
+    var listeners = this._listeners[evt];
+    if (listeners) {
+        var args = [],
+            i = 1;
+        for (; i < arguments.length;)
+            args.push(arguments[i++]);
+        for (i = 0; i < listeners.length;)
+            listeners[i].fn.apply(listeners[i++].ctx, args);
+    }
+    return this;
+};

data/js/node_modules/@protobufjs/eventemitter/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@protobufjs/eventemitter",
+  "description": "A minimal event emitter.",
+  "version": "1.1.0",
+  "author": "Daniel Wirtz <dcode+protobufjs@dcode.io>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dcodeIO/protobuf.js.git"
+  },
+  "license": "BSD-3-Clause",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "devDependencies": {
+    "istanbul": "^0.4.5",
+    "tape": "^4.6.3"
+  },
+  "scripts": {
+    "test": "tape tests/*.js",
+    "coverage": "istanbul cover node_modules/tape/bin/tape tests/*.js"
+  }
+}

data/js/node_modules/@protobufjs/eventemitter/tests/index.js

@@ -0,0 +1,47 @@
+var tape = require("tape");
+
+var EventEmitter = require("..");
+
+tape.test("eventemitter", function(test) {
+
+    var ee = new EventEmitter();
+    var fn;
+    var ctx = {};
+
+    test.doesNotThrow(function() {
+        ee.emit("a", 1);
+        ee.off();
+        ee.off("a");
+        ee.off("a", function() {});
+    }, "should not throw if no listeners are registered");
+    
+    test.equal(ee.on("a", function(arg1) {
+        test.equal(this, ctx, "should be called with this = ctx");
+        test.equal(arg1, 1, "should be called with arg1 = 1");
+    }, ctx), ee, "should return itself when registering events");
+    ee.emit("a", 1);
+
+    ee.off("a");
+    test.same(ee._listeners, { a: [] }, "should remove all listeners of the respective event when calling off(evt)");
+
+    ee.off();
+    test.same(ee._listeners, {}, "should remove all listeners when just calling off()");
+
+    ee.on("a", fn = function(arg1) {
+        test.equal(this, ctx, "should be called with this = ctx");
+        test.equal(arg1, 1, "should be called with arg1 = 1");
+    }, ctx).emit("a", 1);
+
+    ee.off("a", fn);
+    test.same(ee._listeners, { a: [] }, "should remove the exact listener when calling off(evt, fn)");
+
+    ee.on("a", function() {
+        test.equal(this, ee, "should be called with this = ee");
+    }).emit("a");
+
+    test.doesNotThrow(function() {
+        ee.off("a", fn);
+    }, "should not throw if no such listener is found");
+
+    test.end();
+});