initial commit

node_modules/emissary/lib/behavior.js

@@ -0,0 +1,120 @@
+(function() {
+  var Behavior, PropertyAccessors, Signal, helpers, isEqual,
+    __hasProp = {}.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+    __slice = [].slice;
+
+  isEqual = require('underscore-plus').isEqual;
+
+  PropertyAccessors = require('property-accessors');
+
+  Signal = require('./signal');
+
+  module.exports = Behavior = (function(_super) {
+    __extends(Behavior, _super);
+
+    PropertyAccessors.includeInto(Behavior);
+
+    function Behavior() {
+      var args, subscribeCallback, _ref;
+      args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+      if (typeof ((_ref = args[0]) != null ? _ref.call : void 0) !== 'function') {
+        this.value = args.shift();
+      }
+      Behavior.__super__.constructor.call(this, subscribeCallback = args.shift());
+    }
+
+    Behavior.prototype.retained = function() {
+      var _this = this;
+      this.subscribe(this, 'value-internal', function(value) {
+        return _this.value = value;
+      });
+      this.subscribe(this, 'value-subscription-added', function(handler) {
+        return handler(_this.value);
+      });
+      return typeof this.subscribeCallback === "function" ? this.subscribeCallback() : void 0;
+    };
+
+    Behavior.prototype.emit = function() {
+      var args, name;
+      name = arguments[0], args = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
+      if (name === 'value') {
+        this.emit.apply(this, ['value-internal'].concat(__slice.call(args)));
+      }
+      return Behavior.__super__.emit.apply(this, arguments);
+    };
+
+    Behavior.prototype.getValue = function() {
+      if (!(this.retainCount > 0)) {
+        throw new Error("Subscribe to or retain this behavior before calling getValue");
+      }
+      return this.value;
+    };
+
+    Behavior.prototype.and = function(right) {
+      return helpers.combine(this, right, (function(leftValue, rightValue) {
+        return leftValue && rightValue;
+      })).distinctUntilChanged();
+    };
+
+    Behavior.prototype.or = function(right) {
+      return helpers.combine(this, right, (function(leftValue, rightValue) {
+        return leftValue || rightValue;
+      })).distinctUntilChanged();
+    };
+
+    Behavior.prototype.toBehavior = function() {
+      return this;
+    };
+
+    Behavior.prototype.lazyAccessor('changes', function() {
+      var source;
+      source = this;
+      return new Signal(function() {
+        var gotFirst,
+          _this = this;
+        gotFirst = false;
+        return this.subscribe(source, 'value', function() {
+          var metadata, value;
+          value = arguments[0], metadata = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
+          if (gotFirst) {
+            _this.emitValue.apply(_this, [value].concat(__slice.call(metadata)));
+          }
+          return gotFirst = true;
+        });
+      });
+    });
+
+    Behavior.prototype.becomes = function(predicateOrTargetValue) {
+      var predicate, targetValue;
+      if (typeof predicateOrTargetValue !== 'function') {
+        targetValue = predicateOrTargetValue;
+        return this.becomes(function(value) {
+          return isEqual(value, targetValue);
+        });
+      }
+      predicate = predicateOrTargetValue;
+      return this.map(function(value) {
+        return !!predicate(value);
+      }).distinctUntilChanged().changes;
+    };
+
+    Behavior.prototype.becomesLessThan = function(targetValue) {
+      return this.becomes(function(value) {
+        return value < targetValue;
+      });
+    };
+
+    Behavior.prototype.becomesGreaterThan = function(targetValue) {
+      return this.becomes(function(value) {
+        return value > targetValue;
+      });
+    };
+
+    return Behavior;
+
+  })(Signal);
+
+  helpers = require('./helpers');
+
+}).call(this);

node_modules/emissary/lib/emissary.js

@@ -0,0 +1,14 @@
+(function() {
+  var combine;
+
+  combine = require('./helpers').combine;
+
+  module.exports = {
+    Emitter: require('./emitter'),
+    Subscriber: require('./subscriber'),
+    Signal: require('./signal'),
+    Behavior: require('./behavior'),
+    combine: combine
+  };
+
+}).call(this);

node_modules/emissary/lib/emitter.js

