es6_set_polyfill_rails 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 11e2168e18e7e4e1be97fdaeb4ed3cdc541cb0a8
-  data.tar.gz: 3d63d34db859042fb2c283db6452e48aefeec62f
+  metadata.gz: 8afe0f23c538852ad52c80aecde135309147f3a5
+  data.tar.gz: 0ce17e0504f3d087e17a7916f42da4876abdc577
 SHA512:
-  metadata.gz: 79f48a45461efde8a7e80573b6927665ae7e0ee4d424c09b8672f8e198bed3262e4f2fd560d44087546083d6036d441f4b0b062dca551e9d270946b6ab8fe442
-  data.tar.gz: 802ee248bd2271ce118c44801d4abf0396c0cdbdab3838cd2b353bc4bc955d62be9ee95fb62281bbcb4efd5cfa1fd5d889db471408305f636c52f69c3207e2af
+  metadata.gz: 578210730317b711643ebbf60f9889bced0bd1f655fd991b250b0b2133b5f58a0a42791d0d9aaf744ab5298b7d7e3ce3e3ba5a58382279a2b7a20d996d46fea9
+  data.tar.gz: 15e7f3c9f8dcca3c393f54d5fd5fdbd27de46cc929b200d9b440e29e408f74f19c83b61d257b7e5ac475f0e6721eef86b3982f8715a960a2f3ee783d4f69564c

data/app/assets/javascripts/es6_set_polyfill_rails.js