@@ -0,0 +1,384 @@
+(function() {
+  var Emitter, Mixin, Signal, Subscription, removeFromArray, subscriptionRemovedPattern, _ref,
+    __hasProp = {}.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+    __slice = [].slice;
+
+  Mixin = require('mixto');
+
+  Signal = null;
+
+  Subscription = null;
+
+  subscriptionRemovedPattern = /^(last-)?.+-subscription-removed$/;
+
+  module.exports = Emitter = (function(_super) {
+    __extends(Emitter, _super);
+
+    function Emitter() {
+      _ref = Emitter.__super__.constructor.apply(this, arguments);
+      return _ref;
+    }
+
+    Emitter.prototype.eventHandlersByEventName = null;
+
+    Emitter.prototype.eventHandlersByNamespace = null;
+
+    Emitter.prototype.subscriptionCounts = null;
+
+    Emitter.prototype.pauseCountsByEventName = null;
+
+    Emitter.prototype.queuedEventsByEventName = null;
+
+    Emitter.prototype.globalPauseCount = null;
+
+    Emitter.prototype.globalQueuedEvents = null;
+
+    Emitter.prototype.signalsByEventName = null;
+
+    Emitter.prototype.on = function(eventNames, handler) {
+      var eventName, namespace, _base, _base1, _base2, _i, _len, _ref1, _ref2;
+      _ref1 = eventNames.split(/\s+/);
+      for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
+        eventName = _ref1[_i];
+        if (!(eventName !== '')) {
+          continue;
+        }
+        _ref2 = eventName.split('.'), eventName = _ref2[0], namespace = _ref2[1];
+        this.emit("" + eventName + "-subscription-will-be-added", handler);
+        if (this.incrementSubscriptionCount(eventName) === 1) {
+          this.emit("first-" + eventName + "-subscription-will-be-added", handler);
+        }
+        if (this.eventHandlersByEventName == null) {
+          this.eventHandlersByEventName = {};
+        }
+        if ((_base = this.eventHandlersByEventName)[eventName] == null) {
+          _base[eventName] = [];
+        }
+        this.eventHandlersByEventName[eventName].push(handler);
+        if (namespace) {
+          if (this.eventHandlersByNamespace == null) {
+            this.eventHandlersByNamespace = {};
+          }
+          if ((_base1 = this.eventHandlersByNamespace)[namespace] == null) {
+            _base1[namespace] = {};
+          }
+          if ((_base2 = this.eventHandlersByNamespace[namespace])[eventName] == null) {
+            _base2[eventName] = [];
+          }
+          this.eventHandlersByNamespace[namespace][eventName].push(handler);
+        }
+        this.emit("" + eventName + "-subscription-added", handler);
+      }
+      if (Subscription == null) {
+        Subscription = require('./subscription');
+      }
+      return new Subscription(this, eventNames, handler);
+    };
+
+    Emitter.prototype.once = function(eventName, handler) {
+      var subscription;
+      return subscription = this.on(eventName, function() {
+        var args;
+        args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+        subscription.off();
+        return handler.apply(null, args);
+      });
+    };
+
+    Emitter.prototype.signal = function(eventName) {
+      var _base;
+      if (Signal == null) {
+        Signal = require('./signal');
+      }
+      if (this.signalsByEventName == null) {
+        this.signalsByEventName = {};
+      }
+      return (_base = this.signalsByEventName)[eventName] != null ? (_base = this.signalsByEventName)[eventName] : _base[eventName] = Signal.fromEmitter(this, eventName);
+    };
+
+    Emitter.prototype.behavior = function(eventName, initialValue) {
+      return this.signal(eventName).toBehavior(initialValue);
+    };
+
+    Emitter.prototype.emit = function(eventName, payload) {
+      var handler, handlers, queuedEvents, _i, _len, _ref1, _ref2, _ref3;
+      if (arguments.length > 2 || /\s|\./.test(eventName)) {
+        return this.emitSlow.apply(this, arguments);
+      } else {
+        if (this.globalQueuedEvents != null) {
+          return this.globalQueuedEvents.push([eventName, payload]);
+        } else {
+          if (queuedEvents = (_ref1 = this.queuedEventsByEventName) != null ? _ref1[eventName] : void 0) {
+            return queuedEvents.push([eventName, payload]);
+          } else if (handlers = (_ref2 = this.eventHandlersByEventName) != null ? _ref2[eventName] : void 0) {
+            _ref3 = handlers.slice();
+            for (_i = 0, _len = _ref3.length; _i < _len; _i++) {
+              handler = _ref3[_i];
+              handler(payload);
+            }
+            return this.emit("after-" + eventName, payload);
+          }
+        }
+      }
+    };
+
+    Emitter.prototype.emitSlow = function() {
+      var args, eventName, handlers, namespace, queuedEvents, _ref1, _ref2, _ref3, _ref4, _ref5, _ref6;
+      eventName = arguments[0], args = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
+      if (this.globalQueuedEvents) {
+        return this.globalQueuedEvents.push([eventName].concat(__slice.call(args)));
+      } else {
+        _ref1 = eventName.split('.'), eventName = _ref1[0], namespace = _ref1[1];
+        if (namespace) {
+          if (queuedEvents = (_ref2 = this.queuedEventsByEventName) != null ? _ref2[eventName] : void 0) {
+            return queuedEvents.push(["" + eventName + "." + namespace].concat(__slice.call(args)));
+          } else if (handlers = (_ref3 = this.eventHandlersByNamespace) != null ? (_ref4 = _ref3[namespace]) != null ? _ref4[eventName] : void 0 : void 0) {
+            (function(func, args, ctor) {
+              ctor.prototype = func.prototype;
+              var child = new ctor, result = func.apply(child, args);
+              return Object(result) === result ? result : child;
+            })(Array, handlers, function(){}).forEach(function(handler) {
+              return handler.apply(null, args);
+            });
+            return this.emit.apply(this, ["after-" + eventName].concat(__slice.call(args)));
+          }
+        } else {
+          if (queuedEvents = (_ref5 = this.queuedEventsByEventName) != null ? _ref5[eventName] : void 0) {
+            return queuedEvents.push([eventName].concat(__slice.call(args)));
+          } else if (handlers = (_ref6 = this.eventHandlersByEventName) != null ? _ref6[eventName] : void 0) {
+            (function(func, args, ctor) {
+              ctor.prototype = func.prototype;
+              var child = new ctor, result = func.apply(child, args);
+              return Object(result) === result ? result : child;
+            })(Array, handlers, function(){}).forEach(function(handler) {
+              return handler.apply(null, args);
+            });
+            return this.emit.apply(this, ["after-" + eventName].concat(__slice.call(args)));
+          }
+        }
+      }
+    };
+
+    Emitter.prototype.off = function(eventNames, handler) {
+      var eventHandlers, eventName, handlers, namespace, namespaceHandlers, _i, _j, _k, _l, _len, _len1, _len2, _len3, _ref1, _ref10, _ref2, _ref3, _ref4, _ref5, _ref6, _ref7, _ref8, _ref9;
+      if (eventNames) {
+        _ref1 = eventNames.split(/\s+/);
+        for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
+          eventName = _ref1[_i];
+          if (!(eventName !== '')) {
+            continue;
+          }
+          _ref2 = eventName.split('.'), eventName = _ref2[0], namespace = _ref2[1];
+          if (eventName === '') {
+            eventName = void 0;
+          }
+          if (namespace) {
+            if (eventName) {
+              handlers = (_ref3 = (_ref4 = this.eventHandlersByNamespace) != null ? (_ref5 = _ref4[namespace]) != null ? _ref5[eventName] : void 0 : void 0) != null ? _ref3 : [];
+              if (handler != null) {
+                removeFromArray(handlers, handler);
+                this.off(eventName, handler);
+              } else {
+                _ref6 = (function(func, args, ctor) {
+                  ctor.prototype = func.prototype;
+                  var child = new ctor, result = func.apply(child, args);
+                  return Object(result) === result ? result : child;
+                })(Array, handlers, function(){});
+                for (_j = 0, _len1 = _ref6.length; _j < _len1; _j++) {
+                  handler = _ref6[_j];
+                  removeFromArray(handlers, handler);
+                  this.off(eventName, handler);
+                }
+              }
+            } else {
+              namespaceHandlers = (_ref7 = (_ref8 = this.eventHandlersByNamespace) != null ? _ref8[namespace] : void 0) != null ? _ref7 : {};
+              if (handler != null) {
+                for (eventName in namespaceHandlers) {
+                  handlers = namespaceHandlers[eventName];
+                  removeFromArray(handlers, handler);
+                  this.off(eventName, handler);
+                }
+              } else {
+                for (eventName in namespaceHandlers) {
+                  handlers = namespaceHandlers[eventName];
+                  _ref9 = (function(func, args, ctor) {
+                    ctor.prototype = func.prototype;
+                    var child = new ctor, result = func.apply(child, args);
+                    return Object(result) === result ? result : child;
+                  })(Array, handlers, function(){});
+                  for (_k = 0, _len2 = _ref9.length; _k < _len2; _k++) {
+                    handler = _ref9[_k];
+                    removeFromArray(handlers, handler);
+                    this.off(eventName, handler);
+                  }
+                }
+              }
+            }
+          } else {
+            eventHandlers = (_ref10 = this.eventHandlersByEventName) != null ? _ref10[eventName] : void 0;
+            if (eventHandlers == null) {
+              return;
+            }
+            if (handler == null) {
+              for (_l = 0, _len3 = eventHandlers.length; _l < _len3; _l++) {
+                handler = eventHandlers[_l];
+                this.off(eventName, handler);
+              }
+              return;
+            }
+            if (removeFromArray(eventHandlers, handler)) {
+              this.decrementSubscriptionCount(eventName);
+              this.emit("" + eventName + "-subscription-removed", handler);
+              if (this.getSubscriptionCount(eventName) === 0) {
+                this.emit("last-" + eventName + "-subscription-removed", handler);
+                delete this.eventHandlersByEventName[eventName];
+              }
+            }
+          }
+        }
+      } else {
+        for (eventName in this.eventHandlersByEventName) {
+          if (!subscriptionRemovedPattern.test(eventName)) {
+            this.off(eventName);
+          }
+        }
+        for (eventName in this.eventHandlersByEventName) {
+          this.off(eventName);
+        }
+        return this.eventHandlersByNamespace = {};
+      }
+    };
+
+    Emitter.prototype.pauseEvents = function(eventNames) {
+      var eventName, _base, _base1, _i, _len, _ref1, _results;
+      if (eventNames) {
+        _ref1 = eventNames.split(/\s+/);
+        _results = [];
+        for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
+          eventName = _ref1[_i];
+          if (!(eventName !== '')) {
+            continue;
+          }
+          if (this.pauseCountsByEventName == null) {
+            this.pauseCountsByEventName = {};
+          }
+          if (this.queuedEventsByEventName == null) {
+            this.queuedEventsByEventName = {};
+          }
+          if ((_base = this.pauseCountsByEventName)[eventName] == null) {
+            _base[eventName] = 0;
+          }
+          this.pauseCountsByEventName[eventName]++;
+          _results.push((_base1 = this.queuedEventsByEventName)[eventName] != null ? (_base1 = this.queuedEventsByEventName)[eventName] : _base1[eventName] = []);
+        }
+        return _results;
+      } else {
+        if (this.globalPauseCount == null) {
+          this.globalPauseCount = 0;
+        }
+        if (this.globalQueuedEvents == null) {
+          this.globalQueuedEvents = [];
+        }
+        return this.globalPauseCount++;
+      }
+    };
+
+    Emitter.prototype.resumeEvents = function(eventNames) {
+      var event, eventName, queuedEvents, _i, _j, _len, _len1, _ref1, _ref2, _results, _results1;
+      if (eventNames) {
+        _ref1 = eventNames.split(/\s+/);
+        _results = [];
+        for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
+          eventName = _ref1[_i];
+          if (eventName !== '') {
+            if (((_ref2 = this.pauseCountsByEventName) != null ? _ref2[eventName] : void 0) > 0 && --this.pauseCountsByEventName[eventName] === 0) {
+              queuedEvents = this.queuedEventsByEventName[eventName];
+              this.queuedEventsByEventName[eventName] = null;
+              _results.push((function() {
+                var _j, _len1, _results1;
+                _results1 = [];
+                for (_j = 0, _len1 = queuedEvents.length; _j < _len1; _j++) {
+                  event = queuedEvents[_j];
+                  _results1.push(this.emit.apply(this, event));
+                }
+                return _results1;
+              }).call(this));
+            } else {
+              _results.push(void 0);
+            }
+          }
+        }
+        return _results;
+      } else {
+        for (eventName in this.pauseCountsByEventName) {
+          this.resumeEvents(eventName);
+        }
+        if (this.globalPauseCount > 0 && --this.globalPauseCount === 0) {
+          queuedEvents = this.globalQueuedEvents;
+          this.globalQueuedEvents = null;
+          _results1 = [];
+          for (_j = 0, _len1 = queuedEvents.length; _j < _len1; _j++) {
+            event = queuedEvents[_j];
+            _results1.push(this.emit.apply(this, event));
+          }
+          return _results1;
+        }
+      }
+    };
+
+    Emitter.prototype.incrementSubscriptionCount = function(eventName) {
+      var _base;
+      if (this.subscriptionCounts == null) {
+        this.subscriptionCounts = {};
+      }
+      if ((_base = this.subscriptionCounts)[eventName] == null) {
+        _base[eventName] = 0;
+      }
+      return ++this.subscriptionCounts[eventName];
+    };
+
+    Emitter.prototype.decrementSubscriptionCount = function(eventName) {
+      var count;
+      count = --this.subscriptionCounts[eventName];
+      if (count === 0) {
+        delete this.subscriptionCounts[eventName];
+      }
+      return count;
+    };
+
+    Emitter.prototype.getSubscriptionCount = function(eventName) {
+      var count, name, total, _ref1, _ref2, _ref3;
+      if (eventName != null) {
+        return (_ref1 = (_ref2 = this.subscriptionCounts) != null ? _ref2[eventName] : void 0) != null ? _ref1 : 0;
+      } else {
+        total = 0;
+        _ref3 = this.subscriptionCounts;
+        for (name in _ref3) {
+          count = _ref3[name];
+          total += count;
+        }
+        return total;
+      }
+    };
+
+    Emitter.prototype.hasSubscriptions = function(eventName) {
+      return this.getSubscriptionCount(eventName) > 0;
+    };
+
+    return Emitter;
+
+  })(Mixin);
+
+  removeFromArray = function(array, element) {
+    var index;
+    index = array.indexOf(element);
+    if (index > -1) {
+      array.splice(index, 1);
+      return true;
+    } else {
+      return false;
+    }
+  };
+
+}).call(this);

node_modules/emissary/lib/helpers.js

@@ -0,0 +1,55 @@
+(function() {
+  var Behavior, combineArray, combineWithFunction,
+    __slice = [].slice;
+
+  Behavior = require('./behavior');
+
+  exports.combine = function() {
+    var args;
+    args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+    if (args.length === 1 && Array.isArray(args[0])) {
+      return combineArray(args[0]);
+    } else if (typeof args[args.length - 1] === 'function') {
+      return combineWithFunction(args);
+    } else {
+      throw new Error("Invalid object type");
+    }
+  };
+
+  combineArray = function(array) {
+    var behavior;
+    return behavior = new Behavior(function() {
+      var element, i, outputArray, ready, _i, _len,
+        _this = this;
+      outputArray = array.slice();
+      ready = false;
+      for (i = _i = 0, _len = array.length; _i < _len; i = ++_i) {
+        element = array[i];
+        if (element.constructor.name === 'Behavior') {
+          (function(element, i) {
+            return _this.subscribe(element.onValue(function(value, metadata) {
+              if (ready) {
+                outputArray = outputArray.slice();
+              }
+              outputArray[i] = value;
+              if (ready) {
+                return _this.emitValue(outputArray, metadata);
+              }
+            }));
+          })(element, i);
+        }
+      }
+      ready = true;
+      return this.emitValue(outputArray);
+    });
+  };
+
+  combineWithFunction = function(args) {
+    var fn;
+    fn = args.pop();
+    return combineArray(args).map(function(argsArray) {
+      return fn.apply(null, argsArray);
+    });
+  };
+
+}).call(this);