@@ -1,287 +1,1254 @@
-//! Copyright 2012 Eric Wendelin - MIT License
-
-/**
- * es6-map-shim.js is a DESTRUCTIVE shim that follows the latest Map specification as closely as possible.
- * It is destructive in the sense that it overrides native implementations.
- *
- * This library assumes ES5 functionality: Object.create, Object.defineProperty, Array.indexOf, Function.bind
- */
-(function(module) {
-    function Map(iterable) {
-        var _items = [];
-        var _keys = [];
-        var _values = [];
-
-        // Object.is polyfill, courtesy of @WebReflection
-        var is = Object.is || function(a, b) {
-            return a === b ?
-                a !== 0 || 1 / a == 1 / b :
-                a != a && b != b;
-        };
+(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
+'use strict';
 
-        // More reliable indexOf, courtesy of @WebReflection
-        var betterIndexOf = function(value) {
-            if(value != value || value === 0) {
-                for(var i = this.length; i-- && !is(this[i], value);){}
-            } else {
-                i = [].indexOf.call(this, value);
-            }
-            return i;
-        };
+var copy       = require('es5-ext/object/copy')
+  , map        = require('es5-ext/object/map')
+  , callable   = require('es5-ext/object/valid-callable')
+  , validValue = require('es5-ext/object/valid-value')
 
-        var MapIterator = function MapIterator(map, kind) {
-            var _index = 0;
-
-            return Object.create({}, {
-                next: {
-                    value: function() {
-                        // check if index is within bounds
-                        if (_index < map.items().length) {
-                            switch(kind) {
-                                case 'keys': return map.keys()[_index++];
-                                case 'values': return map.values()[_index++];
-                                case 'keys+values': return [].slice.call(map.items()[_index++]);
-                                default: throw new TypeError('Invalid iterator type');
-                            }
-                        }
-                        // TODO: make sure I'm interpreting the spec correctly here
-                        throw new Error('Stop Iteration');
-                    }
-                },
-                iterator: {
-                    value: function() {
-                        return this;
-                    }
-                },
-                toString: {
-                    value: function() {
-                        return '[object Map Iterator]';
-                    }
-                }
-            });
-        };
+  , bind = Function.prototype.bind, defineProperty = Object.defineProperty
+  , hasOwnProperty = Object.prototype.hasOwnProperty
+  , define;
 
-        var _set = function(key, value) {
-            // check if key exists and overwrite
-            var index = betterIndexOf.call(_keys, key);
-            if (index > -1) {
-                _items[index] = value;
-                _values[index] = value;
-            } else {
-                _items.push([key, value]);
-                _keys.push(key);
-                _values.push(value);
-            }
-        };
+define = function (name, desc, bindTo) {
+    var value = validValue(desc) && callable(desc.value), dgs;
+    dgs = copy(desc);
+    delete dgs.writable;
+    delete dgs.value;
+    dgs.get = function () {
+        if (hasOwnProperty.call(this, name)) return value;
+        desc.value = bind.call(value, (bindTo == null) ? this : this[bindTo]);
+        defineProperty(this, name, desc);
+        return this[name];
+    };
+    return dgs;
+};
 
-        var setItem = function(item) {
-            if (item.length !== 2) {
-                throw new TypeError('Invalid iterable passed to Map constructor');
-            }
+module.exports = function (props/*, bindTo*/) {
+    var bindTo = arguments[1];
+    return map(props, function (desc, name) {
+        return define(name, desc, bindTo);
+    });
+};
 
-            _set(item[0], item[1]);
-        };
+},{"es5-ext/object/copy":15,"es5-ext/object/map":23,"es5-ext/object/valid-callable":28,"es5-ext/object/valid-value":29}],2:[function(require,module,exports){
+'use strict';
 
-        // FIXME: accommodate any class that defines an @@iterator method that returns
-        //      an iterator object that produces two element array-like objects
-        if (Array.isArray(iterable)) {
-            iterable.forEach(setItem);
-        } else if (iterable !== undefined) {
-            throw new TypeError('Invalid Map');
-        }
+var assign        = require('es5-ext/object/assign')
+  , normalizeOpts = require('es5-ext/object/normalize-options')
+  , isCallable    = require('es5-ext/object/is-callable')
+  , contains      = require('es5-ext/string/#/contains')
 
-        return Object.create(MapPrototype, {
-            items:{
-                value:function() {
-                    return [].slice.call(_items);
-                }
-            },
-            keys:{
-                value:function() {
-                    return [].slice.call(_keys);
-                }
-            },
-            values:{
-                value:function() {
-                    return [].slice.call(_values);
-                }
-            },
-            has:{
-                value:function(key) {
-                    // TODO: check how spec reads about null values
-                    var index = betterIndexOf.call(_keys, key);
-                    return index > -1;
-                }
-            },
-            get:{
-                value:function(key) {
-                    var index = betterIndexOf.call(_keys, key);
-                    return index > -1 ? _values[index] : undefined;
-                }
-            },
-            set:{
-                value: _set
-            },
-            size:{
-                get:function() {
-                    return _items.length;
-                }
-            },
-            clear:{
-                value:function() {
-                    _keys.length = _values.length = _items.length = 0;
-                }
-            },
-            'delete':{
-                value:function(key) {
-                    var index = betterIndexOf.call(_keys, key);
-                    if (index > -1) {
-                        _keys.splice(index, 1);
-                        _values.splice(index, 1);
-                        _items.splice(index, 1);
-                        return true;
-                    }
-                    return false;
-                }
-            },
-            forEach:{
-                value:function(callbackfn /*, thisArg*/) {
-                    if (typeof callbackfn != 'function') {
-                        throw new TypeError('Invalid callback function given to forEach');
-                    }
-
-                    function tryNext() {
-                        try {
-                            return iter.next();
-                        } catch(e) {
-                            return undefined;
-                        }
-                    }
-
-                    var iter = this.iterator();
-                    var current = tryNext();
-                    var next = tryNext();
-                    while(current !== undefined) {
-                        callbackfn.apply(arguments[1], [current[1], current[0], this]);
-                        current = next;
-                        next = tryNext();
-                    }
-                }
-            },
-            iterator:{
-                value: function() {
-                    return new MapIterator(this, 'keys+values');
-                }
-            },
-            toString:{
-                value: function() {
-                    return '[Object Map]';
-                }
-            }
-        });
+  , d;
+
+d = module.exports = function (dscr, value/*, options*/) {
+    var c, e, w, options, desc;
+    if ((arguments.length < 2) || (typeof dscr !== 'string')) {
+        options = value;
+        value = dscr;
+        dscr = null;
+    } else {
+        options = arguments[2];
+    }
+    if (dscr == null) {
+        c = w = true;
+        e = false;
+    } else {
+        c = contains.call(dscr, 'c');
+        e = contains.call(dscr, 'e');
+        w = contains.call(dscr, 'w');
+    }
+
+    desc = { value: value, configurable: c, enumerable: e, writable: w };
+    return !options ? desc : assign(normalizeOpts(options), desc);
+};
+
+d.gs = function (dscr, get, set/*, options*/) {
+    var c, e, options, desc;
+    if (typeof dscr !== 'string') {
+        options = set;
+        set = get;
+        get = dscr;
+        dscr = null;
+    } else {
+        options = arguments[3];
+    }
+    if (get == null) {
+        get = undefined;
+    } else if (!isCallable(get)) {
+        options = get;
+        get = set = undefined;
+    } else if (set == null) {
+        set = undefined;
+    } else if (!isCallable(set)) {
+        options = set;
+        set = undefined;
+    }
+    if (dscr == null) {
+        c = true;
+        e = false;
+    } else {
+        c = contains.call(dscr, 'c');
+        e = contains.call(dscr, 'e');
+    }
+
+    desc = { get: get, set: set, configurable: c, enumerable: e };
+    return !options ? desc : assign(normalizeOpts(options), desc);
+};
+
+},{"es5-ext/object/assign":12,"es5-ext/object/is-callable":18,"es5-ext/object/normalize-options":24,"es5-ext/string/#/contains":30}],3:[function(require,module,exports){
+// Inspired by Google Closure:
+// http://closure-library.googlecode.com/svn/docs/
+// closure_goog_array_array.js.html#goog.array.clear
+
+'use strict';
+
+var value = require('../../object/valid-value');
+
+module.exports = function () {
+    value(this).length = 0;
+    return this;
+};
+
+},{"../../object/valid-value":29}],4:[function(require,module,exports){
+'use strict';
+
+var toPosInt = require('../../number/to-pos-integer')
+  , value    = require('../../object/valid-value')
+
+  , indexOf = Array.prototype.indexOf
+  , hasOwnProperty = Object.prototype.hasOwnProperty
+  , abs = Math.abs, floor = Math.floor;
+
+module.exports = function (searchElement/*, fromIndex*/) {
+    var i, l, fromIndex, val;
+    if (searchElement === searchElement) { //jslint: ignore
+        return indexOf.apply(this, arguments);
     }
 
-    var notInNode = module == 'undefined';
-    var window = notInNode ? this : global;
-    var module = notInNode ? {} : exports;
-    var MapPrototype = Map.prototype;
-
-    Map.prototype = MapPrototype = Map();
-
-    window.Map = module.Map = window.Map || Map;
-}.call(this, typeof exports));
-//! Copyright 2012 Eric Wendelin - MIT License
-(function() {
-    'use strict';
-
-    /**
-     * Given a filtering function, return a new Map of items matching that
-     * function.
-     *
-     * @param filterFn {Function} that takes up to 3 arguments and returns a Boolean.
-     * @return {Map} a new Map that is the subset of this map's items
-     * that match the given filter function.
-     */
-    Map.prototype.filter = function(filterFn) {
-        if (typeof filterFn != 'function') {
-            throw new TypeError('Expected a function argument');
+    l = toPosInt(value(this).length);
+    fromIndex = arguments[1];
+    if (isNaN(fromIndex)) fromIndex = 0;
+    else if (fromIndex >= 0) fromIndex = floor(fromIndex);
+    else fromIndex = toPosInt(this.length) - floor(abs(fromIndex));
+
+    for (i = fromIndex; i < l; ++i) {
+        if (hasOwnProperty.call(this, i)) {
+            val = this[i];
+            if (val !== val) return i; //jslint: ignore
         }
-        var _map = new Map();
-        this.forEach(function(value, key, map) {
-            if(filterFn(key, value, map)) {
-                _map.set(key, value);
-            }
+    }
+    return -1;
+};
+
+},{"../../number/to-pos-integer":10,"../../object/valid-value":29}],5:[function(require,module,exports){
+'use strict';
+
+var toString = Object.prototype.toString
+
+  , id = toString.call((function () { return arguments; }()));
+
+module.exports = function (x) { return (toString.call(x) === id); };
+
+},{}],6:[function(require,module,exports){
+'use strict';
+
+module.exports = require('./is-implemented')()
+    ? Math.sign
+    : require('./shim');
+
+},{"./is-implemented":7,"./shim":8}],7:[function(require,module,exports){
+'use strict';
+
+module.exports = function () {
+    var sign = Math.sign;
+    if (typeof sign !== 'function') return false;
+    return ((sign(10) === 1) && (sign(-20) === -1));
+};
+
+},{}],8:[function(require,module,exports){
+'use strict';
+
+module.exports = function (value) {
+    value = Number(value);
+    if (isNaN(value) || (value === 0)) return value;
+    return (value > 0) ? 1 : -1;
+};
+
+},{}],9:[function(require,module,exports){
+'use strict';
+
+var sign = require('../math/sign')
+
+  , abs = Math.abs, floor = Math.floor;
+
+module.exports = function (value) {
+    if (isNaN(value)) return 0;
+    value = Number(value);
+    if ((value === 0) || !isFinite(value)) return value;
+    return sign(value) * floor(abs(value));
+};
+
+},{"../math/sign":6}],10:[function(require,module,exports){
+'use strict';
+
+var toInteger = require('./to-integer')
+
+  , max = Math.max;
+
+module.exports = function (value) { return max(0, toInteger(value)); };
+
+},{"./to-integer":9}],11:[function(require,module,exports){
+// Internal method, used by iteration functions.
+// Calls a function for each key-value pair found in object
+// Optionally takes compareFn to iterate object in specific order
+
+'use strict';
+
+var callable = require('./valid-callable')
+  , value    = require('./valid-value')
+
+  , bind = Function.prototype.bind, call = Function.prototype.call, keys = Object.keys
+  , propertyIsEnumerable = Object.prototype.propertyIsEnumerable;
+
+module.exports = function (method, defVal) {
+    return function (obj, cb/*, thisArg, compareFn*/) {
+        var list, thisArg = arguments[2], compareFn = arguments[3];
+        obj = Object(value(obj));
+        callable(cb);
+
+        list = keys(obj);
+        if (compareFn) {
+            list.sort((typeof compareFn === 'function') ? bind.call(compareFn, obj) : undefined);
+        }
+        if (typeof method !== 'function') method = list[method];
+        return call.call(method, list, function (key, index) {
+            if (!propertyIsEnumerable.call(obj, key)) return defVal;
+            return call.call(cb, thisArg, obj[key], key, obj, index);
         });
-        return _map;
     };
+};
+
+},{"./valid-callable":28,"./valid-value":29}],12:[function(require,module,exports){
+'use strict';
+
+module.exports = require('./is-implemented')()
+    ? Object.assign
+    : require('./shim');
+
+},{"./is-implemented":13,"./shim":14}],13:[function(require,module,exports){
+'use strict';
+
+module.exports = function () {
+    var assign = Object.assign, obj;
+    if (typeof assign !== 'function') return false;
+    obj = { foo: 'raz' };
+    assign(obj, { bar: 'dwa' }, { trzy: 'trzy' });
+    return (obj.foo + obj.bar + obj.trzy) === 'razdwatrzy';
+};
+
+},{}],14:[function(require,module,exports){
+'use strict';
+
+var keys  = require('../keys')
+  , value = require('../valid-value')
+
+  , max = Math.max;
 
-    /**
-     * Return a new Map that is the union of this Map and the given other Map.
-     * If there are conflicting keys, the item in the Map argument overrides.
-     *
-     * @param otherMap {Map}
-     * @return {Map} with all non-conflicting items
-     */
-    Map.prototype.merge = function(otherMap) {
-        if (!(otherMap instanceof Map)) {
-            throw new TypeError('Cannot merge with objects that are not Maps');
+module.exports = function (dest, src/*, …srcn*/) {
+    var error, i, l = max(arguments.length, 2), assign;
+    dest = Object(value(dest));
+    assign = function (key) {
+        try { dest[key] = src[key]; } catch (e) {
+            if (!error) error = e;
         }
+    };
+    for (i = 1; i < l; ++i) {
+        src = arguments[i];
+        keys(src).forEach(assign);
+    }
+    if (error !== undefined) throw error;
+    return dest;
+};
+
+},{"../keys":20,"../valid-value":29}],15:[function(require,module,exports){
+'use strict';
+
+var assign = require('./assign')
+  , value  = require('./valid-value');
+
+module.exports = function (obj) {
+    var copy = Object(value(obj));
+    if (copy !== obj) return copy;
+    return assign({}, obj);
+};
+
+},{"./assign":12,"./valid-value":29}],16:[function(require,module,exports){
+// Workaround for http://code.google.com/p/v8/issues/detail?id=2804
+
+'use strict';
+
+var create = Object.create, shim;
 
-        function setAll(value, key) {
-            _map.set(key, value);
+if (!require('./set-prototype-of/is-implemented')()) {
+    shim = require('./set-prototype-of/shim');
+}
+
+module.exports = (function () {
+    var nullObject, props, desc;
+    if (!shim) return create;
+    if (shim.level !== 1) return create;
+
+    nullObject = {};
+    props = {};
+    desc = { configurable: false, enumerable: false, writable: true,
+        value: undefined };
+    Object.getOwnPropertyNames(Object.prototype).forEach(function (name) {
+        if (name === '__proto__') {
+            props[name] = { configurable: true, enumerable: false, writable: true,
+                value: undefined };
+            return;
         }
-        var _map = new Map();
+        props[name] = desc;
+    });
+    Object.defineProperties(nullObject, props);
 
-        this.forEach(setAll);
-        otherMap.forEach(setAll);
-        return _map;
+    Object.defineProperty(shim, 'nullPolyfill', { configurable: false,
+        enumerable: false, writable: false, value: nullObject });
+
+    return function (prototype, props) {
+        return create((prototype === null) ? nullObject : prototype, props);
     };
+}());
+
+},{"./set-prototype-of/is-implemented":26,"./set-prototype-of/shim":27}],17:[function(require,module,exports){
+'use strict';
+
+module.exports = require('./_iterate')('forEach');
+
+},{"./_iterate":11}],18:[function(require,module,exports){
+// Deprecated
+
+'use strict';
+
+module.exports = function (obj) { return typeof obj === 'function'; };
+
+},{}],19:[function(require,module,exports){
+'use strict';
+
+var map = { function: true, object: true };
+
+module.exports = function (x) {
+    return ((x != null) && map[typeof x]) || false;
+};
+
+},{}],20:[function(require,module,exports){
+'use strict';
+
+module.exports = require('./is-implemented')()
+    ? Object.keys
+    : require('./shim');
+
+},{"./is-implemented":21,"./shim":22}],21:[function(require,module,exports){
+'use strict';
+
+module.exports = function () {
+    try {
+        Object.keys('primitive');
+        return true;
+    } catch (e) { return false; }
+};
+
+},{}],22:[function(require,module,exports){
+'use strict';
+
+var keys = Object.keys;
+
+module.exports = function (object) {
+    return keys(object == null ? object : Object(object));
+};
+
+},{}],23:[function(require,module,exports){
+'use strict';
+
+var callable = require('./valid-callable')
+  , forEach  = require('./for-each')
+
+  , call = Function.prototype.call;
+
+module.exports = function (obj, cb/*, thisArg*/) {
+    var o = {}, thisArg = arguments[2];
+    callable(cb);
+    forEach(obj, function (value, key, obj, index) {
+        o[key] = call.call(cb, thisArg, value, key, obj, index);
+    });
+    return o;
+};
+
+},{"./for-each":17,"./valid-callable":28}],24:[function(require,module,exports){
+'use strict';
+
+var forEach = Array.prototype.forEach, create = Object.create;
 
-    /**
-     * Get entry for given key, or if it doesn't exist the default value.
-     *
-     * @param key {Object} anything, including primitives
-     * @param defaultValue {Object}
-     * @return item at key or default
-     */
-    Map.prototype.fetch = function(key, defaultValue) {
-        if (this.has(key)) {
-            return this.get(key);
+var process = function (src, obj) {
+    var key;
+    for (key in src) obj[key] = src[key];
+};
+
+module.exports = function (options/*, …options*/) {
+    var result = create(null);
+    forEach.call(arguments, function (options) {
+        if (options == null) return;
+        process(Object(options), result);
+    });
+    return result;
+};
+
+},{}],25:[function(require,module,exports){
+'use strict';
+
+module.exports = require('./is-implemented')()
+    ? Object.setPrototypeOf
+    : require('./shim');
+
+},{"./is-implemented":26,"./shim":27}],26:[function(require,module,exports){
+'use strict';
+
+var create = Object.create, getPrototypeOf = Object.getPrototypeOf
+  , x = {};
+
+module.exports = function (/*customCreate*/) {
+    var setPrototypeOf = Object.setPrototypeOf
+      , customCreate = arguments[0] || create;
+    if (typeof setPrototypeOf !== 'function') return false;
+    return getPrototypeOf(setPrototypeOf(customCreate(null), x)) === x;
+};
+
+},{}],27:[function(require,module,exports){
+// Big thanks to @WebReflection for sorting this out
+// https://gist.github.com/WebReflection/5593554
+
+'use strict';
+
+var isObject      = require('../is-object')
+  , value         = require('../valid-value')
+
+  , isPrototypeOf = Object.prototype.isPrototypeOf
+  , defineProperty = Object.defineProperty
+  , nullDesc = { configurable: true, enumerable: false, writable: true,
+        value: undefined }
+  , validate;
+
+validate = function (obj, prototype) {
+    value(obj);
+    if ((prototype === null) || isObject(prototype)) return obj;
+    throw new TypeError('Prototype must be null or an object');
+};
+
+module.exports = (function (status) {
+    var fn, set;
+    if (!status) return null;
+    if (status.level === 2) {
+        if (status.set) {
+            set = status.set;
+            fn = function (obj, prototype) {
+                set.call(validate(obj, prototype), prototype);
+                return obj;
+            };
+        } else {
+            fn = function (obj, prototype) {
+                validate(obj, prototype).__proto__ = prototype;
+                return obj;
+            };
         }
-        return defaultValue;
-    };
+    } else {
+        fn = function self(obj, prototype) {
+            var isNullBase;
+            validate(obj, prototype);
+            isNullBase = isPrototypeOf.call(self.nullPolyfill, obj);
+            if (isNullBase) delete self.nullPolyfill.__proto__;
+            if (prototype === null) prototype = self.nullPolyfill;
+            obj.__proto__ = prototype;
+            if (isNullBase) defineProperty(self.nullPolyfill, '__proto__', nullDesc);
+            return obj;
+        };
+    }
+    return Object.defineProperty(fn, 'level', { configurable: false,
+        enumerable: false, writable: false, value: status.level });
+}((function () {
+    var x = Object.create(null), y = {}, set
+      , desc = Object.getOwnPropertyDescriptor(Object.prototype, '__proto__');
+
+    if (desc) {
+        try {
+            set = desc.set; // Opera crashes at this point
+            set.call(x, y);
+        } catch (ignore) { }
+        if (Object.getPrototypeOf(x) === y) return { set: set, level: 2 };
+    }
+
+    x.__proto__ = y;
+    if (Object.getPrototypeOf(x) === y) return { level: 2 };
+
+    x = {};
+    x.__proto__ = y;
+    if (Object.getPrototypeOf(x) === y) return { level: 1 };
+
+    return false;
+}())));
+
+require('../create');
+
+},{"../create":16,"../is-object":19,"../valid-value":29}],28:[function(require,module,exports){
+'use strict';
+
+module.exports = function (fn) {
+    if (typeof fn !== 'function') throw new TypeError(fn + " is not a function");
+    return fn;
+};
+
+},{}],29:[function(require,module,exports){
+'use strict';
+
+module.exports = function (value) {
+    if (value == null) throw new TypeError("Cannot use null or undefined");
+    return value;
+};
+
+},{}],30:[function(require,module,exports){
+'use strict';
+
+module.exports = require('./is-implemented')()
+    ? String.prototype.contains
+    : require('./shim');
+
+},{"./is-implemented":31,"./shim":32}],31:[function(require,module,exports){
+'use strict';
+
+var str = 'razdwatrzy';
+
+module.exports = function () {
+    if (typeof str.contains !== 'function') return false;
+    return ((str.contains('dwa') === true) && (str.contains('foo') === false));
+};
+
+},{}],32:[function(require,module,exports){
+'use strict';
 
-    /**
-     * Return a new Map whose keys are the values of this Map, and values are keys.
-     *
-     * @return a new Map, this map inverted
-     */
-    Map.prototype.invert = function() {
-        var _map = new Map();
-        this.forEach(_map.set);
-        return _map;
+var indexOf = String.prototype.indexOf;
+
+module.exports = function (searchString/*, position*/) {
+    return indexOf.call(this, searchString, arguments[1]) > -1;
+};
+
+},{}],33:[function(require,module,exports){
+'use strict';
+
+var toString = Object.prototype.toString
+
+  , id = toString.call('');
+
+module.exports = function (x) {
+    return (typeof x === 'string') || (x && (typeof x === 'object') &&
+        ((x instanceof String) || (toString.call(x) === id))) || false;
+};
+
+},{}],34:[function(require,module,exports){
+'use strict';
+
+var setPrototypeOf = require('es5-ext/object/set-prototype-of')
+  , contains       = require('es5-ext/string/#/contains')
+  , d              = require('d')
+  , Iterator       = require('./')
+
+  , defineProperty = Object.defineProperty
+  , ArrayIterator;
+
+ArrayIterator = module.exports = function (arr, kind) {
+    if (!(this instanceof ArrayIterator)) return new ArrayIterator(arr, kind);
+    Iterator.call(this, arr);
+    if (!kind) kind = 'value';
+    else if (contains.call(kind, 'key+value')) kind = 'key+value';
+    else if (contains.call(kind, 'key')) kind = 'key';
+    else kind = 'value';
+    defineProperty(this, '__kind__', d('', kind));
+};
+if (setPrototypeOf) setPrototypeOf(ArrayIterator, Iterator);
+
+ArrayIterator.prototype = Object.create(Iterator.prototype, {
+    constructor: d(ArrayIterator),
+    _resolve: d(function (i) {
+        if (this.__kind__ === 'value') return this.__list__[i];
+        if (this.__kind__ === 'key+value') return [i, this.__list__[i]];
+        return i;
+    }),
+    toString: d(function () { return '[object Array Iterator]'; })
+});
+
+},{"./":37,"d":2,"es5-ext/object/set-prototype-of":25,"es5-ext/string/#/contains":30}],35:[function(require,module,exports){
+'use strict';
+
+var isArguments = require('es5-ext/function/is-arguments')
+  , callable    = require('es5-ext/object/valid-callable')
+  , isString    = require('es5-ext/string/is-string')
+  , get         = require('./get')
+
+  , isArray = Array.isArray, call = Function.prototype.call
+  , some = Array.prototype.some;
+
+module.exports = function (iterable, cb/*, thisArg*/) {
+    var mode, thisArg = arguments[2], result, doBreak, broken, i, l, char, code;
+    if (isArray(iterable) || isArguments(iterable)) mode = 'array';
+    else if (isString(iterable)) mode = 'string';
+    else iterable = get(iterable);
+
+    callable(cb);
+    doBreak = function () { broken = true; };
+    if (mode === 'array') {
+        some.call(iterable, function (value) {
+            call.call(cb, thisArg, value, doBreak);
+            if (broken) return true;
+        });
+        return;
+    }
+    if (mode === 'string') {
+        l = iterable.length;
+        for (i = 0; i < l; ++i) {
+            char = iterable[i];
+            if ((i + 1) < l) {
+                code = char.charCodeAt(0);
+                if ((code >= 0xD800) && (code <= 0xDBFF)) char += iterable[++i];
+            }
+            call.call(cb, thisArg, char, doBreak);
+            if (broken) break;
+        }
+        return;
+    }
+    result = iterable.next();
+
+    while (!result.done) {
+        call.call(cb, thisArg, result.value, doBreak);
+        if (broken) return;
+        result = iterable.next();
+    }
+};
+
+},{"./get":36,"es5-ext/function/is-arguments":5,"es5-ext/object/valid-callable":28,"es5-ext/string/is-string":33}],36:[function(require,module,exports){
+'use strict';
+
+var isArguments    = require('es5-ext/function/is-arguments')
+  , isString       = require('es5-ext/string/is-string')
+  , ArrayIterator  = require('./array')
+  , StringIterator = require('./string')
+  , iterable       = require('./valid-iterable')
+  , iteratorSymbol = require('es6-symbol').iterator;
+
+module.exports = function (obj) {
+    if (typeof iterable(obj)[iteratorSymbol] === 'function') return obj[iteratorSymbol]();
+    if (isArguments(obj)) return new ArrayIterator(obj);
+    if (isString(obj)) return new StringIterator(obj);
+    return new ArrayIterator(obj);
+};
+
+},{"./array":34,"./string":39,"./valid-iterable":40,"es5-ext/function/is-arguments":5,"es5-ext/string/is-string":33,"es6-symbol":46}],37:[function(require,module,exports){
+'use strict';
+
+var clear    = require('es5-ext/array/#/clear')
+  , assign   = require('es5-ext/object/assign')
+  , callable = require('es5-ext/object/valid-callable')
+  , value    = require('es5-ext/object/valid-value')
+  , d        = require('d')
+  , autoBind = require('d/auto-bind')
+  , Symbol   = require('es6-symbol')
+
+  , defineProperty = Object.defineProperty
+  , defineProperties = Object.defineProperties
+  , Iterator;
+
+module.exports = Iterator = function (list, context) {
+    if (!(this instanceof Iterator)) return new Iterator(list, context);
+    defineProperties(this, {
+        __list__: d('w', value(list)),
+        __context__: d('w', context),
+        __nextIndex__: d('w', 0)
+    });
+    if (!context) return;
+    callable(context.on);
+    context.on('_add', this._onAdd);
+    context.on('_delete', this._onDelete);
+    context.on('_clear', this._onClear);
+};
+
+defineProperties(Iterator.prototype, assign({
+    constructor: d(Iterator),
+    _next: d(function () {
+        var i;
+        if (!this.__list__) return;
+        if (this.__redo__) {
+            i = this.__redo__.shift();
+            if (i !== undefined) return i;
+        }
+        if (this.__nextIndex__ < this.__list__.length) return this.__nextIndex__++;
+        this._unBind();
+    }),
+    next: d(function () { return this._createResult(this._next()); }),
+    _createResult: d(function (i) {
+        if (i === undefined) return { done: true, value: undefined };
+        return { done: false, value: this._resolve(i) };
+    }),
+    _resolve: d(function (i) { return this.__list__[i]; }),
+    _unBind: d(function () {
+        this.__list__ = null;
+        delete this.__redo__;
+        if (!this.__context__) return;
+        this.__context__.off('_add', this._onAdd);
+        this.__context__.off('_delete', this._onDelete);
+        this.__context__.off('_clear', this._onClear);
+        this.__context__ = null;
+    }),
+    toString: d(function () { return '[object Iterator]'; })
+}, autoBind({
+    _onAdd: d(function (index) {
+        if (index >= this.__nextIndex__) return;
+        ++this.__nextIndex__;
+        if (!this.__redo__) {
+            defineProperty(this, '__redo__', d('c', [index]));
+            return;
+        }
+        this.__redo__.forEach(function (redo, i) {
+            if (redo >= index) this.__redo__[i] = ++redo;
+        }, this);
+        this.__redo__.push(index);
+    }),
+    _onDelete: d(function (index) {
+        var i;
+        if (index >= this.__nextIndex__) return;
+        --this.__nextIndex__;
+        if (!this.__redo__) return;
+        i = this.__redo__.indexOf(index);
+        if (i !== -1) this.__redo__.splice(i, 1);
+        this.__redo__.forEach(function (redo, i) {
+            if (redo > index) this.__redo__[i] = --redo;
+        }, this);
+    }),
+    _onClear: d(function () {
+        if (this.__redo__) clear.call(this.__redo__);
+        this.__nextIndex__ = 0;
+    })
+})));
+
+defineProperty(Iterator.prototype, Symbol.iterator, d(function () {
+    return this;
+}));
+defineProperty(Iterator.prototype, Symbol.toStringTag, d('', 'Iterator'));
+
+},{"d":2,"d/auto-bind":1,"es5-ext/array/#/clear":3,"es5-ext/object/assign":12,"es5-ext/object/valid-callable":28,"es5-ext/object/valid-value":29,"es6-symbol":46}],38:[function(require,module,exports){
+'use strict';
+
+var isArguments    = require('es5-ext/function/is-arguments')
+  , isString       = require('es5-ext/string/is-string')
+  , iteratorSymbol = require('es6-symbol').iterator
+
+  , isArray = Array.isArray;
+
+module.exports = function (value) {
+    if (value == null) return false;
+    if (isArray(value)) return true;
+    if (isString(value)) return true;
+    if (isArguments(value)) return true;
+    return (typeof value[iteratorSymbol] === 'function');
+};
+
+},{"es5-ext/function/is-arguments":5,"es5-ext/string/is-string":33,"es6-symbol":46}],39:[function(require,module,exports){
+// Thanks @mathiasbynens
+// http://mathiasbynens.be/notes/javascript-unicode#iterating-over-symbols
+
+'use strict';
+
+var setPrototypeOf = require('es5-ext/object/set-prototype-of')
+  , d              = require('d')
+  , Iterator       = require('./')
+
+  , defineProperty = Object.defineProperty
+  , StringIterator;
+
+StringIterator = module.exports = function (str) {
+    if (!(this instanceof StringIterator)) return new StringIterator(str);
+    str = String(str);
+    Iterator.call(this, str);
+    defineProperty(this, '__length__', d('', str.length));
+
+};
+if (setPrototypeOf) setPrototypeOf(StringIterator, Iterator);
+
+StringIterator.prototype = Object.create(Iterator.prototype, {
+    constructor: d(StringIterator),
+    _next: d(function () {
+        if (!this.__list__) return;
+        if (this.__nextIndex__ < this.__length__) return this.__nextIndex__++;
+        this._unBind();
+    }),
+    _resolve: d(function (i) {
+        var char = this.__list__[i], code;
+        if (this.__nextIndex__ === this.__length__) return char;
+        code = char.charCodeAt(0);
+        if ((code >= 0xD800) && (code <= 0xDBFF)) return char + this.__list__[this.__nextIndex__++];
+        return char;
+    }),
+    toString: d(function () { return '[object String Iterator]'; })
+});
+
+},{"./":37,"d":2,"es5-ext/object/set-prototype-of":25}],40:[function(require,module,exports){
+'use strict';
+
+var isIterable = require('./is-iterable');
+
+module.exports = function (value) {
+    if (!isIterable(value)) throw new TypeError(value + " is not iterable");
+    return value;
+};
+
+},{"./is-iterable":38}],41:[function(require,module,exports){
+'use strict';
+
+module.exports = require('./is-implemented')() ? Set : require('./polyfill');
+
+},{"./is-implemented":42,"./polyfill":45}],42:[function(require,module,exports){
+'use strict';
+
+module.exports = function () {
+    var set, iterator, result;
+    if (typeof Set !== 'function') return false;
+    set = new Set(['raz', 'dwa', 'trzy']);
+    if (String(set) !== '[object Set]') return false;
+    if (set.size !== 3) return false;
+    if (typeof set.add !== 'function') return false;
+    if (typeof set.clear !== 'function') return false;
+    if (typeof set.delete !== 'function') return false;
+    if (typeof set.entries !== 'function') return false;
+    if (typeof set.forEach !== 'function') return false;
+    if (typeof set.has !== 'function') return false;
+    if (typeof set.keys !== 'function') return false;
+    if (typeof set.values !== 'function') return false;
+
+    iterator = set.values();
+    result = iterator.next();
+    if (result.done !== false) return false;
+    if (result.value !== 'raz') return false;
+
+    return true;
+};
+
+},{}],43:[function(require,module,exports){
+// Exports true if environment provides native `Set` implementation,
+// whatever that is.
+
+'use strict';
+
+module.exports = (function () {
+    if (typeof Set === 'undefined') return false;
+    return (Object.prototype.toString.call(Set.prototype) === '[object Set]');
+}());
+
+},{}],44:[function(require,module,exports){
+'use strict';
+
+var setPrototypeOf    = require('es5-ext/object/set-prototype-of')
+  , contains          = require('es5-ext/string/#/contains')
+  , d                 = require('d')
+  , Iterator          = require('es6-iterator')
+  , toStringTagSymbol = require('es6-symbol').toStringTag
+
+  , defineProperty = Object.defineProperty
+  , SetIterator;
+
+SetIterator = module.exports = function (set, kind) {
+    if (!(this instanceof SetIterator)) return new SetIterator(set, kind);
+    Iterator.call(this, set.__setData__, set);
+    if (!kind) kind = 'value';
+    else if (contains.call(kind, 'key+value')) kind = 'key+value';
+    else kind = 'value';
+    defineProperty(this, '__kind__', d('', kind));
+};
+if (setPrototypeOf) setPrototypeOf(SetIterator, Iterator);
+
+SetIterator.prototype = Object.create(Iterator.prototype, {
+    constructor: d(SetIterator),
+    _resolve: d(function (i) {
+        if (this.__kind__ === 'value') return this.__list__[i];
+        return [this.__list__[i], this.__list__[i]];
+    }),
+    toString: d(function () { return '[object Set Iterator]'; })
+});
+defineProperty(SetIterator.prototype, toStringTagSymbol, d('c', 'Set Iterator'));
+
+},{"d":2,"es5-ext/object/set-prototype-of":25,"es5-ext/string/#/contains":30,"es6-iterator":37,"es6-symbol":46}],45:[function(require,module,exports){
+'use strict';
+
+var clear          = require('es5-ext/array/#/clear')
+  , eIndexOf       = require('es5-ext/array/#/e-index-of')
+  , setPrototypeOf = require('es5-ext/object/set-prototype-of')
+  , callable       = require('es5-ext/object/valid-callable')
+  , d              = require('d')
+  , ee             = require('event-emitter')
+  , Symbol         = require('es6-symbol')
+  , iterator       = require('es6-iterator/valid-iterable')
+  , forOf          = require('es6-iterator/for-of')
+  , Iterator       = require('./lib/iterator')
+  , isNative       = require('./is-native-implemented')
+
+  , call = Function.prototype.call
+  , defineProperty = Object.defineProperty, getPrototypeOf = Object.getPrototypeOf
+  , SetPoly, getValues, NativeSet;
+
+if (isNative) NativeSet = Set;
+
+module.exports = SetPoly = function Set(/*iterable*/) {
+    var iterable = arguments[0], self;
+    if (!(this instanceof SetPoly)) throw new TypeError('Constructor requires \'new\'');
+    if (isNative && setPrototypeOf) self = setPrototypeOf(new NativeSet(), getPrototypeOf(this));
+    else self = this;
+    if (iterable != null) iterator(iterable);
+    defineProperty(self, '__setData__', d('c', []));
+    if (!iterable) return self;
+    forOf(iterable, function (value) {
+        if (eIndexOf.call(this, value) !== -1) return;
+        this.push(value);
+    }, self.__setData__);
+    return self;
+};
+
+if (isNative) {
+    if (setPrototypeOf) setPrototypeOf(SetPoly, NativeSet);
+    SetPoly.prototype = Object.create(NativeSet.prototype, { constructor: d(SetPoly) });
+}
+
+ee(Object.defineProperties(SetPoly.prototype, {
+    add: d(function (value) {
+        if (this.has(value)) return this;
+        this.emit('_add', this.__setData__.push(value) - 1, value);
+        return this;
+    }),
+    clear: d(function () {
+        if (!this.__setData__.length) return;
+        clear.call(this.__setData__);
+        this.emit('_clear');
+    }),
+    delete: d(function (value) {
+        var index = eIndexOf.call(this.__setData__, value);
+        if (index === -1) return false;
+        this.__setData__.splice(index, 1);
+        this.emit('_delete', index, value);
+        return true;
+    }),
+    entries: d(function () { return new Iterator(this, 'key+value'); }),
+    forEach: d(function (cb/*, thisArg*/) {
+        var thisArg = arguments[1], iterator, result, value;
+        callable(cb);
+        iterator = this.values();
+        result = iterator._next();
+        while (result !== undefined) {
+            value = iterator._resolve(result);
+            call.call(cb, thisArg, value, value, this);
+            result = iterator._next();
+        }
+    }),
+    has: d(function (value) {
+        return (eIndexOf.call(this.__setData__, value) !== -1);
+    }),
+    keys: d(getValues = function () { return this.values(); }),
+    size: d.gs(function () { return this.__setData__.length; }),
+    values: d(function () { return new Iterator(this); }),
+    toString: d(function () { return '[object Set]'; })
+}));
+defineProperty(SetPoly.prototype, Symbol.iterator, d(getValues));
+defineProperty(SetPoly.prototype, Symbol.toStringTag, d('c', 'Set'));
+
+},{"./is-native-implemented":43,"./lib/iterator":44,"d":2,"es5-ext/array/#/clear":3,"es5-ext/array/#/e-index-of":4,"es5-ext/object/set-prototype-of":25,"es5-ext/object/valid-callable":28,"es6-iterator/for-of":35,"es6-iterator/valid-iterable":40,"es6-symbol":46,"event-emitter":51}],46:[function(require,module,exports){
+'use strict';
+
+module.exports = require('./is-implemented')() ? Symbol : require('./polyfill');
+
+},{"./is-implemented":47,"./polyfill":49}],47:[function(require,module,exports){
+'use strict';
+
+module.exports = function () {
+    var symbol;
+    if (typeof Symbol !== 'function') return false;
+    symbol = Symbol('test symbol');
+    try { String(symbol); } catch (e) { return false; }
+    if (typeof Symbol.iterator === 'symbol') return true;
+
+    // Return 'true' for polyfills
+    if (typeof Symbol.isConcatSpreadable !== 'object') return false;
+    if (typeof Symbol.iterator !== 'object') return false;
+    if (typeof Symbol.toPrimitive !== 'object') return false;
+    if (typeof Symbol.toStringTag !== 'object') return false;
+    if (typeof Symbol.unscopables !== 'object') return false;
+
+    return true;
+};
+
+},{}],48:[function(require,module,exports){
+'use strict';
+
+module.exports = function (x) {
+    return (x && ((typeof x === 'symbol') || (x['@@toStringTag'] === 'Symbol'))) || false;
+};
+
+},{}],49:[function(require,module,exports){
+// ES2015 Symbol polyfill for environments that do not support it (or partially support it_
+
+'use strict';
+
+var d              = require('d')
+  , validateSymbol = require('./validate-symbol')
+
+  , create = Object.create, defineProperties = Object.defineProperties
+  , defineProperty = Object.defineProperty, objPrototype = Object.prototype
+  , NativeSymbol, SymbolPolyfill, HiddenSymbol, globalSymbols = create(null);
+
+if (typeof Symbol === 'function') NativeSymbol = Symbol;
+
+var generateName = (function () {
+    var created = create(null);
+    return function (desc) {
+        var postfix = 0, name, ie11BugWorkaround;
+        while (created[desc + (postfix || '')]) ++postfix;
+        desc += (postfix || '');
+        created[desc] = true;
+        name = '@@' + desc;
+        defineProperty(objPrototype, name, d.gs(null, function (value) {
+            // For IE11 issue see:
+            // https://connect.microsoft.com/IE/feedbackdetail/view/1928508/
+            //    ie11-broken-getters-on-dom-objects
+            // https://github.com/medikoo/es6-symbol/issues/12
+            if (ie11BugWorkaround) return;
+            ie11BugWorkaround = true;
+            defineProperty(this, name, d(value));
+            ie11BugWorkaround = false;
+        }));
+        return name;
     };
+}());
+
+// Internal constructor (not one exposed) for creating Symbol instances.
+// This one is used to ensure that `someSymbol instanceof Symbol` always return false
+HiddenSymbol = function Symbol(description) {
+    if (this instanceof HiddenSymbol) throw new TypeError('TypeError: Symbol is not a constructor');
+    return SymbolPolyfill(description);
+};
+
+// Exposed `Symbol` constructor
+// (returns instances of HiddenSymbol)
+module.exports = SymbolPolyfill = function Symbol(description) {
+    var symbol;
+    if (this instanceof Symbol) throw new TypeError('TypeError: Symbol is not a constructor');
+    symbol = create(HiddenSymbol.prototype);
+    description = (description === undefined ? '' : String(description));
+    return defineProperties(symbol, {
+        __description__: d('', description),
+        __name__: d('', generateName(description))
+    });
+};
+defineProperties(SymbolPolyfill, {
+    for: d(function (key) {
+        if (globalSymbols[key]) return globalSymbols[key];
+        return (globalSymbols[key] = SymbolPolyfill(String(key)));
+    }),
+    keyFor: d(function (s) {
+        var key;
+        validateSymbol(s);
+        for (key in globalSymbols) if (globalSymbols[key] === s) return key;
+    }),
+
+    // If there's native implementation of given symbol, let's fallback to it
+    // to ensure proper interoperability with other native functions e.g. Array.from
+    hasInstance: d('', (NativeSymbol && NativeSymbol.hasInstance) || SymbolPolyfill('hasInstance')),
+    isConcatSpreadable: d('', (NativeSymbol && NativeSymbol.isConcatSpreadable) ||
+        SymbolPolyfill('isConcatSpreadable')),
+    iterator: d('', (NativeSymbol && NativeSymbol.iterator) || SymbolPolyfill('iterator')),
+    match: d('', (NativeSymbol && NativeSymbol.match) || SymbolPolyfill('match')),
+    replace: d('', (NativeSymbol && NativeSymbol.replace) || SymbolPolyfill('replace')),
+    search: d('', (NativeSymbol && NativeSymbol.search) || SymbolPolyfill('search')),
+    species: d('', (NativeSymbol && NativeSymbol.species) || SymbolPolyfill('species')),
+    split: d('', (NativeSymbol && NativeSymbol.split) || SymbolPolyfill('split')),
+    toPrimitive: d('', (NativeSymbol && NativeSymbol.toPrimitive) || SymbolPolyfill('toPrimitive')),
+    toStringTag: d('', (NativeSymbol && NativeSymbol.toStringTag) || SymbolPolyfill('toStringTag')),
+    unscopables: d('', (NativeSymbol && NativeSymbol.unscopables) || SymbolPolyfill('unscopables'))
+});
+
+// Internal tweaks for real symbol producer
+defineProperties(HiddenSymbol.prototype, {
+    constructor: d(SymbolPolyfill),
+    toString: d('', function () { return this.__name__; })
+});
+
+// Proper implementation of methods exposed on Symbol.prototype
+// They won't be accessible on produced symbol instances as they derive from HiddenSymbol.prototype
+defineProperties(SymbolPolyfill.prototype, {
+    toString: d(function () { return 'Symbol (' + validateSymbol(this).__description__ + ')'; }),
+    valueOf: d(function () { return validateSymbol(this); })
+});
+defineProperty(SymbolPolyfill.prototype, SymbolPolyfill.toPrimitive, d('',
+    function () { return validateSymbol(this); }));
+defineProperty(SymbolPolyfill.prototype, SymbolPolyfill.toStringTag, d('c', 'Symbol'));
+
+// Proper implementaton of toPrimitive and toStringTag for returned symbol instances
+defineProperty(HiddenSymbol.prototype, SymbolPolyfill.toStringTag,
+    d('c', SymbolPolyfill.prototype[SymbolPolyfill.toStringTag]));
+
+// Note: It's important to define `toPrimitive` as last one, as some implementations
+// implement `toPrimitive` natively without implementing `toStringTag` (or other specified symbols)
+// And that may invoke error in definition flow:
+// See: https://github.com/medikoo/es6-symbol/issues/13#issuecomment-164146149
+defineProperty(HiddenSymbol.prototype, SymbolPolyfill.toPrimitive,
+    d('c', SymbolPolyfill.prototype[SymbolPolyfill.toPrimitive]));
+
+},{"./validate-symbol":50,"d":2}],50:[function(require,module,exports){
+'use strict';
+
+var isSymbol = require('./is-symbol');
+
+module.exports = function (value) {
+    if (!isSymbol(value)) throw new TypeError(value + " is not a symbol");
+    return value;
+};
+
+},{"./is-symbol":48}],51:[function(require,module,exports){
+'use strict';
+
+var d        = require('d')
+  , callable = require('es5-ext/object/valid-callable')
 
-    /**
-     * Remove items from this Map as designated by a filtering function.
-     *
-     * @param filterFn {Function} using key, value and/or index and returning a Boolean
-     */
-    Map.prototype.reject = function(filterFn) {
-        if (typeof filterFn != 'function') {
-            throw new TypeError('Expected a function argument');
+  , apply = Function.prototype.apply, call = Function.prototype.call
+  , create = Object.create, defineProperty = Object.defineProperty
+  , defineProperties = Object.defineProperties
+  , hasOwnProperty = Object.prototype.hasOwnProperty
+  , descriptor = { configurable: true, enumerable: false, writable: true }
+
+  , on, once, off, emit, methods, descriptors, base;
+
+on = function (type, listener) {
+    var data;
+
+    callable(listener);
+
+    if (!hasOwnProperty.call(this, '__ee__')) {
+        data = descriptor.value = create(null);
+        defineProperty(this, '__ee__', descriptor);
+        descriptor.value = null;
+    } else {
+        data = this.__ee__;
+    }
+    if (!data[type]) data[type] = listener;
+    else if (typeof data[type] === 'object') data[type].push(listener);
+    else data[type] = [data[type], listener];
+
+    return this;
+};
+
+once = function (type, listener) {
+    var once, self;
+
+    callable(listener);
+    self = this;
+    on.call(this, type, once = function () {
+        off.call(self, type, once);
+        apply.call(listener, this, arguments);
+    });
+
+    once.__eeOnceListener__ = listener;
+    return this;
+};
+
+off = function (type, listener) {
+    var data, listeners, candidate, i;
+
+    callable(listener);
+
+    if (!hasOwnProperty.call(this, '__ee__')) return this;
+    data = this.__ee__;
+    if (!data[type]) return this;
+    listeners = data[type];
+
+    if (typeof listeners === 'object') {
+        for (i = 0; (candidate = listeners[i]); ++i) {
+            if ((candidate === listener) ||
+                    (candidate.__eeOnceListener__ === listener)) {
+                if (listeners.length === 2) data[type] = listeners[i ? 0 : 1];
+                else listeners.splice(i, 1);
+            }
         }
-        this.forEach(function(value, key, map) {
-            if(filterFn(key, value, map)) {
-                map['delete'](key);
+    } else {
+        if ((listeners === listener) ||
+                (listeners.__eeOnceListener__ === listener)) {
+            delete data[type];
+        }
+    }
+
+    return this;
+};
+
+emit = function (type) {
+    var i, l, listener, listeners, args;
+
+    if (!hasOwnProperty.call(this, '__ee__')) return;
+    listeners = this.__ee__[type];
+    if (!listeners) return;
+
+    if (typeof listeners === 'object') {
+        l = arguments.length;
+        args = new Array(l - 1);
+        for (i = 1; i < l; ++i) args[i - 1] = arguments[i];
+
+        listeners = listeners.slice();
+        for (i = 0; (listener = listeners[i]); ++i) {
+            apply.call(listener, this, args);
+        }
+    } else {
+        switch (arguments.length) {
+        case 1:
+            call.call(listeners, this);
+            break;
+        case 2:
+            call.call(listeners, this, arguments[1]);
+            break;
+        case 3:
+            call.call(listeners, this, arguments[1], arguments[2]);
+            break;
+        default:
+            l = arguments.length;
+            args = new Array(l - 1);
+            for (i = 1; i < l; ++i) {
+                args[i - 1] = arguments[i];
             }
-        }.bind(this));
-    };
+            apply.call(listeners, this, args);
+        }
+    }
+};
 
-    /**
-     * @return true if there are no entries in this Map.
-     */
-    Map.prototype.isEmpty = function() {
-        return this.keys().length === 0;
-    };
-})();
+methods = {
+    on: on,
+    once: once,
+    off: off,
+    emit: emit
+};
+
+descriptors = {
+    on: d(on),
+    once: d(once),
+    off: d(off),
+    emit: d(emit)
+};
+
+base = defineProperties({}, descriptors);
+
+module.exports = exports = function (o) {
+    return (o == null) ? create(base) : defineProperties(Object(o), descriptors);
+};
+exports.methods = methods;
+
+},{"d":2,"es5-ext/object/valid-callable":28}]},{},[41]);
+
+var Set = require('es6-set');