node_modules/emissary/lib/signal.js

@@ -0,0 +1,292 @@
+(function() {
+  var Behavior, Emitter, Signal, Subscriber, isEqual,
+    __hasProp = {}.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+    __slice = [].slice;
+
+  isEqual = require('underscore-plus').isEqual;
+
+  Emitter = require('./emitter');
+
+  Subscriber = require('./subscriber');
+
+  Behavior = null;
+
+  module.exports = Signal = (function(_super) {
+    __extends(Signal, _super);
+
+    Subscriber.includeInto(Signal);
+
+    Signal.fromEmitter = function(emitter, eventName) {
+      return new Signal(function() {
+        var _this = this;
+        return this.subscribe(emitter, eventName, function() {
+          var metadata, value;
+          value = arguments[0], metadata = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
+          return _this.emitValue.apply(_this, [value].concat(__slice.call(metadata)));
+        });
+      });
+    };
+
+    function Signal(subscribeCallback) {
+      var _this = this;
+      this.subscribeCallback = subscribeCallback;
+      this.retainCount = 0;
+      this.on('value-subscription-will-be-added', function() {
+        return _this.retain();
+      });
+      this.on('value-subscription-removed', function() {
+        return _this.release();
+      });
+    }
+
+    Signal.prototype.isSignal = true;
+
+    Signal.prototype.retained = function() {
+      return typeof this.subscribeCallback === "function" ? this.subscribeCallback() : void 0;
+    };
+
+    Signal.prototype.released = function() {
+      return this.unsubscribe();
+    };
+
+    Signal.prototype.retain = function() {
+      if (++this.retainCount === 1) {
+        if (typeof this.retained === "function") {
+          this.retained();
+        }
+      }
+      return this;
+    };
+
+    Signal.prototype.release = function() {
+      if (--this.retainCount === 0) {
+        if (typeof this.released === "function") {
+          this.released();
+        }
+      }
+      return this;
+    };
+
+    Signal.prototype.onValue = function(handler) {
+      return this.on('value', handler);
+    };
+
+    Signal.prototype.emitValue = function(value, metadata) {
+      if (metadata == null) {
+        metadata = {};
+      }
+      if (metadata.source == null) {
+        metadata.source = this;
+      }
+      return this.emit('value', value, metadata);
+    };
+
+    Signal.prototype.toBehavior = function(initialValue) {
+      var source;
+      source = this;
+      return this.buildBehavior(initialValue, function() {
+        var _this = this;
+        return this.subscribe(source, 'value', function() {
+          var metadata, value;
+          value = arguments[0], metadata = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
+          return _this.emitValue.apply(_this, [value].concat(__slice.call(metadata)));
+        });
+      });
+    };
+
+    Signal.prototype.changes = function() {
+      return this;
+    };
+
+    Signal.prototype.injectMetadata = function(fn) {
+      var source;
+      source = this;
+      return new this.constructor(function() {
+        var _this = this;
+        return this.subscribe(source, 'value', function(value, metadata) {
+          var k, newMetadata, v;
+          newMetadata = fn(value, metadata);
+          for (k in newMetadata) {
+            v = newMetadata[k];
+            metadata[k] = v;
+          }
+          return _this.emitValue(value, metadata);
+        });
+      });
+    };
+
+    Signal.prototype.filter = function(predicate) {
+      var source;
+      source = this;
+      return new this.constructor(function() {
+        var _this = this;
+        return this.subscribe(source, 'value', function() {
+          var metadata, value;
+          value = arguments[0], metadata = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
+          if (predicate.call(value, value)) {
+            return _this.emitValue.apply(_this, [value].concat(__slice.call(metadata)));
+          }
+        });
+      });
+    };
+
+    Signal.prototype.filterDefined = function() {
+      return this.filter(function(value) {
+        return value != null;
+      });
+    };
+
+    Signal.prototype.map = function(fn) {
+      var property, source;
+      if (typeof fn === 'string') {
+        property = fn;
+        fn = function(value) {
+          return value != null ? value[property] : void 0;
+        };
+      }
+      source = this;
+      return new this.constructor(function() {
+        var _this = this;
+        return this.subscribe(source, 'value', function() {
+          var metadata, value;
+          value = arguments[0], metadata = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
+          return _this.emitValue.apply(_this, [fn.call(value, value)].concat(__slice.call(metadata)));
+        });
+      });
+    };
+
+    Signal.prototype["switch"] = function(fn) {
+      var source;
+      source = this.map(fn);
+      return new this.constructor(function() {
+        var currentSignal,
+          _this = this;
+        currentSignal = null;
+        return this.subscribe(source, 'value', function(newSignal, outerMetadata) {
+          if (currentSignal != null) {
+            _this.unsubscribe(currentSignal);
+          }
+          currentSignal = newSignal;
+          if (currentSignal != null) {
+            return _this.subscribe(currentSignal, 'value', function(value, innerMetadata) {
+              return _this.emitValue(value, innerMetadata);
+            });
+          } else {
+            return _this.emitValue(void 0, outerMetadata);
+          }
+        });
+      });
+    };
+
+    Signal.prototype.skipUntil = function(predicateOrTargetValue) {
+      var doneSkipping, predicate, targetValue;
+      if (typeof predicateOrTargetValue !== 'function') {
+        targetValue = predicateOrTargetValue;
+        return this.skipUntil(function(value) {
+          return isEqual(value, targetValue);
+        });
+      }
+      predicate = predicateOrTargetValue;
+      doneSkipping = false;
+      return this.filter(function(value) {
+        if (doneSkipping) {
+          return true;
+        }
+        if (predicate(value)) {
+          return doneSkipping = true;
+        } else {
+          return false;
+        }
+      });
+    };
+
+    Signal.prototype.scan = function(initialValue, fn) {
+      var source;
+      source = this;
+      return this.buildBehavior(initialValue, function() {
+        var oldValue,
+          _this = this;
+        oldValue = initialValue;
+        return this.subscribe(source, 'value', function() {
+          var metadata, newValue;
+          newValue = arguments[0], metadata = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
+          return _this.emitValue.apply(_this, [(oldValue = fn(oldValue, newValue))].concat(__slice.call(metadata)));
+        });
+      });
+    };
+
+    Signal.prototype.diff = function(initialValue, fn) {
+      var source;
+      source = this;
+      return this.buildBehavior(function() {
+        var oldValue,
+          _this = this;
+        oldValue = initialValue;
+        return this.subscribe(source, 'value', function() {
+          var fnOldValue, metadata, newValue;
+          newValue = arguments[0], metadata = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
+          fnOldValue = oldValue;
+          oldValue = newValue;
+          return _this.emitValue.apply(_this, [fn(fnOldValue, newValue)].concat(__slice.call(metadata)));
+        });
+      });
+    };
+
+    Signal.prototype.distinctUntilChanged = function() {
+      var source;
+      source = this;
+      return new this.constructor(function() {
+        var oldValue, receivedValue,
+          _this = this;
+        receivedValue = false;
+        oldValue = void 0;
+        return this.subscribe(source, 'value', function() {
+          var metadata, newValue;
+          newValue = arguments[0], metadata = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
+          if (receivedValue) {
+            if (isEqual(oldValue, newValue)) {
+              return oldValue = newValue;
+            } else {
+              oldValue = newValue;
+              return _this.emitValue.apply(_this, [newValue].concat(__slice.call(metadata)));
+            }
+          } else {
+            receivedValue = true;
+            oldValue = newValue;
+            return _this.emitValue.apply(_this, [newValue].concat(__slice.call(metadata)));
+          }
+        });
+      });
+    };
+
+    Signal.prototype.equals = function(expected) {
+      return this.map(function(actual) {
+        return isEqual(actual, expected);
+      }).distinctUntilChanged();
+    };
+
+    Signal.prototype.isDefined = function() {
+      return this.map(function(value) {
+        return value != null;
+      }).distinctUntilChanged();
+    };
+
+    Signal.prototype.buildBehavior = function() {
+      var args;
+      args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+      if (Behavior == null) {
+        Behavior = require('./behavior');
+      }
+      return (function(func, args, ctor) {
+        ctor.prototype = func.prototype;
+        var child = new ctor, result = func.apply(child, args);
+        return Object(result) === result ? result : child;
+      })(Behavior, args, function(){});
+    };
+
+    return Signal;
+
+  })(Emitter);
+
+}).call(this);

node_modules/emissary/lib/subscriber.js

@@ -0,0 +1,109 @@
+(function() {
+  var Mixin, Signal, Subscriber, Subscription, WeakMap, _ref, _ref1,
+    __hasProp = {}.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+    __slice = [].slice;
+
+  Mixin = require('mixto');
+
+  Signal = null;
+
+  WeakMap = (_ref = global.WeakMap) != null ? _ref : require('es6-weak-map');
+
+  Subscription = require('./subscription');
+
+  module.exports = Subscriber = (function(_super) {
+    __extends(Subscriber, _super);
+
+    function Subscriber() {
+      _ref1 = Subscriber.__super__.constructor.apply(this, arguments);
+      return _ref1;
+    }
+
+    Subscriber.prototype.subscribeWith = function(eventEmitter, methodName, args) {
+      var callback, eventNames;
+      if (eventEmitter[methodName] == null) {
+        throw new Error("Object does not have method '" + methodName + "' with which to subscribe");
+      }
+      eventEmitter[methodName].apply(eventEmitter, args);
+      eventNames = args[0];
+      callback = args[args.length - 1];
+      return this.addSubscription(new Subscription(eventEmitter, eventNames, callback));
+    };
+
+    Subscriber.prototype.addSubscription = function(subscription) {
+      var emitter;
+      if (this._subscriptions == null) {
+        this._subscriptions = [];
+      }
+      this._subscriptions.push(subscription);
+      emitter = subscription.emitter;
+      if (emitter != null) {
+        if (this._subscriptionsByObject == null) {
+          this._subscriptionsByObject = new WeakMap;
+        }
+        if (this._subscriptionsByObject.has(emitter)) {
+          this._subscriptionsByObject.get(emitter).push(subscription);
+        } else {
+          this._subscriptionsByObject.set(emitter, [subscription]);
+        }
+      }
+      return subscription;
+    };
+
+    Subscriber.prototype.subscribe = function() {
+      var args, eventEmitterOrSubscription;
+      eventEmitterOrSubscription = arguments[0], args = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
+      if (args.length === 0) {
+        return this.addSubscription(eventEmitterOrSubscription);
+      } else {
+        if (args.length === 1 && eventEmitterOrSubscription.isSignal) {
+          args.unshift('value');
+        }
+        return this.subscribeWith(eventEmitterOrSubscription, 'on', args);
+      }
+    };
+
+    Subscriber.prototype.subscribeToCommand = function() {
+      var args, eventEmitter;
+      eventEmitter = arguments[0], args = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
+      return this.subscribeWith(eventEmitter, 'command', args);
+    };
+
+    Subscriber.prototype.unsubscribe = function(object) {
+      var index, subscription, _i, _j, _len, _len1, _ref2, _ref3, _ref4, _ref5, _ref6, _ref7;
+      if (object != null) {
+        _ref4 = (_ref2 = (_ref3 = this._subscriptionsByObject) != null ? _ref3.get(object) : void 0) != null ? _ref2 : [];
+        for (_i = 0, _len = _ref4.length; _i < _len; _i++) {
+          subscription = _ref4[_i];
+          if (typeof subscription.dispose === 'function') {
+            subscription.dispose();
+          } else {
+            subscription.off();
+          }
+          index = this._subscriptions.indexOf(subscription);
+          if (index >= 0) {
+            this._subscriptions.splice(index, 1);
+          }
+        }
+        return (_ref5 = this._subscriptionsByObject) != null ? _ref5["delete"](object) : void 0;
+      } else {
+        _ref7 = (_ref6 = this._subscriptions) != null ? _ref6 : [];
+        for (_j = 0, _len1 = _ref7.length; _j < _len1; _j++) {
+          subscription = _ref7[_j];
+          if (typeof subscription.dispose === 'function') {
+            subscription.dispose();
+          } else {
+            subscription.off();
+          }
+        }
+        this._subscriptions = null;
+        return this._subscriptionsByObject = null;
+      }
+    };
+
+    return Subscriber;
+
+  })(Mixin);
+
+}).call(this);

node_modules/emissary/lib/subscription.js

@@ -0,0 +1,40 @@
+(function() {
+  var Emitter, Subscription,
+    __hasProp = {}.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
+
+  Emitter = require('./emitter');
+
+  module.exports = Subscription = (function(_super) {
+    __extends(Subscription, _super);
+
+    Subscription.prototype.cancelled = false;
+
+    function Subscription(emitter, eventNames, handler) {
+      this.emitter = emitter;
+      this.eventNames = eventNames;
+      this.handler = handler;
+    }
+
+    Subscription.prototype.off = function() {
+      return this.dispose();
+    };
+
+    Subscription.prototype.dispose = function() {
+      var unsubscribe, _ref;
+      if (this.cancelled) {
+        return;
+      }
+      unsubscribe = (_ref = this.emitter.off) != null ? _ref : this.emitter.removeListener;
+      unsubscribe.call(this.emitter, this.eventNames, this.handler);
+      this.emitter = null;
+      this.handler = null;
+      this.cancelled = true;
+      return this.emit('cancelled');
+    };
+
+    return Subscription;
+
+  })(Emitter);
+
+}).call(this);