(function() {
/*globals Frampton:true */
var define, require;
var global = this;

/**

This loader code is taken from the guys over at Ember
https://github.com/emberjs/ember.js/

Copyright (c) 2015 Yehuda Katz, Tom Dale and Ember.js contributors

Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

*/
(function() {

  if (typeof Frampton === 'undefined') {
    Frampton = {};
  };

  if (typeof Frampton.__loader === 'undefined') {

    var registry = {};
    var seen = {};

    define = function(name, deps, callback) {

      var value = {};

      if (!callback) {
        value.deps = [];
        value.callback = deps;
      } else {
        value.deps = deps;
        value.callback = callback;
      }

      registry[name] = value;
    };

    require = function(name) {
      return internalRequire(name, null);
    };

    function internalRequire(name, referrerName) {

      var exports = seen[name];
      var module = {};

      if (exports !== undefined) {
        return exports;
      }

      exports = {};
      module.exports = exports;

      if (!registry[name]) {
        if (referrerName) {
          throw new Error('Could not find module ' + name + ' required by: ' + referrerName);
        } else {
          throw new Error('Could not find module ' + name);
        }
      }

      var mod = registry[name];
      var deps = mod.deps;
      var callback = mod.callback;
      var reified = [];
      var len = deps.length;
      var i = 0;

      for (; i<len; i++) {
        if (deps[i] === 'exports') {
          reified.push(exports);
        } else if (deps[i] === 'module') {
          reified.push(module);
        } else {
          reified.push(internalRequire(resolve(deps[i], name), name));
        }
      }

      callback.apply(this, reified);

      seen[name] = (reified[1] && reified[1].exports) ? reified[1].exports : reified[0];

      return seen[name];
    };

    function resolve(child, name) {

      if (child.charAt(0) !== '.') {
        return child;
      }

      var parts = child.split('/');
      var parentBase = name.split('/').slice(0, -1);
      var len = parts.length;
      var i = 0;

      for (; i < len; i++) {

        var part = parts[i];

        if (part === '..') {
          parentBase.pop();
        } else if (part === '.') {
          continue;
        } else {
          parentBase.push(part);
        }
      }

      return parentBase.join('/');
    }

    Frampton.__loader = {
      define: define,
      require: require,
      registry: registry
    };

  } else {
    define = Frampton.__loader.define;
    require = Frampton.__loader.require;
  }

}());

define('frampton-data', ['frampton/namespace', 'frampton-data/task/create', 'frampton-data/task/sync', 'frampton-data/task/delay', 'frampton-data/task/fail', 'frampton-data/task/never', 'frampton-data/task/sequence', 'frampton-data/task/succeed', 'frampton-data/task/when', 'frampton-data/task/batch', 'frampton-data/task/execute', 'frampton-data/union/create', 'frampton-data/record/create', 'frampton-data/maybe/create', 'frampton-data/maybe/just', 'frampton-data/maybe/nothing', 'frampton-data/result/success', 'frampton-data/result/failure', 'frampton-data/result/from_throwable'], function (_namespace, _create, _sync, _delay, _fail, _never, _sequence, _succeed, _when, _batch, _execute, _create3, _create5, _create7, _just, _nothing, _success, _failure, _from_throwable) {
  'use strict';

  var _namespace2 = _interopRequireDefault(_namespace);

  var _create2 = _interopRequireDefault(_create);

  var _sync2 = _interopRequireDefault(_sync);

  var _delay2 = _interopRequireDefault(_delay);

  var _fail2 = _interopRequireDefault(_fail);

  var _never2 = _interopRequireDefault(_never);

  var _sequence2 = _interopRequireDefault(_sequence);

  var _succeed2 = _interopRequireDefault(_succeed);

  var _when2 = _interopRequireDefault(_when);

  var _batch2 = _interopRequireDefault(_batch);

  var _execute2 = _interopRequireDefault(_execute);

  var _create4 = _interopRequireDefault(_create3);

  var _create6 = _interopRequireDefault(_create5);

  var _just2 = _interopRequireDefault(_just);

  var _nothing2 = _interopRequireDefault(_nothing);

  var _success2 = _interopRequireDefault(_success);

  var _failure2 = _interopRequireDefault(_failure);

  var _from_throwable2 = _interopRequireDefault(_from_throwable);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * @name Data
   * @namespace
   * @memberof Frampton
   */
  _namespace2.default.Data = {};

  /**
   * @name Task
   * @memberof Frampton.Data
   * @class A data type for wrapping impure computations
   * @constructor does not be called by the user.
   */
  _namespace2.default.Data.Task = {};
  _namespace2.default.Data.Task.delay = _delay2.default;
  _namespace2.default.Data.Task.create = _create2.default;
  _namespace2.default.Data.Task.sync = _sync2.default;
  _namespace2.default.Data.Task.fail = _fail2.default;
  _namespace2.default.Data.Task.succeed = _succeed2.default;
  _namespace2.default.Data.Task.never = _never2.default;
  _namespace2.default.Data.Task.sequence = _sequence2.default;
  _namespace2.default.Data.Task.when = _when2.default;
  _namespace2.default.Data.Task.batch = _batch2.default;
  _namespace2.default.Data.Task.execute = _execute2.default;

  /**
   * @name Union
   * @memberof Frampton.Data
   * @class
   */
  _namespace2.default.Data.Union = {};
  _namespace2.default.Data.Union.create = _create4.default;

  /**
   * @name Record
   * @memberof Frampton.Data
   * @class
   */
  _namespace2.default.Data.Record = {};
  _namespace2.default.Data.Record.create = _create6.default;

  /**
   * @name Maybe
   * @memberof Frampton.Data
   * @class
   */
  _namespace2.default.Data.Maybe = {};
  _namespace2.default.Data.Maybe.create = _create7.createMaybe;
  _namespace2.default.Data.Maybe.Just = _just2.default;
  _namespace2.default.Data.Maybe.Nothing = _nothing2.default;

  /**
   * @name Result
   * @memberof Frampton.Data
   * @class
   */
  _namespace2.default.Data.Result = {};
  _namespace2.default.Data.Result.fromThrowable = _from_throwable2.default;
  _namespace2.default.Data.Result.Success = _success2.default;
  _namespace2.default.Data.Result.Failure = _failure2.default;
});
define('frampton-data/maybe/create', ['exports', 'frampton-utils/is_something', 'frampton-utils/is_function', 'frampton-utils/of_value', 'frampton-utils/is_equal'], function (exports, _is_something, _is_function, _of_value, _is_equal) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.NothingType = exports.JustType = exports.createMaybe = undefined;

  var _is_something2 = _interopRequireDefault(_is_something);

  var _is_function2 = _interopRequireDefault(_is_function);

  var _of_value2 = _interopRequireDefault(_of_value);

  var _is_equal2 = _interopRequireDefault(_is_equal);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function create(val) {
    if ((0, _is_something2.default)(val)) {
      return new Just(val);
    } else {
      return new Nothing();
    }
  }

  /**
   * @name Maybe
   * @class
   * @abstract
   * @private
   * @memberof Frampton.Data
   */
  function Maybe() {}

  /**
   * @name toString
   * @method
   * @memberof Frampton.Data.Mabye#
   * @returns {String}
   */
  Maybe.prototype.toString = function () {
    return 'Just(' + this._value + ')';
  };

  /**
   * join :: Maybe (a -> b) -> Maybe a -> Maybe b
   *
   * Applies the function in one maybe to the value of another.
   *
   * @name join
   * @method
   * @memberof Frampton.Data.Maybe#
   * @param {Frampton.Data.Maybe} mb
   * @returns {Frampton.Data.Maybe}
   */
  Maybe.prototype.ap = function (mb) {
    return create(this._value(mb._value));
  };

  /**
   * join :: Maybe (Maybe a) -> Maybe a
   *
   * Takes a nested Maybe and removes one level of nesting.
   *
   * @name join
   * @method
   * @memberof Frampton.Data.Maybe#
   * @returns {Frampton.Data.Maybe}
   */
  Maybe.prototype.join = function () {
    return this.get();
  };

  /**
   * @name fork
   * @method
   * @memberof Frampton.Data.Maybe#
   * @param {Function} justFn Function to call with value of Just
   * @param {Function} nothingFn Function to call with value of Nothing
   * @returns {*} The return value of the matching function
   */
  Maybe.prototype.fork = function (justFn, _) {
    return justFn(this._value);
  };

  /**
   * map :: Maybe a -> (a -> b) -> Maybe b
   *
   * Transforms the value of a Maybe with the given function.
   *
   * @name map
   * @method
   * @memberof Frampton.Data.Maybe#
   * @param {Function} mapping Function used to map value of Maybe
   * @returns {Frampton.Data.Maybe}
   */
  Maybe.prototype.map = function (mapping) {
    var mappingFn = (0, _is_function2.default)(mapping) ? mapping : (0, _of_value2.default)(mapping);
    return create(mappingFn(this._value));
  };

  /**
   * chain :: Maybe a -> (a -> Maybe b) -> Maybe b
   *
   * Takes the value of a Maybe and gives it to a function that returns a new Maybe.
   *
   * @name chain
   * @method
   * @memberof Frampton.Data.Maybe#
   * @param {Function} mapping Function used to create new Maybe
   * @returns {Frampton.Data.Maybe}
   */
  Maybe.prototype.chain = function (mapping) {
    return this.map(mapping).join();
  };

  /**
   * filter :: Maybe a -> (a -> Boolean) -> Maybe a
   *
   * Turns a Just into a Nothing if the predicate returns false
   *
   * @name filter
   * @method
   * @memberof Frampton.Data.Maybe#
   * @param {Function} predicate Function used to test value
   * @returns {Frampton.Data.Maybe}
   */
  Maybe.prototype.filter = function (predicate) {
    var filterFn = (0, _is_function2.default)(predicate) ? predicate : (0, _is_equal2.default)(predicate);
    if (filterFn(this._value)) {
      return new Just(this._value);
    } else {
      return new Nothing();
    }
  };

  /**
   * get :: Maybe a -> a
   *
   * Extract the value from a Maybe
   *
   * @name get
   * @method
   * @memberof Frampton.Data.Maybe#
   * @returns {*}
   */
  Maybe.prototype.get = function () {
    return this._value;
  };

  /**
   * getOrElse :: Maybe a -> a -> a
   *
   * @name getOrElse
   * @method
   * @memberof Frampton.Data.Maybe#
   * @returns {*}
   */
  Maybe.prototype.getOrElse = function (_) {
    return this._value;
  };

  /**
   * isNothing :: Maybe a -> Boolean
   *
   * @name isNothing
   * @method
   * @memberof Frampton.Data.Maybe#
   * @returns {Boolean}
   */
  Maybe.prototype.isNothing = function () {
    return false;
  };

  /**
   * isJust :: Maybe a -> Boolean
   *
   * @name isJust
   * @method
   * @memberof Frampton.Data.Maybe#
   * @returns {Boolean}
   */
  Maybe.prototype.isJust = function () {
    return false;
  };

  /**
   * @name Just
   * @class
   * @extends Frampton.Data.Maybe
   */
  function Just(val) {
    this._value = val;
  }

  Just.prototype = new Maybe();

  Just.prototype.isJust = function () {
    return true;
  };

  /**
   * @name Nothing
   * @class
   * @extends Frampton.Data.Maybe
   */
  function Nothing() {}

  Nothing.prototype = new Maybe();

  Nothing.prototype.toString = function () {
    return 'Nothing';
  };

  Nothing.prototype.fork = function (_, nothingFn) {
    return nothingFn();
  };

  Nothing.prototype.join = function () {
    return new Nothing();
  };

  Nothing.prototype.map = function (_) {
    return new Nothing();
  };

  Nothing.prototype.filter = function (_) {
    return new Nothing();
  };

  Nothing.prototype.ap = function (_) {
    return new Nothing();
  };

  Nothing.prototype.chain = function (_) {
    return new Nothing();
  };

  Nothing.prototype.get = function () {
    throw new Error('Cannot get the value of a Nothing');
  };

  Nothing.prototype.getOrElse = function (val) {
    return val;
  };

  Nothing.prototype.isNothing = function () {
    return true;
  };

  var createMaybe = exports.createMaybe = create;

  var JustType = exports.JustType = Just;

  var NothingType = exports.NothingType = Nothing;
});
define('frampton-data/maybe/just', ['exports', 'frampton-data/maybe/create'], function (exports, _create) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = create_just;
  function create_just(val) {
    return new _create.JustType(val);
  }
});
define('frampton-data/maybe/nothing', ['exports', 'frampton-data/maybe/create'], function (exports, _create) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = create_nothing;
  function create_nothing() {
    return new _create.NothingType();
  }
});
define('frampton-data/record/create', ['exports', 'frampton/namespace', 'frampton-utils/guid', 'frampton-utils/warn', 'frampton-object/merge', 'frampton-object/keys', 'frampton-object/map', 'frampton-object/reduce'], function (exports, _namespace, _guid, _warn, _merge, _keys, _map, _reduce) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = create_record;

  var _namespace2 = _interopRequireDefault(_namespace);

  var _guid2 = _interopRequireDefault(_guid);

  var _warn2 = _interopRequireDefault(_warn);

  var _merge2 = _interopRequireDefault(_merge);

  var _keys2 = _interopRequireDefault(_keys);

  var _map2 = _interopRequireDefault(_map);

  var _reduce2 = _interopRequireDefault(_reduce);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  var denylist = ['_id', '_props', 'ctor', 'keys', 'get', 'set', 'update', 'data'];

  function validateData(props, data) {
    if (!_namespace2.default.isProd()) {
      for (var prop in data) {
        if (props.indexOf(prop) === -1) {
          throw new TypeError('Frampton.Data.Record received unknown key: ' + prop);
        }
      }
    }
  }

  function makeRecord(data, id, props) {

    var model = {};
    model.ctor = 'Frampton.Data.Record';

    // private
    model._id = id;
    model._props = props;

    /**
     * @name data
     * @memberof Frampton.Data.Record#
     * @returns {Object}
     */
    model.data = function () {
      return Object.freeze(data);
    };

    /**
     * @name keys
     * @memberof Frampton.Data.Record#
     * @returns {Array}
     */
    model.keys = function () {
      return Object.freeze(props);
    };

    /**
     * @name update
     * @memberof Frampton.Data.Record#
     * @param {Object} update
     * @returns {Object}
     */
    model.update = function (update) {
      // In dev mode verify object properties
      validateData(props, update);
      return create_record((0, _merge2.default)(data, update), id, props);
    };

    /**
     * @name set
     * @memberof Frampton.Data.Record#
     * @param {String} key
     * @param {*} value
     * @returns {Frampont.Data.Record}
     */
    model.set = function (key, value) {
      var update = {};
      update[key] = value;
      return model.update(update);
    };

    /**
     * @name map
     * @memberof Frampton.Data.Record#
     * @method
     * @param {Function} mapping
     * @returns {Frampton.Data.Record}
     */
    model.map = function (mapping) {
      var update = (0, _map2.default)(mapping, data);
      return create_record((0, _merge2.default)(data, update), id, props);
    };

    /**
     * @name reduce
     * @memberof Frampton.Data.Record#
     * @method
     * @param {Function} mapping
     * @param {*} initial
     * @returns {Frampton.Data.Record}
     */
    model.reduce = function (mapping, initial) {
      return (0, _reduce2.default)(mapping, initial, data);
    };

    for (var i = 0; i < props.length; i++) {
      var key = props[i];
      var value = data[key];
      if (denylist.indexOf(key) === -1) {
        model[key] = value;
      } else {
        (0, _warn2.default)('Frampton.Data.Record received a protected key: ' + key);
      }
    }

    return Object.freeze(model);
  }

  function create_record(data) {
    return makeRecord(data, (0, _guid2.default)(), (0, _keys2.default)(data));
  }
});
define('frampton-data/result/failure', ['exports', 'frampton-data/result/result'], function (exports, _result) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = failure;
  function failure(err) {
    return new _result.FailureType(err);
  }
});
define('frampton-data/result/from_throwable', ['exports', 'frampton-utils/curry_n', 'frampton-data/result/success', 'frampton-data/result/failure'], function (exports, _curry_n, _success, _failure) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = from_throwable;

  var _curry_n2 = _interopRequireDefault(_curry_n);

  var _success2 = _interopRequireDefault(_success);

  var _failure2 = _interopRequireDefault(_failure);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function from_throwable(fn) {
    var arity = fn.length;
    return (0, _curry_n2.default)(arity, function () {
      try {
        return (0, _success2.default)(fn.apply(undefined, arguments));
      } catch (e) {
        return (0, _failure2.default)(e.message);
      }
    });
  }
});
define('frampton-data/result/result', ['exports', 'frampton-utils/of_value', 'frampton-utils/is_equal', 'frampton-utils/is_function'], function (exports, _of_value, _is_equal, _is_function) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.FailureType = exports.SuccessType = undefined;

  var _of_value2 = _interopRequireDefault(_of_value);

  var _is_equal2 = _interopRequireDefault(_is_equal);

  var _is_function2 = _interopRequireDefault(_is_function);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * @name Result
   * @class
   * @abstract
   * @memberof Frampton.Data
   */
  function Result() {}

  /**
   * Provides a string representation of this Result
   *
   * @name toString
   * @method
   * @override
   * @memberof Frampton.Data.Result#
   * @returns {String}
   */
  Result.prototype.toString = function () {
    return 'Success(' + this._value + ')';
  };

  /**
   * Maps the successful value of a Result. Failures are returned unaltered.
   *
   * @name map
   * @method
   * @memberof Frampton.Data.Result#
   * @param {Function} mapping Function used to map successful value
   * @returns {Frampton.Data.Result}
   */
  Result.prototype.map = function (mapping) {
    var mappingFn = (0, _is_function2.default)(mapping) ? mapping : (0, _of_value2.default)(mapping);
    return new Success(mappingFn(this._value));
  };

  /**
   * Maps the failed value of a Result. Successes are returned unaltered.
   *
   * @name mapFailure
   * @method
   * @memberof Frampton.Data.Result#
   * @param {Function} mapping Function used to map failed value
   * @returns {Frampton.Data.Result}
   */
  Result.prototype.mapFailure = function (_) {
    return new Success(this._value);
  };

  /**
   * Filters successful values. If the predicate fails the success becomes a failure.
   *
   * @name filter
   * @method
   * @memberof Frampton.Data.Result#
   * @param {Function} predicate Function to test successful values
   * @returns {Frampton.Data.Result}
   */
  Result.prototype.filter = function (predicate) {
    var filterFn = (0, _is_function2.default)(predicate) ? predicate : (0, _is_equal2.default)(predicate);
    if (filterFn(this._value)) {
      return new Success(this._value);
    } else {
      return new Failure(this._value);
    }
  };

  /**
   * Handle the value in a Result. Given two functions it will call the appropriate one
   * with the value of this Result and return the return value of that function.
   *
   * @name fork
   * @method
   * @memberof Frampton.Data.Result#
   * @param {Function} success Function to call for Successes
   * @param {Function} failure Function to call for Failures
   * @returns {*} The result of the given callback function
   */
  Result.prototype.fork = function (success, _) {
    return success(this._value);
  };

  /**
   * Is this Result a Success?
   *
   * @name isSuccess
   * @method
   * @memberof Frampton.Data.Result#
   * @returns {Boolean}
   */
  Result.prototype.isSuccess = function () {
    return false;
  };

  /**
   * Is this Result a Failure?
   *
   * @name isFailure
   * @method
   * @memberof Frampton.Data.Result#
   * @returns {Boolean}
   */
  Result.prototype.isFailure = function () {
    return false;
  };

  function Success(val) {
    this._value = val;
  }

  Success.prototype = new Result();

  Success.prototype.isSuccess = function () {
    return true;
  };

  function Failure(err) {
    this._value = err;
  }

  Failure.prototype = new Result();

  Failure.prototype.toString = function () {
    return 'Failure(' + this._value + ')';
  };

  Failure.prototype.map = function (_) {
    return new Failure(this._value);
  };

  Failure.prototype.mapFailure = function (mapping) {
    var mappingFn = (0, _is_function2.default)(mapping) ? mapping : (0, _of_value2.default)(mapping);
    return new Failure(mappingFn(this._value));
  };

  Failure.prototype.filter = function (_) {
    return new Failure(this._value);
  };

  Failure.prototype.fork = function (_, failure) {
    return failure(this._value);
  };

  Failure.prototype.isFailure = function () {
    return true;
  };

  var SuccessType = exports.SuccessType = Success;

  var FailureType = exports.FailureType = Failure;
});
define('frampton-data/result/success', ['exports', 'frampton-data/result/result'], function (exports, _result) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = success;
  function success(val) {
    return new _result.SuccessType(val);
  }
});
define('frampton-data/task/batch', ['exports', 'frampton-data/task/create'], function (exports, _create) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = batch;

  var _create2 = _interopRequireDefault(_create);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function batch() {
    for (var _len = arguments.length, list = Array(_len), _key = 0; _key < _len; _key++) {
      list[_key] = arguments[_key];
    }

    return (0, _create2.default)(function (sinks) {
      var len = list.length;
      for (var i = 0; i < len; i++) {
        list[i].run(sinks);
      }
    });
  }
});
define('frampton-data/task/create', ['exports', 'frampton-utils/immediate', 'frampton-utils/is_function', 'frampton-utils/noop', 'frampton-utils/of_value', 'frampton-utils/is_equal', 'frampton-data/task/valid_sinks'], function (exports, _immediate, _is_function, _noop, _of_value, _is_equal, _valid_sinks) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.Task = undefined;
  exports.default = create_task;

  var _immediate2 = _interopRequireDefault(_immediate);

  var _is_function2 = _interopRequireDefault(_is_function);

  var _noop2 = _interopRequireDefault(_noop);

  var _of_value2 = _interopRequireDefault(_of_value);

  var _is_equal2 = _interopRequireDefault(_is_equal);

  var _valid_sinks2 = _interopRequireDefault(_valid_sinks);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function _classCallCheck(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError("Cannot call a class as a function");
    }
  }

  var _createClass = function () {
    function defineProperties(target, props) {
      for (var i = 0; i < props.length; i++) {
        var descriptor = props[i];
        descriptor.enumerable = descriptor.enumerable || false;
        descriptor.configurable = true;
        if ("value" in descriptor) descriptor.writable = true;
        Object.defineProperty(target, descriptor.key, descriptor);
      }
    }

    return function (Constructor, protoProps, staticProps) {
      if (protoProps) defineProperties(Constructor.prototype, protoProps);
      if (staticProps) defineProperties(Constructor, staticProps);
      return Constructor;
    };
  }();

  var Task = exports.Task = function () {
    function Task(computation) {
      _classCallCheck(this, Task);

      this.fn = computation;
    }

    /**
     * Takes a hash of functions to call based on the resolution of the Task and runs the computation
     * contained within this Task.
     *
     * The sinks object should be of the form:
     * {
     *   reject : (err) => {},
     *   resolve : (val) => {},
     *   progress : (prog) => {}
     * }
     *
     * Each function is used by the contained computation to update us on the state of the running
     * computation.
     *
     * @name run
     * @method
     * @memberof Frampton.Data.Task#
     * @param {Object} sinks
     * @param {Function} sinks.reject - The function to call on failure.
     * @param {Function} sinks.resolve - The function to call on success.
     * @param {Function} sinks.progress - The function to call on progress.
     */


    _createClass(Task, [{
      key: 'run',
      value: function run(sinks) {
        var _this = this;

        (0, _immediate2.default)(function () {
          try {
            _this.fn((0, _valid_sinks2.default)(sinks));
          } catch (e) {
            sinks.reject(e);
          }
        });
      }

      /**
       * of(return) :: a -> Success a
       *
       * Returns a Task that always resolves with the given value.
       *
       * @name of
       * @method
       * @memberof Frampton.Data.Task#
       * @param {*} val - Value to resolve task with
       * @returns {Frampton.Data.Task}
       */

    }, {
      key: 'of',
      value: function of(val) {
        return new Task(function (sinks) {
          sinks.resolve(val);
        });
      }

      /**
       * join :: Task x (Task x a) -> Task x a
       *
       * Takes a nested Task and removes one level of nesting.
       *
       * @name join
       * @method
       * @memberof Frampton.Data.Task#
       * @returns {Frampton.Data.Task}
       */

    }, {
      key: 'join',
      value: function join() {
        var source = this;
        return new Task(function (sinks) {
          source.run({
            reject: sinks.reject,
            resolve: function resolve(val) {
              val.run(sinks);
            },
            progress: _noop2.default
          });
        });
      }

      /**
       * concat(>>) :: Task x a -> Task x b -> Task x b
       *
       * Runs one task after another, discarding the return value of the first.
       *
       * @name concat
       * @method
       * @memberof Frampton.Data.Task#
       * @param {Frampton.Data.Task} task - Task to run after this task
       * @returns {Frampton.Data.Task}
       */

    }, {
      key: 'concat',
      value: function concat(task) {
        var source = this;
        return new Task(function (sinks) {
          source.run({
            reject: sinks.reject,
            resolve: function resolve(val) {
              task.run(sinks);
            },
            progress: _noop2.default
          });
        });
      }

      /**
       * chain(>>=) :: Task x a -> (a -> Task x b) -> Task x b
       *
       * Maps the return value of one Task to another Task, chaining two Tasks together.
       *
       * @name chain
       * @method
       * @memberof Frampton.Data.Task#
       * @param {Function} mapping - Function to map the return value of this Task to another Task.
       * @returns {Frampton.Data.Task}
       */

    }, {
      key: 'chain',
      value: function chain(mapping) {
        return this.map(mapping).join();
      }

      /**
       * ap(<*>) :: Task x (a -> b) -> Task x a -> Task x b
       *
       * @name ap
       * @method
       * @memberof Frampton.Data.Task#
       * @param {Frampton.Data.Task} task
       * @returns {Frampton.Data.Task}
       */

    }, {
      key: 'ap',
      value: function ap(task) {
        return this.chain(function (fn) {
          return task.map(fn);
        });
      }

      /**
       * recover :: Task x a -> (x -> b) -> Task x b
       *
       * Used to map a reject to a resolve.
       *
       * @name recover
       * @method
       * @memberof Frampton.Data.Task#
       * @param {Function} mapping
       * @returns {Frampton.Data.Task}
       */

    }, {
      key: 'recover',
      value: function recover(mapping) {
        var source = this;
        return new Task(function (sinks) {
          source.run({
            reject: function reject(err) {
              sinks.resolve(mapping(err));
            },
            resolve: sinks.resolve,
            progress: sinks.progress
          });
        });
      }

      /**
       * default :: Task x a -> b -> Task x b
       *
       * Returns the given value as a resolve in case of a reject.
       *
       * @name default
       * @method
       * @memberof Frampton.Data.Task#
       * @param {*} val - A value to map errors to
       * @returns {Frampton.Data.Task}
       */

    }, {
      key: 'default',
      value: function _default(val) {
        return this.recover(function () {
          return val;
        });
      }

      /**
       * progress :: Task x a -> (a -> b) -> Task x b
       *
       * Maps progress branch to resolution branch
       *
       * @name progress
       * @method
       * @memberof Frampton.Data.Task#
       * @param {Function} mapping
       * @returns {Frampton.Data.Task}
       */

    }, {
      key: 'progress',
      value: function progress(mapping) {
        var source = this;
        var mappingFn = (0, _is_function2.default)(mapping) ? mapping : (0, _of_value2.default)(mapping);
        return new Task(function (sinks) {
          source.run({
            reject: sinks.reject,
            resolve: sinks.resolve,
            progress: function progress(val) {
              sinks.resolve(mappingFn(val));
            }
          });
        });
      }

      /**
       * map :: Task x a -> (a -> b) -> Task x b
       *
       * @name map
       * @method
       * @memberof Frampton.Data.Task#
       * @param {Function} mapping
       * @returns {Frampton.Data.Task}
       */

    }, {
      key: 'map',
      value: function map(mapping) {
        var source = this;
        var mappingFn = (0, _is_function2.default)(mapping) ? mapping : (0, _of_value2.default)(mapping);
        return new Task(function (sinks) {
          source.run({
            reject: sinks.reject,
            resolve: function resolve(val) {
              sinks.resolve(mappingFn(val));
            },
            progress: sinks.progress
          });
        });
      }

      /**
       * success :: Task x a -> (a -> b) -> Task x b
       *
       * A symantic alias for Task.prototype.map
       *
       * @name success
       * @method
       * @memberof Frampton.Data.Task#
       * @param {Function} mapping - The function to map the resolve value.
       * @returns {Frampton.Data.Task}
       */

    }, {
      key: 'success',
      value: function success(mapping) {
        return this.map(mapping);
      }

      /**
       * filter :: Task x a -> (a -> b) -> Task x b
       *
       * @name filter
       * @method
       * @memberof Frampton.Data.Task#
       * @param {Function} predicate - The function to filter the resolve value.
       * @returns {Frampton.Data.Task}
       */

    }, {
      key: 'filter',
      value: function filter(predicate) {
        var source = this;
        var filterFn = (0, _is_function2.default)(predicate) ? predicate : (0, _is_equal2.default)(predicate);
        return new Task(function (sinks) {
          source.run({
            reject: sinks.reject,
            resolve: function resolve(val) {
              if (filterFn(val)) {
                sinks.resolve(val);
              } else {
                sinks.reject(val);
              }
            },
            progress: sinks.progress
          });
        });
      }

      /**
       * validate :: Task x a -> (a -> b) -> Task x b
       *
       * A symantic alias for filter. Used to validate the return value of a Task. It the given
       * predicate returns false a resolve is turned into a reject.
       *
       * @name validate
       * @method
       * @memberof Frampton.Data.Task#
       * @param {Function} predicate - The function to validate the resolve value.
       * @returns {Frampton.Data.Task}
       */

    }, {
      key: 'validate',
      value: function validate(predicate) {
        return this.filter(predicate);
      }
    }]);

    return Task;
  }();

  /**
   * Method for creating new Tasks. This method should be used instead of calling the Task
   * constructor directly.
   *
   * @name create
   * @method
   * @memberof Frampton.Data.Task
   * @param {Function} computation - The function the Task should execute
   * @returns {Frampton.Data.Task}
   */
  function create_task(computation) {
    return new Task(computation);
  }
});
define('frampton-data/task/delay', ['exports', 'frampton-data/task/create', 'frampton-utils/curry_n'], function (exports, _create, _curry_n) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _create2 = _interopRequireDefault(_create);

  var _curry_n2 = _interopRequireDefault(_curry_n);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry_n2.default)(2, function delay(time, val) {
    return (0, _create2.default)(function (sinks) {
      setTimeout(function () {
        sinks.resolve(val);
      }, time);
    });
  });
});
define('frampton-data/task/execute', ['exports', 'frampton-utils/log', 'frampton-utils/warn'], function (exports, _log, _warn) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = execute;

  var _log2 = _interopRequireDefault(_log);

  var _warn2 = _interopRequireDefault(_warn);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * execute :: Signal Task x a -> Signal a -> ()
   *
   * Takes a Signal of Tasks to execute and a function to call with the resolve values
   * of those Tasks. Progress and reject values are ignored (logged to the console in dev mode).
   * It is suggested to use Tasks that have their reject and progress values mapped to reslove
   * values using the recover and progress methods on the Task prototype.
   *
   * @name execute
   * @memberof Frampton.Task
   * @static
   * @param {Frampton.Signals.Signal} tasks - Signal of Tasks to execute
   * @param {Function} value - A function to pass the resolve values to
   */
  function execute(tasks, value) {
    tasks.value(function (task) {
      task.run({
        reject: function reject(err) {
          (0, _warn2.default)('Error running task: ', err);
        },
        resolve: function resolve(val) {
          value(val);
        },
        progress: function progress(val) {
          (0, _log2.default)('Task progress: ', val);
        }
      });
    });
  }
});
define('frampton-data/task/fail', ['exports', 'frampton-data/task/create'], function (exports, _create) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = fail;

  var _create2 = _interopRequireDefault(_create);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * fail :: x -> Task x a
   *
   * Creates a Task that always fails with the given value.
   *
   * @name fail
   * @method
   * @memberof Frampton.Data.Task
   * @param {*} err - Value used as the return value of the reject branch.
   * @returns {Frampton.Data.Task}
   */
  function fail(err) {
    return (0, _create2.default)(function (sinks) {
      return sinks.reject(err);
    });
  }
});
define('frampton-data/task/never', ['exports', 'frampton-data/task/create'], function (exports, _create) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = never;

  var _create2 = _interopRequireDefault(_create);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * never :: Task x a
   *
   * Creates a Task that never resolves.
   *
   * @name never
   * @method
   * @memberof Frampton.Data.Task
   * @returns {Frampton.Data.Task}
   */
  function never() {
    return (0, _create2.default)(function () {});
  }
});
define("frampton-data/task/sequence", ["exports"], function (exports) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = sequence;
  /**
   * sequence :: [Task x a] -> Task x a
   *
   * Creates a Task that runs the given Tasks in the order they are passed in. The new
   * Task will resolve when all of its parent Tasks have resolved. The resolve value of
   * the new Task is the resolve value of the last of its parents Tasks. The resolve
   * values for all other Tasks are discarded.
   *
   * @name sequence
   * @method
   * @memberof Frampton.Data.Task
   * @param {Frampton.Data.Task[]} tasks - The Tasks to wait for
   * @returns {Frampton.Data.Task}
   */
  function sequence() {
    for (var _len = arguments.length, tasks = Array(_len), _key = 0; _key < _len; _key++) {
      tasks[_key] = arguments[_key];
    }

    return tasks.reduce(function (acc, next) {
      return acc.concat(next);
    });
  }
});
define('frampton-data/task/succeed', ['exports', 'frampton-data/task/create'], function (exports, _create) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = succeed;

  var _create2 = _interopRequireDefault(_create);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * succeed :: a -> Task x a
   *
   * Creates a Task that always succeeds with the given value.
   *
   * @name succeed
   * @method
   * @memberof Frampton.Data.Task
   * @param {*} val - Value used as the return value of the resolve branch.
   * @returns {Frampton.Data.Task}
   */
  function succeed(val) {
    return (0, _create2.default)(function (sinks) {
      return sinks.resolve(val);
    });
  }
});
define('frampton-data/task/sync', ['exports', 'frampton-data/task/create', 'frampton-data/task/valid_sinks'], function (exports, _create, _valid_sinks) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.SyncTask = undefined;
  exports.default = create_sync;

  var _valid_sinks2 = _interopRequireDefault(_valid_sinks);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function _classCallCheck(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError("Cannot call a class as a function");
    }
  }

  var _createClass = function () {
    function defineProperties(target, props) {
      for (var i = 0; i < props.length; i++) {
        var descriptor = props[i];
        descriptor.enumerable = descriptor.enumerable || false;
        descriptor.configurable = true;
        if ("value" in descriptor) descriptor.writable = true;
        Object.defineProperty(target, descriptor.key, descriptor);
      }
    }

    return function (Constructor, protoProps, staticProps) {
      if (protoProps) defineProperties(Constructor.prototype, protoProps);
      if (staticProps) defineProperties(Constructor, staticProps);
      return Constructor;
    };
  }();

  function _possibleConstructorReturn(self, call) {
    if (!self) {
      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
    }

    return call && (typeof call === "object" || typeof call === "function") ? call : self;
  }

  function _inherits(subClass, superClass) {
    if (typeof superClass !== "function" && superClass !== null) {
      throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
    }

    subClass.prototype = Object.create(superClass && superClass.prototype, {
      constructor: {
        value: subClass,
        enumerable: false,
        writable: true,
        configurable: true
      }
    });
    if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
  }

  var SyncTask = exports.SyncTask = function (_Task) {
    _inherits(SyncTask, _Task);

    function SyncTask(computation) {
      _classCallCheck(this, SyncTask);

      return _possibleConstructorReturn(this, (SyncTask.__proto__ || Object.getPrototypeOf(SyncTask)).call(this, computation));
    }

    /**
     * Takes a hash of functions to call based on the resolution of the Task and runs the computation
     * contained within this Task.
     *
     * The sinks object should be of the form:
     * {
     *   reject : (err) => {},
     *   resolve : (val) => {},
     *   progress : (prog) => {}
     * }
     *
     * Each function is used by the contained computation to update us on the state of the running
     * computation.
     *
     * @name run
     * @method
     * @memberof Frampton.Data.SyncTask#
     * @param {Object} sinks
     * @param {Function} sinks.reject - The function to call on failure.
     * @param {Function} sinks.resolve - The function to call on success.
     * @param {Function} sinks.progress - The function to call on progress.
     */


    _createClass(SyncTask, [{
      key: 'run',
      value: function run(sinks) {
        try {
          this.fn((0, _valid_sinks2.default)(sinks));
        } catch (e) {
          sinks.reject(e);
        }
      }
    }]);

    return SyncTask;
  }(_create.Task);

  function create_sync(computation) {
    return new SyncTask(computation);
  }
});
define('frampton-data/task/valid_sinks', ['exports', 'frampton-utils/noop'], function (exports, _noop) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = valid_sinks;

  var _noop2 = _interopRequireDefault(_noop);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * @name validSinks
   * @param {Object} sinks - Sinks to validate
   * @returns {Object} The validated sinks
   */
  function valid_sinks(sinks) {
    return {
      reject: sinks.reject || _noop2.default,
      resolve: sinks.resolve || _noop2.default,
      progress: sinks.progress || _noop2.default
    };
  }
});
define('frampton-data/task/when', ['exports', 'frampton-utils/log', 'frampton-utils/warn', 'frampton-data/task/create'], function (exports, _log, _warn, _create) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = when;

  var _log2 = _interopRequireDefault(_log);

  var _warn2 = _interopRequireDefault(_warn);

  var _create2 = _interopRequireDefault(_create);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function logError(err) {
    (0, _warn2.default)('error in task: ', err);
  }

  function logProgress(val) {
    (0, _log2.default)('progress in task: ', val);
  }

  /**
   * when :: [Task x a] -> Task x [a]
   *
   * Creates a Task that waits for each of the given Tasks to resolve before it resolves.
   * When it does resolve, it resolves with an Array containing the resolved values of each
   * of its parent Tasks. The Array contains the resolve values in the same order as the
   * order that the parent Tasks were passed in.
   *
   * @name when
   * @method
   * @memberof Frampton.Data.Task
   * @param {Frampton.Data.Task[]} tasks - The Tasks to wait for
   * @returns {Frampton.Data.Task}
   */
  function when() {
    for (var _len = arguments.length, tasks = Array(_len), _key = 0; _key < _len; _key++) {
      tasks[_key] = arguments[_key];
    }

    return (0, _create2.default)(function (sinks) {

      var valueArray = new Array(tasks.length);
      var len = tasks.length;
      var idx = 0;
      var count = 0;

      tasks.forEach(function (task) {
        var index = idx++;
        task.run({
          reject: function reject(err) {
            logError(err);
            count = count + 1;
            valueArray[index] = null;
            if (count === len) {
              sinks.resolve(valueArray);
            }
          },
          resolve: function resolve(val) {
            count = count + 1;
            valueArray[index] = val;
            if (count === len) {
              sinks.resolve(valueArray);
            }
          },

          progress: logProgress
        });
      });
    });
  }
});
define('frampton-data/union/create', ['exports', 'frampton-utils/curry_n', 'frampton-object/keys', 'frampton-data/union/utils/create_type', 'frampton-data/union/utils/case_of', 'frampton-data/union/utils/validate_types'], function (exports, _curry_n, _keys, _create_type, _case_of, _validate_types) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = create_union;

  var _curry_n2 = _interopRequireDefault(_curry_n);

  var _keys2 = _interopRequireDefault(_keys);

  var _create_type2 = _interopRequireDefault(_create_type);

  var _case_of2 = _interopRequireDefault(_case_of);

  var _validate_types2 = _interopRequireDefault(_validate_types);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**

    const Action = Union({
      Foo : ['name', 'id'],
      Bar : ['id', 'description']
    });

    const foo = Action.Foo('test', 89);

   */

  /**
   * Creates constructors for each type described in config
   *
   * @name create
   * @memberof Frampton.Data.Union
   * @param {Object} values
   * @returns {Frampton.Data.Union}
   */
  function create_union(values) {
    var parent = {};
    var children = (0, _keys2.default)(values);
    (0, _validate_types2.default)(children);

    parent.ctor = 'Frampton.Data.Union';
    parent.children = children;
    parent.match = (0, _curry_n2.default)(3, _case_of2.default, parent);

    for (var name in values) {
      parent[name] = (0, _create_type2.default)(name, values[name]);
    }

    return Object.freeze(parent);
  }
});
define('frampton-data/union/utils/case_of', ['exports', 'frampton-utils/is_nothing', 'frampton-data/union/utils/validate_options', 'frampton-data/union/utils/get_match'], function (exports, _is_nothing, _validate_options, _get_match) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = case_of;

  var _is_nothing2 = _interopRequireDefault(_is_nothing);

  var _validate_options2 = _interopRequireDefault(_validate_options);

  var _get_match2 = _interopRequireDefault(_get_match);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function _toConsumableArray(arr) {
    if (Array.isArray(arr)) {
      for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {
        arr2[i] = arr[i];
      }

      return arr2;
    } else {
      return Array.from(arr);
    }
  }

  /**
   * @name caseOf
   * @memberof Frampton.Data.Union
   * @param {Object} parent
   * @param {Object} cases
   * @param {Frampton.Data.Union} child
   * @returns {*}
   */
  function case_of(parent, cases, child) {

    // Validate we have exhausitve pattern match
    (0, _validate_options2.default)(parent, cases);

    var match = (0, _get_match2.default)(child, cases);

    if ((0, _is_nothing2.default)(match)) {
      throw new Error('No match for value with name: ' + child.ctor);
    } else {
      // Destructure arguments for passing to callback
      return match.apply(undefined, _toConsumableArray(child._values));
    }
  }
});
define('frampton-data/union/utils/create_type', ['exports', 'frampton-utils/warn', 'frampton-utils/curry_n', 'frampton-utils/is_string', 'frampton-data/union/utils/to_string', 'frampton-data/union/utils/validate_names'], function (exports, _warn, _curry_n, _is_string, _to_string, _validate_names) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = create_type;

  var _warn2 = _interopRequireDefault(_warn);

  var _curry_n2 = _interopRequireDefault(_curry_n);

  var _is_string2 = _interopRequireDefault(_is_string);

  var _to_string2 = _interopRequireDefault(_to_string);

  var _validate_names2 = _interopRequireDefault(_validate_names);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * @name createType
   * @memberof Frampton.Data.Union
   * @param {String} name
   * @param {Object} fields
   * @returns {Function}
   */
  function create_type(name, fields) {

    (0, _validate_names2.default)(fields);
    var len = fields.length;

    return (0, _curry_n2.default)(len, function () {
      for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      var argLen = args.length;

      if (len !== argLen) {
        (0, _warn2.default)('Frampton.Data.Union.' + name + ' expected ' + len + ' arguments but received ' + argLen + '.');
      }

      var child = {};
      child.ctor = name;
      child.toString = _to_string2.default;
      child._values = args;
      child._keys = fields;

      for (var i = 0; i < argLen; i++) {
        var field = fields[i];
        if ((0, _is_string2.default)(field)) {
          child[field] = args[i];
        } else {
          (0, _warn2.default)('Frampton.Data.Union.' + name + ' received argument without associated field.');
        }
      }

      return Object.freeze(child);
    });
  }
});
define('frampton-data/union/utils/get_match', ['exports', 'frampton-utils/is_something', 'frampton-data/union/utils/wildcard'], function (exports, _is_something, _wildcard) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = get_match;

  var _is_something2 = _interopRequireDefault(_is_something);

  var _wildcard2 = _interopRequireDefault(_wildcard);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * @name getMatch
   * @memberof Frampton.Data.Union.Utils
   * @param {}
   * @param {}
   */
  function get_match(child, cases) {
    var match = cases[child.ctor];
    if ((0, _is_something2.default)(match)) {
      return match;
    } else {
      return cases[_wildcard2.default];
    }
  }
});
define('frampton-data/union/utils/to_string', ['exports'], function (exports) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = to_string;
  function to_string() {
    var value = this._values.join(',');
    return 'Union.' + this.ctor + '(' + value + ')';
  }
});
define('frampton-data/union/utils/validate_names', ['exports', 'frampton-utils/is_array', 'frampton-data/union/utils/wildcard'], function (exports, _is_array, _wildcard) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = validate_names;

  var _is_array2 = _interopRequireDefault(_is_array);

  var _wildcard2 = _interopRequireDefault(_wildcard);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  var denylist = ['ctor', 'get', 'set', 'update'];

  function validate_names(names) {

    if (!(0, _is_array2.default)(names)) {
      throw new Error('Frampton.Data.Union must receive an array of fields for each type');
    }

    var len = names.length;
    for (var i = 0; i < len; i++) {
      var name = names[i];
      if (denylist.indexOf(name) > -1 || name === _wildcard2.default) {
        throw new Error('Frampton.Data.Union recieved reserved field name ' + name);
      }
    }
  }
});
define('frampton-data/union/utils/validate_options', ['exports', 'frampton-utils/warn', 'frampton-data/union/utils/wildcard'], function (exports, _warn, _wildcard) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = validate_options;

  var _warn2 = _interopRequireDefault(_warn);

  var _wildcard2 = _interopRequireDefault(_wildcard);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function hasMatch(cases, child) {
    return cases.hasOwnProperty(_wildcard2.default) || cases.hasOwnProperty(child);
  }

  function validate_options(parent, cases) {
    var children = parent.children;
    var len = children.length;
    for (var i = 0; i < len; i++) {
      var child = children[i];
      if (!hasMatch(cases, child)) {
        (0, _warn2.default)('Non-exhaustive pattern match for case: ' + child);
      }
    }
  }
});
define('frampton-data/union/utils/validate_types', ['exports'], function (exports) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = validate_types;
  var denylist = ['ctor', 'children', 'caseOf', 'match'];

  function validate_types(types) {
    var len = types.length;
    for (var i = 0; i < len; i++) {
      var name = types[i];
      if (denylist.indexOf(name) !== -1) {
        throw new Error('Frampton.Data.Union received a protected key: ' + name);
      }
    }
  }
});
define('frampton-data/union/utils/wildcard', ['exports'], function (exports) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = 'Otherwise';
});
define('frampton-events', ['frampton/namespace', 'frampton-events/on_event', 'frampton-events/on_selector', 'frampton-events/contains', 'frampton-events/event_target', 'frampton-events/event_value', 'frampton-events/get_position', 'frampton-events/get_position_relative', 'frampton-events/has_selector', 'frampton-events/contains_selector', 'frampton-events/selector_contains', 'frampton-events/closest_to_event', 'frampton-events/prevent_default'], function (_namespace, _on_event, _on_selector, _contains, _event_target, _event_value, _get_position, _get_position_relative, _has_selector, _contains_selector, _selector_contains, _closest_to_event, _prevent_default) {
  'use strict';

  var _namespace2 = _interopRequireDefault(_namespace);

  var _on_event2 = _interopRequireDefault(_on_event);

  var _on_selector2 = _interopRequireDefault(_on_selector);

  var _contains2 = _interopRequireDefault(_contains);

  var _event_target2 = _interopRequireDefault(_event_target);

  var _event_value2 = _interopRequireDefault(_event_value);

  var _get_position2 = _interopRequireDefault(_get_position);

  var _get_position_relative2 = _interopRequireDefault(_get_position_relative);

  var _has_selector2 = _interopRequireDefault(_has_selector);

  var _contains_selector2 = _interopRequireDefault(_contains_selector);

  var _selector_contains2 = _interopRequireDefault(_selector_contains);

  var _closest_to_event2 = _interopRequireDefault(_closest_to_event);

  var _prevent_default2 = _interopRequireDefault(_prevent_default);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * @name Events
   * @namespace
   * @memberof Frampton
   */
  _namespace2.default.Events = {};
  _namespace2.default.Events.onEvent = _on_event2.default;
  _namespace2.default.Events.onSelector = _on_selector2.default;
  _namespace2.default.Events.contains = _contains2.default;
  _namespace2.default.Events.eventTarget = _event_target2.default;
  _namespace2.default.Events.eventValue = _event_value2.default;
  _namespace2.default.Events.hasSelector = _has_selector2.default;
  _namespace2.default.Events.containsSelector = _contains_selector2.default;
  _namespace2.default.Events.selectorContains = _selector_contains2.default;
  _namespace2.default.Events.getPosition = _get_position2.default;
  _namespace2.default.Events.getPositionRelative = _get_position_relative2.default;
  _namespace2.default.Events.closestToEvent = _closest_to_event2.default;
  _namespace2.default.Events.preventDefault = _prevent_default2.default;
});
define('frampton-events/closest_to_event', ['exports', 'frampton-utils/curry', 'frampton-utils/compose', 'frampton-style/closest', 'frampton-events/event_target'], function (exports, _curry, _compose, _closest, _event_target) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  var _compose2 = _interopRequireDefault(_compose);

  var _closest2 = _interopRequireDefault(_closest);

  var _event_target2 = _interopRequireDefault(_event_target);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function closest_to_event(selector, evt) {
    return (0, _compose2.default)((0, _closest2.default)(selector), _event_target2.default)(evt);
  });
});
define('frampton-events/contains', ['exports', 'frampton-utils/curry', 'frampton-utils/compose', 'frampton-html/contains', 'frampton-events/event_target'], function (exports, _curry, _compose, _contains, _event_target) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  var _compose2 = _interopRequireDefault(_compose);

  var _contains2 = _interopRequireDefault(_contains);

  var _event_target2 = _interopRequireDefault(_event_target);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function curried_contains(element, evt) {
    return (0, _compose2.default)((0, _contains2.default)(element), _event_target2.default)(evt);
  });
});
define('frampton-events/contains_selector', ['exports', 'frampton-utils/curry', 'frampton-utils/compose', 'frampton-style/contains', 'frampton-events/event_target'], function (exports, _curry, _compose, _contains, _event_target) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  var _compose2 = _interopRequireDefault(_compose);

  var _contains2 = _interopRequireDefault(_contains);

  var _event_target2 = _interopRequireDefault(_event_target);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function contains_selector(selector, evt) {
    return (0, _compose2.default)((0, _contains2.default)(selector), _event_target2.default)(evt);
  });
});
define('frampton-events/document_cache', ['exports', 'frampton-events/simple_cache'], function (exports, _simple_cache) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _simple_cache2 = _interopRequireDefault(_simple_cache);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _simple_cache2.default)();
});
define('frampton-events/event_dispatcher', ['exports', 'frampton-utils/assert', 'frampton-utils/is_function', 'frampton-utils/is_defined', 'frampton-utils/lazy', 'frampton-events/event_map'], function (exports, _assert, _is_function, _is_defined, _lazy, _event_map) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.removeListener = exports.addListener = undefined;

  var _assert2 = _interopRequireDefault(_assert);

  var _is_function2 = _interopRequireDefault(_is_function);

  var _is_defined2 = _interopRequireDefault(_is_defined);

  var _lazy2 = _interopRequireDefault(_lazy);

  var _event_map2 = _interopRequireDefault(_event_map);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  // get dom event -> filter -> return stream
  function addDomEvent(name, node, callback) {
    node.addEventListener(name, callback, !_event_map2.default[name].bubbles);
  }

  function addCustomEvent(name, target, callback) {
    var listen = (0, _is_function2.default)(target.addEventListener) ? target.addEventListener : (0, _is_function2.default)(target.on) ? target.on : null;

    (0, _assert2.default)('Frampton.Events.addListener received an unknown type as target', (0, _is_function2.default)(listen));

    listen.call(target, name, callback);
  }

  function removeDomEvent(name, node, callback) {
    node.removeEventListener(name, callback, !_event_map2.default[name].bubbles);
  }

  function removeCustomEvent(name, target, callback) {
    var remove = (0, _is_function2.default)(target.removeEventListener) ? target.removeEventListener : (0, _is_function2.default)(target.off) ? target.off : null;

    (0, _assert2.default)('Frampton.Events.removeListener received an unknown type as target', (0, _is_function2.default)(remove));

    remove.call(target, name, callback);
  }

  var addListener = exports.addListener = function addListener(eventName, target, callback) {
    if ((0, _is_defined2.default)(_event_map2.default[eventName]) && (0, _is_function2.default)(target.addEventListener)) {
      addDomEvent(eventName, target, callback);
    } else {
      addCustomEvent(eventName, target, callback);
    }

    return (0, _lazy2.default)(removeListener, [eventName, target, callback]);
  };

  var removeListener = exports.removeListener = function removeListener(eventName, target, callback) {
    if ((0, _is_defined2.default)(_event_map2.default[eventName]) && (0, _is_function2.default)(target.removeEventListener)) {
      removeDomEvent(eventName, target, callback);
    } else {
      removeCustomEvent(eventName, target, callback);
    }
  };
});
define("frampton-events/event_map", ["exports"], function (exports) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = {

    abort: {
      bubbles: true,
      signal: null
    },

    blur: {
      bubbles: false,
      signal: null
    },

    change: {
      bubbles: true,
      signal: null
    },

    click: {
      bubbles: true,
      signal: null
    },

    error: {
      bubbles: true,
      signal: null
    },

    focus: {
      bubbles: false,
      signal: null
    },

    focusin: {
      bubbles: true,
      signal: null
    },

    focusout: {
      bubbles: true,
      signal: null
    },

    input: {
      bubbles: true,
      signal: null
    },

    keyup: {
      bubbles: true,
      signal: null
    },

    keydown: {
      bubbles: true,
      signal: null
    },

    keypress: {
      bubbles: true,
      signal: null
    },

    load: {
      bubbles: true,
      signal: null
    },

    mousedown: {
      bubbles: true,
      signal: null
    },

    mouseup: {
      bubbles: true,
      signal: null
    },

    mousemove: {
      bubbles: true,
      signal: null
    },

    mouseenter: {
      bubbles: false,
      signal: null
    },

    mouseleave: {
      bubbles: false,
      signal: null
    },

    mouseover: {
      bubbles: true,
      signal: null
    },

    mouseout: {
      bubbles: true,
      signal: null
    },

    touchstart: {
      bubbles: true,
      signal: null
    },

    touchend: {
      bubbles: true,
      signal: null
    },

    touchcancel: {
      bubbles: true,
      signal: null
    },

    touchleave: {
      bubbles: true,
      signal: null
    },

    touchmove: {
      bubbles: true,
      signal: null
    },

    submit: {
      bubbles: true,
      signal: null
    },

    animationstart: {
      bubbles: true,
      signal: null
    },

    animationend: {
      bubbles: true,
      signal: null
    },

    animationiteration: {
      bubbles: true,
      signal: null
    },

    transitionend: {
      bubbles: true,
      signal: null
    },

    drag: {
      bubbles: true,
      signal: null
    },

    drop: {
      bubbles: true,
      signal: null
    },

    dragstart: {
      bubbles: true,
      signal: null
    },

    dragend: {
      bubbles: true,
      signal: null
    },

    dragenter: {
      bubbles: true,
      signal: null
    },

    dragleave: {
      bubbles: true,
      signal: null
    },

    dragover: {
      bubbles: true,
      signal: null
    },

    scroll: {
      bubbles: true,
      signal: null
    },

    wheel: {
      bubbles: true,
      signal: null
    }
  };
});
define('frampton-events/event_supported', ['exports', 'frampton-utils/is_function', 'frampton-utils/memoize'], function (exports, _is_function, _memoize) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _is_function2 = _interopRequireDefault(_is_function);

  var _memoize2 = _interopRequireDefault(_memoize);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  var TAGNAMES = {
    select: 'input',
    change: 'input',
    submit: 'form',
    reset: 'form',
    error: 'img',
    load: 'img',
    abort: 'img'
  };

  /**
   * Tests whether a given event is supported by the current browser.
   *
   * @name eventSupported
   * @static
   * @private
   * @memberof Frampton.Events
   * @param {String} eventName The name of the event to test
   * @returns {Boolean} Is the event supported
   */
  exports.default = (0, _memoize2.default)(function event_supported(eventName) {
    var el = document.createElement(TAGNAMES[eventName] || 'div');
    eventName = 'on' + eventName;
    var isSupported = eventName in el;
    if (!isSupported) {
      el.setAttribute(eventName, 'return;');
      isSupported = (0, _is_function2.default)(el[eventName]);
    }
    el = null;
    return !!isSupported;
  });
});
define("frampton-events/event_target", ["exports"], function (exports) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = event_target;
  /**
   * eventTarget :: DomEvent -> Object
   *
   * @name eventTarget
   * @memberof Frampton.Events
   * @static
   * @param {Object} evt
   * @returns {Object} The target value of the event object, usually a DomNode
   */
  function event_target(evt) {
    return evt.target;
  }
});
define('frampton-events/event_value', ['exports', 'frampton-utils/compose', 'frampton-html/element_value', 'frampton-events/event_target'], function (exports, _compose, _element_value, _event_target) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _compose2 = _interopRequireDefault(_compose);

  var _element_value2 = _interopRequireDefault(_element_value);

  var _event_target2 = _interopRequireDefault(_event_target);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _compose2.default)(_element_value2.default, _event_target2.default);
});
define('frampton-events/get_document_signal', ['exports', 'frampton-events/document_cache', 'frampton-events/get_event_signal'], function (exports, _document_cache, _get_event_signal) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = get_document_signal;

  var _document_cache2 = _interopRequireDefault(_document_cache);

  var _get_event_signal2 = _interopRequireDefault(_get_event_signal);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * @name getDocumentSignal
   * @memberof Frampton.Events
   * @static
   * @private
   * @param {String} name Event name to look up
   * @returns {Frampton.Signal.Signal}
   */
  function get_document_signal(name) {
    return (0, _document_cache2.default)(name, function () {
      return (0, _get_event_signal2.default)(name, document);
    });
  }
});
define('frampton-events/get_event_signal', ['exports', 'frampton-utils/is_empty', 'frampton-signal/create', 'frampton-events/event_dispatcher'], function (exports, _is_empty, _create, _event_dispatcher) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = get_event_signal;

  var _is_empty2 = _interopRequireDefault(_is_empty);

  var _create2 = _interopRequireDefault(_create);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function get_event_signal(name, target) {
    var parts = name.split(' ').filter(function (val) {
      return !(0, _is_empty2.default)(val);
    });
    var len = parts.length;
    var sigs = [];
    for (var i = 0; i < len; i++) {
      var sig = (0, _create2.default)();
      (0, _event_dispatcher.addListener)(parts[i], target, sig.push);
      sigs.push(sig);
    }
    return (0, _create.mergeMany)(sigs);
  }
});
define("frampton-events/get_position", ["exports"], function (exports) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = get_position;
  /**
   * getPosition :: DomEvent -> [Number, Number]
   *
   * @name getPosition
   * @memberof Frampton.Events
   * @static
   * @param {Object} evt
   * @returns {Array} A pair where the 0 index is the x coord and the 1 index is the y coord
   */
  function get_position(evt) {

    var posx = 0;
    var posy = 0;
    var body = document.body;
    var documentElement = document.documentElement;

    if (evt.pageX || evt.pageY) {
      posx = evt.pageX;
      posy = evt.pageY;
    } else if (evt.clientX || evt.clientY) {
      posx = evt.clientX + body.scrollLeft + documentElement.scrollLeft;
      posy = evt.clientY + body.scrollTop + documentElement.scrollTop;
    }

    return [posx, posy];
  }
});
define('frampton-events/get_position_relative', ['exports', 'frampton-utils/curry', 'frampton-events/get_position'], function (exports, _curry, _get_position) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  var _get_position2 = _interopRequireDefault(_get_position);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function get_position_relative(node, evt) {

    var position = (0, _get_position2.default)(evt);

    var rect = node.getBoundingClientRect();
    var rel_x = rect.left + document.body.scrollLeft + document.documentElement.scrollLeft;
    var rel_y = rect.top + document.body.scrollTop + document.documentElement.scrollTop;

    var pos_x = position[0] - Math.round(rel_x) - node.clientLeft;
    var pos_y = position[1] - Math.round(rel_y) - node.clientTop;

    return [pos_x, pos_y];
  });
});
define('frampton-events/has_selector', ['exports', 'frampton-utils/curry', 'frampton-utils/compose', 'frampton-style/matches', 'frampton-events/event_target'], function (exports, _curry, _compose, _matches, _event_target) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  var _compose2 = _interopRequireDefault(_compose);

  var _matches2 = _interopRequireDefault(_matches);

  var _event_target2 = _interopRequireDefault(_event_target);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function has_selector(selector, evt) {
    return (0, _compose2.default)((0, _matches2.default)(selector), _event_target2.default)(evt);
  });
});
define('frampton-events/on_event', ['exports', 'frampton-utils/is_function', 'frampton-utils/is_nothing', 'frampton-events/contains', 'frampton-events/event_map', 'frampton-events/get_document_signal', 'frampton-events/get_event_signal'], function (exports, _is_function, _is_nothing, _contains, _event_map, _get_document_signal, _get_event_signal) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = on_event;

  var _is_function2 = _interopRequireDefault(_is_function);

  var _is_nothing2 = _interopRequireDefault(_is_nothing);

  var _contains2 = _interopRequireDefault(_contains);

  var _event_map2 = _interopRequireDefault(_event_map);

  var _get_document_signal2 = _interopRequireDefault(_get_document_signal);

  var _get_event_signal2 = _interopRequireDefault(_get_event_signal);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * onEvent :: String -> Dom -> Signal Event
   *
   * @name onEvent
   * @memberof Frampton.Events
   * @static
   * @param {String} eventName Name of event to listen for
   * @param {Object} target    Object on which to listen for event
   * @returns {Frampton.Signal.Signal} A Signal of all occurances of the given event on the given object
   */
  function on_event(eventName, target) {
    if (_event_map2.default[eventName] && ((0, _is_nothing2.default)(target) || (0, _is_function2.default)(target.addEventListener))) {
      if ((0, _is_nothing2.default)(target)) {
        return (0, _get_document_signal2.default)(eventName);
      } else {
        return (0, _get_document_signal2.default)(eventName).filter((0, _contains2.default)(target));
      }
    } else {
      return (0, _get_event_signal2.default)(eventName, target);
    }
  }
});
define('frampton-events/on_selector', ['exports', 'frampton-utils/is_something', 'frampton-utils/is_string', 'frampton-utils/is_empty', 'frampton-events/closest_to_event', 'frampton-events/selector_contains', 'frampton-events/event_map', 'frampton-events/get_document_signal', 'frampton-events/selector_cache'], function (exports, _is_something, _is_string, _is_empty, _closest_to_event, _selector_contains, _event_map, _get_document_signal, _selector_cache) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _is_something2 = _interopRequireDefault(_is_something);

  var _is_string2 = _interopRequireDefault(_is_string);

  var _is_empty2 = _interopRequireDefault(_is_empty);

  var _closest_to_event2 = _interopRequireDefault(_closest_to_event);

  var _selector_contains2 = _interopRequireDefault(_selector_contains);

  var _event_map2 = _interopRequireDefault(_event_map);

  var _get_document_signal2 = _interopRequireDefault(_get_document_signal);

  var _selector_cache2 = _interopRequireDefault(_selector_cache);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function validateEventName(name) {
    var parts = name.split(' ').filter(function (val) {
      return !(0, _is_empty2.default)(val);
    });
    var len = parts.length;
    for (var i = 0; i < len; i++) {
      if (!(0, _is_something2.default)(_event_map2.default[parts[i]])) {
        return false;
      }
    }
    return true;
  }

  function mouseEnterSelector(selector) {
    var previousElement = null;
    return (0, _get_document_signal2.default)('mouseover').filter(function (evt) {
      var current = (0, _closest_to_event2.default)(selector, evt);
      if ((0, _is_something2.default)(current) && current !== previousElement) {
        previousElement = current;
        return true;
      } else {
        return false;
      }
    });
  }

  function mouseLeaveSelector(selector) {
    var previousElement = null;
    return (0, _get_document_signal2.default)('mouseleave').filter(function (evt) {
      var current = (0, _closest_to_event2.default)(selector, evt);
      if ((0, _is_something2.default)(current) && current !== previousElement) {
        previousElement = current;
        return true;
      } else if ((0, _is_something2.default)(current)) {
        previousElement = current;
        return false;
      } else {
        return false;
      }
    });
  }

  /**
   * onSelector :: String -> String -> Signal Event
   *
   * @name onSelector
   * @memberof Frampton.Events
   * @static
   * @param {String} eventName Name of event to listen for
   * @param {String} selector  Selector to filter events by
   * @returns {Frampton.Signal.Signal} A Signal of all occurances of the given event within given selector
   */
  function onSelector(eventName, selector) {
    if (validateEventName(eventName) && (0, _is_string2.default)(selector)) {
      return (0, _selector_cache2.default)(eventName + ' | ' + selector, function () {
        if (eventName === 'mouseenter') {
          return mouseEnterSelector(selector);
        } else if (eventName === 'mouseleave') {
          return mouseLeaveSelector(selector);
        } else {
          return (0, _get_document_signal2.default)(eventName).filter(function (evt) {
            return (0, _selector_contains2.default)(selector, evt);
          });
        }
      });
    } else {
      throw new Error('Frampton.Events.onSelector given unexpected arguments name: ' + eventName + ', selector: ' + selector);
    }
  }

  exports.default = onSelector;
});
define('frampton-events/once', ['exports', 'frampton-events/listen'], function (exports, _listen) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = once;
  function once(eventName, target) {
    return (0, _listen.listen)(eventName, target).take(1);
  }
});
define('frampton-events/prevent_default', ['exports', 'frampton-utils/is_function', 'frampton-utils/is_object'], function (exports, _is_function, _is_object) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  exports.default = function (evt) {
    if ((0, _is_object2.default)(evt) && (0, _is_function2.default)(evt.preventDefault) && (0, _is_function2.default)(evt.stopPropagation)) {
      evt.preventDefault();
      evt.stopPropagation();
    }
    return evt;
  };

  var _is_function2 = _interopRequireDefault(_is_function);

  var _is_object2 = _interopRequireDefault(_is_object);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }
});
define('frampton-events/selector_cache', ['exports', 'frampton-events/simple_cache'], function (exports, _simple_cache) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _simple_cache2 = _interopRequireDefault(_simple_cache);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _simple_cache2.default)();
});
define('frampton-events/selector_contains', ['exports', 'frampton-utils/curry', 'frampton-utils/is_something', 'frampton-events/closest_to_event'], function (exports, _curry, _is_something, _closest_to_event) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  var _is_something2 = _interopRequireDefault(_is_something);

  var _closest_to_event2 = _interopRequireDefault(_closest_to_event);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function selector_contains(selector, evt) {
    return (0, _is_something2.default)((0, _closest_to_event2.default)(selector, evt));
  });
});
define('frampton-events/simple_cache', ['exports', 'frampton-utils/is_nothing'], function (exports, _is_nothing) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  exports.default = function () {

    var store = {};

    return function (name, fn) {
      if ((0, _is_nothing2.default)(store[name])) {
        store[name] = fn();
      }
      return store[name];
    };
  };

  var _is_nothing2 = _interopRequireDefault(_is_nothing);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }
});
define('frampton-html', ['frampton/namespace', 'frampton-html/attribute', 'frampton-html/contains', 'frampton-html/data', 'frampton-html/element_value', 'frampton-html/set_html'], function (_namespace, _attribute, _contains, _data, _element_value, _set_html) {
  'use strict';

  var _namespace2 = _interopRequireDefault(_namespace);

  var _attribute2 = _interopRequireDefault(_attribute);

  var _contains2 = _interopRequireDefault(_contains);

  var _data2 = _interopRequireDefault(_data);

  var _element_value2 = _interopRequireDefault(_element_value);

  var _set_html2 = _interopRequireDefault(_set_html);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * @name Html
   * @namespace
   * @memberof Frampton
   */
  _namespace2.default.Html = {};
  _namespace2.default.Html.attribute = _attribute2.default;
  _namespace2.default.Html.contains = _contains2.default;
  _namespace2.default.Html.elementValue = _element_value2.default;
  _namespace2.default.Html.data = _data2.default;
  _namespace2.default.Html.set = _set_html2.default;
});
define('frampton-html/attribute', ['exports', 'frampton-utils/curry_n'], function (exports, _curry_n) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry_n2 = _interopRequireDefault(_curry_n);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry_n2.default)(2, function (name, element) {
    return element.getAttribute(name);
  });
});
define('frampton-html/contains', ['exports', 'frampton-utils/curry', 'frampton-utils/is_function'], function (exports, _curry, _is_function) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  var _is_function2 = _interopRequireDefault(_is_function);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function (parent, child) {
    if (parent === child) {
      return true;
    } else if ((0, _is_function2.default)(parent.contains)) {
      return parent.contains(child);
    } else {
      while (child = child.parentNode) {
        if (parent === child) {
          return true;
        }
        return false;
      }
    }
  });
});
define('frampton-html/data', ['exports', 'frampton-utils/curry', 'frampton-html/attribute'], function (exports, _curry, _attribute) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  var _attribute2 = _interopRequireDefault(_attribute);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function (name, element) {
    return (0, _attribute2.default)('data-' + name, element);
  });
});
define("frampton-html/element_value", ["exports"], function (exports) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = element_value;
  /**
   * elementValue :: Object -> Any
   *
   * @name elementValue
   * @method
   * @memberof Frampton.Html
   * @param {Object} element
   * @returns {*}
   */
  function element_value(element) {
    return element.value || null;
  }
});
define("frampton-html/remove", ["exports"], function (exports) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = remove;
  function remove(element) {
    var parent = element.parentNode;
    parent.removeChild(element);
  }
});
define('frampton-html/set_html', ['exports', 'frampton-utils/curry'], function (exports, _curry) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function (element, html) {
    element.innerHTML = html;
  });
});
define('frampton-list', ['frampton/namespace', 'frampton-list/add', 'frampton-list/append', 'frampton-list/at', 'frampton-list/contains', 'frampton-list/copy', 'frampton-list/diff', 'frampton-list/drop', 'frampton-list/each', 'frampton-list/filter', 'frampton-list/find', 'frampton-list/first', 'frampton-list/foldl', 'frampton-list/foldr', 'frampton-list/init', 'frampton-list/last', 'frampton-list/length', 'frampton-list/max', 'frampton-list/min', 'frampton-list/prepend', 'frampton-list/product', 'frampton-list/remove', 'frampton-list/remove_index', 'frampton-list/replace', 'frampton-list/replace_index', 'frampton-list/reverse', 'frampton-list/second', 'frampton-list/split', 'frampton-list/sum', 'frampton-list/tail', 'frampton-list/take', 'frampton-list/third', 'frampton-list/zip'], function (_namespace, _add, _append, _at, _contains, _copy, _diff, _drop, _each, _filter, _find, _first, _foldl, _foldr, _init, _last, _length, _max, _min, _prepend, _product, _remove, _remove_index, _replace, _replace_index, _reverse, _second, _split, _sum, _tail, _take, _third, _zip) {
  'use strict';

  var _namespace2 = _interopRequireDefault(_namespace);

  var _add2 = _interopRequireDefault(_add);

  var _append2 = _interopRequireDefault(_append);

  var _at2 = _interopRequireDefault(_at);

  var _contains2 = _interopRequireDefault(_contains);

  var _copy2 = _interopRequireDefault(_copy);

  var _diff2 = _interopRequireDefault(_diff);

  var _drop2 = _interopRequireDefault(_drop);

  var _each2 = _interopRequireDefault(_each);

  var _filter2 = _interopRequireDefault(_filter);

  var _find2 = _interopRequireDefault(_find);

  var _first2 = _interopRequireDefault(_first);

  var _foldl2 = _interopRequireDefault(_foldl);

  var _foldr2 = _interopRequireDefault(_foldr);

  var _init2 = _interopRequireDefault(_init);

  var _last2 = _interopRequireDefault(_last);

  var _length2 = _interopRequireDefault(_length);

  var _max2 = _interopRequireDefault(_max);

  var _min2 = _interopRequireDefault(_min);

  var _prepend2 = _interopRequireDefault(_prepend);

  var _product2 = _interopRequireDefault(_product);

  var _remove2 = _interopRequireDefault(_remove);

  var _remove_index2 = _interopRequireDefault(_remove_index);

  var _replace2 = _interopRequireDefault(_replace);

  var _replace_index2 = _interopRequireDefault(_replace_index);

  var _reverse2 = _interopRequireDefault(_reverse);

  var _second2 = _interopRequireDefault(_second);

  var _split2 = _interopRequireDefault(_split);

  var _sum2 = _interopRequireDefault(_sum);

  var _tail2 = _interopRequireDefault(_tail);

  var _take2 = _interopRequireDefault(_take);

  var _third2 = _interopRequireDefault(_third);

  var _zip2 = _interopRequireDefault(_zip);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * @name List
   * @namespace
   * @memberof Frampton
   */
  _namespace2.default.List = {};
  _namespace2.default.List.add = _add2.default;
  _namespace2.default.List.append = _append2.default;
  _namespace2.default.List.at = _at2.default;
  _namespace2.default.List.contains = _contains2.default;
  _namespace2.default.List.copy = _copy2.default;
  _namespace2.default.List.diff = _diff2.default;
  _namespace2.default.List.drop = _drop2.default;
  _namespace2.default.List.each = _each2.default;
  _namespace2.default.List.filter = _filter2.default;
  _namespace2.default.List.find = _find2.default;
  _namespace2.default.List.first = _first2.default;
  _namespace2.default.List.foldl = _foldl2.default;
  _namespace2.default.List.foldr = _foldr2.default;
  _namespace2.default.List.init = _init2.default;
  _namespace2.default.List.last = _last2.default;
  _namespace2.default.List.length = _length2.default;
  _namespace2.default.List.max = _max2.default;
  _namespace2.default.List.min = _min2.default;
  _namespace2.default.List.prepend = _prepend2.default;
  _namespace2.default.List.product = _product2.default;
  _namespace2.default.List.remove = _remove2.default;
  _namespace2.default.List.removeAt = _remove_index2.default;
  _namespace2.default.List.replace = _replace2.default;
  _namespace2.default.List.replaceAt = _replace_index2.default;
  _namespace2.default.List.reverse = _reverse2.default;
  _namespace2.default.List.second = _second2.default;
  _namespace2.default.List.split = _split2.default;
  _namespace2.default.List.sum = _sum2.default;
  _namespace2.default.List.tail = _tail2.default;
  _namespace2.default.List.take = _take2.default;
  _namespace2.default.List.third = _third2.default;
  _namespace2.default.List.zip = _zip2.default;
});
define('frampton-list/add', ['exports', 'frampton-utils/curry_n', 'frampton-list/contains', 'frampton-list/append'], function (exports, _curry_n, _contains, _append) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry_n2 = _interopRequireDefault(_curry_n);

  var _contains2 = _interopRequireDefault(_contains);

  var _append2 = _interopRequireDefault(_append);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry_n2.default)(2, function add_to_list(xs, obj) {
    return !(0, _contains2.default)(xs, obj) ? (0, _append2.default)(xs, obj) : xs;
  });
});
define('frampton-list/append', ['exports', 'frampton-utils/curry_n'], function (exports, _curry_n) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry_n2 = _interopRequireDefault(_curry_n);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function _toConsumableArray(arr) {
    if (Array.isArray(arr)) {
      for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {
        arr2[i] = arr[i];
      }

      return arr2;
    } else {
      return Array.from(arr);
    }
  }

  exports.default = (0, _curry_n2.default)(2, function (xs, obj) {
    return [].concat(_toConsumableArray(xs), [obj]);
  });
});
define('frampton-list/at', ['exports', 'frampton-utils/curry_n', 'frampton-utils/assert', 'frampton-utils/is_defined', 'frampton-utils/is_array'], function (exports, _curry_n, _assert, _is_defined, _is_array) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry_n2 = _interopRequireDefault(_curry_n);

  var _assert2 = _interopRequireDefault(_assert);

  var _is_defined2 = _interopRequireDefault(_is_defined);

  var _is_array2 = _interopRequireDefault(_is_array);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry_n2.default)(2, function at(index, xs) {
    (0, _assert2.default)("Frampton.List.at recieved a non-array", (0, _is_array2.default)(xs));
    return (0, _is_defined2.default)(xs[index]) ? xs[index] : null;
  });
});
define('frampton-list/contains', ['exports', 'frampton-utils/curry_n'], function (exports, _curry_n) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry_n2 = _interopRequireDefault(_curry_n);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry_n2.default)(2, function (xs, obj) {
    return xs.indexOf(obj) > -1;
  });
});
define('frampton-list/copy', ['exports', 'frampton-list/length'], function (exports, _length) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = copy;

  var _length2 = _interopRequireDefault(_length);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * @name copy
   * @method
   * @memberof Frampton.List
   */
  function copy(xs, begin, end) {

    var argLen = (0, _length2.default)(xs);
    var idx = 0;
    var arr;

    begin = begin || 0;
    end = end || argLen;
    var arrLen = end - begin;

    if (argLen > 0) {
      arr = new Array(arrLen);
      for (var i = begin; i < end; i++) {
        arr[idx++] = xs[i];
      }
    }

    return arr || [];
  }
});
define('frampton-list/diff', ['exports', 'frampton-utils/curry_n', 'frampton-list/contains', 'frampton-list/each'], function (exports, _curry_n, _contains, _each) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry_n2 = _interopRequireDefault(_curry_n);

  var _contains2 = _interopRequireDefault(_contains);

  var _each2 = _interopRequireDefault(_each);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry_n2.default)(2, function curried_diff(xs, ys) {

    var diff = [];

    (0, _each2.default)(function (item) {
      if (!(0, _contains2.default)(ys, item)) {
        diff.push(item);
      }
    }, xs);

    return diff;
  });
});
define('frampton-list/drop', ['exports', 'frampton-utils/assert', 'frampton-utils/curry_n', 'frampton-utils/is_array', 'frampton-list/filter'], function (exports, _assert, _curry_n, _is_array, _filter) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _assert2 = _interopRequireDefault(_assert);

  var _curry_n2 = _interopRequireDefault(_curry_n);

  var _is_array2 = _interopRequireDefault(_is_array);

  var _filter2 = _interopRequireDefault(_filter);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry_n2.default)(2, function curried_drop(n, xs) {
    (0, _assert2.default)("Frampton.List.drop recieved a non-array", (0, _is_array2.default)(xs));
    return (0, _filter2.default)(function (next) {
      if (n === 0) {
        return true;
      } else {
        n--;
      }
      return false;
    }, xs);
  });
});
define('frampton-list/each', ['exports', 'frampton-utils/curry_n'], function (exports, _curry_n) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry_n2 = _interopRequireDefault(_curry_n);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry_n2.default)(2, function curried_each(fn, xs) {
    var len = xs.length;
    for (var i = 0; i < len; i++) {
      fn(xs[i], i);
    }
  });
});
define('frampton-list/filter', ['exports', 'frampton-utils/curry_n', 'frampton-list/length'], function (exports, _curry_n, _length) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry_n2 = _interopRequireDefault(_curry_n);

  var _length2 = _interopRequireDefault(_length);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry_n2.default)(2, function filter(predicate, xs) {

    var len = (0, _length2.default)(xs);
    var newList = [];

    for (var i = 0; i < len; i++) {
      if (predicate(xs[i])) {
        newList.push(xs[i]);
      }
    }

    return newList;
  });
});
define('frampton-list/find', ['exports', 'frampton-utils/curry_n'], function (exports, _curry_n) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry_n2 = _interopRequireDefault(_curry_n);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry_n2.default)(2, function (obj, xs) {
    return xs.indexOf(obj);
  });
});
define('frampton-list/first', ['exports', 'frampton-list/at'], function (exports, _at) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _at2 = _interopRequireDefault(_at);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _at2.default)(0);
});
define('frampton-list/foldl', ['exports', 'frampton-utils/assert', 'frampton-utils/curry_n', 'frampton-utils/is_array'], function (exports, _assert, _curry_n, _is_array) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _assert2 = _interopRequireDefault(_assert);

  var _curry_n2 = _interopRequireDefault(_curry_n);

  var _is_array2 = _interopRequireDefault(_is_array);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry_n2.default)(3, function curried_foldl(fn, acc, xs) {
    (0, _assert2.default)("Frampton.List.foldl recieved a non-array", (0, _is_array2.default)(xs));
    var len = xs.length;
    for (var i = 0; i < len; i++) {
      acc = fn(acc, xs[i]);
    }
    return acc;
  });
});
define('frampton-list/foldr', ['exports', 'frampton-utils/assert', 'frampton-utils/curry_n', 'frampton-utils/is_array'], function (exports, _assert, _curry_n, _is_array) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _assert2 = _interopRequireDefault(_assert);

  var _curry_n2 = _interopRequireDefault(_curry_n);

  var _is_array2 = _interopRequireDefault(_is_array);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry_n2.default)(3, function curried_foldr(fn, acc, xs) {
    (0, _assert2.default)("Frampton.List.foldr recieved a non-array", (0, _is_array2.default)(xs));
    var len = xs.length;
    while (len--) {
      acc = fn(acc, xs[len]);
    }
    return acc;
  });
});
define('frampton-list/init', ['exports', 'frampton-utils/assert', 'frampton-utils/is_array'], function (exports, _assert, _is_array) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = init;

  var _assert2 = _interopRequireDefault(_assert);

  var _is_array2 = _interopRequireDefault(_is_array);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * @name init
   * @method
   * @memberof Frampton.List
   */
  function init(xs) {
    (0, _assert2.default)("Frampton.List.init recieved a non-array", (0, _is_array2.default)(xs));
    switch (xs.length) {

      case 0:
        return [];

      default:
        return xs.slice(0, xs.length - 1);
    }
  }
});
define('frampton-list/last', ['exports', 'frampton-utils/assert', 'frampton-utils/is_array'], function (exports, _assert, _is_array) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = last;

  var _assert2 = _interopRequireDefault(_assert);

  var _is_array2 = _interopRequireDefault(_is_array);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * @name last
   * @method
   * @memberof Frampton.List
   */
  function last(xs) {
    (0, _assert2.default)("Frampton.List.last recieved a non-array", (0, _is_array2.default)(xs));
    switch (xs.length) {

      case 0:
        return null;

      default:
        return xs[xs.length - 1];
    }
  }
});
define('frampton-list/length', ['exports', 'frampton-utils/is_something', 'frampton-utils/is_defined'], function (exports, _is_something, _is_defined) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = length;

  var _is_something2 = _interopRequireDefault(_is_something);

  var _is_defined2 = _interopRequireDefault(_is_defined);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * @name length
   * @method
   * @memberof Frampton.List
   */
  function length(xs) {
    return (0, _is_something2.default)(xs) && (0, _is_defined2.default)(xs.length) ? xs.length : 0;
  }
});
define('frampton-list/max', ['exports', 'frampton-list/foldl', 'frampton-utils/is_nothing'], function (exports, _foldl, _is_nothing) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = maximum;

  var _foldl2 = _interopRequireDefault(_foldl);

  var _is_nothing2 = _interopRequireDefault(_is_nothing);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * @name maximum
   * @method
   * @memberof Frampton.List
   * @param {Array} xs
   */
  function maximum(xs) {
    return (0, _foldl2.default)(function (acc, next) {
      if ((0, _is_nothing2.default)(acc) || next > acc) {
        acc = next;
      }
      return acc;
    }, null, xs);
  }
});
define('frampton-list/min', ['exports', 'frampton-list/foldl', 'frampton-utils/is_nothing'], function (exports, _foldl, _is_nothing) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = min;

  var _foldl2 = _interopRequireDefault(_foldl);

  var _is_nothing2 = _interopRequireDefault(_is_nothing);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * @name min
   * @method
   * @memberof Frampton.List
   * @param {Array} xs
   */
  function min(xs) {
    return (0, _foldl2.default)(function (acc, next) {
      if ((0, _is_nothing2.default)(acc) || next < acc) {
        acc = next;
      }
      return acc;
    }, null, xs);
  }
});
define('frampton-list/prepend', ['exports', 'frampton-utils/curry_n'], function (exports, _curry_n) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry_n2 = _interopRequireDefault(_curry_n);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function _toConsumableArray(arr) {
    if (Array.isArray(arr)) {
      for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {
        arr2[i] = arr[i];
      }

      return arr2;
    } else {
      return Array.from(arr);
    }
  }

  exports.default = (0, _curry_n2.default)(2, function (obj, xs) {
    return [obj].concat(_toConsumableArray(xs));
  });
});
define('frampton-list/product', ['exports', 'frampton-list/foldl'], function (exports, _foldl) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = product;

  var _foldl2 = _interopRequireDefault(_foldl);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * @name product
   * @method
   * @memberof Frampton.List
   * @param {Array} xs
   */
  function product(xs) {
    return (0, _foldl2.default)(function (acc, next) {
      return acc * next;
    }, 1, xs);
  }
});
define('frampton-list/remove', ['exports', 'frampton-utils/curry_n', 'frampton-list/filter'], function (exports, _curry_n, _filter) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry_n2 = _interopRequireDefault(_curry_n);

  var _filter2 = _interopRequireDefault(_filter);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry_n2.default)(2, function curried_remove(obj, xs) {
    return (0, _filter2.default)(function (next) {
      return next !== obj;
    }, xs);
  });
});
define('frampton-list/remove_index', ['exports', 'frampton-list/length'], function (exports, _length) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = remove_index;

  var _length2 = _interopRequireDefault(_length);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * @name removeIndex
   * @method
   * @memberof Frampton.List
   * @param {Number} index
   * @param {Array} xs
   * @returns {Array} A new array
   */
  function remove_index(index, xs) {

    var len = (0, _length2.default)(xs);
    var newList = [];

    for (var i = 0; i < len; i++) {
      if (i !== index) {
        newList.push(xs[i]);
      }
    }

    return newList;
  }
});
define('frampton-list/replace', ['exports', 'frampton-utils/curry_n', 'frampton-list/find', 'frampton-list/replace_index'], function (exports, _curry_n, _find, _replace_index) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry_n2 = _interopRequireDefault(_curry_n);

  var _find2 = _interopRequireDefault(_find);

  var _replace_index2 = _interopRequireDefault(_replace_index);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry_n2.default)(2, function replace(oldObj, newObj, xs) {
    var index = (0, _find2.default)(oldObj, xs);
    if (index > -1) {
      return (0, _replace_index2.default)(index, newObj, xs);
    } else {
      return xs;
    }
  });
});
define('frampton-list/replace_index', ['exports', 'frampton-utils/curry_n', 'frampton-list/length'], function (exports, _curry_n, _length) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry_n2 = _interopRequireDefault(_curry_n);

  var _length2 = _interopRequireDefault(_length);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry_n2.default)(2, function replace_index(index, obj, xs) {
    var len = (0, _length2.default)(xs);
    var newArray = new Array(len);
    for (var i = 0; i < len; i++) {
      if (i === index) {
        newArray[i] = obj;
      } else {
        newArray[i] = xs[i];
      }
    }
    return newArray;
  });
});
define('frampton-list/reverse', ['exports', 'frampton-list/foldr'], function (exports, _foldr) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = reverse;

  var _foldr2 = _interopRequireDefault(_foldr);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * reverse :: List a -> List a
   *
   * @name reverse
   * @method
   * @memberof Frampton.List
   */
  function reverse(xs) {
    return (0, _foldr2.default)(function (acc, next) {
      acc.push(next);
      return acc;
    }, [], xs);
  }
});
define('frampton-list/second', ['exports', 'frampton-list/at'], function (exports, _at) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _at2 = _interopRequireDefault(_at);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _at2.default)(1);
});
define('frampton-list/split', ['exports', 'frampton-utils/curry_n'], function (exports, _curry_n) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry_n2 = _interopRequireDefault(_curry_n);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry_n2.default)(2, function split(n, xs) {
    var ys = [];
    var zs = [];
    var len = xs.length;

    for (var i = 0; i < len; i++) {
      if (i < n) {
        ys.push(xs[i]);
      } else {
        zs.push(xs[i]);
      }
    }

    return [ys, zs];
  });
});
define('frampton-list/sum', ['exports', 'frampton-list/foldl'], function (exports, _foldl) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = sum;

  var _foldl2 = _interopRequireDefault(_foldl);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * + sum :: Number a => List a -> a
   *
   * @name sum
   * @method
   * @memberof Frampton.List
   * @param {Array} xs
   */
  function sum(xs) {
    return (0, _foldl2.default)(function (acc, next) {
      return acc + next;
    }, 0, xs);
  }
});
define('frampton-list/tail', ['exports', 'frampton-utils/assert', 'frampton-utils/is_array'], function (exports, _assert, _is_array) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = tail;

  var _assert2 = _interopRequireDefault(_assert);

  var _is_array2 = _interopRequireDefault(_is_array);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * @name tail
   * @method
   * @memberof Frampton.List
   */
  function tail(xs) {
    (0, _assert2.default)("Frampton.List.tail recieved a non-array", (0, _is_array2.default)(xs));
    switch (xs.length) {
      case 0:
        return [];
      default:
        return xs.slice(1);
    }
  }
});
define('frampton-list/take', ['exports', 'frampton-utils/assert', 'frampton-utils/curry_n', 'frampton-utils/is_array', 'frampton-math/min'], function (exports, _assert, _curry_n, _is_array, _min) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _assert2 = _interopRequireDefault(_assert);

  var _curry_n2 = _interopRequireDefault(_curry_n);

  var _is_array2 = _interopRequireDefault(_is_array);

  var _min2 = _interopRequireDefault(_min);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry_n2.default)(2, function take(num, xs) {
    (0, _assert2.default)("Frampton.List.take recieved a non-array", (0, _is_array2.default)(xs));
    var newList = [];
    var len = (0, _min2.default)(xs.length, num);
    for (var i = 0; i < len; i++) {
      newList.push(xs[i]);
    }
    return newList;
  });
});
define('frampton-list/third', ['exports', 'frampton-list/at'], function (exports, _at) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _at2 = _interopRequireDefault(_at);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _at2.default)(2);
});
define('frampton-list/zip', ['exports', 'frampton-utils/curry_n'], function (exports, _curry_n) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry_n2 = _interopRequireDefault(_curry_n);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry_n2.default)(2, function zip_array(xs, ys) {

    var xLen = xs.length;
    var yLen = ys.length;
    var len = xLen > yLen ? yLen : xLen;
    var zs = new Array(len);

    for (var i = 0; i < len; i++) {
      zs[i] = [xs[i], ys[i]];
    }

    return zs;
  });
});
define('frampton-math', ['frampton/namespace', 'frampton-math/add', 'frampton-math/subtract', 'frampton-math/multiply', 'frampton-math/divide', 'frampton-math/modulo', 'frampton-math/max', 'frampton-math/min'], function (_namespace, _add, _subtract, _multiply, _divide, _modulo, _max, _min) {
  'use strict';

  var _namespace2 = _interopRequireDefault(_namespace);

  var _add2 = _interopRequireDefault(_add);

  var _subtract2 = _interopRequireDefault(_subtract);

  var _multiply2 = _interopRequireDefault(_multiply);

  var _divide2 = _interopRequireDefault(_divide);

  var _modulo2 = _interopRequireDefault(_modulo);

  var _max2 = _interopRequireDefault(_max);

  var _min2 = _interopRequireDefault(_min);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * @name Math
   * @namespace
   * @memberof Frampton
   */
  _namespace2.default.Math = {};
  _namespace2.default.Math.add = _add2.default;
  _namespace2.default.Math.subtract = _subtract2.default;
  _namespace2.default.Math.multiply = _multiply2.default;
  _namespace2.default.Math.divide = _divide2.default;
  _namespace2.default.Math.modulo = _modulo2.default;
  _namespace2.default.Math.max = _max2.default;
  _namespace2.default.Math.min = _min2.default;
});
define('frampton-math/add', ['exports', 'frampton-utils/curry'], function (exports, _curry) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function add(left, right) {
    return left + right;
  });
});
define('frampton-math/divide', ['exports', 'frampton-utils/curry'], function (exports, _curry) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function divide(left, right) {
    return left / right;
  });
});
define('frampton-math/max', ['exports', 'frampton-utils/curry'], function (exports, _curry) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function max(left, right) {
    return left > right ? left : right;
  });
});
define('frampton-math/min', ['exports', 'frampton-utils/curry'], function (exports, _curry) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function min(left, right) {
    return left < right ? left : right;
  });
});
define('frampton-math/modulo', ['exports', 'frampton-utils/curry'], function (exports, _curry) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function modulo(left, right) {
    return left % right;
  });
});
define('frampton-math/multiply', ['exports', 'frampton-utils/curry'], function (exports, _curry) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function multiply(a, b) {
    return a * b;
  });
});
define('frampton-math/subtract', ['exports', 'frampton-utils/curry'], function (exports, _curry) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function (left, right) {
    return left - right;
  });
});
define('frampton-object', ['frampton/namespace', 'frampton-object/as_list', 'frampton-object/copy', 'frampton-object/filter', 'frampton-object/for_each', 'frampton-object/get', 'frampton-object/keys', 'frampton-object/map', 'frampton-object/merge', 'frampton-object/reduce', 'frampton-object/set', 'frampton-object/update', 'frampton-object/values'], function (_namespace, _as_list, _copy, _filter, _for_each, _get, _keys, _map, _merge, _reduce, _set, _update, _values) {
  'use strict';

  var _namespace2 = _interopRequireDefault(_namespace);

  var _as_list2 = _interopRequireDefault(_as_list);

  var _copy2 = _interopRequireDefault(_copy);

  var _filter2 = _interopRequireDefault(_filter);

  var _for_each2 = _interopRequireDefault(_for_each);

  var _get2 = _interopRequireDefault(_get);

  var _keys2 = _interopRequireDefault(_keys);

  var _map2 = _interopRequireDefault(_map);

  var _merge2 = _interopRequireDefault(_merge);

  var _reduce2 = _interopRequireDefault(_reduce);

  var _set2 = _interopRequireDefault(_set);

  var _update2 = _interopRequireDefault(_update);

  var _values2 = _interopRequireDefault(_values);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * @name Object
   * @namespace
   * @memberof Frampton
   */
  _namespace2.default.Object = {};
  _namespace2.default.Object.asList = _as_list2.default;
  _namespace2.default.Object.copy = _copy2.default;
  _namespace2.default.Object.each = _for_each2.default;
  _namespace2.default.Object.filter = _filter2.default;
  _namespace2.default.Object.get = _get2.default;
  _namespace2.default.Object.keys = _keys2.default;
  _namespace2.default.Object.map = _map2.default;
  _namespace2.default.Object.merge = _merge2.default;
  _namespace2.default.Object.reduce = _reduce2.default;
  _namespace2.default.Object.set = _set2.default;
  _namespace2.default.Object.update = _update2.default;
  _namespace2.default.Object.values = _values2.default;
});
define('frampton-object/as_list', ['exports', 'frampton-object/reduce'], function (exports, _reduce) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = as_list;

  var _reduce2 = _interopRequireDefault(_reduce);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  // as_list :: Object -> Array [String, *]
  /**
   * @name as_list
   * @method
   * @memberof Frampton.Record
   * @param {Object} obj Object to transform
   * @returns {Array}
   */
  function as_list(obj) {
    return (0, _reduce2.default)(function (acc, nextValue, nextKey) {
      acc.push([nextKey, nextValue]);
      return acc;
    }, [], obj);
  }
});
define('frampton-object/copy', ['exports', 'frampton-object/for_each'], function (exports, _for_each) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = copy_object;

  var _for_each2 = _interopRequireDefault(_for_each);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * copy :: Object -> Object
   *
   * @name copy
   * @method
   * @memberof Frampton.Object
   * @param {Object} obj object to copy
   * @returns {Object}
   */
  function copy_object(obj) {

    var newObj = {};

    (0, _for_each2.default)(function (value, key) {
      newObj[key] = value;
    }, obj);

    return newObj;
  }
});
define('frampton-object/filter', ['exports', 'frampton-utils/curry', 'frampton-object/for_each'], function (exports, _curry, _for_each) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  var _for_each2 = _interopRequireDefault(_for_each);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function curried_filter(predicate, obj) {

    var newObj = {};

    (0, _for_each2.default)(function (value, key) {
      if (predicate(value, key)) {
        newObj[key] = value;
      }
    }, obj);

    return newObj;
  });
});
define('frampton-object/for_each', ['exports', 'frampton-utils/curry'], function (exports, _curry) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function curried_for_each(fn, obj) {
    for (var key in obj) {
      if (obj.hasOwnProperty(key)) {
        fn(obj[key], key);
      }
    }
  });
});
define('frampton-object/get', ['exports', 'frampton-utils/curry', 'frampton-utils/is_nothing', 'frampton-utils/is_string', 'frampton-utils/is_primitive'], function (exports, _curry, _is_nothing, _is_string, _is_primitive) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  var _is_nothing2 = _interopRequireDefault(_is_nothing);

  var _is_string2 = _interopRequireDefault(_is_string);

  var _is_primitive2 = _interopRequireDefault(_is_primitive);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function _toArray(arr) {
    return Array.isArray(arr) ? arr : Array.from(arr);
  }

  exports.default = (0, _curry2.default)(function get(prop, obj) {

    if ((0, _is_primitive2.default)(obj) || (0, _is_nothing2.default)(obj)) {
      return null;
    } else if ((0, _is_string2.default)(prop)) {
      var parts = (prop || '').split('.').filter(function (val) {
        return val.trim() !== '';
      });

      if (parts.length > 1) {
        var _parts = _toArray(parts),
            head = _parts[0],
            tail = _parts.slice(1);

        var sub = obj[head];
        return !(0, _is_primitive2.default)(sub) ? get(tail.join('.'), sub) : null;
      } else {
        return obj[parts[0]] || null;
      }
    } else {
      return obj[prop] || null;
    }
  });
});
define('frampton-object/keys', ['exports', 'frampton-utils/is_function'], function (exports, _is_function) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = keys;

  var _is_function2 = _interopRequireDefault(_is_function);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  var hasOwnProp = Object.prototype.hasOwnProperty;

  function getKeys(obj) {
    var result = [];
    for (var key in obj) {
      if (hasOwnProp.call(obj, key)) {
        result.push(key);
      }
    }
    return result;
  }

  /**
   * @name keys
   * @method
   * @memberof Frampton.Object
   * @param {Object} obj Object whose keys to get
   * @returns {String[]}
   */
  function keys(obj) {
    if ((0, _is_function2.default)(Object.keys)) {
      return Object.keys(obj).filter(function (key) {
        return hasOwnProp.call(obj, key);
      });
    } else {
      return getKeys(obj);
    }
  }
});
define('frampton-object/map', ['exports', 'frampton-utils/curry', 'frampton-object/for_each'], function (exports, _curry, _for_each) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  var _for_each2 = _interopRequireDefault(_for_each);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function curried_map(fn, obj) {

    var newObj = {};

    (0, _for_each2.default)(function (value, key) {
      newObj[key] = fn(value, key);
    }, obj);

    return newObj;
  });
});
define('frampton-object/merge', ['exports', 'frampton-utils/curry', 'frampton-utils/extend'], function (exports, _curry, _extend) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  var _extend2 = _interopRequireDefault(_extend);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function curried_merge(obj1, obj2) {
    return (0, _extend2.default)({}, obj1, obj2);
  });
});
define('frampton-object/reduce', ['exports', 'frampton-utils/curry', 'frampton-object/for_each'], function (exports, _curry, _for_each) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  var _for_each2 = _interopRequireDefault(_for_each);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function curried_reduce(fn, acc, obj) {

    (0, _for_each2.default)(function (value, key) {
      acc = fn(acc, value, key);
    }, obj);

    return acc;
  });
});
define('frampton-object/set', ['exports', 'frampton-utils/curry', 'frampton-utils/is_string', 'frampton-object/keys'], function (exports, _curry, _is_string, _keys) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  var _is_string2 = _interopRequireDefault(_is_string);

  var _keys2 = _interopRequireDefault(_keys);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function _toArray(arr) {
    return Array.isArray(arr) ? arr : Array.from(arr);
  }

  function setValue(prop, value, oldObj, newObj) {
    if (!(0, _is_string2.default)(prop)) {
      throw new Error('Property to set must be a string');
    } else {
      var _split$filter = (prop || '').split('.').filter(function (val) {
        return val.trim() !== '';
      }),
          _split$filter2 = _toArray(_split$filter),
          head = _split$filter2[0],
          tail = _split$filter2.slice(1);

      var keys = (0, _keys2.default)(oldObj);

      if (keys.indexOf(head) === -1) {
        keys.push(head);
      }

      for (var i = 0; i < keys.length; i++) {
        var key = keys[i];
        if (key === head) {
          if (tail.length > 0) {
            var nextObj = oldObj[key] || {};
            newObj[key] = setValue(tail.join('.'), value, nextObj, {});
          } else {
            newObj[key] = value;
          }
        } else {
          newObj[key] = oldObj[key];
        }
      }
    }

    return newObj;
  }

  /**
   * set :: String -> Any -> Object -> Object
   *
   * @name set
   * @method
   * @memberof Frampton.Object
   * @param {String} key The key to update
   * @param {*} value The value to update to
   * @param {Object} obj The object to update
   * @returns {Object}
   */
  exports.default = (0, _curry2.default)(function set(prop, value, obj) {
    return setValue(prop, value, obj, {});
  });
});
define('frampton-object/update', ['exports', 'frampton-utils/is_object', 'frampton-object/keys'], function (exports, _is_object, _keys) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = update_object;

  var _is_object2 = _interopRequireDefault(_is_object);

  var _keys2 = _interopRequireDefault(_keys);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function isNode(obj) {
    return (
      obj !== undefined &&
      obj !== null &&
      obj.tagName !== undefined &&
      obj.nodeType !== undefined
    );
  }

  /**
   * update :: Object -> Object -> Object
   *
   * @name update
   * @method
   * @memberof Frampton.Object
   * @param {Object} base   object to copy
   * @param {Object} update object describing desired udpate
   * @returns {Object}
   */
  function update_object(base, update) {

    var newObj = {};
    var baseKeys = (0, _keys2.default)(base);
    var updateKeys = (0, _keys2.default)(update);

    for (var i = 0; i < updateKeys.length; i++) {
      var key = updateKeys[i];
      if (baseKeys.indexOf(key) === -1) {
        baseKeys.push(key);
      }
    }

    for (var _i = 0; _i < baseKeys.length; _i++) {
      var _key = baseKeys[_i];
      var baseValue = base[_key];
      var updateValue = update[_key];
      if (isNode(updateValue)) {
        newObj[_key] = updateValue;
      } else if (isNode(baseValue) && updateValue !== undefined) {
        newObj[_key] = updateValue;
      } else if ((0, _is_object2.default)(baseValue) && (0, _is_object2.default)(updateValue)) {
        newObj[_key] = update_object(baseValue, updateValue);
      } else if (updateValue !== undefined) {
        newObj[_key] = updateValue;
      } else {
        newObj[_key] = baseValue;
      }
    }

    return newObj;
  }
});
define('frampton-object/values', ['exports', 'frampton-utils/is_object'], function (exports, _is_object) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = values;

  var _is_object2 = _interopRequireDefault(_is_object);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  var hasOwnProp = Object.prototype.hasOwnProperty;

  /**
   * @name values
   * @method
   * @memberof Frampton.Object
   * @param {Object} obj Object whose values to get
   * @returns {String[]}
   */
  function values(obj) {
    var result = [];
    if ((0, _is_object2.default)(obj)) {
      for (var key in obj) {
        if (hasOwnProp.call(obj, key)) {
          result.push(obj[key]);
        }
      }
    }
    return result;
  }
});
define('frampton-signal', ['frampton/namespace', 'frampton-signal/create', 'frampton-signal/stepper', 'frampton-signal/combine', 'frampton-signal/swap', 'frampton-signal/toggle', 'frampton-signal/is_signal', 'frampton-signal/forward'], function (_namespace, _create, _stepper, _combine, _swap, _toggle, _is_signal, _forward) {
  'use strict';

  var _namespace2 = _interopRequireDefault(_namespace);

  var _create2 = _interopRequireDefault(_create);

  var _stepper2 = _interopRequireDefault(_stepper);

  var _combine2 = _interopRequireDefault(_combine);

  var _swap2 = _interopRequireDefault(_swap);

  var _toggle2 = _interopRequireDefault(_toggle);

  var _is_signal2 = _interopRequireDefault(_is_signal);

  var _forward2 = _interopRequireDefault(_forward);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * @name Signal
   * @class
   * @memberof Frampton
   */
  _namespace2.default.Signal = {};
  _namespace2.default.Signal.create = _create2.default;
  _namespace2.default.Signal.stepper = _stepper2.default;
  _namespace2.default.Signal.combine = _combine2.default;
  _namespace2.default.Signal.merge = _create.mergeMany;
  _namespace2.default.Signal.swap = _swap2.default;
  _namespace2.default.Signal.toggle = _toggle2.default;
  _namespace2.default.Signal.isSignal = _is_signal2.default;
  _namespace2.default.Signal.forward = _forward2.default;
});
define('frampton-signal/combine', ['exports', 'frampton-signal/create'], function (exports, _create) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = combine;


  /**
   * Method to combine multiple Signals into one with a given mapping function. Values
   * of the Signals are passed to the mapping function in the same order they appear
   * in the array.
   *
   * @name combine
   * @method
   * @memberof Frampton.Signal
   * @param {Function} mapping - Function used to combine given Signals
   * @param {Frampton.Signal[]} parents - Array of Signals to combine
   * @returns {Frampton.Signal} A new Signal
   */
  function combine(mapping, parents) {
    return (0, _create.createSignal)(function (self) {
      self.push(mapping.apply(null, parents.map(function (parent) {
        return parent._value;
      })));
    }, parents);
  }
});
define('frampton-signal/create', ['exports', 'frampton-utils/guid', 'frampton-utils/is_defined', 'frampton-utils/is_promise', 'frampton-utils/is_function', 'frampton-utils/is_equal', 'frampton-utils/of_value', 'frampton-utils/noop', 'frampton-utils/log'], function (exports, _guid, _is_defined, _is_promise, _is_function, _is_equal, _of_value, _noop, _log) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.createSignal = createSignal;
  exports.mergeMany = mergeMany;
  exports.default = create;

  var _guid2 = _interopRequireDefault(_guid);

  var _is_defined2 = _interopRequireDefault(_is_defined);

  var _is_promise2 = _interopRequireDefault(_is_promise);

  var _is_function2 = _interopRequireDefault(_is_function);

  var _is_equal2 = _interopRequireDefault(_is_equal);

  var _of_value2 = _interopRequireDefault(_of_value);

  var _noop2 = _interopRequireDefault(_noop);

  var _log2 = _interopRequireDefault(_log);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  // STATE
  var signalGraph = [];
  var updateQueue = [];
  var updateInProgress = false;

  // Removing duplicates from right->left ensures all of a node's dependencies have
  // been updated before the node is updated.
  function removeDuplicatesWeigthed(graph) {
    var temp = [];
    var i = graph.length - 1;
    for (; i >= 0; i--) {
      if (temp.indexOf(graph[i]) === -1) {
        temp.unshift(graph[i]);
      }
    }
    return temp;
  }

  // Build the initial graph by queuing children breadth first
  function buildRawGraph(sig) {
    var graph = [];
    return function addChildren(next) {
      var len = next._children.length;
      var i;
      for (i = 0; i < len; i++) {
        graph.push(next._children[i]);
      }
      for (i = 0; i < len; i++) {
        addChildren(next._children[i]);
      }
      return graph;
    }(sig);
  }

  function buildSignalGraph(sig) {
    return removeDuplicatesWeigthed(buildRawGraph(sig));
  }

  function finishUpdate() {
    var len = signalGraph.length;
    var sig = null;
    var i;
    for (i = 0; i < len; i++) {
      sig = signalGraph[i];
      sig._updater = null;
      sig._queued = false;
    }
    signalGraph.length = 0;
  }

  function runUpdate() {
    var numberOfNodes = signalGraph.length;
    var node = null;
    var i = 0;
    updateInProgress = true;
    for (i = 0; i < numberOfNodes; i++) {
      node = signalGraph[i];
      if (node._queued) {
        node._update(node);
      }
    }
    finishUpdate();
    updateInProgress = false;
  }

  function markChildren(sig) {
    var len = sig._children.length;
    var child = null;
    var i;
    for (i = 0; i < len; i++) {
      child = sig._children[i];
      child._updater = sig;
      child._queued = true;
    }
  }

  function notInGraph(sig) {
    return signalGraph.indexOf(sig) === -1;
  }

  function scheduleUpdate(sig, val) {
    updateQueue.push({
      signal: sig,
      value: val
    });
  }

  function checkUpdateQueue() {
    var update;
    if (updateQueue.length > 0) {
      update = updateQueue.shift();
      updateValue(update.signal, update.value);
    }
  }

  function updateValue(sig, val) {
    if ((0, _is_promise2.default)(val)) {
      val.then(sig.push);
    } else {
      sig._value = val;
      sig._hasValue = true;
      markChildren(sig);
      if (!updateInProgress) {
        signalGraph = buildSignalGraph(sig);
        runUpdate();
        checkUpdateQueue();
      } else if (notInGraph(sig)) {
        scheduleUpdate(sig, val);
      }
    }
  }

  function toString() {
    return 'Signal(' + this._value + ')';
  }

  /**
   * @name merge
   * @method
   * @memberof Frampton.Signal.Signal#
   * @param {Frampton.Signal.Signal} sig2
   * @returns {Frampton.Signal.Signal}
   */
  function merge(sig2) {
    var sig1 = this;
    return mergeMany([sig1, sig2]);
  }

  /**
   * ap(<*>) :: Signal (a -> b) -> Signal a -> Signal b
   *
   * @name ap
   * @method
   * @memberof Frampton.Signal.Signal#
   * @param {Frampton.Signal.Signal} arg
   * @returns {Frampton.Signal.Signal}
   */
  function ap(arg) {
    var parent = this;
    var initial = parent._hasValue && arg._hasValue ? parent._value(arg._value) : undefined;
    return createSignal(function (self) {
      self.push(parent._value(arg._value));
    }, [parent], initial);
  }

  /**
   * @name sample
   * @method
   * @private
   * @memberof Frampton.Signal.Signal#
   * @param {Frampton.Signal.Signal} tag
   * @returns {Frampton.Signal.Signal}
   */
  function sample(tag) {
    var parent = this;
    return createSignal(function (self) {
      self.push(tag._value);
    }, [parent], tag._value);
  }

  /**
   * @name take
   * @method
   * @private
   * @memberof Frampton.Signal.Signal#
   * @param {Number} limit
   * @returns {Frampton.Signal.Signal}
   */
  function take(limit) {
    var parent = this;
    return createSignal(function (self) {
      if (limit-- > 0) {
        self.push(parent._value);
      } else {
        self.close();
      }
    }, [parent]);
  }

  /**
   * Like reduce on Arrays, this method is used to reduce all values of a Signal down to a
   * single value using the given function.
   *
   * The function recieves arguments in the order of (accumulator, next value). The function
   * returns a new value that will then be the new accumulator for the next interation.
   *
   * @name fold
   * @method
   * @private
   * @memberof Frampton.Signal.Signal#
   * @param {Function} fn
   * @param {Function} initial
   * @returns {Frampton.Signal.Signal}
   */
  function fold(fn, initial) {
    var parent = this;
    return createSignal(function (self) {
      self.push(fn(self._value, parent._value));
    }, [parent], initial);
  }

  /**
   * Return the values of these signals as a tuple
   *
   * @name zip
   * @method
   * @private
   * @memberof Frampton.Signal.Signal#
   * @param {Frampton.Signal.Signal} sig
   * @returns {Frampton.Signal.Signal}
   */
  function zip(sig) {
    var parent = this;
    var initial = [parent._value, sig._value];
    return createSignal(function (self) {
      self.push([parent._value, sig._value]);
    }, [parent], initial);
  }

  /**
   * Remove values from the Signal based on the given predicate function. If a function is not
   * given then filter will use strict equals with the value given to test new values on the
   * Signal.
   *
   * @name filter
   * @method
   * @private
   * @memberof Frampton.Signal.Signal#
   * @param {*} predicate - Usually a function to test values of the Signal
   * @returns {Frampton.Signal.Signal}
   */
  function filter(predicate) {
    var parent = this;
    var filterFn = (0, _is_function2.default)(predicate) ? predicate : (0, _is_equal2.default)(predicate);
    var initial = parent._hasValue && filterFn(parent._value) ? parent._value : undefined;
    return createSignal(function (self) {
      if (filterFn(parent._value)) {
        self.push(parent._value);
      }
    }, [parent], initial);
  }

  /**
   * @name filterPrevious
   * @method
   * @private
   * @memberof Frampton.Signal.Signal#
   * @param {Function} predicate - A binary function to test the previous value against the current
   *                               value to decide if you want to keep the new value.
   * @returns {Frampton.Signal.Signal}
   */
  function filterPrevious(predicate) {
    var parent = this;
    var initial = parent._hasValue ? parent._value : undefined;
    return createSignal(function (self) {
      if (predicate(self._value, parent._value)) {
        self.push(parent._value);
      }
    }, [parent], initial);
  }

  /**
   * @name and
   * @method
   * @private
   * @memberof Frampton.Signal.Signal#
   * @param {Frampton.Signal.Signal} predicate - A Signal that must be truthy for values on this Signal
   *                                             to continue.
   * @returns {Frampton.Signal.Signal}
   */
  function and(predicate) {
    var parent = this;
    var initial = parent._hasValue && predicate._value ? parent._value : undefined;
    return createSignal(function (self) {
      if (predicate._value) {
        self.push(parent._value);
      }
    }, [parent], initial);
  }

  /**
   * @name not
   * @method
   * @private
   * @memberof Frampton.Signal.Signal#
   * @param {Frampton.Signal.Signal} predicate - A Signal that must be falsy for values on this Signal
   *                                             to continue.
   * @returns {Frampton.Signal.Signal}
   */
  function not(predicate) {
    var parent = this;
    var initial = parent._hasValue && !predicate._value ? parent._value : undefined;
    return createSignal(function (self) {
      if (!predicate._value) {
        self.push(parent.value);
      }
    }, [parent], initial);
  }

  /**
   * @name map
   * @method
   * @private
   * @memberof Frampton.Signal.Signal#
   * @param {*} mapping - A function or value to map the signal with. If a function, the value
   *                        on the parent signal will be passed to the function and the signal will
   *                        be mapped to the return value of the function. If a value, the value of
   *                        the parent signal will be replaced with the value.
   * @returns {Frampton.Signal.Signal} A new signal with mapped values
   */
  function map(mapping) {
    var parent = this;
    var mappingFn = (0, _is_function2.default)(mapping) ? mapping : (0, _of_value2.default)(mapping);
    var initial = parent._hasValue ? mappingFn(parent._value) : undefined;
    return createSignal(function (self) {
      self.push(mappingFn(parent._value));
    }, [parent], initial);
  }

  /**
   * @name debounce
   * @method
   * @private
   * @memberof Frampton.Signal.Signal#
   * @param {Number} delay - Milliseconds to debounce the signal
   * @returns {Frampton.Signal.Signal}
   */
  function debounce(delay) {
    var parent = this;
    var timer = null;
    return createSignal(function (self) {
      if (timer) {
        clearTimeout(timer);
      }

      timer = setTimeout(function () {
        self.push(parent._value);
        timer = null;
      }, delay || 10);
    }, [parent], parent._value);
  }

  /**
   * @name throttle
   * @method
   * @private
   * @memberof Frampton.Signal.Signal#
   * @param {Number} delay - Milliseconds to throttle the signal
   * @returns {Frampton.Signal.Signal}
   */
  function throttle(delay) {
    var parent = this;
    var timer = null;
    return createSignal(function (self) {
      if (!timer) {
        timer = setTimeout(function () {
          self.push(parent._value);
          timer = null;
        }, delay || 10);
      }
    }, [parent], parent._value);
  }

  /**
   * @name delay
   * @method
   * @private
   * @memberof Frampton.Signal.Signal#
   * @param {Number} time - Milliseconds to delay values of this Signal.
   * @returns {Frampton.Signal.Signal}
   */
  function delay(time) {
    var parent = this;
    return createSignal(function (self) {
      (function (saved) {
        setTimeout(function () {
          self.push(saved);
        }, time);
      })(parent._value);
    }, [parent], parent._value);
  }

  /**
   * dropRepeats :: Signal a -> Signal a
   *
   * Uses strict equals to drop repeated values from the parent signal.
   *
   * @name dropRepeats
   * @method
   * @memberof Frampton.Signal.Signal#
   * @returns {Frampton.Signal.Signal}
   */
  function dropRepeats() {
    return this.filterPrevious(function (prev, next) {
      return prev !== next;
    });
  }

  /**
   * Calls the given function when this signal updates. This function will call for the first
   * time the next time the Signal updates. If there is a current value on the Signal it is
   * ignored. If you are interested in the current value of the Signal use either the value or
   * changes method.
   *
   * @name next
   * @method
   * @memberof Frampton.Signal.Signal#
   * @param {Function} fn - The function to call
   * @returns {Frampton.Signal.Signal}
   */
  function next(fn) {
    var parent = this;
    return createSignal(function (self) {
      fn(parent._value);
    }, [parent]);
  }

  /**
   * Calls the given function when this Signal has a value. The function is called immediately
   * if this Signal already has a value, then is called again each time this Signal updates.
   *
   * @name value
   * @method
   * @memberof Frampton.Signal.Signal#
   * @param {Function} fn - The function to call
   * @returns {Frampton.Signal.Signal}
   */
  function value(fn) {
    var parent = this;
    var child = createSignal(function (self) {
      fn(parent._value);
    }, [parent], parent._value);

    if (child._hasValue) {
      fn(child._value);
    }

    return child;
  }

  /**
   * Works just like the value method, just repeated values are dropped.
   *
   * @name changes
   * @method
   * @memberof Frampton.Signal.Signal#
   * @param {Function} fn - The function to call
   * @returns {Frampton.Signal.Signal}
   */
  function changes(fn) {
    return this.dropRepeats().value(fn);
  }

  /**
   * Removes the Signal from the Signal graph.
   *
   * @name close
   * @method
   * @memberof Frampton.Signal.Signal#
   */
  function close() {

    var sig = this;

    sig._children.forEach(function (child) {
      child._parents = child._parents.filter(function (parent) {
        return parent._id !== sig._id;
      });
    });

    sig._parents.forEach(function (parent) {
      parent._children = parent._children.filter(function (child) {
        return child._id !== sig._id;
      });
    });

    sig._children.length = 0;
    sig._parents.length = 0;
  }

  /**
   * Logs the values of a given signal to the console.
   *
   * @name logValue
   * @method
   * @memberof Frampton.Signal.Signal#
   * @returns {Frampton.Signal.Signal}
   */
  function logValue(msg) {
    var parent = this;
    return createSignal(function (self) {
      if (msg) {
        (0, _log2.default)(msg, parent._value);
      } else {
        (0, _log2.default)(parent._value);
      }
      self.push(parent._value);
    }, [parent], parent._value);
  }

  /**
   * @name createSignal
   * @memberof Frampton.Signal
   * @method
   * @private
   * @param {function}                 update  - Function to call when this signal updates
   * @param {Frampton.Signal.Signal[]} parents - List of signals this signal depends on
   * @param {*}                        initial - Initial value for this signal
   * @returns {Frampton.Signal.Signal}
   */
  function createSignal(update, parents, initial) {

    var signal = {};

    signal.push = function (val) {
      updateValue(signal, val);
    };

    signal.get = function () {
      return signal._value;
    };

    // Constructor
    signal.ctor = 'Frampton.Signal';

    // Private
    signal._id = (0, _guid2.default)();
    signal._value = initial;
    signal._hasValue = (0, _is_defined2.default)(initial);
    signal._queued = false;
    signal._updater = null;
    signal._parents = parents || [];
    signal._children = [];
    signal._update = update || _noop2.default;

    // Public
    signal.throttle = throttle;
    signal.debounce = debounce;
    signal.delay = delay;
    signal.ap = ap;
    signal.merge = merge;
    signal.zip = zip;
    signal.map = map;
    signal.filter = filter;
    signal.filterPrevious = filterPrevious;
    signal.and = and;
    signal.not = not;
    signal.fold = fold;
    signal.sample = sample;
    signal.take = take;
    signal.dropRepeats = dropRepeats;
    signal.log = logValue;
    signal.next = next;
    signal.value = value;
    signal.changes = changes;
    signal.close = close;
    signal.toString = toString;

    for (var i = 0; i < signal._parents.length; i++) {
      signal._parents[i]._children.push(signal);
    }

    return Object.seal(signal);
  }

  /**
   * @name mergeMany
   * @memberof Frampton.Signal
   * @method
   * @param {Frampton.Signal.Signal[]} parents - Signals to merge
   */
  function mergeMany(parents) {
    var initial = parents.length > 0 ? parents[0]._value : undefined;
    return createSignal(function (self) {
      self.push(self._updater._value);
    }, parents, initial);
  }

  /**
   * Used to create new instances of Frampton.Signal. This should be used instead of calling
   * the Signal constructor directly.
   *
   * @name create
   * @memberof Frampton.Signal
   * @method
   * @param {*} [initial] - Initial value for this signal
   * @returns {Frampton.Signal}
   */
  function create(initial) {
    return createSignal(null, null, initial);
  }
});
define("frampton-signal/forward", ["exports"], function (exports) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = forward;
  /**
   * @name forward
   * @memberof Frampton.Signal
   * @param {Frampton.Signal#} sig
   * @param {Function} mapping
   * @returns {Frampton.Signal#}
   */
  function forward(sig, mapping) {
    return function (val) {
      sig.push(mapping(val));
    };
  }
});
define('frampton-signal/is_signal', ['exports', 'frampton-utils/is_function', 'frampton-utils/is_string'], function (exports, _is_function, _is_string) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = is_signal;

  var _is_function2 = _interopRequireDefault(_is_function);

  var _is_string2 = _interopRequireDefault(_is_string);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function is_signal(obj) {
    return (0, _is_function2.default)(obj) && (0, _is_string2.default)(obj.ctor) && obj.ctor === 'Frampton.Signal';
  }
});
define('frampton-signal/stepper', ['exports', 'frampton-utils/curry', 'frampton-signal/create'], function (exports, _curry, _create) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  var _create2 = _interopRequireDefault(_create);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function (initial, updater) {
    var sig = (0, _create2.default)(initial);
    return sig.merge(updater.dropRepeats());
  });
});
define('frampton-signal/swap', ['exports', 'frampton-utils/curry', 'frampton-signal/stepper'], function (exports, _curry, _stepper) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  var _stepper2 = _interopRequireDefault(_stepper);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function toggle(sig1, sig2) {
    return (0, _stepper2.default)(false, sig1.map(true).merge(sig2.map(false)));
  });
});
define('frampton-signal/toggle', ['exports', 'frampton-utils/assert', 'frampton-utils/curry', 'frampton-utils/is_boolean', 'frampton-signal/create'], function (exports, _assert, _curry, _is_boolean, _create) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _assert2 = _interopRequireDefault(_assert);

  var _curry2 = _interopRequireDefault(_curry);

  var _is_boolean2 = _interopRequireDefault(_is_boolean);

  var _create2 = _interopRequireDefault(_create);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function (initial, updater) {
    (0, _assert2.default)('Frampton.Signal.toggle must be initialized with a Boolean', (0, _is_boolean2.default)(initial));
    var sig = (0, _create2.default)(initial);
    var current = initial;
    return sig.merge(updater.map(function () {
      current = !current;
      return current;
    }));
  });
});
define('frampton-string', ['frampton/namespace', 'frampton-string/capitalize', 'frampton-string/contains', 'frampton-string/dash_to_camel', 'frampton-string/ends_with', 'frampton-string/is_empty', 'frampton-string/join', 'frampton-string/length', 'frampton-string/lines', 'frampton-string/normalize_newline', 'frampton-string/replace', 'frampton-string/split', 'frampton-string/starts_with', 'frampton-string/trim', 'frampton-string/words'], function (_namespace, _capitalize, _contains, _dash_to_camel, _ends_with, _is_empty, _join, _length, _lines, _normalize_newline, _replace, _split, _starts_with, _trim, _words) {
  'use strict';

  var _namespace2 = _interopRequireDefault(_namespace);

  var _capitalize2 = _interopRequireDefault(_capitalize);

  var _contains2 = _interopRequireDefault(_contains);

  var _dash_to_camel2 = _interopRequireDefault(_dash_to_camel);

  var _ends_with2 = _interopRequireDefault(_ends_with);

  var _is_empty2 = _interopRequireDefault(_is_empty);

  var _join2 = _interopRequireDefault(_join);

  var _length2 = _interopRequireDefault(_length);

  var _lines2 = _interopRequireDefault(_lines);

  var _normalize_newline2 = _interopRequireDefault(_normalize_newline);

  var _replace2 = _interopRequireDefault(_replace);

  var _split2 = _interopRequireDefault(_split);

  var _starts_with2 = _interopRequireDefault(_starts_with);

  var _trim2 = _interopRequireDefault(_trim);

  var _words2 = _interopRequireDefault(_words);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * @name String
   * @namespace
   * @memberof Frampton
   */
  _namespace2.default.String = {};
  _namespace2.default.String.capitalize = _capitalize2.default;
  _namespace2.default.String.contains = _contains2.default;
  _namespace2.default.String.dashToCamel = _dash_to_camel2.default;
  _namespace2.default.String.endsWith = _ends_with2.default;
  _namespace2.default.String.isEmpty = _is_empty2.default;
  _namespace2.default.String.join = _join2.default;
  _namespace2.default.String.length = _length2.default;
  _namespace2.default.String.lines = _lines2.default;
  _namespace2.default.String.normalizeNewline = _normalize_newline2.default;
  _namespace2.default.String.replace = _replace2.default;
  _namespace2.default.String.split = _split2.default;
  _namespace2.default.String.startsWith = _starts_with2.default;
  _namespace2.default.String.trim = _trim2.default;
  _namespace2.default.String.words = _words2.default;
});
define("frampton-string/capitalize", ["exports"], function (exports) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = capitalize;
  function capitalize(str) {
    return str.charAt(0).toUpperCase() + str.slice(1);
  }
});
define('frampton-string/contains', ['exports', 'frampton-utils/curry'], function (exports, _curry) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function contains(sub, str) {
    return str.indexOf(sub) > -1;
  });
});
define("frampton-string/dash_to_camel", ["exports"], function (exports) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = dash_to_camel;
  function dash_to_camel(str) {
    return str.replace(/-([a-z])/g, function (m, w) {
      return w.toUpperCase();
    });
  }
});
define('frampton-string/ends_with', ['exports', 'frampton-utils/curry'], function (exports, _curry) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function ends_with(sub, str) {
    return str.length >= sub.length && str.lastIndexOf(sub) === str.length - sub.length;
  });
});
define('frampton-string/is_empty', ['exports'], function (exports) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = is_empty;
  function is_empty(str) {
    return str.trim() === '';
  }
});
define('frampton-string/join', ['exports', 'frampton-utils/curry'], function (exports, _curry) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function join(sep, strs) {
    return strs.join(sep);
  });
});
define('frampton-string/length', ['exports', 'frampton-utils/is_something', 'frampton-utils/is_defined', 'frampton-string/normalize_newline'], function (exports, _is_something, _is_defined, _normalize_newline) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = length;

  var _is_something2 = _interopRequireDefault(_is_something);

  var _is_defined2 = _interopRequireDefault(_is_defined);

  var _normalize_newline2 = _interopRequireDefault(_normalize_newline);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * @name length
   * @memberof Frampton.String
   * @static
   * @param {String}
   * @returns {Number}
   */
  function length(str) {
    return (0, _is_something2.default)(str) && (0, _is_defined2.default)(str.length) ? (0, _normalize_newline2.default)(str).length : 0;
  }
});
define("frampton-string/lines", ["exports"], function (exports) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = lines;
  // lines :: String -> Array String
  function lines(str) {
    return str.split(/\r\n|\r|\n/g);
  }
});
define('frampton-string/normalize_newline', ['exports'], function (exports) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = normalize_newline;
  /**
   * Returns a string with newlines normalized to \n. Windows machines will use
   * \r\n for newlines which can lead to irregularities when dealing with strings
   *
   * @name normalizeNewline
   * @memberof Frampton.String
   * @static
   * @param {String} str
   * @returns {String}
   */
  function normalize_newline(str) {
    return str.replace(/\r\n/g, '\n');
  }
});
define('frampton-string/replace', ['exports', 'frampton-utils/curry'], function (exports, _curry) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function replace(newSubStr, oldSubStr, str) {
    return str.replace(oldSubStr, newSubStr);
  });
});
define('frampton-string/split', ['exports', 'frampton-utils/curry'], function (exports, _curry) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function join(sep, str) {
    return str.split(sep);
  });
});
define('frampton-string/starts_with', ['exports', 'frampton-utils/curry'], function (exports, _curry) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function starts_with(sub, str) {
    return str.indexOf(sub) === 0;
  });
});
define("frampton-string/trim", ["exports"], function (exports) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = trim;
  function trim(str) {
    return str.trim();
  }
});
define("frampton-string/words", ["exports"], function (exports) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = words;
  // words :: String -> Array String
  function words(str) {
    return str.trim().split(/\s+/g);
  }
});
define('frampton-style', ['frampton/namespace', 'frampton-style/add_class', 'frampton-style/apply_styles', 'frampton-style/closest', 'frampton-style/contains', 'frampton-style/current_value', 'frampton-style/has_class', 'frampton-style/matches', 'frampton-style/remove_class', 'frampton-style/remove_style', 'frampton-style/remove_styles', 'frampton-style/selector_contains', 'frampton-style/set_style', 'frampton-style/supported', 'frampton-style/supported_props'], function (_namespace, _add_class, _apply_styles, _closest, _contains, _current_value, _has_class, _matches, _remove_class, _remove_style, _remove_styles, _selector_contains, _set_style, _supported, _supported_props) {
  'use strict';

  var _namespace2 = _interopRequireDefault(_namespace);

  var _add_class2 = _interopRequireDefault(_add_class);

  var _apply_styles2 = _interopRequireDefault(_apply_styles);

  var _closest2 = _interopRequireDefault(_closest);

  var _contains2 = _interopRequireDefault(_contains);

  var _current_value2 = _interopRequireDefault(_current_value);

  var _has_class2 = _interopRequireDefault(_has_class);

  var _matches2 = _interopRequireDefault(_matches);

  var _remove_class2 = _interopRequireDefault(_remove_class);

  var _remove_style2 = _interopRequireDefault(_remove_style);

  var _remove_styles2 = _interopRequireDefault(_remove_styles);

  var _selector_contains2 = _interopRequireDefault(_selector_contains);

  var _set_style2 = _interopRequireDefault(_set_style);

  var _supported2 = _interopRequireDefault(_supported);

  var _supported_props2 = _interopRequireDefault(_supported_props);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * @name Style
   * @namespace
   * @memberof Frampton
   */
  _namespace2.default.Style = {};
  _namespace2.default.Style.addClass = _add_class2.default;
  _namespace2.default.Style.applyStyles = _apply_styles2.default;
  _namespace2.default.Style.closest = _closest2.default;
  _namespace2.default.Style.contains = _contains2.default;
  _namespace2.default.Style.current = _current_value2.default;
  _namespace2.default.Style.hasClass = _has_class2.default;
  _namespace2.default.Style.matches = _matches2.default;
  _namespace2.default.Style.removeClass = _remove_class2.default;
  _namespace2.default.Style.removeStyle = _remove_style2.default;
  _namespace2.default.Style.removeStyles = _remove_styles2.default;
  _namespace2.default.Style.selectorContains = _selector_contains2.default;
  _namespace2.default.Style.setStyle = _set_style2.default;
  _namespace2.default.Style.supported = _supported2.default;
  _namespace2.default.Style.supportedProps = _supported_props2.default;
});
define('frampton-style/add_class', ['exports', 'frampton-utils/curry'], function (exports, _curry) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function add_class(element, name) {
    element.classList.add(name);
  });
});
define('frampton-style/apply_styles', ['exports', 'frampton-utils/curry', 'frampton-utils/is_something', 'frampton-style/remove_style', 'frampton-style/set_style'], function (exports, _curry, _is_something, _remove_style, _set_style) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  var _is_something2 = _interopRequireDefault(_is_something);

  var _remove_style2 = _interopRequireDefault(_remove_style);

  var _set_style2 = _interopRequireDefault(_set_style);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function apply_styles(element, props) {
    for (var key in props) {
      var value = props[key];
      if ((0, _is_something2.default)(value)) {
        (0, _set_style2.default)(element, key, value);
      } else {
        (0, _remove_style2.default)(element, key, value);
      }
    }
  });
});
define('frampton-style/closest', ['exports', 'frampton-utils/curry', 'frampton-style/matches'], function (exports, _curry, _matches) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  var _matches2 = _interopRequireDefault(_matches);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function closest(selector, element) {

    while (element) {
      if ((0, _matches2.default)(selector, element)) {
        break;
      }
      element = element.parentElement;
    }

    return element || null;
  });
});
define('frampton-style/contains', ['exports', 'frampton-utils/curry', 'frampton-style/matches'], function (exports, _curry, _matches) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  var _matches2 = _interopRequireDefault(_matches);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function contains(selector, element) {
    return (0, _matches2.default)(selector, element) || element.querySelectorAll(selector).length > 0;
  });
});
define('frampton-style/current_value', ['exports', 'frampton-utils/curry', 'frampton-style/supported'], function (exports, _curry, _supported) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  var _supported2 = _interopRequireDefault(_supported);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  var style = window.getComputedStyle;

  /**
   * current :: DomNode -> String -> String
   *
   * @name currentValue
   * @method
   * @memberof Frampton.Style
   * @param {Object} element DomNode whose property to check
   * @param {String} prop    Name of property to check
   * @returns {String} String representation of current property value
   */
  exports.default = (0, _curry2.default)(function current_value(element, prop) {
    return style(element).getPropertyValue((0, _supported2.default)(prop));
  });
});
define('frampton-style/has_class', ['exports', 'frampton-utils/curry'], function (exports, _curry) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function has_class(name, element) {
    return element.classList.contains(name);
  });
});
define('frampton-style/matches', ['exports', 'frampton-utils/curry', 'frampton-utils/is_function'], function (exports, _curry, _is_function) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  var _is_function2 = _interopRequireDefault(_is_function);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function matches(selector, element) {

    if ((0, _is_function2.default)(element.matches)) {
      return element.matches(selector);
    } else {
      var elementList = document.querySelectorAll(selector);
      var i = 0;

      while (elementList[i] && elementList[i] !== element) {
        i++;
      }

      return elementList[i] ? true : false;
    }
  });
});
define('frampton-style/remove_class', ['exports', 'frampton-utils/curry'], function (exports, _curry) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function remove_class(element, name) {
    element.classList.remove(name);
  });
});
define('frampton-style/remove_style', ['exports', 'frampton-utils/curry', 'frampton-style/supported'], function (exports, _curry, _supported) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  var _supported2 = _interopRequireDefault(_supported);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function remove_style(element, key) {
    element.style.removeProperty((0, _supported2.default)(key));
  });
});
define('frampton-style/remove_styles', ['exports', 'frampton-utils/curry'], function (exports, _curry) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function remove_styles(element, props) {
    for (var key in props) {
      element.style.removeProperty(key);
    }
  });
});
define('frampton-style/selector_contains', ['exports', 'frampton-utils/curry', 'frampton-html/contains'], function (exports, _curry, _contains) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  var _contains2 = _interopRequireDefault(_contains);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function selector_contains(selector, element) {

    var elementList = document.querySelectorAll(selector);
    var i = 0;

    while (elementList[i] && !(0, _contains2.default)(elementList[i], element)) {
      i++;
    }

    return elementList[i] ? true : false;
  });
});
define('frampton-style/set_style', ['exports', 'frampton-utils/curry', 'frampton-style/supported'], function (exports, _curry, _supported) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  var _supported2 = _interopRequireDefault(_supported);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function set_style(element, key, value) {
    element.style.setProperty((0, _supported2.default)(key), value, '');
  });
});
define('frampton-style/supported', ['exports', 'frampton-utils/memoize', 'frampton-style/supported_by_element'], function (exports, _memoize, _supported_by_element) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _memoize2 = _interopRequireDefault(_memoize);

  var _supported_by_element2 = _interopRequireDefault(_supported_by_element);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _memoize2.default)((0, _supported_by_element2.default)(document.createElement('div')));
});
define('frampton-style/supported_by_element', ['exports', 'frampton-utils/curry', 'frampton-utils/is_something', 'frampton-string/capitalize', 'frampton-string/dash_to_camel'], function (exports, _curry, _is_something, _capitalize, _dash_to_camel) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  var _is_something2 = _interopRequireDefault(_is_something);

  var _capitalize2 = _interopRequireDefault(_capitalize);

  var _dash_to_camel2 = _interopRequireDefault(_dash_to_camel);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  var vendors = {
    'webkit': 'webkit',
    'Webkit': 'webkit',
    'Moz': 'moz',
    'ms': 'ms',
    'Ms': 'ms'
  };

  /**
   * @name supportedByElement
   * @method
   * @memberof Frampton.Style
   * @param {Object} element
   * @param {String} prop
   * @returns {String}
   */
  exports.default = (0, _curry2.default)(function supported_by_element(element, prop) {

    var camelProp = (0, _dash_to_camel2.default)(prop);

    if ((0, _is_something2.default)(element.style[camelProp])) {
      return prop;
    }

    for (var key in vendors) {
      var propToCheck = key + (0, _capitalize2.default)(camelProp);
      if ((0, _is_something2.default)(element.style[propToCheck])) {
        return ('-' + vendors[key] + '-' + prop).toLowerCase();
      }
    }

    return null;
  });
});
define('frampton-style/supported_props', ['exports', 'frampton-utils/warn', 'frampton-style/supported'], function (exports, _warn, _supported) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = supported_props;

  var _warn2 = _interopRequireDefault(_warn);

  var _supported2 = _interopRequireDefault(_supported);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * @name supportedProps
   * @method
   * @memberof Frampton.Style
   * @param {Object} props
   * @returns {Object}
   */
  function supported_props(props) {
    var obj = {};
    var temp;
    for (var key in props) {
      temp = (0, _supported2.default)(key);
      if (temp) {
        obj[(0, _supported2.default)(key)] = props[key];
      } else {
        (0, _warn2.default)('style prop ' + key + ' is not supported by this browser');
      }
    }
    return obj;
  }
});
define('frampton-utils', ['frampton/namespace', 'frampton-utils/always', 'frampton-utils/apply', 'frampton-utils/assert', 'frampton-utils/compose', 'frampton-utils/curry', 'frampton-utils/curry_n', 'frampton-utils/equal', 'frampton-utils/error', 'frampton-utils/extend', 'frampton-utils/flip_args', 'frampton-utils/has_length', 'frampton-utils/has_prop', 'frampton-utils/identity', 'frampton-utils/immediate', 'frampton-utils/is_array', 'frampton-utils/is_boolean', 'frampton-utils/is_defined', 'frampton-utils/is_empty', 'frampton-utils/is_equal', 'frampton-utils/is_false', 'frampton-utils/is_function', 'frampton-utils/is_node', 'frampton-utils/is_nothing', 'frampton-utils/is_null', 'frampton-utils/is_number', 'frampton-utils/is_numeric', 'frampton-utils/is_object', 'frampton-utils/is_primitive', 'frampton-utils/is_promise', 'frampton-utils/is_something', 'frampton-utils/is_string', 'frampton-utils/is_true', 'frampton-utils/is_undefined', 'frampton-utils/is_value', 'frampton-utils/lazy', 'frampton-utils/log', 'frampton-utils/memoize', 'frampton-utils/noop', 'frampton-utils/not', 'frampton-utils/of_value', 'frampton-utils/once', 'frampton-utils/warn'], function (_namespace, _always, _apply, _assert, _compose, _curry, _curry_n, _equal, _error, _extend, _flip_args, _has_length, _has_prop, _identity, _immediate, _is_array, _is_boolean, _is_defined, _is_empty, _is_equal, _is_false, _is_function, _is_node, _is_nothing, _is_null, _is_number, _is_numeric, _is_object, _is_primitive, _is_promise, _is_something, _is_string, _is_true, _is_undefined, _is_value, _lazy, _log, _memoize, _noop, _not, _of_value, _once, _warn) {
  'use strict';

  var _namespace2 = _interopRequireDefault(_namespace);

  var _always2 = _interopRequireDefault(_always);

  var _apply2 = _interopRequireDefault(_apply);

  var _assert2 = _interopRequireDefault(_assert);

  var _compose2 = _interopRequireDefault(_compose);

  var _curry2 = _interopRequireDefault(_curry);

  var _curry_n2 = _interopRequireDefault(_curry_n);

  var _equal2 = _interopRequireDefault(_equal);

  var _error2 = _interopRequireDefault(_error);

  var _extend2 = _interopRequireDefault(_extend);

  var _flip_args2 = _interopRequireDefault(_flip_args);

  var _has_length2 = _interopRequireDefault(_has_length);

  var _has_prop2 = _interopRequireDefault(_has_prop);

  var _identity2 = _interopRequireDefault(_identity);

  var _immediate2 = _interopRequireDefault(_immediate);

  var _is_array2 = _interopRequireDefault(_is_array);

  var _is_boolean2 = _interopRequireDefault(_is_boolean);

  var _is_defined2 = _interopRequireDefault(_is_defined);

  var _is_empty2 = _interopRequireDefault(_is_empty);

  var _is_equal2 = _interopRequireDefault(_is_equal);

  var _is_false2 = _interopRequireDefault(_is_false);

  var _is_function2 = _interopRequireDefault(_is_function);

  var _is_node2 = _interopRequireDefault(_is_node);

  var _is_nothing2 = _interopRequireDefault(_is_nothing);

  var _is_null2 = _interopRequireDefault(_is_null);

  var _is_number2 = _interopRequireDefault(_is_number);

  var _is_numeric2 = _interopRequireDefault(_is_numeric);

  var _is_object2 = _interopRequireDefault(_is_object);

  var _is_primitive2 = _interopRequireDefault(_is_primitive);

  var _is_promise2 = _interopRequireDefault(_is_promise);

  var _is_something2 = _interopRequireDefault(_is_something);

  var _is_string2 = _interopRequireDefault(_is_string);

  var _is_true2 = _interopRequireDefault(_is_true);

  var _is_undefined2 = _interopRequireDefault(_is_undefined);

  var _is_value2 = _interopRequireDefault(_is_value);

  var _lazy2 = _interopRequireDefault(_lazy);

  var _log2 = _interopRequireDefault(_log);

  var _memoize2 = _interopRequireDefault(_memoize);

  var _noop2 = _interopRequireDefault(_noop);

  var _not2 = _interopRequireDefault(_not);

  var _of_value2 = _interopRequireDefault(_of_value);

  var _once2 = _interopRequireDefault(_once);

  var _warn2 = _interopRequireDefault(_warn);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * @name Utils
   * @namespace
   * @memberof Frampton
   */
  _namespace2.default.Utils = {};
  _namespace2.default.Utils.always = _always2.default;
  _namespace2.default.Utils.apply = _apply2.default;
  _namespace2.default.Utils.assert = _assert2.default;
  _namespace2.default.Utils.compose = _compose2.default;
  _namespace2.default.Utils.curry = _curry2.default;
  _namespace2.default.Utils.curryN = _curry_n2.default;
  _namespace2.default.Utils.equal = _equal2.default;
  _namespace2.default.Utils.error = _error2.default;
  _namespace2.default.Utils.extend = _extend2.default;
  _namespace2.default.Utils.flip = _flip_args2.default;
  _namespace2.default.Utils.hasLength = _has_length2.default;
  _namespace2.default.Utils.hasProp = _has_prop2.default;
  _namespace2.default.Utils.identity = _identity2.default;
  _namespace2.default.Utils.immediate = _immediate2.default;
  _namespace2.default.Utils.isArray = _is_array2.default;
  _namespace2.default.Utils.isBoolean = _is_boolean2.default;
  _namespace2.default.Utils.isDefined = _is_defined2.default;
  _namespace2.default.Utils.isEmpty = _is_empty2.default;
  _namespace2.default.Utils.isEqual = _is_equal2.default;
  _namespace2.default.Utils.isFalse = _is_false2.default;
  _namespace2.default.Utils.isFunction = _is_function2.default;
  _namespace2.default.Utils.isNode = _is_node2.default;
  _namespace2.default.Utils.isNothing = _is_nothing2.default;
  _namespace2.default.Utils.isNull = _is_null2.default;
  _namespace2.default.Utils.isNumber = _is_number2.default;
  _namespace2.default.Utils.isNumeric = _is_numeric2.default;
  _namespace2.default.Utils.isObject = _is_object2.default;
  _namespace2.default.Utils.isPrimitive = _is_primitive2.default;
  _namespace2.default.Utils.isPromise = _is_promise2.default;
  _namespace2.default.Utils.isSomething = _is_something2.default;
  _namespace2.default.Utils.isString = _is_string2.default;
  _namespace2.default.Utils.isTrue = _is_true2.default;
  _namespace2.default.Utils.isUndefined = _is_undefined2.default;
  _namespace2.default.Utils.isValue = _is_value2.default;
  _namespace2.default.Utils.lazy = _lazy2.default;
  _namespace2.default.Utils.log = _log2.default;
  _namespace2.default.Utils.memoize = _memoize2.default;
  _namespace2.default.Utils.noop = _noop2.default;
  _namespace2.default.Utils.not = _not2.default;
  _namespace2.default.Utils.ofValue = _of_value2.default;
  _namespace2.default.Utils.once = _once2.default;
  _namespace2.default.Utils.warn = _warn2.default;
});
define('frampton-utils/always', ['exports', 'frampton-utils/curry_n'], function (exports, _curry_n) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry_n2 = _interopRequireDefault(_curry_n);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry_n2.default)(2, function always(fn) {
    for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
      args[_key - 1] = arguments[_key];
    }

    var value;
    return function () {
      if (value === undefined) {
        value = fn.apply(undefined, args);
      }
      return value;
    };
  });
});
define("frampton-utils/apply", ["exports"], function (exports) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = apply;
  /**
   * Takes a function and warps it to be called at a later time.
   *
   * @name apply
   * @method
   * @memberof Frampton.Utils
   * @param {Function} fn      The function to wrap.
   * @param {Object}   thisArg Context in which to apply function.
   */
  function apply(fn) {
    return fn.call(null);
  }
});
define('frampton-utils/assert', ['exports', 'frampton/namespace'], function (exports, _namespace) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = assert;

  var _namespace2 = _interopRequireDefault(_namespace);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * Occassionally we need to blow things up if something isn't right.
   *
   * @name assert
   * @method
   * @memberof Frampton.Utils
   * @param {String} msg  - Message to throw with error.
   * @param {Boolean} cond - A condition that evaluates to a Boolean. If false, an error is thrown.
   */
  function assert(msg, cond) {
    if (!_namespace2.default.isProd() && !cond) {
      throw new Error(msg || 'An error occured'); // Boom!
    }
  }
});
define('frampton-utils/compose', ['exports', 'frampton-utils/assert', 'frampton-list/foldr', 'frampton-list/first'], function (exports, _assert, _foldr, _first) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = compose;

  var _assert2 = _interopRequireDefault(_assert);

  var _foldr2 = _interopRequireDefault(_foldr);

  var _first2 = _interopRequireDefault(_first);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function _toConsumableArray(arr) {
    if (Array.isArray(arr)) {
      for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {
        arr2[i] = arr[i];
      }

      return arr2;
    } else {
      return Array.from(arr);
    }
  }

  /**
   * Compose takes any number of functions and returns a function that when
   * executed will call the passed functions in order, passing the return of
   * each function to the next function in the execution order.
   *
   * @name compose
   * @memberof Frampton.Utils
   * @method
   * @param {function} functions - Any number of function used to build the composition.
   * @returns {function} A new function that runs each of the given functions in succession
   */
  function compose() {
    for (var _len = arguments.length, fns = Array(_len), _key = 0; _key < _len; _key++) {
      fns[_key] = arguments[_key];
    }

    (0, _assert2.default)("Compose did not receive any arguments. You can't compose nothing.", fns.length > 0);
    return function composition() {
      for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
        args[_key2] = arguments[_key2];
      }

      return (0, _first2.default)((0, _foldr2.default)(function (args, fn) {
        return [fn.apply(undefined, _toConsumableArray(args))];
      }, args, fns));
    };
  }
});
define('frampton-utils/curry', ['exports', 'frampton-utils/curry_n'], function (exports, _curry_n) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = curry;

  var _curry_n2 = _interopRequireDefault(_curry_n);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * Takes a function and returns a new function that will wait to execute the original
   * function until it has received all of its arguments. Each time the function is called
   * without receiving all of its arguments it will return a new function waiting for the
   * remaining arguments.
   *
   * @name curry
   * @memberof Frampton.Utils
   * @method
   * @param {Function} curry - Function to curry.
   * @returns {Function} A curried version of the function passed in.
   */
  function curry(fn) {
    return (0, _curry_n2.default)(fn.length, fn);
  }
});
define('frampton-utils/curry_n', ['exports', 'frampton-utils/assert', 'frampton-utils/is_function'], function (exports, _assert, _is_function) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = curry_n;

  var _assert2 = _interopRequireDefault(_assert);

  var _is_function2 = _interopRequireDefault(_is_function);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function _toConsumableArray(arr) {
    if (Array.isArray(arr)) {
      for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {
        arr2[i] = arr[i];
      }

      return arr2;
    } else {
      return Array.from(arr);
    }
  }

  /**
   * Takes a function and returns a new function that will wait to execute the original
   * function until it has received all of its arguments. Each time the function is called
   * without receiving all of its arguments it will return a new function waiting for the
   * remaining arguments.
   *
   * @name curryN
   * @memberof Frampton.Utils
   * @method
   * @param {Number} arity - Number of arguments for function
   * @param {Function} fn - Function to curry.
   * @returns {Function} A curried version of the function passed in.
   */
  function curry_n(arity, fn) {
    for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
      args[_key - 2] = arguments[_key];
    }

    (0, _assert2.default)('Argument passed to curry is not a function', (0, _is_function2.default)(fn));

    return function curried() {
      for (var _len2 = arguments.length, args2 = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
        args2[_key2] = arguments[_key2];
      }

      // an array of arguments for this instance of the curried function
      var locals = args.concat(args2);

      // If we have all the arguments, apply the function and return result
      if (locals.length >= arity) {
        return fn.apply(undefined, _toConsumableArray(locals));

        // If we don't have all the arguments, return a new function that awaits remaining arguments
      } else {
        return curry_n.apply(null, [arity, fn].concat(locals));
      }
    };
  }
});
define('frampton-utils/equal', ['exports', 'frampton-utils/is_object', 'frampton-utils/is_array'], function (exports, _is_object, _is_array) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = deep_equal;

  var _is_object2 = _interopRequireDefault(_is_object);

  var _is_array2 = _interopRequireDefault(_is_array);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * equal :: Object -> Object -> Boolean
   *
   * @name equal
   * @memberof Frampton.Utils
   * @method
   * @param {*} obj1
   * @param {*} obj2
   * @returns {Boolean}
   */
  function deep_equal(obj1, obj2) {

    var depth = 0;
    var original1 = obj1;
    var original2 = obj2;

    function _equal(obj1, obj2) {

      depth++;

      if (
      // If we're dealing with a circular reference, return reference equality.
      !(depth > 1 && original1 === obj1 && original2 === obj2) && ((0, _is_object2.default)(obj1) || (0, _is_array2.default)(obj1)) && ((0, _is_object2.default)(obj2) || (0, _is_array2.default)(obj2))) {

        for (var key in obj1) {
          if (!obj2 || !_equal(obj1[key], obj2[key])) {
            return false;
          }
        }

        return true;
      } else {
        return obj1 === obj2;
      }
    }

    return _equal(obj1, obj2);
  }
});
define('frampton-utils/error', ['exports', 'frampton/namespace', 'frampton-utils/is_something'], function (exports, _namespace, _is_something) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = error;

  var _namespace2 = _interopRequireDefault(_namespace);

  var _is_something2 = _interopRequireDefault(_is_something);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function error(msg, data) {

    if (_namespace2.default.isDev()) {

      if ((0, _is_something2.default)(console.error)) {
        if ((0, _is_something2.default)(data)) {
          console.error(msg, data);
        } else {
          console.error(msg);
        }
      } else if ((0, _is_something2.default)(console.log)) {
        if ((0, _is_something2.default)(data)) {
          console.log('Error: ' + msg, data);
        } else {
          console.log('Error: ' + msg);
        }
      }
    }

    return msg;
  }
});
define('frampton-utils/extend', ['exports', 'frampton-list/foldl'], function (exports, _foldl) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = extend;

  var _foldl2 = _interopRequireDefault(_foldl);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * Extends one object with one or more other objects
   *
   * @name extend
   * @memberof Frampton.Utils
   * @method
   * @param {Object} base
   * @param {Object} args
   * @returns {Object}
   */
  function extend(base) {
    for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
      args[_key - 1] = arguments[_key];
    }

    return (0, _foldl2.default)(function (acc, next) {
      for (var key in next) {
        if (next.hasOwnProperty(key)) {
          acc[key] = next[key];
        }
      }
      return acc;
    }, base, args);
  }
});
define("frampton-utils/flip_args", ["exports"], function (exports) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = flip_args;
  function flip_args(fn) {
    return function flipped(a, b) {
      return fn(b, a);
    };
  }
});
define('frampton-utils/guid', ['exports'], function (exports) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = guid;
  var id = 0;

  function guid() {
    id += 1;
    return 'fr-id-' + id;
  }
});
define('frampton-utils/has_length', ['exports', 'frampton-utils/curry'], function (exports, _curry) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function has_length(len, obj) {
    return obj && obj.length && obj.length >= len ? true : false;
  });
});
define('frampton-utils/has_prop', ['exports', 'frampton-utils/curry', 'frampton-object/get', 'frampton-utils/is_something'], function (exports, _curry, _get, _is_something) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  var _get2 = _interopRequireDefault(_get);

  var _is_something2 = _interopRequireDefault(_is_something);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function has_prop(prop, obj) {
    return (0, _is_something2.default)((0, _get2.default)(prop, obj));
  });
});
define("frampton-utils/identity", ["exports"], function (exports) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = identity;
  /**
   * identity :: a -> a
   *
   * @name identity
   * @method
   * @memberof Frampton.Utils
   * @param {*} x
   * @returns {*}
   */
  function identity(x) {
    return x;
  }
});
define("frampton-utils/immediate", ["exports"], function (exports) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = immediate;
  /**
   * immediate :: Function -> ()
   *
   * @name immediate
   * @method
   * @memberof Frampton.Utils
   * @param {Function} fn
   * @param {Object}   [context]
   */
  function immediate(fn, context) {
    setTimeout(fn.bind(context || null), 0);
  }
});
define("frampton-utils/is_array", ["exports"], function (exports) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = is_array;
  /**
   * Returns a boolean telling us if a given object is an array
   *
   * @name isArray
   * @method
   * @memberof Frampton.Utils
   * @param {Object} arr
   * @returns {Boolean}
   */
  function is_array(arr) {
    return Array.isArray ? Array.isArray(arr) : Object.prototype.toString.call(arr) === "[object Array]";
  }
});
define('frampton-utils/is_boolean', ['exports'], function (exports) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = is_boolean;
  /**
   * Returns a boolean telling us if a given value is a boolean
   *
   * @name isBoolean
   * @method
   * @memberof Frampton.Utils
   * @param {*} obj
   * @returns {Boolean}
   */
  function is_boolean(obj) {
    return typeof obj === 'boolean';
  }
});
define('frampton-utils/is_defined', ['exports', 'frampton-utils/is_undefined'], function (exports, _is_undefined) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = is_defined;

  var _is_undefined2 = _interopRequireDefault(_is_undefined);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * Returns a boolean telling us if a given value is defined
   *
   * @name isDefined
   * @method
   * @memberof Frampton.Utils
   * @param {*} obj
   * @returns {Boolean}
   */
  function is_defined(obj) {
    return !(0, _is_undefined2.default)(obj);
  }
});
define('frampton-utils/is_empty', ['exports', 'frampton-utils/is_nothing'], function (exports, _is_nothing) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = is_empty;

  var _is_nothing2 = _interopRequireDefault(_is_nothing);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * Returns a boolean telling us if a given value doesn't exist or has length 0
   *
   * @name isEmpty
   * @method
   * @memberof Frampton.Utils
   * @param {*} obj
   * @returns {Boolean}
   */
  function is_empty(obj) {
    return (0, _is_nothing2.default)(obj) || !obj.length || 0 === obj.length;
  }
});
define('frampton-utils/is_equal', ['exports', 'frampton-utils/curry'], function (exports, _curry) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function is_equal(a, b) {
    return a === b;
  });
});
define("frampton-utils/is_false", ["exports"], function (exports) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = is_false;
  /**
   * isFalse :: a -> Boolean
   *
   * @name isFalse
   * @method
   * @memberof Frampton.Utils
   * @param {*} obj
   * @returns {Boolean}
   */
  function is_false(obj) {
    return obj === false;
  }
});
define('frampton-utils/is_function', ['exports'], function (exports) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = is_function;
  /**
   * Returns true/false is the object a fucntion
   *
   * @name isFunction
   * @method
   * @memberof Frampton.Utils
   * @param {*} fn
   * @returns {Boolean}
   */
  function is_function(fn) {
    return typeof fn === 'function';
  }
});
define('frampton-utils/is_node', ['exports', 'frampton-utils/is_something', 'frampton-utils/is_object', 'frampton-utils/is_defined'], function (exports, _is_something, _is_object, _is_defined) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = is_node;

  var _is_something2 = _interopRequireDefault(_is_something);

  var _is_object2 = _interopRequireDefault(_is_object);

  var _is_defined2 = _interopRequireDefault(_is_defined);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * Returns true/false is the object a DomNode
   *
   * @name isNode
   * @method
   * @memberof Frampton.Utils
   * @param {*} obj
   * @returns {Boolean}
   */
  function is_node(obj) {
    return (0, _is_something2.default)(obj) && (0, _is_object2.default)(obj) && (0, _is_defined2.default)(obj.nodeType) && (0, _is_defined2.default)(obj.nodeName);
  }
});
define('frampton-utils/is_nothing', ['exports', 'frampton-utils/is_undefined', 'frampton-utils/is_null'], function (exports, _is_undefined, _is_null) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = is_nothing;

  var _is_undefined2 = _interopRequireDefault(_is_undefined);

  var _is_null2 = _interopRequireDefault(_is_null);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * Returns true/false is the object null or undefined
   *
   * @name isNothing
   * @method
   * @memberof Frampton.Utils
   * @param {*} obj
   * @returns {Boolean}
   */
  function is_nothing(obj) {
    return (0, _is_undefined2.default)(obj) || (0, _is_null2.default)(obj);
  }
});
define("frampton-utils/is_null", ["exports"], function (exports) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = is_null;
  /**
   * Returns true/false is the object null
   *
   * @name isNull
   * @method
   * @memberof Frampton.Utils
   * @param {*} obj
   * @returns {Boolean}
   */
  function is_null(obj) {
    return obj === null;
  }
});
define('frampton-utils/is_number', ['exports'], function (exports) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = is_number;
  /**
   * Returns true/false is the object a number
   *
   * @name isNumber
   * @method
   * @memberof Frampton.Utils
   * @param {*} obj
   * @returns {Boolean}
   */
  function is_number(obj) {
    return typeof obj === 'number';
  }
});
define("frampton-utils/is_numeric", ["exports"], function (exports) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = is_numeric;
  function is_numeric(val) {
    return !isNaN(val);
  }
});
define('frampton-utils/is_object', ['exports', 'frampton-utils/is_something', 'frampton-utils/is_array'], function (exports, _is_something, _is_array) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = isObject;

  var _is_something2 = _interopRequireDefault(_is_something);

  var _is_array2 = _interopRequireDefault(_is_array);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
    return typeof obj;
  } : function (obj) {
    return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
  };

  /**
   * Returns true/false is the object a regular Object
   *
   * @name isObject
   * @method
   * @memberof Frampton.Utils
   * @param {*} obj
   * @returns {Boolean}
   */
  function isObject(obj) {
    return (0, _is_something2.default)(obj) && !(0, _is_array2.default)(obj) && (typeof obj === 'undefined' ? 'undefined' : _typeof(obj)) === 'object';
  }
});
define('frampton-utils/is_primitive', ['exports', 'frampton-utils/is_number', 'frampton-utils/is_boolean', 'frampton-utils/is_string'], function (exports, _is_number, _is_boolean, _is_string) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = is_primitive;

  var _is_number2 = _interopRequireDefault(_is_number);

  var _is_boolean2 = _interopRequireDefault(_is_boolean);

  var _is_string2 = _interopRequireDefault(_is_string);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * Returns true/false is the value a primitive value
   *
   * @name isPrimitive
   * @method
   * @memberof Frampton.Utils
   * @param {*} obj
   * @returns {Boolean}
   */
  function is_primitive(obj) {
    return (0, _is_number2.default)(obj) || (0, _is_boolean2.default)(obj) || (0, _is_string2.default)(obj);
  }
});
define('frampton-utils/is_promise', ['exports', 'frampton-utils/is_object', 'frampton-utils/is_function'], function (exports, _is_object, _is_function) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = is_promise;

  var _is_object2 = _interopRequireDefault(_is_object);

  var _is_function2 = _interopRequireDefault(_is_function);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * Returns true/false indicating if object appears to be a Promise
   *
   * @name isPromise
   * @method
   * @memberof Frampton.Utils
   * @param {*} obj
   * @returns {Boolean}
   */
  function is_promise(obj) {
    return (0, _is_object2.default)(obj) && (0, _is_function2.default)(obj.then);
  }
});
define('frampton-utils/is_something', ['exports', 'frampton-utils/is_nothing'], function (exports, _is_nothing) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = is_something;

  var _is_nothing2 = _interopRequireDefault(_is_nothing);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * Returns true/false indicating if object is not null or undefined
   *
   * @name isSomething
   * @method
   * @memberof Frampton.Utils
   * @param {*} obj
   * @returns {Boolean}
   */
  function is_something(obj) {
    return !(0, _is_nothing2.default)(obj);
  }
});
define('frampton-utils/is_string', ['exports'], function (exports) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = is_string;
  /**
   * Returns true/false indicating if object is a String
   *
   * @name isString
   * @method
   * @memberof Frampton.Utils
   * @param {*} obj
   * @returns {Boolean}
   */
  function is_string(obj) {
    return typeof obj === 'string';
  }
});
define("frampton-utils/is_true", ["exports"], function (exports) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = is_true;
  /**
   * isTrue :: a -> Boolean
   *
   * @name isTrue
   * @method
   * @memberof Frampton.Utils
   * @param {*} obj
   * @returns {Boolean}
   */
  function is_true(obj) {
    return obj === true;
  }
});
define('frampton-utils/is_undefined', ['exports'], function (exports) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = is_undefined;
  /**
   * Returns true/false indicating if object is undefined
   *
   * @name isUndefined
   * @method
   * @memberof Frampton.Utils
   * @param {*} obj
   * @returns {Boolean}
   */
  function is_undefined(obj) {
    return typeof obj === 'undefined';
  }
});
define("frampton-utils/is_value", ["exports"], function (exports) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = is_value;
  function is_value(test) {
    return function (val) {
      return val === test;
    };
  }
});
define('frampton-utils/lazy', ['exports', 'frampton-utils/curry_n'], function (exports, _curry_n) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry_n2 = _interopRequireDefault(_curry_n);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry_n2.default)(2, function lazy(fn, args) {
    return function () {
      return fn.apply(null, args);
    };
  });
});
define('frampton-utils/log', ['exports', 'frampton/namespace', 'frampton-utils/is_something'], function (exports, _namespace, _is_something) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = log;

  var _namespace2 = _interopRequireDefault(_namespace);

  var _is_something2 = _interopRequireDefault(_is_something);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function log(msg, data) {

    if (_namespace2.default.isDev() && (0, _is_something2.default)(console.log)) {
      if ((0, _is_something2.default)(data)) {
        console.log(msg, data);
      } else {
        console.log(msg);
      }
    }

    return msg;
  }
});
define('frampton-utils/map', ['exports', 'frampton-utils/curry_n'], function (exports, _curry_n) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry_n2 = _interopRequireDefault(_curry_n);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry_n2.default)(2, function (fn, xs) {
    return xs.map(fn);
  });
});
define('frampton-utils/memoize', ['exports', 'frampton-utils/is_string', 'frampton-utils/is_number'], function (exports, _is_string, _is_number) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = memoize;

  var _is_string2 = _interopRequireDefault(_is_string);

  var _is_number2 = _interopRequireDefault(_is_number);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * @name memoize
   * @method
   * @memberof Frampton.Utils
   * @param {Function} fn
   * @returns {Function}
   */
  function memoize(fn) {

    var store = {};
    var len = fn.length;

    return function () {
      for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      var key = len === 1 && ((0, _is_string2.default)(args[0]) || (0, _is_number2.default)(args[0])) ? args[0] : JSON.stringify(args);

      if (key in store) {
        return store[key];
      } else {
        return store[key] = fn.apply(undefined, args);
      }
    };
  }
});
define("frampton-utils/noop", ["exports"], function (exports) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = noop;
  /**
   * @name noop
   * @method
   * @memberof Frampton.Utils
   */
  function noop() {}
});
define('frampton-utils/not', ['exports', 'frampton-utils/curry_n', 'frampton-utils/to_boolean'], function (exports, _curry_n, _to_boolean) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry_n2 = _interopRequireDefault(_curry_n);

  var _to_boolean2 = _interopRequireDefault(_to_boolean);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry_n2.default)(2, function (fn, arg) {
    return !(0, _to_boolean2.default)(fn(arg));
  });
});
define('frampton-utils/not_implemented', ['exports'], function (exports) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  exports.default = function () {
    throw new Error('This method has not been implemented');
  };
});
define("frampton-utils/of_value", ["exports"], function (exports) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = of_value;
  /**
   * Creates a function that always returns the specified value.
   *
   * @name ofValue
   * @method
   * @memberof Frampton.Utils
   * @param {*} value
   * @returns {Function}
   */
  function of_value(value) {
    return function () {
      return value;
    };
  }
});
define('frampton-utils/once', ['exports', 'frampton-utils/warn'], function (exports, _warn) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = once;

  var _warn2 = _interopRequireDefault(_warn);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * Create a function that can only be called once.
   *
   * @name once
   * @method
   * @memberof Frampton.Utils
   * @param {Function} fn
   * @returns {Function}
   */
  function once(fn) {
    var called = false;
    return function () {
      if (called === false) {
        called = true;
        return fn.apply(undefined, arguments);
      } else {
        (0, _warn2.default)('Once function called multiple times');
      }
    };
  }
});
define("frampton-utils/to_boolean", ["exports"], function (exports) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  exports.default = function (val) {
    return !!val;
  };
});
define('frampton-utils/warn', ['exports', 'frampton/namespace', 'frampton-utils/is_something'], function (exports, _namespace, _is_something) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = warn;

  var _namespace2 = _interopRequireDefault(_namespace);

  var _is_something2 = _interopRequireDefault(_is_something);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function warn(msg, data) {

    if (_namespace2.default.isDev()) {

      if ((0, _is_something2.default)(console.warn)) {
        if ((0, _is_something2.default)(data)) {
          console.warn(msg, data);
        } else {
          console.warn(msg);
        }
      } else if ((0, _is_something2.default)(console.log)) {
        if ((0, _is_something2.default)(data)) {
          console.log(msg, data);
        } else {
          console.log(msg);
        }
      }
    }

    return msg;
  }
});
define('frampton', ['exports', 'frampton/namespace', 'frampton-utils', 'frampton-list', 'frampton-object', 'frampton-string', 'frampton-math', 'frampton-events', 'frampton-data', 'frampton-signal', 'frampton-html', 'frampton-style'], function (exports, _namespace) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _namespace2 = _interopRequireDefault(_namespace);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = _namespace2.default;
});
define('frampton/namespace', ['exports'], function (exports) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  /*globals Frampton:true */

  /**
   * The parent namespace for everything else in Frampton
   *
   * @name Frampton
   * @namespace
   */
  Frampton.VERSION = '0.3.6';

  Frampton.TEST = 'test';

  Frampton.DEV = 'dev';

  Frampton.PROD = 'prod';

  if (typeof Frampton.ENV === 'undefined') {
    Frampton.ENV = {};
  }

  if (typeof Frampton.ENV.MODE === 'undefined') {
    Frampton.ENV.MODE = Frampton.PROD;
  }

  if (typeof Frampton.ENV.MOCK === 'undefined') {
    Frampton.ENV.MOCK = {};
  }

  Frampton.mock = function (key) {
    return Frampton.ENV.MOCK && Frampton.ENV.MOCK[key] ? Frampton.ENV.MOCK[key] : null;
  };

  Frampton.isDev = function () {
    return Frampton.ENV.MODE === Frampton.DEV;
  };

  Frampton.isTest = function () {
    return Frampton.ENV.MODE === Frampton.TEST;
  };

  Frampton.isProd = function () {
    return Frampton.ENV.MODE === Frampton.PROD;
  };

  exports.default = Frampton;
});
require("frampton");
})();

(function() {
/*globals Frampton:true */
var define, require;
var global = this;

(function() {

  if (typeof Frampton === 'undefined') {
    throw new Error('Frampton is undefined');
  }

  define = Frampton.__loader.define;
  require = Frampton.__loader.require;

}());

define('frampton-dom', ['frampton/namespace', 'frampton-dom/diff', 'frampton-dom/update', 'frampton-dom/scene', 'frampton-dom/map', 'frampton-dom/html/dom'], function (_namespace, _diff, _update, _scene, _map, _dom) {
  'use strict';

  var _namespace2 = _interopRequireDefault(_namespace);

  var _diff2 = _interopRequireDefault(_diff);

  var _update2 = _interopRequireDefault(_update);

  var _scene2 = _interopRequireDefault(_scene);

  var _map2 = _interopRequireDefault(_map);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * @name DOM
   * @namespace
   * @memberof Frampton
   */
  _namespace2.default.DOM = {};
  _namespace2.default.DOM.VERSION = '0.1.8';
  _namespace2.default.DOM.diff = _diff2.default;
  _namespace2.default.DOM.update = _update2.default;
  _namespace2.default.DOM.scene = _scene2.default;
  _namespace2.default.DOM.map = _map2.default;

  /**
   * @name Html
   * @namespace
   * @memberof Frampton.DOM
   */
  _namespace2.default.DOM.Html = {};
  // PRIMITIVES
  _namespace2.default.DOM.Html.node = _dom.node;
  _namespace2.default.DOM.Html.text = _dom.text;
  // BASICS
  _namespace2.default.DOM.Html.div = _dom.div;
  _namespace2.default.DOM.Html.span = _dom.span;
  _namespace2.default.DOM.Html.p = _dom.p;
  _namespace2.default.DOM.Html.a = _dom.a;
  // SEMANTIC
  _namespace2.default.DOM.Html.header = _dom.header;
  _namespace2.default.DOM.Html.footer = _dom.footer;
  _namespace2.default.DOM.Html.article = _dom.article;
  _namespace2.default.DOM.Html.section = _dom.section;
  _namespace2.default.DOM.Html.aside = _dom.aside;
  _namespace2.default.DOM.Html.main = _dom.main;
  _namespace2.default.DOM.Html.nav = _dom.nav;
  _namespace2.default.DOM.Html.menu = _dom.menu;
  _namespace2.default.DOM.Html.menuitem = _dom.menuitem;
  _namespace2.default.DOM.Html.address = _dom.address;
  _namespace2.default.DOM.Html.summary = _dom.summary;
  _namespace2.default.DOM.Html.details = _dom.details;
  _namespace2.default.DOM.Html.progress = _dom.progress;
  // LISTS
  _namespace2.default.DOM.Html.ul = _dom.ul;
  _namespace2.default.DOM.Html.ol = _dom.ol;
  _namespace2.default.DOM.Html.li = _dom.li;
  // DESCRIPTION LISTS
  _namespace2.default.DOM.Html.dl = _dom.dl;
  _namespace2.default.DOM.Html.dt = _dom.dt;
  _namespace2.default.DOM.Html.dd = _dom.dd;
  // HEADINGS
  _namespace2.default.DOM.Html.h1 = _dom.h1;
  _namespace2.default.DOM.Html.h2 = _dom.h2;
  _namespace2.default.DOM.Html.h3 = _dom.h3;
  _namespace2.default.DOM.Html.h4 = _dom.h4;
  _namespace2.default.DOM.Html.h5 = _dom.h5;
  _namespace2.default.DOM.Html.h6 = _dom.h6;
  // FORMATTING
  _namespace2.default.DOM.Html.strong = _dom.strong;
  _namespace2.default.DOM.Html.em = _dom.em;
  _namespace2.default.DOM.Html.pre = _dom.pre;
  _namespace2.default.DOM.Html.code = _dom.code;
  _namespace2.default.DOM.Html.abbr = _dom.abbr;
  _namespace2.default.DOM.Html.mark = _dom.mark;
  // FORMS
  _namespace2.default.DOM.Html.form = _dom.form;
  _namespace2.default.DOM.Html.legend = _dom.legend;
  _namespace2.default.DOM.Html.fieldset = _dom.fieldset;
  _namespace2.default.DOM.Html.input = _dom.input;
  _namespace2.default.DOM.Html.label = _dom.label;
  _namespace2.default.DOM.Html.button = _dom.button;
  _namespace2.default.DOM.Html.textarea = _dom.textarea;
  _namespace2.default.DOM.Html.option = _dom.option;
  _namespace2.default.DOM.Html.optgroup = _dom.optgroup;
  _namespace2.default.DOM.Html.select = _dom.select;
  // MEDIA
  _namespace2.default.DOM.Html.figure = _dom.figure;
  _namespace2.default.DOM.Html.img = _dom.img;
  _namespace2.default.DOM.Html.video = _dom.video;
  _namespace2.default.DOM.Html.audio = _dom.audio;
  _namespace2.default.DOM.Html.source = _dom.source;
  _namespace2.default.DOM.Html.figcaption = _dom.figcaption;
  // TABLES
  _namespace2.default.DOM.Html.table = _dom.table;
  _namespace2.default.DOM.Html.thead = _dom.thead;
  _namespace2.default.DOM.Html.tbody = _dom.tbody;
  _namespace2.default.DOM.Html.tfoot = _dom.tfoot;
  _namespace2.default.DOM.Html.tr = _dom.tr;
  _namespace2.default.DOM.Html.td = _dom.td;
  _namespace2.default.DOM.Html.col = _dom.col;
  _namespace2.default.DOM.Html.colgroup = _dom.colgroup;
  _namespace2.default.DOM.Html.caption = _dom.caption;
});
define('frampton-dom/diff', ['exports', 'frampton-utils/is_defined', 'frampton-utils/is_undefined', 'frampton-utils/is_something', 'frampton-utils/warn', 'frampton-math/max', 'frampton-dom/virtual/patch', 'frampton-dom/utils/is_node', 'frampton-dom/utils/is_text', 'frampton-dom/utils/props_diff', 'frampton-dom/utils/is_same_node'], function (exports, _is_defined, _is_undefined, _is_something, _warn, _max, _patch, _is_node, _is_text, _props_diff, _is_same_node) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = diff;

  var _is_defined2 = _interopRequireDefault(_is_defined);

  var _is_undefined2 = _interopRequireDefault(_is_undefined);

  var _is_something2 = _interopRequireDefault(_is_something);

  var _warn2 = _interopRequireDefault(_warn);

  var _max2 = _interopRequireDefault(_max);

  var _is_node2 = _interopRequireDefault(_is_node);

  var _is_text2 = _interopRequireDefault(_is_text);

  var _props_diff2 = _interopRequireDefault(_props_diff);

  var _is_same_node2 = _interopRequireDefault(_is_same_node);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function indexesMatch(oldIndex, newIndex) {
    return (0, _is_defined2.default)(oldIndex) && (0, _is_defined2.default)(newIndex) && oldIndex === newIndex;
  }

  function diffTrees(oldTree, newTree) {
    var patch, newPatch;

    // Same reference, no need to do anything
    if (oldTree === newTree) {
      return;

      // New tree is a valid node
    } else if ((0, _is_node2.default)(newTree)) {
      if ((0, _is_node2.default)(oldTree)) {
        if ((0, _is_same_node2.default)(oldTree, newTree)) {
          var pDiff = (0, _props_diff2.default)(oldTree, newTree);
          if ((0, _is_something2.default)(pDiff)) {
            newPatch = (0, _patch.props)(newTree, pDiff);
          }
          patch = diffChildren(oldTree, newTree);
        } else {
          newPatch = (0, _patch.replace)(oldTree, newTree);
        }
      } else {
        newPatch = (0, _patch.insert)(null, newTree);
      }

      // Ooops, tree isn't a valid node
    } else {
      throw new Error('Root of DOM should be a VirtualNode');
    }

    if (newPatch) {
      patch = patch || [];
      patch._p = newPatch;
    }

    return patch;
  }

  function diffChildren(oldNode, newNode) {

    // Same reference
    if (oldNode === newNode) {
      return;
    }

    var oldChildren = oldNode.children;
    var newChildren = newNode.children;
    var newLength = newChildren.length;
    var oldLength = oldChildren.length;
    var len = (0, _max2.default)(oldLength, newLength);
    var orderMap = [];
    var inserts = [];
    var newKeys = {};
    var oldKeys = {};
    var dirty = false;
    var parentPatch = void 0;

    // Create a map of keys to their new index O(n)
    for (var i = 0; i < newLength; i++) {
      var child = newChildren[i];
      if ((0, _is_node2.default)(child)) {
        var key = child.key;
        if (key) {
          newKeys[key] = i;
        }
      }
    }

    // Create a map of keys to their old index O(n)
    for (var _i = 0; _i < oldLength; _i++) {
      var _child = oldChildren[_i];
      if ((0, _is_node2.default)(_child)) {
        var _key = _child.key;
        if (_key) {
          oldKeys[_key] = _i;
        }
      }
    }

    // O(n)
    for (var _i2 = 0; _i2 < len; _i2++) {
      var oldChild = oldChildren[_i2];
      var newChild = newChildren[_i2];
      var newIndex = void 0;
      var oldIndex = void 0;
      var newPatch = void 0;
      var patch = void 0;

      // We have a new node
      if ((0, _is_node2.default)(newChild)) {

        // Index of new node in previous DOM
        oldIndex = oldKeys[newChild.key];

        // We have an old node
        if ((0, _is_node2.default)(oldChild)) {

          // Index of old node in new DOM
          newIndex = newKeys[oldChild.key];

          // If old and new are the same, no changes
          if (indexesMatch(oldIndex, newIndex)) {
            orderMap[_i2] = _i2;
            var pDiff = (0, _props_diff2.default)(oldChild, newChild);
            if ((0, _is_something2.default)(pDiff)) {
              newPatch = (0, _patch.props)(newChild, pDiff);
            }
            patch = diffChildren(oldChild, newChild);
          } else {

            // Old node has no new index, delete it
            if ((0, _is_undefined2.default)(newIndex)) {
              dirty = true;
              if (oldChild.attributes.transitionOut) {
                orderMap[_i2] = (0, _patch.remove)(null, oldChild.attributes.transitionOut);
              } else {
                orderMap[_i2] = undefined;
              }

              // The index changed, we have a move
            } else if (newIndex !== _i2) {
              dirty = true;
              orderMap[_i2] = newIndex;
              var _pDiff = (0, _props_diff2.default)(oldChild, newChildren[newIndex]);
              if ((0, _is_something2.default)(_pDiff)) {
                newPatch = (0, _patch.props)(null, _pDiff);
              }
              patch = diffChildren(oldChild, newChildren[newIndex]);
            }

            // The new node is an insert
            if ((0, _is_undefined2.default)(oldIndex)) {
              inserts[_i2] = (0, _patch.insert)(null, newChild);
            }
          }

          // We have no old node, or it is text
        } else if ((0, _is_undefined2.default)(oldIndex)) {
          dirty = true;
          orderMap[_i2] = undefined;
          inserts[_i2] = (0, _patch.insert)(null, newChild);
        }

        // New node is text
      } else if ((0, _is_text2.default)(newChild)) {

        // Old node was text
        if ((0, _is_text2.default)(oldChild)) {

          // Both nodes are text, index is the same
          orderMap[_i2] = _i2;

          // Text nodes are the same if they have same text, duh.
          if (oldChild.text !== newChild.text) {
            newPatch = (0, _patch.text)(oldChild, newChild.text);
          }

          // Old node was a node
        } else if ((0, _is_node2.default)(oldChild)) {
          dirty = true;
          newIndex = newKeys[oldChild.key];

          // Old node was deleted
          if ((0, _is_undefined2.default)(newIndex)) {
            if (oldChild.attributes.transitionOut) {
              orderMap[_i2] = (0, _patch.remove)(null, oldChild.attributes.transitionOut);
            } else {
              orderMap[_i2] = undefined;
            }

            // Old node was moved
          } else if (newIndex !== _i2) {
            orderMap[_i2] = newIndex;
            var _pDiff2 = (0, _props_diff2.default)(oldChild, newChildren[newIndex]);
            if ((0, _is_something2.default)(_pDiff2)) {
              newPatch = (0, _patch.props)(newChildren[newIndex], _pDiff2);
            }
            patch = diffChildren(oldChild, newChildren[newIndex]);

            // Shouldn't happen
          } else {
            (0, _warn2.default)('Should not get here, new node is text');
          }

          inserts[_i2] = (0, _patch.insert)(null, newChild);

          // No old node, straight insert
        } else {
          inserts[_i2] = (0, _patch.insert)(null, newChild);
        }

        // If there is no new node here, index is vacant
      } else {

        // This is going to be dirty somehow
        dirty = true;

        // Index of old node in new DOM
        newIndex = newKeys[oldChild.key];

        if ((0, _is_defined2.default)(newIndex)) {
          dirty = true;
          orderMap[_i2] = newIndex;
          var _pDiff3 = (0, _props_diff2.default)(oldChild, newChildren[newIndex]);
          if ((0, _is_something2.default)(_pDiff3)) {
            newPatch = (0, _patch.props)(newChildren[newIndex], _pDiff3);
          }
          patch = diffChildren(oldChild, newChildren[newIndex]);
        } else {
          if (oldChild.attributes.transitionOut) {
            orderMap[_i2] = (0, _patch.remove)(null, oldChild.attributes.transitionOut);
          } else {
            orderMap[_i2] = undefined;
          }
        }
      }

      if (newPatch) {
        patch = patch || [];
        patch._p = newPatch;
      }

      if (patch) {
        parentPatch = parentPatch || [];
        parentPatch[_i2] = patch;
      }
    }

    if (dirty) {
      parentPatch = parentPatch || [];
      parentPatch._o = (0, _patch.reorder)(null, orderMap);
    }

    if (inserts.length > 0) {
      parentPatch = parentPatch || [];
      parentPatch._i = inserts;
    }

    return parentPatch;
  }

  /**
   * @name diff
   * @param {Frampton.DOM.VirtualNode} oldTree The old virtual tree
   * @param {Frampton.DOM.VirtualNode} newTree The virtual tree to diff against
   * @param {Array} patch
   */
  function diff(oldTree, newTree) {
    var patch = diffTrees(oldTree, newTree) || [];
    return [patch];
  }
});
define('frampton-dom/events/add_event', ['exports', 'frampton-utils/immediate', 'frampton-dom/events/event_map', 'frampton-dom/events/utils/node_gate', 'frampton-dom/events/utils/make_handler'], function (exports, _immediate, _event_map, _node_gate, _make_handler) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = add_event;

  var _immediate2 = _interopRequireDefault(_immediate);

  var _event_map2 = _interopRequireDefault(_event_map);

  var _node_gate2 = _interopRequireDefault(_node_gate);

  var _make_handler2 = _interopRequireDefault(_make_handler);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * @name addEvent
   * @method
   * @memberof Frampton.DOM.events
   * @private
   * @param {String} name
   * @param {Element} node
   * @param {Function} handler
   */
  function add_event(name, node, messages, mappings, decorator) {
    name = _event_map2.default[name] || name;
    (0, _immediate2.default)(function () {

      var handler = (0, _make_handler2.default)(messages, mappings, decorator);

      // Transitionend events will not be fired for child nodes. The event must occur on this node.
      if (name === 'transitionend') {
        handler = (0, _node_gate2.default)(node, handler);
      }

      node['on' + name] = handler;
    });
  }
});
define('frampton-dom/events/event_map', ['exports'], function (exports) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = {
    onClick: 'click',
    onMouseOver: 'mouseover',
    onMouseOut: 'mouseout',
    onMouseEnter: 'mouseenter',
    onMouseLeave: 'mouseleave',
    onFocus: 'focus',
    onBlur: 'blur',
    onSubmit: 'submit',
    onLoad: 'load',
    onAbort: 'abort',
    onError: 'error',
    onResize: 'resize',
    onTouchStart: 'touchstart',
    onTouchEnd: 'touchend',
    onTouchMove: 'touchmove',
    onTouchEnter: 'touchenter',
    onTouchLeave: 'touchleave',
    onTouchCancel: 'touchcancel',
    onSelect: 'select',
    onChange: 'change',
    onInput: 'input',
    onKeyUp: 'keyup',
    onKeyDown: 'keydown',
    onKeyPress: 'keypress',
    onDrag: 'drag',
    onDragEnd: 'dragend',
    onDragEnter: 'dragenter',
    onDragLeave: 'dragleave',
    onDragOver: 'dragover',
    onDragStart: 'dragstart',
    onDrop: 'drop',
    onCanPlay: 'canplay',
    onAudioStart: 'audiostart',
    onAudioEnd: 'audioend',
    onSeeked: 'seeked',
    onSeeking: 'seeking',
    onPlay: 'play',
    onPlaying: 'playing',
    onPause: 'pause',
    onTimeUpdate: 'timeupdate',
    onEnded: 'ended',
    onStalled: 'stalled',
    onScroll: 'scroll',
    onWheel: 'wheel',
    onTransitionEnd: 'transitionend'
  };
});
define('frampton-dom/events/remove_event', ['exports', 'frampton-utils/immediate', 'frampton-dom/events/event_map'], function (exports, _immediate, _event_map) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = remove_event;

  var _immediate2 = _interopRequireDefault(_immediate);

  var _event_map2 = _interopRequireDefault(_event_map);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * @name removeEvent
   * @method
   * @memberof Frampton.DOM.events
   * @private
   * @param {String} name
   * @param {Element} node
   */
  function remove_event(name, node) {
    name = _event_map2.default[name] || name;
    (0, _immediate2.default)(function () {
      node['on' + name] = null;
    });
  }
});
define('frampton-dom/events/utils/is_event', ['exports', 'frampton-utils/is_something', 'frampton-dom/events/event_map'], function (exports, _is_something, _event_map) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = is_event;

  var _is_something2 = _interopRequireDefault(_is_something);

  var _event_map2 = _interopRequireDefault(_event_map);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function is_event(name) {
    return (0, _is_something2.default)(_event_map2.default[name]);
  }
});
define("frampton-dom/events/utils/make_handler", ["exports"], function (exports) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = make_handler;
  /**
   * @name makeHandler
   * @method
   * @private
   * @memberof Frampton.DOM.Events.Utils
   */
  function make_handler(messages, mappings, decorator) {
    return function (evt) {
      var value = decorator(evt);
      var len = mappings.length;
      for (var i = 0; i < len; i++) {
        value = mappings[i](value);
      }
      messages(value);
    };
  }
});
define("frampton-dom/events/utils/node_gate", ["exports"], function (exports) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = node_gate;
  /**
   *  Only allow an event through if it's target is the given node
   */
  function node_gate(node, fn) {
    return function (evt) {
      if (evt.target === node) {
        return fn(evt);
      }
    };
  }
});
define('frampton-dom/html/dom', ['exports', 'frampton-utils/is_array', 'frampton-utils/warn', 'frampton-dom/virtual/node', 'frampton-dom/virtual/text'], function (exports, _is_array, _warn, _node, _text) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.td = exports.tr = exports.th = exports.colgroup = exports.col = exports.tfoot = exports.thead = exports.tbody = exports.caption = exports.table = exports.em = exports.strong = exports.code = exports.pre = exports.textarea = exports.input = exports.select = exports.button = exports.label = exports.optgroup = exports.option = exports.fieldset = exports.legend = exports.form = exports.figcaption = exports.figure = exports.source = exports.audio = exports.video = exports.img = exports.dd = exports.dt = exports.dl = exports.li = exports.ol = exports.ul = exports.h6 = exports.h5 = exports.h4 = exports.h3 = exports.h2 = exports.h1 = exports.progress = exports.details = exports.summary = exports.address = exports.menuitem = exports.menu = exports.nav = exports.main = exports.aside = exports.section = exports.article = exports.footer = exports.header = exports.a = exports.p = exports.span = exports.div = exports.text = exports.node = undefined;

  var _is_array2 = _interopRequireDefault(_is_array);

  var _warn2 = _interopRequireDefault(_warn);

  var _node2 = _interopRequireDefault(_node);

  var _text2 = _interopRequireDefault(_text);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  // GENERIC DOM NODE

  var node = exports.node = function node(name, attrs, children) {
    return (0, _node2.default)(name, attrs, children);
  };

  // TEXT NODE

  var text = exports.text = function text(value) {
    return (0, _text2.default)(value);
  };

  // BASIC TAGS

  var div = exports.div = function div(attrs, children) {
    return (0, _node2.default)('div', attrs, children);
  };

  var span = exports.span = function span(attrs, children) {
    return (0, _node2.default)('span', attrs, children);
  };

  var p = exports.p = function p(attrs, children) {
    return (0, _node2.default)('p', attrs, children);
  };

  var a = exports.a = function a(attrs, children) {
    return (0, _node2.default)('a', attrs, children);
  };

  // SEMANTIC

  var header = exports.header = function header(attrs, children) {
    return (0, _node2.default)('header', attrs, children);
  };

  var footer = exports.footer = function footer(attrs, children) {
    return (0, _node2.default)('footer', attrs, children);
  };

  var article = exports.article = function article(attrs, children) {
    return (0, _node2.default)('article', attrs, children);
  };

  var section = exports.section = function section(attrs, children) {
    return (0, _node2.default)('section', attrs, children);
  };

  var aside = exports.aside = function aside(attrs, children) {
    return (0, _node2.default)('aside', attrs, children);
  };

  var main = exports.main = function main(attrs, children) {
    return (0, _node2.default)('main', attrs, children);
  };

  var nav = exports.nav = function nav(attrs, children) {
    return (0, _node2.default)('nav', attrs, children);
  };

  var menu = exports.menu = function menu(attrs, children) {
    return (0, _node2.default)('menu', attrs, children);
  };

  var menuitem = exports.menuitem = function menuitem(attrs, children) {
    return (0, _node2.default)('menuitem', attrs, children);
  };

  var address = exports.address = function address(attrs, children) {
    return (0, _node2.default)('address', attrs, children);
  };

  var summary = exports.summary = function summary(attrs, children) {
    return (0, _node2.default)('summary', attrs, children);
  };

  var details = exports.details = function details(attrs, children) {
    return (0, _node2.default)('details', attrs, children);
  };

  var progress = exports.progress = function progress(attrs, children) {
    return (0, _node2.default)('progress', attrs, children);
  };

  // HEADINGS

  var h1 = exports.h1 = function h1(attrs, children) {
    return (0, _node2.default)('h1', attrs, children);
  };

  var h2 = exports.h2 = function h2(attrs, children) {
    return (0, _node2.default)('h2', attrs, children);
  };

  var h3 = exports.h3 = function h3(attrs, children) {
    return (0, _node2.default)('h3', attrs, children);
  };

  var h4 = exports.h4 = function h4(attrs, children) {
    return (0, _node2.default)('h4', attrs, children);
  };

  var h5 = exports.h5 = function h5(attrs, children) {
    return (0, _node2.default)('h5', attrs, children);
  };

  var h6 = exports.h6 = function h6(attrs, children) {
    return (0, _node2.default)('h6', attrs, children);
  };

  // LISTS

  var ul = exports.ul = function ul(attrs, children) {
    return (0, _node2.default)('ul', attrs, children);
  };

  var ol = exports.ol = function ol(attrs, children) {
    return (0, _node2.default)('ol', attrs, children);
  };

  var li = exports.li = function li(attrs, children) {
    return (0, _node2.default)('li', attrs, children);
  };

  // DESCRIPTION LISTS

  var dl = exports.dl = function dl(attrs, children) {
    return (0, _node2.default)('dl', attrs, children);
  };

  var dt = exports.dt = function dt(attrs, children) {
    return (0, _node2.default)('dt', attrs, children);
  };

  var dd = exports.dd = function dd(attrs, children) {
    return (0, _node2.default)('dd', attrs, children);
  };

  // MEDIA

  var img = exports.img = function img(attrs, children) {
    if ((0, _is_array2.default)(children) && children.length > 0) {
      (0, _warn2.default)('Html img tag does not support children');
    }
    return (0, _node2.default)('img', attrs, []);
  };

  var video = exports.video = function video(attrs, children) {
    return (0, _node2.default)('video', attrs, children);
  };

  var audio = exports.audio = function audio(attrs, children) {
    return (0, _node2.default)('audio', attrs, children);
  };

  var source = exports.source = function source(attrs, children) {
    return (0, _node2.default)('source', attrs, children);
  };

  var figure = exports.figure = function figure(attrs, children) {
    return (0, _node2.default)('figure', attrs, children);
  };

  var figcaption = exports.figcaption = function figcaption(attrs, children) {
    return (0, _node2.default)('figcaption', attrs, children);
  };

  // FORMS

  var form = exports.form = function form(attrs, children) {
    return (0, _node2.default)('form', attrs, children);
  };

  var legend = exports.legend = function legend(attrs, children) {
    return (0, _node2.default)('legend', attrs, children);
  };

  var fieldset = exports.fieldset = function fieldset(attrs, children) {
    return (0, _node2.default)('fieldset', attrs, children);
  };

  var option = exports.option = function option(attrs, children) {
    return (0, _node2.default)('option', attrs, children);
  };

  var optgroup = exports.optgroup = function optgroup(attrs, children) {
    return (0, _node2.default)('optgroup', attrs, children);
  };

  var label = exports.label = function label(attrs, children) {
    return (0, _node2.default)('label', attrs, children);
  };

  var button = exports.button = function button(attrs, children) {
    return (0, _node2.default)('button', attrs, children);
  };

  var select = exports.select = function select(attrs, children) {
    return (0, _node2.default)('select', attrs, children);
  };

  var input = exports.input = function input(attrs, children) {
    if ((0, _is_array2.default)(children) && children.length > 0) {
      (0, _warn2.default)('Html input tag does not support children');
    }
    return (0, _node2.default)('input', attrs, children);
  };

  var textarea = exports.textarea = function textarea(attrs, children) {
    return (0, _node2.default)('textarea', attrs, children);
  };

  // FORMATTING

  var pre = exports.pre = function pre(attrs, children) {
    return (0, _node2.default)('pre', attrs, children);
  };

  var code = exports.code = function code(attrs, children) {
    return (0, _node2.default)('code', attrs, children);
  };

  var strong = exports.strong = function strong(attrs, children) {
    return (0, _node2.default)('strong', attrs, children);
  };

  var em = exports.em = function em(attrs, children) {
    return (0, _node2.default)('em', attrs, children);
  };

  var abbr = exports.abbr = function abbr(attrs, children) {
    return (0, _node2.default)('abbr', attrs, children);
  };

  var mark = exports.mark = function mark(attrs, children) {
    return (0, _node2.default)('mark', attrs, children);
  };

  // TABLES

  var table = exports.table = function table(attrs, children) {
    return (0, _node2.default)('table', attrs, children);
  };

  var caption = exports.caption = function caption(attrs, children) {
    return (0, _node2.default)('caption', attrs, children);
  };

  var tbody = exports.tbody = function tbody(attrs, children) {
    return (0, _node2.default)('tbody', attrs, children);
  };

  var thead = exports.thead = function thead(attrs, children) {
    return (0, _node2.default)('thead', attrs, children);
  };

  var tfoot = exports.tfoot = function tfoot(attrs, children) {
    return (0, _node2.default)('tfoot', attrs, children);
  };

  var col = exports.col = function col(attrs, children) {
    return (0, _node2.default)('col', attrs, children);
  };

  var colgroup = exports.colgroup = function colgroup(attrs, children) {
    return (0, _node2.default)('colgroup', attrs, children);
  };

  var th = exports.th = function th(attrs, children) {
    return (0, _node2.default)('th', attrs, children);
  };

  var tr = exports.tr = function tr(attrs, children) {
    return (0, _node2.default)('tr', attrs, children);
  };

  var td = exports.td = function td(attrs, children) {
    return (0, _node2.default)('td', attrs, children);
  };
});
define('frampton-dom/map', ['exports', 'frampton-dom/utils/is_node'], function (exports, _is_node) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  exports.default = function (mapping, tree) {
    applyMapping(mapping, tree);
    return tree;
  };

  var _is_node2 = _interopRequireDefault(_is_node);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function applyMapping(mapping, tree) {
    if ((0, _is_node2.default)(tree)) {
      var children = tree.children;
      var len = children.length;
      tree.mappings.push(mapping);
      for (var i = 0; i < len; i++) {
        var child = children[i];
        applyMapping(mapping, child);
      }
    }
  }
});
define('frampton-dom/ops/apply_attributes', ['exports', 'frampton-utils/is_nothing', 'frampton-utils/is_object', 'frampton-utils/warn', 'frampton-list/contains', 'frampton-dom/ops/apply_styles', 'frampton-dom/ops/apply_classes', 'frampton-dom/utils/validated_class', 'frampton-dom/utils/validated_transition', 'frampton-dom/ops/apply_transition', 'frampton-dom/events/utils/is_event', 'frampton-dom/events/add_event', 'frampton-dom/events/remove_event'], function (exports, _is_nothing, _is_object, _warn, _contains, _apply_styles, _apply_classes, _validated_class, _validated_transition, _apply_transition, _is_event, _add_event, _remove_event) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = apply_attributes;

  var _is_nothing2 = _interopRequireDefault(_is_nothing);

  var _is_object2 = _interopRequireDefault(_is_object);

  var _warn2 = _interopRequireDefault(_warn);

  var _contains2 = _interopRequireDefault(_contains);

  var _apply_styles2 = _interopRequireDefault(_apply_styles);

  var _apply_classes2 = _interopRequireDefault(_apply_classes);

  var _validated_class2 = _interopRequireDefault(_validated_class);

  var _validated_transition2 = _interopRequireDefault(_validated_transition);

  var _apply_transition2 = _interopRequireDefault(_apply_transition);

  var _is_event2 = _interopRequireDefault(_is_event);

  var _add_event2 = _interopRequireDefault(_add_event);

  var _remove_event2 = _interopRequireDefault(_remove_event);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  // Properties to not add to DOM node
  var denylist = ['key', 'transitionIn', 'transitionOut'];

  /**
   * @name applyAttributes
   * @param {Element} node Dom element to apply attributes to
   * @param {VirtualNode} vnode VirtualNode representing this node
   * @param {Object} attrs Hash of attributes to apply
   * @param {Functon} messages Function to handle events
   */
  function apply_attributes(node, vnode, attrs, messages) {
    for (var name in attrs) {
      var value = attrs[name];
      if ((0, _is_nothing2.default)(value) || value === false) {
        if ((0, _is_event2.default)(name)) {
          (0, _remove_event2.default)(name, node);
        } else {

          if (name === 'focus') {
            node.removeAttribute('data-fr-dom-focus');
          } else if (name === 'html') {
            node.innerHTML = '';
          } else if (name === 'value') {
            node.value = '';
          } else if (name === 'checked') {
            node.checked = false;
          } else {
            node.removeAttribute(name);
          }
        }
      } else {

        if (name === 'style') {
          if ((0, _is_object2.default)(value)) {
            (0, _apply_styles2.default)(node, value);
          } else {
            (0, _warn2.default)('Style attribute is not an object');
          }
        } else if (name === 'transition') {
          (0, _apply_transition2.default)(node, (0, _validated_transition2.default)(value));
        } else if (name === 'class') {
          (0, _apply_classes2.default)(node, (0, _validated_class2.default)(value));
        } else if (name === 'focus') {
          node.setAttribute('data-fr-dom-focus', value);
        } else if (name === 'html') {
          node.innerHTML = value;
        } else if (name === 'value') {
          if (node.type === 'text' || node.type === 'textarea') {
            var cursor = node.selectionStart;
            node.value = value;
            node.selectionStart = cursor;
            node.selectionEnd = cursor;
          } else {
            node.value = value;
          }
        } else if (name === 'checked') {
          node.checked = true;
        } else if ((0, _is_event2.default)(name)) {
          (0, _add_event2.default)(name, node, messages, vnode.mappings, value);
        } else if (!(0, _contains2.default)(denylist, name)) {
          node.setAttribute(name, value);
        }
      }
    }
  }
});
define("frampton-dom/ops/apply_classes", ["exports"], function (exports) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = apply_classes;
  function apply_classes(node, diff) {
    var toAdd = diff.add || [];
    var toRemove = diff.remove || [];
    var addLen = toAdd.length;
    var removeLen = toRemove.length;

    if (removeLen > 0) {
      for (var i = 0; i < removeLen; i++) {
        node.classList.remove(toRemove[i]);
      }
    }

    if (addLen > 0) {
      for (var _i = 0; _i < addLen; _i++) {
        node.classList.add(toAdd[_i]);
      }
    }
  }
});
define('frampton-dom/ops/apply_globals', ['exports', 'frampton-utils/is_something'], function (exports, _is_something) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = apply_globals;

  var _is_something2 = _interopRequireDefault(_is_something);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * We would like to apply some attributes after the DOM is constructed,
   * such as focus.
   */
  function apply_globals(root) {
    var focused = root.querySelector('[data-fr-dom-focus="true"]');
    if ((0, _is_something2.default)(focused) && focused.nodeType === 1) {
      focused.focus();
    }
  }
});
define('frampton-dom/ops/apply_patch', ['exports', 'frampton-utils/is_numeric', 'frampton-dom/utils/node_at_index', 'frampton-dom/ops/execute_patch', 'frampton-dom/ops/perform_inserts', 'frampton-dom/ops/reset_child_state'], function (exports, _is_numeric, _node_at_index, _execute_patch, _perform_inserts, _reset_child_state) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = apply_patch;

  var _is_numeric2 = _interopRequireDefault(_is_numeric);

  var _node_at_index2 = _interopRequireDefault(_node_at_index);

  var _execute_patch2 = _interopRequireDefault(_execute_patch);

  var _perform_inserts2 = _interopRequireDefault(_perform_inserts);

  var _reset_child_state2 = _interopRequireDefault(_reset_child_state);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * @name applyPatch
   * @param {Array} patch
   * @param {Element} parent
   * @param {Element} current
   */
  function apply_patch(patch, messages, parent, current) {

    (0, _reset_child_state2.default)(current);

    // Apply patches to child nodes
    for (var key in patch) {
      if ((0, _is_numeric2.default)(key)) {
        var child = (0, _node_at_index2.default)(current, key);
        apply_patch(patch[key], messages, current, child);
      }
    }

    // Reorder child nodes
    if (patch._o) {
      (0, _execute_patch2.default)(patch._o, messages, parent, current);
    }

    // Insert new nodes
    if (patch._i) {
      (0, _perform_inserts2.default)(current, patch._i, messages);
    }

    // Patch props and text
    if (patch._p) {
      (0, _execute_patch2.default)(patch._p, messages, parent, current);
    }
  }
});
define('frampton-dom/ops/apply_styles', ['exports', 'frampton-utils/is_something', 'frampton-style/set_style', 'frampton-style/remove_style'], function (exports, _is_something, _set_style, _remove_style) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = apply_styles;

  var _is_something2 = _interopRequireDefault(_is_something);

  var _set_style2 = _interopRequireDefault(_set_style);

  var _remove_style2 = _interopRequireDefault(_remove_style);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function apply_styles(node, props, isTransition) {
    for (var key in props) {
      var value = props[key];
      if (isTransition && key === 'height' && value === 'auto') {
        var firstChild = node.firstElementChild;
        if (firstChild) {
          var height = firstChild.offsetHeight;
          (0, _set_style2.default)(node, 'height', height + 'px');
        }
      } else if (isTransition && key === 'width' && value === 'auto') {
        var _firstChild = node.firstElementChild;
        if (_firstChild) {
          var width = _firstChild.offsetWidth;
          (0, _set_style2.default)(node, 'width', width + 'px');
        }
      } else if ((0, _is_something2.default)(value)) {
        (0, _set_style2.default)(node, key, value);
      } else {
        (0, _remove_style2.default)(node, key);
      }
    }
  }
});
define('frampton-dom/ops/apply_transition', ['exports', 'frampton-utils/guid', 'frampton-style/set_style', 'frampton-style/remove_style', 'frampton-dom/utils/reflow', 'frampton-dom/utils/normalized_frame', 'frampton-utils/immediate', 'frampton-dom/ops/apply_styles', 'frampton-dom/ops/apply_classes', 'frampton-dom/utils/validated_class'], function (exports, _guid, _set_style, _remove_style, _reflow, _normalized_frame, _immediate, _apply_styles, _apply_classes, _validated_class) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = apply_transition;

  var _guid2 = _interopRequireDefault(_guid);

  var _set_style2 = _interopRequireDefault(_set_style);

  var _remove_style2 = _interopRequireDefault(_remove_style);

  var _reflow2 = _interopRequireDefault(_reflow);

  var _normalized_frame2 = _interopRequireDefault(_normalized_frame);

  var _immediate2 = _interopRequireDefault(_immediate);

  var _apply_styles2 = _interopRequireDefault(_apply_styles);

  var _apply_classes2 = _interopRequireDefault(_apply_classes);

  var _validated_class2 = _interopRequireDefault(_validated_class);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function setupTransitionEnd(node, endFrame, id) {
    function eventHandler(evt) {
      var target = evt.target;
      var transitionId = target.getAttribute('data-transition');
      if (evt.target === node) {
        if (transitionId === id) {
          if (endFrame.height === 'auto') {
            (0, _set_style2.default)(node, 'height', 'auto');
          }

          if (endFrame.width === 'auto') {
            (0, _set_style2.default)(node, 'width', 'auto');
          }

          node.removeAttribute('data-transition');
          (0, _remove_style2.default)(node, 'transition-property');
        }

        node.removeEventListener('transitionend', eventHandler);
      }
    }

    node.addEventListener('transitionend', eventHandler);
  }

  /**
   * @name applyTransition
   * @param {Element} node Dom element to apply transition to
   * @param {Object} desc An object describing the transition to make
   */
  function apply_transition(node, desc) {
    // If a transition on a given node we need a unique id for each
    // transition to know we are handling the correct one.
    var transitionId = (0, _guid2.default)();
    var props = desc.props.join(',');
    var startClasses = (0, _validated_class2.default)(desc.from.class);
    var startFrame = (0, _normalized_frame2.default)(desc.from.style);

    (0, _immediate2.default)(function () {
      (0, _apply_classes2.default)(node, startClasses);
      (0, _apply_styles2.default)(node, startFrame, true);
      (0, _set_style2.default)(node, 'transition-property', props);
      node.setAttribute('data-transition', transitionId);
      // Force a reflow to make sure we're in a good state
      (0, _reflow2.default)(node);

      (0, _immediate2.default)(function () {
        var endClasses = (0, _validated_class2.default)(desc.to.class);
        var endFrame = (0, _normalized_frame2.default)(desc.to.style);

        setupTransitionEnd(node, endFrame, transitionId);
        (0, _apply_styles2.default)(node, endFrame, true);
        (0, _apply_classes2.default)(node, endClasses);
      });
    });
  }
});
define('frampton-dom/ops/create_element', ['exports', 'frampton-dom/utils/is_text', 'frampton-dom/ops/apply_attributes'], function (exports, _is_text, _apply_attributes) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = create_element;

  var _is_text2 = _interopRequireDefault(_is_text);

  var _apply_attributes2 = _interopRequireDefault(_apply_attributes);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  var doc = window.document;

  /*
   * Take a VirtualNode and turns it into real DOM
   *
   * @name createElement
   * @memberOf Frampton.DOM
   * @method
   * @private
   * @param {VirtualNode}
   * @returns {Element} A new HTML Element
   */
  function create_element(vnode, messages) {

    if ((0, _is_text2.default)(vnode)) {
      return doc.createTextNode(vnode.text);
    }

    var children = vnode.children;
    var len = children.length;
    var node = doc.createElement(vnode.tagName);
    (0, _apply_attributes2.default)(node, vnode, vnode.attributes, messages);

    for (var i = 0; i < len; i++) {
      var childNode = create_element(children[i], messages);
      if (childNode) {
        node.appendChild(childNode);
      }
    }

    return node;
  }
});
define('frampton-dom/ops/execute_patch', ['exports', 'frampton-dom/virtual/patch_types', 'frampton-dom/ops/remove_node', 'frampton-dom/ops/replace_node', 'frampton-dom/ops/reorder_nodes', 'frampton-dom/ops/insert_node', 'frampton-dom/ops/update_text', 'frampton-dom/ops/apply_attributes'], function (exports, _patch_types, _remove_node, _replace_node, _reorder_nodes, _insert_node, _update_text, _apply_attributes) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = execute_patch;

  var _patch_types2 = _interopRequireDefault(_patch_types);

  var _remove_node2 = _interopRequireDefault(_remove_node);

  var _replace_node2 = _interopRequireDefault(_replace_node);

  var _reorder_nodes2 = _interopRequireDefault(_reorder_nodes);

  var _insert_node2 = _interopRequireDefault(_insert_node);

  var _update_text2 = _interopRequireDefault(_update_text);

  var _apply_attributes2 = _interopRequireDefault(_apply_attributes);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function execute_patch(patch, messages, parentNode, currentNode) {

    var type = patch.type;
    var update = patch.update;
    var vnode = patch.node;

    switch (type) {

      case _patch_types2.default.NONE:
        break;

      case _patch_types2.default.APPEND:
        return (0, _insert_node2.default)(parentNode, null, update, messages);

      case _patch_types2.default.INSERT:
        return (0, _insert_node2.default)(parentNode, currentNode, update, messages);

      case _patch_types2.default.REMOVE:
        return (0, _remove_node2.default)(currentNode);

      case _patch_types2.default.REPLACE:
        return (0, _replace_node2.default)(currentNode, update, messages);

      case _patch_types2.default.PROPS:
        return (0, _apply_attributes2.default)(currentNode, vnode, update, messages);

      case _patch_types2.default.TEXT:
        return (0, _update_text2.default)(currentNode, update);

      case _patch_types2.default.REORDER:
        return (0, _reorder_nodes2.default)(parentNode, currentNode, update);

      default:
        throw new Error('Unrecognized patch type: ' + type);
    }
  }
});
define('frampton-dom/ops/insert_node', ['exports', 'frampton-dom/ops/create_element', 'frampton-dom/utils/transition_in'], function (exports, _create_element, _transition_in) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = insert_node;

  var _create_element2 = _interopRequireDefault(_create_element);

  var _transition_in2 = _interopRequireDefault(_transition_in);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /*
   * @name insertNode
   * @memberOf Frampton.DOM
   * @method
   * @private
   * @param {Element} parent
   * @param {Element} current
   * @param {VirtualNode} vnode
   */
  function insert_node(parent, current, vnode, messages) {
    var child = (0, _create_element2.default)(vnode, messages);

    if (vnode.attributes && vnode.attributes.transitionIn) {
      (0, _transition_in2.default)(child, vnode.attributes.transitionIn);
    }

    if (parent) {
      if (current) {
        parent.insertBefore(child, current);
      } else {
        parent.appendChild(child);
      }
    }
  }
});
define('frampton-dom/ops/perform_inserts', ['exports', 'frampton-utils/is_numeric', 'frampton-dom/virtual/patch_types', 'frampton-dom/ops/execute_patch'], function (exports, _is_numeric, _patch_types, _execute_patch) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = perform_inserts;

  var _is_numeric2 = _interopRequireDefault(_is_numeric);

  var _patch_types2 = _interopRequireDefault(_patch_types);

  var _execute_patch2 = _interopRequireDefault(_execute_patch);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * @name performInserts
   * @memberof Frampton.DOM.Ops
   * @private
   * @param {Element} current
   * @param {Object} patches
   */
  function perform_inserts(current, patches, messages) {

    var arr = [];
    var len = current ? current.childNodes.length : 0;

    for (var i = 0; i < len; i++) {
      var child = current.childNodes[i];
      // Filter out nodes that are transitioning out
      if (child.nodeType === 3 || child.getAttribute('data-transition-out') !== 'true') {
        arr.push(child);
      }
    }

    var cursor = 0;

    for (var key in patches) {
      if ((0, _is_numeric2.default)(key)) {
        var update = patches[key];
        (0, _execute_patch2.default)(update, messages, current, arr[key - cursor]);
        if (update.type === _patch_types2.default.INSERT) {
          cursor += 1;
        }
      }
    }
  }
});
define("frampton-dom/ops/remove_node", ["exports"], function (exports) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = remove_node;
  /*
   * @name removeNode
   * @memberOf Frampton.DOM
   * @method
   * @private
   * @param {Element} node
   */
  function remove_node(node) {
    if (node && node.parentNode) {
      var parent = node.parentNode;
      if (parent) {
        parent.removeChild(node);
      }
    }
  }
});
define('frampton-dom/ops/reorder_nodes', ['exports', 'frampton-utils/is_number', 'frampton-dom/utils/is_patch', 'frampton-dom/ops/remove_node', 'frampton-dom/utils/transition_out'], function (exports, _is_number, _is_patch, _remove_node, _transition_out) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = reorder_nodes;

  var _is_number2 = _interopRequireDefault(_is_number);

  var _is_patch2 = _interopRequireDefault(_is_patch);

  var _remove_node2 = _interopRequireDefault(_remove_node);

  var _transition_out2 = _interopRequireDefault(_transition_out);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /*
   * @name reorderNodes
   * @memberOf Frampton.DOM
   * @method
   * @private
   * @param {Element} parent
   * @param {Array} order
   */
  function reorder_nodes(parent, current, order) {

    var children = current.childNodes;
    var len = children.length;
    var arr = [];
    var remove = [];
    var map = [];

    /**
     * If child nodes were still transitioning out from a previous invokation of
     * reorderNodes they will not be in our diff and need to be removed. Otherwise
     * we collect a reference to the children in their original order.
     */
    for (var i = 0; i < len; i++) {
      var child = children[i];
      if (child.nodeType === 1 && child.getAttribute('data-transition-out') === 'true') {
        remove.push(child);
      } else {
        arr.push(child);
      }
    }

    /**
     * Because transitions are applied asyncronously it is possible for nodes
     * transitioning out to still be in the DOM but not in our virtual DOM.
     */
    for (var _i = 0; _i < remove.length; _i++) {
      var _child = remove[_i];
      (0, _remove_node2.default)(_child);
    }

    // Easy look up for what new indexes should be
    for (var _i2 = 0; _i2 < order.length; _i2++) {
      var next = order[_i2];
      if ((0, _is_number2.default)(next)) {
        map[next] = _i2;
      }
    }

    /**
     * Cursor is used to keep our position when dealing with nodes that are
     * transitioning out, therefore still in the DOM but we don't want to
     * consider its position when inserting new elements.
     */
    var cursor = 0;

    for (var _i3 = 0; _i3 < len; _i3++) {

      var oldChild = arr[_i3];

      if (oldChild && order[_i3] === undefined) {
        (0, _remove_node2.default)(oldChild);
      }

      if ((0, _is_patch2.default)(order[_i3])) {
        (0, _transition_out2.default)(oldChild, order[_i3].update);
        cursor += 1;
      }

      var newChildIndex = map[_i3];
      var ref = current.childNodes[_i3 + cursor];

      if (newChildIndex !== undefined) {
        var node = arr[newChildIndex];

        // We have a new node, but no old node at this position.
        if (node && !ref) {
          current.appendChild(node);

          // We have an old node here, insert the new node before it.
        } else if (node && ref !== node) {
          current.insertBefore(node, ref);

          // Things stay the same.
        } else if (node && ref === node) {
          /* No move */
        }
      }
    }
  }
});
define('frampton-dom/ops/replace_node', ['exports', 'frampton-dom/ops/create_element'], function (exports, _create_element) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = replace_node;

  var _create_element2 = _interopRequireDefault(_create_element);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /*
   * @name replaceNode
   * @memberOf Frampton.DOM
   * @method
   * @private
   * @param {Element} oldNode Node to replace
   * @param {VirtualNode} vnode VirtualNode representing replacement
   */
  function replace_node(oldNode, vnode, messages) {
    if (oldNode) {
      var parent = oldNode.parentNode;
      var newNode = (0, _create_element2.default)(vnode, messages);
      if (parent) {
        parent.replaceChild(newNode, oldNode);
      }
    }
  }
});
define('frampton-dom/ops/reset_child_state', ['exports', 'frampton-utils/is_defined', 'frampton-dom/ops/remove_node'], function (exports, _is_defined, _remove_node) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = reset_child_state;

  var _is_defined2 = _interopRequireDefault(_is_defined);

  var _remove_node2 = _interopRequireDefault(_remove_node);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function isTransitioningOut(child) {
    return (0, _is_defined2.default)(child) && child.nodeType === 1 && child.getAttribute('data-transition-out') === 'true';
  }

  /**
   * Nodes that are transitioning out should just be removed to get us in a good
   * state before performing the next set of updates.
   */
  function reset_child_state(node) {
    if (node && node.childNodes) {
      var children = node.childNodes;
      var len = children.length;
      for (var i = 0; i < len; i++) {
        var child = children[i];
        if (isTransitioningOut(child)) {
          (0, _remove_node2.default)(child);
        }
      }
    }
  }
});
define("frampton-dom/ops/update_text", ["exports"], function (exports) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = update_text;
  /*
   * @name updateText
   * @memberOf Frampton.DOM
   * @method
   * @private
   * @param {Element} node Node to update
   * @param {String} text New text to display
   */
  function update_text(node, text) {
    if (node && node.textContent !== undefined) {
      node.textContent = text;
    }
  }
});
define('frampton-dom/scene', ['exports', 'frampton-dom/utils/request_frame', 'frampton-dom/update'], function (exports, _request_frame, _update) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = scene;

  var _request_frame2 = _interopRequireDefault(_request_frame);

  var _update2 = _interopRequireDefault(_update);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  var STATES = {
    NOTHING: 0,
    PENDING: 1
  };

  /**
   * Start a new VirtualDOM scene. The scene takes a root node to attach
   * to and returns a function to schedule updates. You give the scheduler
   * a new VirtualNode and it will schedule the diff and update of the
   * previous DOM.
   *
   * @name scene
   * @memberof Frampton.DOM
   * @method
   * @param {Element} rootNode The node to attach our scene to
   * @param {Function} messages A function to handle events in the DOM
   * @returns {Function} A function to schedule updates
   */
  function scene(rootNode, messages) {

    var savedDOM = null;
    var scheduledDOM = null;
    var state = STATES.NOTHING;

    function draw() {
      (0, _update2.default)({
        rootNode: rootNode,
        messages: messages,
        oldTree: savedDOM,
        newTree: scheduledDOM
      });
      savedDOM = scheduledDOM;
      state = STATES.NOTHING;
    }

    return function scheduler(dom) {
      scheduledDOM = dom;

      switch (state) {

        case STATES.NOTHING:
          (0, _request_frame2.default)(draw);
          state = STATES.PENDING;
          break;

        default:
          state = STATES.PENDING;
          break;
      }
    };
  }
});
define('frampton-dom/update', ['exports', 'frampton-utils/noop', 'frampton-dom/diff', 'frampton-dom/ops/apply_patch', 'frampton-dom/ops/apply_globals'], function (exports, _noop, _diff, _apply_patch, _apply_globals) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = run_update;

  var _noop2 = _interopRequireDefault(_noop);

  var _diff2 = _interopRequireDefault(_diff);

  var _apply_patch2 = _interopRequireDefault(_apply_patch);

  var _apply_globals2 = _interopRequireDefault(_apply_globals);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * @name update
   * @method
   * @memberof Frampton.DOM
   * @param {Object} config
   * @param {Element} config.rootNode - Node to draw inside of.
   * @param {Function} config.messages - Callback for events.
   * @param {Frampton.DOM.VirtualNode} config.oldTree The old virtual dom
   * @param {Frampton.DOM.VirtualNode} config.newTree The new virtual dom
   */
  function run_update(config) {
    var patch = (0, _diff2.default)(config.oldTree, config.newTree);
    (0, _apply_patch2.default)(patch, config.messages || _noop2.default, config.rootNode, config.rootNode);
    (0, _apply_globals2.default)(config.rootNode);
  }
});
define('frampton-dom/utils/diff_class', ['exports', 'frampton-list/length', 'frampton-dom/utils/empty_class', 'frampton-dom/utils/validated_class'], function (exports, _length, _empty_class, _validated_class) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = diff_class;

  var _length2 = _interopRequireDefault(_length);

  var _empty_class2 = _interopRequireDefault(_empty_class);

  var _validated_class2 = _interopRequireDefault(_validated_class);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function diff_class(oldClass, newClass) {
    oldClass = (0, _validated_class2.default)(oldClass);
    newClass = (0, _validated_class2.default)(newClass);
    var oLen = (0, _length2.default)(oldClass.add);
    var nLen = (0, _length2.default)(newClass.add);
    var diff;

    for (var i = 0; i < oLen; i++) {
      if (newClass.add.indexOf(oldClass.add[i]) === -1) {
        diff = diff || (0, _empty_class2.default)();
        diff.remove = diff.remove || [];
        diff.remove.push(oldClass.add[i]);
      }
    }

    for (var _i = 0; _i < nLen; _i++) {
      if (oldClass.add.indexOf(newClass.add[_i]) === -1) {
        diff = diff || (0, _empty_class2.default)();
        diff.add = diff.add || [];
        diff.add.push(newClass.add[_i]);
      }
    }

    return diff;
  }
});
define('frampton-dom/utils/diff_props', ['exports', 'frampton-utils/is_object', 'frampton-utils/is_undefined', 'frampton-dom/utils/diff_class', 'frampton-dom/utils/validated_transition'], function (exports, _is_object, _is_undefined, _diff_class, _validated_transition) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = diff_props;

  var _is_object2 = _interopRequireDefault(_is_object);

  var _is_undefined2 = _interopRequireDefault(_is_undefined);

  var _diff_class2 = _interopRequireDefault(_diff_class);

  var _validated_transition2 = _interopRequireDefault(_validated_transition);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function diff_props(oldProps, newProps) {

    var diff;

    for (var key in oldProps) {

      var oldValue = oldProps[key];
      var newValue = newProps[key];

      if ((0, _is_undefined2.default)(newValue)) {
        diff = diff || {};
        diff[key] = undefined;
      }

      if (key === 'style') {
        newValue = newValue || {};
      }

      if (key === 'transition') {
        oldValue = (0, _validated_transition2.default)(oldValue);
        newValue = (0, _validated_transition2.default)(newValue);
        var tempDiff = diff_props(oldValue, newValue);
        if (tempDiff) {
          diff = diff || {};
          diff[key] = tempDiff;
        }
      } else if (key === 'class') {
        newValue = newValue || '';
        var _tempDiff = (0, _diff_class2.default)(oldValue, newValue);
        if (_tempDiff) {
          diff = diff || {};
          diff[key] = _tempDiff;
        }
      } else if ((0, _is_object2.default)(oldValue) && (0, _is_object2.default)(newValue)) {
        var _tempDiff2 = diff_props(oldValue, newValue);
        if (_tempDiff2) {
          diff = diff || {};
          diff[key] = _tempDiff2;
        }
      } else if (oldValue !== newValue) {
        diff = diff || {};
        diff[key] = newValue;
      }
    }

    for (var _key in newProps) {
      if ((0, _is_undefined2.default)(oldProps[_key])) {
        var _newValue = newProps[_key];
        diff = diff || {};
        diff[_key] = _newValue;
      }
    }

    return diff;
  }
});
define('frampton-dom/utils/easing', ['exports'], function (exports) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = {
    'in': 'ease-in',
    'out': 'ease-out',
    'in-out': 'ease-in-out',
    'snap': 'cubic-bezier(0,1,.5,1)',
    'linear': 'cubic-bezier(0.250, 0.250, 0.750, 0.750)',
    'ease-in-quad': 'cubic-bezier(0.550, 0.085, 0.680, 0.530)',
    'ease-in-cubic': 'cubic-bezier(0.550, 0.055, 0.675, 0.190)',
    'ease-in-quart': 'cubic-bezier(0.895, 0.030, 0.685, 0.220)',
    'ease-in-quint': 'cubic-bezier(0.755, 0.050, 0.855, 0.060)',
    'ease-in-sine': 'cubic-bezier(0.470, 0.000, 0.745, 0.715)',
    'ease-in-expo': 'cubic-bezier(0.950, 0.050, 0.795, 0.035)',
    'ease-in-circ': 'cubic-bezier(0.600, 0.040, 0.980, 0.335)',
    'ease-in-back': 'cubic-bezier(0.600, -0.280, 0.735, 0.045)',
    'ease-out-quad': 'cubic-bezier(0.250, 0.460, 0.450, 0.940)',
    'ease-out-cubic': 'cubic-bezier(0.215, 0.610, 0.355, 1.000)',
    'ease-out-quart': 'cubic-bezier(0.165, 0.840, 0.440, 1.000)',
    'ease-out-quint': 'cubic-bezier(0.230, 1.000, 0.320, 1.000)',
    'ease-out-sine': 'cubic-bezier(0.390, 0.575, 0.565, 1.000)',
    'ease-out-expo': 'cubic-bezier(0.190, 1.000, 0.220, 1.000)',
    'ease-out-circ': 'cubic-bezier(0.075, 0.820, 0.165, 1.000)',
    'ease-out-back': 'cubic-bezier(0.175, 0.885, 0.320, 1.275)',
    'ease-in-out-quart': 'cubic-bezier(0.770, 0.000, 0.175, 1.000)',
    'ease-in-out-quint': 'cubic-bezier(0.860, 0.000, 0.070, 1.000)',
    'ease-in-out-sine': 'cubic-bezier(0.445, 0.050, 0.550, 0.950)',
    'ease-in-out-expo': 'cubic-bezier(1.000, 0.000, 0.000, 1.000)',
    'ease-in-out-circ': 'cubic-bezier(0.785, 0.135, 0.150, 0.860)',
    'ease-in-out-back': 'cubic-bezier(0.680, -0.550, 0.265, 1.550)'
  };
});
define("frampton-dom/utils/empty_class", ["exports"], function (exports) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = empty_class;
  function empty_class() {
    return {
      add: [],
      remove: []
    };
  }
});
define('frampton-dom/utils/empty_transition', ['exports', 'frampton-dom/utils/empty_class'], function (exports, _empty_class) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = empty_transition;

  var _empty_class2 = _interopRequireDefault(_empty_class);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function empty_transition() {
    return {
      props: [],
      from: {
        class: (0, _empty_class2.default)(),
        style: {}
      },
      to: {
        class: (0, _empty_class2.default)(),
        style: {}
      },
      cleanup: {
        class: (0, _empty_class2.default)(),
        style: {}
      }
    };
  }
});
define('frampton-dom/utils/is_node', ['exports', 'frampton-utils/is_object'], function (exports, _is_object) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = is_text;

  var _is_object2 = _interopRequireDefault(_is_object);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function is_text(node) {
    return (0, _is_object2.default)(node) && node.ctor === 'VirtualNode';
  }
});
define('frampton-dom/utils/is_patch', ['exports', 'frampton-utils/is_object'], function (exports, _is_object) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = is_patch;

  var _is_object2 = _interopRequireDefault(_is_object);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function is_patch(node) {
    return (0, _is_object2.default)(node) && node.ctor === 'VirtualPatch';
  }
});
define('frampton-dom/utils/is_same_node', ['exports', 'frampton-utils/is_defined'], function (exports, _is_defined) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = is_same_node;

  var _is_defined2 = _interopRequireDefault(_is_defined);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function keysMatch(oldKey, newKey) {
    return (0, _is_defined2.default)(oldKey) && (0, _is_defined2.default)(newKey) && oldKey === newKey;
  }

  function is_same_node(oldNode, newNode) {
    return (0, _is_defined2.default)(oldNode) && (0, _is_defined2.default)(newNode) && oldNode.tagName === newNode.tagName && keysMatch(oldNode.key, newNode.key);
  }
});
define('frampton-dom/utils/is_text', ['exports', 'frampton-utils/is_object'], function (exports, _is_object) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = is_text;

  var _is_object2 = _interopRequireDefault(_is_object);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function is_text(node) {
    return (0, _is_object2.default)(node) && node.ctor === 'VirtualText';
  }
});
define("frampton-dom/utils/node_at_index", ["exports"], function (exports) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = node_at_index;
  function node_at_index(node, index) {
    if (node && node.childNodes) {
      return node.childNodes[index] || null;
    } else {
      return null;
    }
  }
});
define('frampton-dom/utils/normalized_frame', ['exports', 'frampton-utils/is_number', 'frampton-list/contains', 'frampton-dom/utils/easing'], function (exports, _is_number, _contains, _easing) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = normalized_frame;

  var _is_number2 = _interopRequireDefault(_is_number);

  var _contains2 = _interopRequireDefault(_contains);

  var _easing2 = _interopRequireDefault(_easing);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  var alias_mapping = {
    duration: 'transition-duration',
    delay: 'transition-delay'
  };

  var durations = (0, _contains2.default)(['transition-duration', 'transition-delay']);

  var pixels = (0, _contains2.default)(['height', 'width', 'left', 'top', 'right', 'bottom']);

  function normalized_frame(frame) {
    var obj = {};
    for (var key in frame) {
      if (alias_mapping[key]) {
        if ((0, _is_number2.default)(frame[key])) {
          obj[alias_mapping[key]] = frame[key] + 'ms';
        } else {
          obj[alias_mapping[key]] = frame[key];
        }
      } else if (pixels(key) && (0, _is_number2.default)(frame[key])) {
        obj[key] = frame[key] + 'px';
      } else if (durations(key) && (0, _is_number2.default)(frame[key])) {
        obj[key] = frame[key] + 'ms';
      } else if (key === 'transition-timing-function') {
        obj[key] = _easing2.default[frame[key]] ? _easing2.default[frame[key]] : frame[key];
      } else {
        obj[key] = frame[key];
      }
    }
    return obj;
  }
});
define('frampton-dom/utils/not_empty', ['exports'], function (exports) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = notEmtpy;
  function notEmtpy(str) {
    return str.trim() !== '';
  }
});
define('frampton-dom/utils/props_diff', ['exports', 'frampton-dom/utils/diff_props'], function (exports, _diff_props) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = props_diff;

  var _diff_props2 = _interopRequireDefault(_diff_props);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function props_diff(oldNode, newNode) {
    return (0, _diff_props2.default)(oldNode.attributes, newNode.attributes);
  }
});
define("frampton-dom/utils/reflow", ["exports"], function (exports) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = reflow;
  /**
   * Forces browser reflow by reading the offsetHeight of given element
   *
   * @name reflow
   * @method
   * @private
   * @memberof Frampton.DOM.Utils
   * @param {Object} element DomNode to reflow
   */
  function reflow(element) {
    return element.offsetWidth;
  }
});
define('frampton-dom/utils/request_frame', ['exports', 'frampton-utils/is_function'], function (exports, _is_function) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  exports.default = function (callback) {
    if ((0, _is_function2.default)(window.requestAnimationFrame)) {
      window.requestAnimationFrame(callback);
    } else {
      setTimeout(callback, 1000 / 60);
    }
  };

  var _is_function2 = _interopRequireDefault(_is_function);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }
});
define('frampton-dom/utils/transition_in', ['exports', 'frampton-dom/ops/apply_transition', 'frampton-dom/utils/validated_transition'], function (exports, _apply_transition, _validated_transition) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = transitionIn;

  var _apply_transition2 = _interopRequireDefault(_apply_transition);

  var _validated_transition2 = _interopRequireDefault(_validated_transition);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function handleTransition(node) {
    function eventHandler(evt) {
      if (evt.target === node) {
        node.removeEventListener('transitionend', eventHandler);
        node.removeAttribute('data-transition-in');
      }
    }
    node.addEventListener('transitionend', eventHandler);
  }

  function transitionIn(node, transition) {
    handleTransition(node);
    node.setAttribute('data-transition-in', 'true');
    (0, _apply_transition2.default)(node, (0, _validated_transition2.default)(transition));
  }
});
define('frampton-dom/utils/transition_out', ['exports', 'frampton-dom/ops/remove_node', 'frampton-dom/ops/apply_transition', 'frampton-dom/utils/validated_transition'], function (exports, _remove_node, _apply_transition, _validated_transition) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = transitionOut;

  var _remove_node2 = _interopRequireDefault(_remove_node);

  var _apply_transition2 = _interopRequireDefault(_apply_transition);

  var _validated_transition2 = _interopRequireDefault(_validated_transition);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function handleTransition(node) {
    function eventHandler(evt) {
      if (evt.target === node) {
        node.removeEventListener('transitionend', eventHandler);
        (0, _remove_node2.default)(node);
      }
    }
    node.addEventListener('transitionend', eventHandler);
  }

  function transitionOut(node, transition) {
    handleTransition(node);
    node.removeAttribute('data-transition-in');
    node.setAttribute('data-transition-out', 'true');
    (0, _apply_transition2.default)(node, (0, _validated_transition2.default)(transition));
  }
});
define('frampton-dom/utils/validated_class', ['exports', 'frampton-utils/is_array', 'frampton-utils/is_string', 'frampton-utils/is_object', 'frampton-dom/utils/not_empty', 'frampton-dom/utils/empty_class'], function (exports, _is_array, _is_string, _is_object, _not_empty, _empty_class) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = validated_class;

  var _is_array2 = _interopRequireDefault(_is_array);

  var _is_string2 = _interopRequireDefault(_is_string);

  var _is_object2 = _interopRequireDefault(_is_object);

  var _not_empty2 = _interopRequireDefault(_not_empty);

  var _empty_class2 = _interopRequireDefault(_empty_class);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function splitClass(str) {
    return str.split(' ').filter(_not_empty2.default);
  }

  /**
   * @name validatedClass
   */
  function validated_class(str) {

    var newClass = (0, _empty_class2.default)();

    if ((0, _is_string2.default)(str)) {

      newClass.add = splitClass(str);
    } else if ((0, _is_object2.default)(str)) {

      if ((0, _is_array2.default)(str.add)) {
        newClass.add = str.add;
      } else if ((0, _is_string2.default)(str.add)) {
        newClass.add = splitClass(str.add);
      }

      if ((0, _is_array2.default)(str.remove)) {
        newClass.remove = str.remove;
      } else if ((0, _is_string2.default)(str.remove)) {
        newClass.remove = splitClass(str.remove);
      }
    }

    return newClass;
  }
});
define('frampton-dom/utils/validated_transition', ['exports', 'frampton-dom/utils/normalized_frame', 'frampton-dom/utils/validated_class', 'frampton-dom/utils/empty_transition'], function (exports, _normalized_frame, _validated_class, _empty_transition) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = validated_transition;

  var _normalized_frame2 = _interopRequireDefault(_normalized_frame);

  var _validated_class2 = _interopRequireDefault(_validated_class);

  var _empty_transition2 = _interopRequireDefault(_empty_transition);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  var DENYLIST = ['display', 'transition', 'transition-property', 'transition-duration', 'transition-delay', 'transition-timing-function'];

  function shouldAddProp(transition, prop) {
    return transition.props.indexOf(prop) === -1 && DENYLIST.indexOf(prop) === -1;
  }

  function isEmptyDesc(desc) {
    return !desc.cleanup && !desc.from && !desc.to && !desc.class && !desc.style;
  }

  function validated_transition(desc) {

    if (!desc) {
      return (0, _empty_transition2.default)();
    } else {

      var newTransition = (0, _empty_transition2.default)();

      if (isEmptyDesc(desc)) {
        newTransition.to.style = (0, _normalized_frame2.default)(desc || {});
      } else {
        if (desc.cleanup) {
          if (desc.cleanup.style || desc.cleanup.class) {
            newTransition.cleanup.class = (0, _validated_class2.default)(desc.cleanup.class);
            newTransition.cleanup.style = (0, _normalized_frame2.default)(desc.cleanup.style || {});
          } else {
            newTransition.cleanup.style = (0, _normalized_frame2.default)(desc.cleanup || {});
          }
        }

        if (desc.from) {
          if (desc.from.style || desc.from.class) {
            newTransition.from.class = (0, _validated_class2.default)(desc.from.class);
            newTransition.from.style = (0, _normalized_frame2.default)(desc.from.style || {});
          } else {
            newTransition.from.style = (0, _normalized_frame2.default)(desc.from || {});
          }
        }

        if (desc.to) {
          if (desc.to.style || desc.to.class) {
            newTransition.to.class = (0, _validated_class2.default)(desc.to.class);
            newTransition.to.style = (0, _normalized_frame2.default)(desc.to.style || {});
          } else {
            newTransition.to.style = (0, _normalized_frame2.default)(desc.to || {});
          }
        }

        if (desc.class) {
          newTransition.to.class = (0, _validated_class2.default)(desc.class);
        }

        if (desc.style) {
          newTransition.to.style = (0, _normalized_frame2.default)(desc.style || {});
        }
      }

      for (var key in newTransition.to.style) {
        if (shouldAddProp(newTransition, key)) {
          newTransition.props.push(key);
        }
      }

      for (var _key in newTransition.from.style) {
        if (shouldAddProp(newTransition, _key)) {
          newTransition.props.push(_key);
        }
      }

      return newTransition;
    }
  }
});
define('frampton-dom/virtual/node', ['exports', 'frampton-list/length', 'frampton-utils/is_defined', 'frampton-utils/is_array', 'frampton-utils/is_object', 'frampton-utils/is_string'], function (exports, _length, _is_defined, _is_array, _is_object, _is_string) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = VirtualNode;

  var _length2 = _interopRequireDefault(_length);

  var _is_defined2 = _interopRequireDefault(_is_defined);

  var _is_array2 = _interopRequireDefault(_is_array);

  var _is_object2 = _interopRequireDefault(_is_object);

  var _is_string2 = _interopRequireDefault(_is_string);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  var noChildren = [];
  var noAttributes = {};

  /**
   * @name VirtualNode
   * @memberof Frampton.DOM
   * @class
   * @private
   * @param {String} name Tag name for new node
   * @param {Object} attrs Attributes to apply to new node
   * @param {Array} children List of child nodes
   * @returns {VirtualNode} A new VirtualNode
   */
  function VirtualNode(name, attrs, children) {

    if (!(0, _is_string2.default)(name)) {
      throw new Error('VirtualNode must have a string name');
    }

    if ((0, _is_array2.default)(attrs)) {
      children = attrs;
    }

    attrs = (0, _is_object2.default)(attrs) ? attrs : noAttributes;
    children = (0, _is_array2.default)(children) ? children : noChildren;

    return {
      ctor: 'VirtualNode',
      id: attrs.id,
      key: (0, _is_defined2.default)(attrs.key) ? attrs.key : attrs.id,
      tagName: name,
      attributes: attrs,
      children: children,
      length: (0, _length2.default)(children),
      mappings: []
    };
  }
});
define('frampton-dom/virtual/patch', ['exports', 'frampton-dom/virtual/patch_types'], function (exports, _patch_types) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.reorder = exports.text = exports.props = exports.replace = exports.remove = exports.insert = exports.none = undefined;

  var _patch_types2 = _interopRequireDefault(_patch_types);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * @name VirtualPatch
   * @memberof Frampton.DOM
   * @class
   * @private
   * @param {Number} type Type of patch
   * @param {VirtualNode} node VirtualNode to patch
   * @param {*} update Description of update to make
   * @returns {VirtualPatch} A new VirtualPatch
   */
  function VirtualPatch(type, node, update) {
    return {
      ctor: 'VirtualPatch',
      type: type,
      node: node,
      update: update
    };
  }

  var none = exports.none = function none(node, patch) {
    return VirtualPatch(_patch_types2.default.NONE, node, patch);
  };

  var insert = exports.insert = function insert(node, patch) {
    return VirtualPatch(_patch_types2.default.INSERT, node, patch);
  };

  var remove = exports.remove = function remove(node, patch) {
    return VirtualPatch(_patch_types2.default.REMOVE, node, patch);
  };

  var replace = exports.replace = function replace(node, patch) {
    return VirtualPatch(_patch_types2.default.REPLACE, node, patch);
  };

  var props = exports.props = function props(node, patch) {
    return VirtualPatch(_patch_types2.default.PROPS, node, patch);
  };

  var text = exports.text = function text(node, patch) {
    return VirtualPatch(_patch_types2.default.TEXT, node, patch);
  };

  var reorder = exports.reorder = function reorder(node, patch) {
    return VirtualPatch(_patch_types2.default.REORDER, node, patch);
  };
});
define("frampton-dom/virtual/patch_types", ["exports"], function (exports) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = {
    NONE: 0,
    INSERT: 1,
    REMOVE: 2,
    REPLACE: 3,
    PROPS: 4,
    REORDER: 5,
    TEXT: 6
  };
});
define('frampton-dom/virtual/text', ['exports'], function (exports) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = VirtualText;
  /**
   * @name VirtualText
   * @memberof Frampton.DOM
   * @class
   * @private
   * @param {String} str Text content for new text node
   * @returns {VirtualText} A new VirtualText
   */
  function VirtualText(str) {
    return {
      ctor: 'VirtualText',
      text: str
    };
  }
});
require("frampton-dom");
})();

(function() {
/*globals Frampton:true */
var define, require;
var global = this;

(function() {

  if (typeof Frampton === 'undefined') {
    throw new Error('Frampton is undefined');
  };

  define = Frampton.__loader.define;
  require = Frampton.__loader.require;

}());
define('frampton-io', ['frampton/namespace', 'frampton-io/response', 'frampton-io/http/request', 'frampton-io/http/send', 'frampton-io/http/delete', 'frampton-io/http/put', 'frampton-io/http/patch', 'frampton-io/http/get', 'frampton-io/http/post', 'frampton-io/http/post_json', 'frampton-io/http/post_string', 'frampton-io/http/upload', 'frampton-io/http/utils/url', 'frampton-io/http/utils/query_pair', 'frampton-io/http/utils/query_escape', 'frampton-io/http/utils/query_string', 'frampton-io/http/utils/uri_encode', 'frampton-io/http/utils/uri_decode', 'frampton-io/file/read', 'frampton-io/file/data_url', 'frampton-io/file/binary_string', 'frampton-io/file/array_buffer', 'frampton-io/file/text'], function (_namespace, _response, _request, _send, _delete, _put, _patch, _get, _post, _post_json, _post_string, _upload, _url, _query_pair, _query_escape, _query_string, _uri_encode, _uri_decode, _read, _data_url, _binary_string, _array_buffer, _text) {
  'use strict';

  var _namespace2 = _interopRequireDefault(_namespace);

  var _response2 = _interopRequireDefault(_response);

  var _request2 = _interopRequireDefault(_request);

  var _send2 = _interopRequireDefault(_send);

  var _delete2 = _interopRequireDefault(_delete);

  var _put2 = _interopRequireDefault(_put);

  var _patch2 = _interopRequireDefault(_patch);

  var _get2 = _interopRequireDefault(_get);

  var _post2 = _interopRequireDefault(_post);

  var _post_json2 = _interopRequireDefault(_post_json);

  var _post_string2 = _interopRequireDefault(_post_string);

  var _upload2 = _interopRequireDefault(_upload);

  var _url2 = _interopRequireDefault(_url);

  var _query_pair2 = _interopRequireDefault(_query_pair);

  var _query_escape2 = _interopRequireDefault(_query_escape);

  var _query_string2 = _interopRequireDefault(_query_string);

  var _uri_encode2 = _interopRequireDefault(_uri_encode);

  var _uri_decode2 = _interopRequireDefault(_uri_decode);

  var _read2 = _interopRequireDefault(_read);

  var _data_url2 = _interopRequireDefault(_data_url);

  var _binary_string2 = _interopRequireDefault(_binary_string);

  var _array_buffer2 = _interopRequireDefault(_array_buffer);

  var _text2 = _interopRequireDefault(_text);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * @name IO
   * @namespace
   * @memberof Frampton
   */
  _namespace2.default.IO = {};
  _namespace2.default.IO.VERSION = '0.1.3';
  _namespace2.default.IO.Response = _response2.default;

  /**
   * @name Http
   * @memberof Frampton.IO
   * @namespace
   */
  _namespace2.default.IO.Http = {};
  _namespace2.default.IO.Http.Request = _request2.default;
  _namespace2.default.IO.Http.send = _send2.default;
  _namespace2.default.IO.Http.get = _get2.default;
  _namespace2.default.IO.Http.post = _post2.default;
  _namespace2.default.IO.Http.postJson = _post_json2.default;
  _namespace2.default.IO.Http.postString = _post_string2.default;
  _namespace2.default.IO.Http.delete = _delete2.default;
  _namespace2.default.IO.Http.patch = _patch2.default;
  _namespace2.default.IO.Http.put = _put2.default;
  _namespace2.default.IO.Http.upload = _upload2.default;

  /**
   * @name Utils
   * @memberof Frampton.IO.Http
   * @namespace
   */
  _namespace2.default.IO.Http.Utils = {};
  _namespace2.default.IO.Http.Utils.url = _url2.default;
  _namespace2.default.IO.Http.Utils.queryPair = _query_pair2.default;
  _namespace2.default.IO.Http.Utils.queryEscape = _query_escape2.default;
  _namespace2.default.IO.Http.Utils.queryString = _query_string2.default;
  _namespace2.default.IO.Http.Utils.uriEncode = _uri_encode2.default;
  _namespace2.default.IO.Http.Utils.uriDecode = _uri_decode2.default;

  /**
   * @name File
   * @memberof Frampton.IO
   * @namespace
   */
  _namespace2.default.IO.File = {};
  _namespace2.default.IO.File.read = _read2.default;
  _namespace2.default.IO.File.dataUrl = _data_url2.default;
  _namespace2.default.IO.File.binaryString = _binary_string2.default;
  _namespace2.default.IO.File.arrayBuffer = _array_buffer2.default;
  _namespace2.default.IO.File.text = _text2.default;
});
define('frampton-io/file/array_buffer', ['exports', 'frampton-io/file/read'], function (exports, _read) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = array_buffer;

  var _read2 = _interopRequireDefault(_read);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function array_buffer(file) {
    return (0, _read2.default)('ARRAY_BUFFER', file);
  }
});
define('frampton-io/file/binary_string', ['exports', 'frampton-io/file/read'], function (exports, _read) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = binary_string;

  var _read2 = _interopRequireDefault(_read);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function binary_string(file) {
    return (0, _read2.default)('BINARY_STRING', file);
  }
});
define('frampton-io/file/data_url', ['exports', 'frampton-io/file/read'], function (exports, _read) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = data_url;

  var _read2 = _interopRequireDefault(_read);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function data_url(file) {
    return (0, _read2.default)('DATA_URL', file);
  }
});
define('frampton-io/file/read', ['exports', 'frampton-data/task/create', 'frampton-io/response', 'frampton-io/file/read_api'], function (exports, _create, _response, _read_api) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = read_file;

  var _create2 = _interopRequireDefault(_create);

  var _response2 = _interopRequireDefault(_response);

  var _read_api2 = _interopRequireDefault(_read_api);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  // read_file :: String -> File -> Task Response
  function read_file(method, file) {

    return (0, _create2.default)(function (sinks) {

      var reader = (0, _read_api2.default)();

      if (sinks.start) {
        reader.addEventListener('loadstart', function (evt) {
          sinks.start((0, _response2.default)('start', 0, null));
        });
      }

      if (sinks.progress) {
        reader.addEventListener('progress', function (evt) {
          sinks.progress((0, _response2.default)('progress', evt.loaded / evt.total, null));
        });
      }

      reader.addEventListener('load', function (evt) {
        sinks.resolve((0, _response2.default)('success', 1, evt.target.result));
      });

      reader.addEventListener('error', function (err) {
        sinks.reject((0, _response2.default)('error', 0, err.message));
      });

      reader.addEventListener('abort', function (evt) {
        sinks.reject((0, _response2.default)('error', 0, 'abort'));
      });

      switch (method) {
        case 'DATA_URL':
          reader.readAsDataURL(file);
          break;

        case 'ARRAY_BUFFER':
          reader.readAsArrayBuffer(file);
          break;

        case 'TEXT':
          reader.readAsText(file);
          break;

        case 'BINARY_STRING':
          reader.readAsBinaryString(file);
          break;
      }
    });
  }
});
define('frampton-io/file/read_api', ['exports', 'frampton/namespace', 'frampton-utils/apply'], function (exports, _namespace, _apply) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = ajax;

  var _namespace2 = _interopRequireDefault(_namespace);

  var _apply2 = _interopRequireDefault(_apply);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function MockReader() {
    this.listeners = {};
    this.readTime = Math.random() * 3000 + 300;
    this.progress = 0;
  }

  MockReader.prototype.timeout = 10000;

  MockReader.prototype.read = function () {
    var _this = this;

    this.progressInterval = setInterval(function () {
      if (_this.listeners['progress']) {
        _this.listeners['progress'].forEach(function (next) {
          _this.progress += 15;
          next({
            loaded: _this.progress / _this.readTime * 500,
            total: 500
          });
        });
      }
    }, 20);

    setTimeout(function () {

      if (_this.progressInterval) {
        clearInterval(_this.progressInterval);
        _this.progressInterval = null;
      }

      if (_this.listeners['load']) {
        _this.listeners['load'].forEach(function (next) {
          next({
            target: {
              result: 'test'
            }
          });
        });
      }
    }, this.readTime);

    if (this.listeners['start']) {
      this.listeners['start'].forEach(_apply2.default);
    }
  };

  MockReader.prototype.addEventListener = function (name, callback) {

    if (!this.listeners[name]) {
      this.listeners[name] = [];
    }

    if (this.listeners[name].indexOf(callback) === -1) {
      this.listeners[name].push(callback);
    }
  };

  MockReader.prototype.readAsDataURL = function (file) {
    this.read(file);
  };

  MockReader.prototype.readAsArrayBuffer = function (file) {
    this.read(file);
  };

  MockReader.prototype.readAsText = function (file) {
    this.read(file);
  };

  MockReader.prototype.readAsBinaryString = function (file) {
    this.read(file);
  };

  function ajax() {
    if (_namespace2.default.isTest()) {
      return new MockReader();
    } else {
      return new FileReader();
    }
  }
});
define('frampton-io/file/text', ['exports', 'frampton-io/file/read'], function (exports, _read) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = text;

  var _read2 = _interopRequireDefault(_read);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function text(file) {
    return (0, _read2.default)('TEXT', file);
  }
});
define('frampton-io/http/delete', ['exports', 'frampton-io/http/request', 'frampton-io/http/send', 'frampton-io/http/utils/default_settings'], function (exports, _request, _send, _default_settings) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = delete_request;

  var _request2 = _interopRequireDefault(_request);

  var _send2 = _interopRequireDefault(_send);

  var _default_settings2 = _interopRequireDefault(_default_settings);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * Returns a task that will perform an HTTP DELETE
   *
   * @name delete
   * @method
   * @memberof Frampton.IO.Http
   * @param {String} url  Url to send request to
   * @param {Object} data Data to send with request
   * @returns {Frampton.Data.Task}
   */
  function delete_request(url, data) {
    return (0, _send2.default)(_default_settings2.default, (0, _request2.default)(url, 'DELETE', data || null));
  }
});
define('frampton-io/http/get', ['exports', 'frampton-io/http/request', 'frampton-io/http/utils/url', 'frampton-io/http/send', 'frampton-io/http/utils/default_settings'], function (exports, _request, _url, _send, _default_settings) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = get_request;

  var _request2 = _interopRequireDefault(_request);

  var _url2 = _interopRequireDefault(_url);

  var _send2 = _interopRequireDefault(_send);

  var _default_settings2 = _interopRequireDefault(_default_settings);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * Returns a task that will perform an HTTP GET
   *
   * @name get
   * @method
   * @memberof Frampton.IO.Http
   * @param {String} url    Url to send request to
   * @param {Object} [data] Data to send with request. Is encoded and appended to url.
   * @returns {Frampton.Data.Task} A Task of a Response
   */
  function get_request(url, data) {
    return (0, _send2.default)(_default_settings2.default, (0, _request2.default)((0, _url2.default)(url, data)));
  }
});
define('frampton-io/http/patch', ['exports', 'frampton-io/http/request', 'frampton-io/http/send', 'frampton-io/http/utils/default_settings'], function (exports, _request, _send, _default_settings) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = patch_request;

  var _request2 = _interopRequireDefault(_request);

  var _send2 = _interopRequireDefault(_send);

  var _default_settings2 = _interopRequireDefault(_default_settings);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * Returns a task that will perform an HTTP PATCH
   *
   * @name patch
   * @method
   * @memberof Frampton.IO.Http
   * @param {String} url  Url to send request to
   * @param {Object} data Data to send with request
   * @returns {Frampton.Data.Task}
   */
  function patch_request(url, data) {
    return (0, _send2.default)(_default_settings2.default, (0, _request2.default)(url, 'PATCH', data || null));
  }
});
define('frampton-io/http/post', ['exports', 'frampton-io/http/request', 'frampton-io/http/send', 'frampton-io/http/utils/default_settings'], function (exports, _request, _send, _default_settings) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = post_request;

  var _request2 = _interopRequireDefault(_request);

  var _send2 = _interopRequireDefault(_send);

  var _default_settings2 = _interopRequireDefault(_default_settings);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * Returns a task that will perform an HTTP POST
   *
   * @name post
   * @method
   * @memberof Frampton.IO.Http
   * @param {String} url  Url to send request to
   * @param {Object} data Data to send with request
   * @returns {Frampton.Data.Task}
   */
  function post_request(url, data, headers) {
    return (0, _send2.default)(_default_settings2.default, (0, _request2.default)(url, 'POST', data || null, headers || null));
  }
});
define('frampton-io/http/post_json', ['exports', 'frampton-utils/curry', 'frampton-utils/is_object', 'frampton-io/http/post'], function (exports, _curry, _is_object, _post) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  var _is_object2 = _interopRequireDefault(_is_object);

  var _post2 = _interopRequireDefault(_post);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function post_json(url, data) {

    if ((0, _is_object2.default)(data)) {
      data = JSON.stringify(data);
    }

    return (0, _post2.default)(url, data || null, {
      'Content-Type': 'application/json'
    });
  });
});
define('frampton-io/http/post_string', ['exports', 'frampton-utils/curry', 'frampton-utils/is_object', 'frampton-io/http/post', 'frampton-io/http/utils/query_string'], function (exports, _curry, _is_object, _post, _query_string) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  var _is_object2 = _interopRequireDefault(_is_object);

  var _post2 = _interopRequireDefault(_post);

  var _query_string2 = _interopRequireDefault(_query_string);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function post_string(url, data) {

    if ((0, _is_object2.default)(data)) {
      data = (0, _query_string2.default)(data);
    }

    return (0, _post2.default)(url, data || null, {
      'Content-Type': 'application/x-www-form-urlencoded'
    });
  });
});
define('frampton-io/http/put', ['exports', 'frampton-io/http/request', 'frampton-io/http/send', 'frampton-io/http/utils/default_settings'], function (exports, _request, _send, _default_settings) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = put_request;

  var _request2 = _interopRequireDefault(_request);

  var _send2 = _interopRequireDefault(_send);

  var _default_settings2 = _interopRequireDefault(_default_settings);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * Returns a task that will perform an HTTP PUT
   *
   * @name put
   * @method
   * @memberof Frampton.IO.Http
   * @param {String} url  Url to send request to
   * @param {Object} data Data to send with request
   * @returns {Frampton.Data.Task}
   */
  function put_request(url, data) {
    return (0, _send2.default)(_default_settings2.default, (0, _request2.default)(url, 'PUT', data || null));
  }
});
define('frampton-io/http/request', ['exports'], function (exports) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = Request;
  /**
   * @name Request
   * @method
   * @memberof Frampton.IO.Http
   * @param {String} url            Url to send request to.
   * @param {String} [method='GET'] Http request method to use
   * @param {Object} [data=null]    Data to send with request
   * @param {Object} [headers={}]   Headers to add to request
   * @returns {Object}
   */
  function Request(url, method, data, headers) {
    return {
      url: url,
      timestamp: Date.now(),
      method: method || 'GET',
      body: data || null,
      headers: headers || {}
    };
  }
});
define('frampton-io/http/send', ['exports', 'frampton-utils/error', 'frampton-data/task/create', 'frampton-io/http/utils/ajax_api', 'frampton-io/response'], function (exports, _error, _create, _ajax_api, _response) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = send;

  var _error2 = _interopRequireDefault(_error);

  var _create2 = _interopRequireDefault(_create);

  var _ajax_api2 = _interopRequireDefault(_ajax_api);

  var _response2 = _interopRequireDefault(_response);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * Perform an AJAX request and return an EventStream that reports the progress.
   *
   * @name send
   * @method
   * @memberof Frampton.IO.Http
   * @param {Object} settings A hash of general settings for the request
   * @param {Object} request  A hash describing the request to be made
   * @returns {Frampton.Task} An EventStream of Response objects
   */
  function send(settings, request) {

    var xhr = (0, _ajax_api2.default)();

    return (0, _create2.default)(function (sinks) {

      xhr.open(request.method, request.url, true);

      if (sinks.start) {
        xhr.addEventListener('loadstart', function (evt) {
          sinks.start((0, _response2.default)('start', 0, null));
        });
      }

      if (sinks.progress) {
        xhr.addEventListener('progress', function (evt) {
          var progress = (evt.loaded || evt.position) / (evt.total || evt.totalSize);
          progress = progress === Infinity ? 100 : progress;
          sinks.progress((0, _response2.default)('progress', progress, null));
        });
      }

      xhr.addEventListener('error', function (err) {
        (0, _error2.default)('Processing ' + request.method + ' for: ' + request.url);
        sinks.reject((0, _response2.default)('error', 0, err.message));
      });

      xhr.addEventListener('timeout', function (err) {
        (0, _error2.default)('Timeout ' + request.method + ' for: ' + request.url);
        sinks.reject((0, _response2.default)('error', 0, 'timeout'));
      });

      xhr.addEventListener('load', function (evt) {

        var target = evt.target;
        var response;

        try {
          response = JSON.parse(target.response);
        } catch (e) {
          response = target.response;
        }

        if (target.status >= 200 && target.status < 300) {
          sinks.resolve((0, _response2.default)('success', 1, response));
        } else {
          (0, _error2.default)('Non-200 response ' + request.method + ' for: ' + request.url);
          sinks.reject((0, _response2.default)('error', 0, response));
        }
      });

      for (var key in request.headers) {
        xhr.setRequestHeader(key, request.headers[key]);
      }

      xhr.timeout = settings.timeout;

      xhr.send(request.body);
    });
  }
});
define('frampton-io/http/upload', ['exports', 'frampton-utils/curry', 'frampton-io/http/post'], function (exports, _curry, _post) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  var _post2 = _interopRequireDefault(_post);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function upload(url, file) {
    var formData = new FormData();
    formData.append('file-0', file);
    return (0, _post2.default)(url, formData);
  });
});
define('frampton-io/http/upload_many', ['exports', 'frampton-utils/curry', 'frampton-io/http/post'], function (exports, _curry, _post) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  var _post2 = _interopRequireDefault(_post);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function upload(url, files) {
    var formData = new FormData();
    for (var i = 0; i < files.length; i++) {
      formData.append('file-' + i, files[i]);
    }
    return (0, _post2.default)(url, formData);
  });
});
define('frampton-io/http/utils/ajax_api', ['exports', 'frampton/namespace', 'frampton-utils/apply'], function (exports, _namespace, _apply) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = ajax_api;

  var _namespace2 = _interopRequireDefault(_namespace);

  var _apply2 = _interopRequireDefault(_apply);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function MockAjax() {
    this.method = 'GET';
    this.url = '';
    this.listeners = {};
    this.headers = {};
    this.requestTime = Math.random() * 1000 + 300;
    this.progress = 0;
  }

  MockAjax.prototype.timeout = 10000;

  MockAjax.prototype.open = function (method, url) {
    this.method = method;
    this.url = url;
  };

  MockAjax.prototype.send = function () {
    var _this = this;

    this.progressInterval = setInterval(function () {
      if (_this.listeners['progress']) {
        _this.listeners['progress'].forEach(function (next) {
          _this.progress += 15;
          next({
            loaded: _this.progress / _this.requestTime * 500,
            total: 500
          });
        });
      }
    }, 20);

    setTimeout(function () {

      var methodUrl = _this.method + ':' + _this.url;
      var methodResponse = _namespace2.default.mock(methodUrl);
      var baseResponse = _namespace2.default.mock(_this.url);
      var data = methodResponse || baseResponse || 'test';

      if (_this.progressInterval) {
        clearInterval(_this.progressInterval);
        _this.progressInterval = null;
      }

      if (_this.listeners['load']) {
        _this.listeners['load'].forEach(function (next) {
          next({
            target: {
              response: data,
              status: 200
            },
            total: 500,
            loaded: 500
          });
        });
      }
    }, this.requestTime);

    if (this.listeners['start']) {
      this.listeners['start'].forEach(_apply2.default);
    }
  };

  MockAjax.prototype.addEventListener = function (name, callback) {

    if (!this.listeners[name]) {
      this.listeners[name] = [];
    }

    if (this.listeners[name].indexOf(callback) === -1) {
      this.listeners[name].push(callback);
    }
  };

  MockAjax.prototype.setRequestHeader = function (key, value) {
    this.headers[key] = value;
  };

  /**
   * Returns either an instance of XMLHttpRequest or a mock instance if in testing mode.
   *
   * @name ajaxApi
   * @method
   * @memberof Frampton.IO.Http
   * @returns {Object} Instance of XMLHttpRequest for current environment
   */
  function ajax_api() {
    if (_namespace2.default.isTest()) {
      return new MockAjax();
    } else {
      return new XMLHttpRequest();
    }
  }
});
define("frampton-io/http/utils/default_settings", ["exports"], function (exports) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = Object.freeze({
    timeout: 30 * 1000
  });
});
define('frampton-io/http/utils/query_escape', ['exports', 'frampton-utils/memoize', 'frampton-io/http/utils/uri_encode', 'frampton-string/join', 'frampton-string/split'], function (exports, _memoize, _uri_encode, _join, _split) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _memoize2 = _interopRequireDefault(_memoize);

  var _uri_encode2 = _interopRequireDefault(_uri_encode);

  var _join2 = _interopRequireDefault(_join);

  var _split2 = _interopRequireDefault(_split);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _memoize2.default)(function query_escape(str) {
    return (0, _join2.default)('+', (0, _split2.default)('%20', (0, _uri_encode2.default)(str)));
  });
});
define('frampton-io/http/utils/query_pair', ['exports', 'frampton-io/http/utils/query_escape'], function (exports, _query_escape) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = query_pair;

  var _query_escape2 = _interopRequireDefault(_query_escape);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  // query_pair :: [String, String] -> String
  function query_pair(pair) {
    return (0, _query_escape2.default)(pair[0]) + '=' + (0, _query_escape2.default)(pair[1]);
  }
});
define('frampton-io/http/utils/query_string', ['exports', 'frampton-utils/is_array', 'frampton-utils/is_object', 'frampton-utils/is_something', 'frampton-string/join', 'frampton-io/http/utils/query_escape'], function (exports, _is_array, _is_object, _is_something, _join, _query_escape) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = query_string;

  var _is_array2 = _interopRequireDefault(_is_array);

  var _is_object2 = _interopRequireDefault(_is_object);

  var _is_something2 = _interopRequireDefault(_is_something);

  var _join2 = _interopRequireDefault(_join);

  var _query_escape2 = _interopRequireDefault(_query_escape);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function encode(prefix, obj, add) {

    if ((0, _is_array2.default)(obj)) {

      for (var i = 0; i < obj.length; i++) {

        encode(prefix + '[]', obj[i], add);
      }
    } else if ((0, _is_object2.default)(obj)) {

      for (var key in obj) {

        encode(prefix + '[' + key + ']', obj[key], add);
      }
    } else {
      add(prefix, obj);
    }
  }

  function query_string(args) {

    var params = [];

    function add(key, value) {
      if ((0, _is_something2.default)(value)) {
        params[params.length] = (0, _query_escape2.default)(key) + '=' + (0, _query_escape2.default)(value);
      }
    }

    for (var key in args) {
      encode(key, args[key], add);
    }

    return (0, _join2.default)('&', params);
  }
});
define('frampton-io/http/utils/query_unescape', ['exports', 'frampton-utils/memoize', 'frampton-io/http/utils/uri_decode', 'frampton-string/join', 'frampton-string/split'], function (exports, _memoize, _uri_decode, _join, _split) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _memoize2 = _interopRequireDefault(_memoize);

  var _uri_decode2 = _interopRequireDefault(_uri_decode);

  var _join2 = _interopRequireDefault(_join);

  var _split2 = _interopRequireDefault(_split);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _memoize2.default)(function query_unescape(str) {
    return (0, _join2.default)(' ', (0, _split2.default)('+', (0, _uri_decode2.default)(str)));
  });
});
define('frampton-io/http/utils/uri_decode', ['exports', 'frampton-utils/memoize'], function (exports, _memoize) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _memoize2 = _interopRequireDefault(_memoize);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _memoize2.default)(function uri_decode(str) {
    return decodeURIComponent(str);
  });
});
define('frampton-io/http/utils/uri_encode', ['exports', 'frampton-utils/memoize'], function (exports, _memoize) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _memoize2 = _interopRequireDefault(_memoize);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _memoize2.default)(function uri_encode(str) {
    return encodeURIComponent(str);
  });
});
define('frampton-io/http/utils/url', ['exports', 'frampton-utils/curry', 'frampton-io/http/utils/query_string'], function (exports, _curry, _query_string) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  var _query_string2 = _interopRequireDefault(_query_string);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function url_builder(domain, args) {
    if (!args) return domain;
    return domain + '?' + (0, _query_string2.default)(args);
  });
});
define("frampton-io/response", ["exports"], function (exports) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = Response;
  /**
   * @name Response
   * @method
   * @memberof Frampton.IO
   * @param {String} status       Current status of request
   * @param {Number} [progress=0] Current progress (0-1) of request
   * @param {Object} [data=null]  Data returned by request
   * @returns {Object}
   */
  function Response(status, progress, data) {
    return {
      status: status,
      timestamp: Date.now(),
      progress: progress || 0,
      complete: progress === 1,
      data: data || null
    };
  }
});
require("frampton-io");
})();

(function() {
/*globals Frampton:true */
var define, require;
var global = this;

(function() {

  if (typeof Frampton === 'undefined') {
    throw new Error('Frampton is undefined');
  };

  define = Frampton.__loader.define;
  require = Frampton.__loader.require;

}());
define('frampton-history', ['frampton/namespace', 'frampton-history/methods/set_hash', 'frampton-history/methods/push_state', 'frampton-history/methods/replace_state', 'frampton-history/methods/history_changes', 'frampton-history/signals/location', 'frampton-history/signals/depth', 'frampton-history/signals/state', 'frampton-history/signals/search', 'frampton-history/signals/hash', 'frampton-history/signals/path'], function (_namespace, _set_hash, _push_state, _replace_state, _history_changes, _location, _depth, _state, _search, _hash, _path) {
  'use strict';

  var _namespace2 = _interopRequireDefault(_namespace);

  var _set_hash2 = _interopRequireDefault(_set_hash);

  var _push_state2 = _interopRequireDefault(_push_state);

  var _replace_state2 = _interopRequireDefault(_replace_state);

  var _history_changes2 = _interopRequireDefault(_history_changes);

  var _location2 = _interopRequireDefault(_location);

  var _depth2 = _interopRequireDefault(_depth);

  var _state2 = _interopRequireDefault(_state);

  var _search2 = _interopRequireDefault(_search);

  var _hash2 = _interopRequireDefault(_hash);

  var _path2 = _interopRequireDefault(_path);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * @name History
   * @namespace
   * @memberof Frampton
   */
  _namespace2.default.History = {};
  _namespace2.default.History.VERSION = '0.1.0';
  _namespace2.default.History.pushState = _push_state2.default;
  _namespace2.default.History.replaceState = _replace_state2.default;
  _namespace2.default.History.setHash = _set_hash2.default;
  _namespace2.default.History.changes = _history_changes2.default;
  _namespace2.default.History.location = _location2.default;
  _namespace2.default.History.depth = _depth2.default;
  _namespace2.default.History.state = _state2.default;
  _namespace2.default.History.hash = _hash2.default;
  _namespace2.default.History.path = _path2.default;
  _namespace2.default.History.search = _search2.default;
});
define('frampton-history/history_stack', ['exports', 'frampton-list/last', 'frampton-history/signals/depth', 'frampton-history/signals/stack'], function (exports, _last, _depth, _stack) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.popHistory = exports.replaceHistory = exports.pushHistory = exports.stack = undefined;

  var _last2 = _interopRequireDefault(_last);

  var _depth2 = _interopRequireDefault(_depth);

  var _stack2 = _interopRequireDefault(_stack);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * The current state of the application history.
   *
   * @name stack
   * @private
   * @memberof Frampton.History
   * @type {Object}
   */
  var state = {
    currentState: null,
    currentId: 0,
    _store: []
  };

  /**
   * Pushes a new state onto the application's internal history stack. In doing
   * so it also updates the current depth of the history stack.
   *
   * @name pushHistory
   * @method
   * @private
   * @memberof Frampton.History
   * @param {Object} newState
   */
  var pushHistory = function push_state(newState) {
    state._store.push(newState);
    state.currentState = newState;
    state.currentId = newState.id;
    _depth2.default.push(state._store.length);
    _stack2.default.push(null);
  };

  /**
   * Replaces the current state on the application's internal history stack.
   *
   * @name replaceHistory
   * @method
   * @private
   * @memberof Frampton.History
   * @param {Object} newState
   */
  var replaceHistory = function replace_state(newState) {
    state.currentState = newState;
    state.currentId = newState.id;
    _stack2.default.push(null);
  };

  /**
   * Pops the last element from the application's internal history stack. In doing
   * so it also updates the current depth of the history stack.
   *
   * @name popHistory
   * @method
   * @private
   * @memberof Frampton.History
   */
  var popHistory = function pop_history() {
    state._store.pop();
    state.currentState = (0, _last2.default)(state._store);
    state.currentId = state.currentState ? state.currentState.id : 0;
    _depth2.default.push(state._store.length);
    _stack2.default.push(null);
  };

  exports.stack = state;
  exports.pushHistory = pushHistory;
  exports.replaceHistory = replaceHistory;
  exports.popHistory = popHistory;
});
define('frampton-history/methods/history_changes', ['exports', 'frampton-history/signals/location'], function (exports, _location) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = history_change;

  var _location2 = _interopRequireDefault(_location);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * @name historyChange
   * @method
   * @memberof Frampton.History.Methods
   * @param {Function} fn A function to call when history changes
   */
  function history_change(fn) {
    _location2.default.next(fn);
  }
});
define('frampton-history/methods/push_state', ['exports', 'frampton-data/task/create', 'frampton-utils/guid', 'frampton-history/utils/get_history', 'frampton-history/history_stack'], function (exports, _create, _guid, _get_history, _history_stack) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _create2 = _interopRequireDefault(_create);

  var _guid2 = _interopRequireDefault(_guid);

  var _get_history2 = _interopRequireDefault(_get_history);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = function (state) {
    return (0, _create2.default)(function (sinks) {
      state.id = (0, _guid2.default)();
      (0, _get_history2.default)().pushState(state, state.name, state.path);
      (0, _history_stack.pushHistory)(state);
      sinks.resolve(null);
    });
  };
});
define('frampton-history/methods/replace_state', ['exports', 'frampton-data/task/create', 'frampton-utils/guid', 'frampton-history/utils/get_history', 'frampton-history/history_stack'], function (exports, _create, _guid, _get_history, _history_stack) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _create2 = _interopRequireDefault(_create);

  var _guid2 = _interopRequireDefault(_guid);

  var _get_history2 = _interopRequireDefault(_get_history);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = function (state) {
    return (0, _create2.default)(function (sinks) {
      state.id = (0, _guid2.default)();
      (0, _get_history2.default)().replaceState(state, state.name, state.path);
      (0, _history_stack.replaceHistory)(state);
      sinks.resolve(null);
    });
  };
});
define('frampton-history/methods/set_hash', ['exports', 'frampton-history/history_stack'], function (exports, _history_stack) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = set_hash;


  /**
   * @name setHash
   * @method
   * @memberof Frampton.History
   * @param {String} hash
   */
  function set_hash(hash) {
    (0, _history_stack.pushState)({
      name: 'hash',
      path: '#' + hash
    });
  }
});
define('frampton-history/signals/depth', ['exports', 'frampton-signal/create'], function (exports, _create) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _create2 = _interopRequireDefault(_create);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _create2.default)(0);
});
define('frampton-history/signals/hash', ['exports', 'frampton-signal/stepper', 'frampton-history/utils/get_location', 'frampton-history/signals/hash_base'], function (exports, _stepper, _get_location, _hash_base) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _stepper2 = _interopRequireDefault(_stepper);

  var _get_location2 = _interopRequireDefault(_get_location);

  var _hash_base2 = _interopRequireDefault(_hash_base);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _stepper2.default)((0, _get_location2.default)().hash, _hash_base2.default);
});
define('frampton-history/signals/hash_base', ['exports', 'frampton-history/signals/location'], function (exports, _location) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _location2 = _interopRequireDefault(_location);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = _location2.default.map(function (loc) {
    return loc.hash.replace('#', '');
  });
});
define('frampton-history/signals/history', ['exports', 'frampton-history/utils/get_history', 'frampton-history/signals/stack', 'frampton-history/signals/popstate'], function (exports, _get_history, _stack, _popstate) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _get_history2 = _interopRequireDefault(_get_history);

  var _stack2 = _interopRequireDefault(_stack);

  var _popstate2 = _interopRequireDefault(_popstate);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = _stack2.default.merge(_popstate2.default).map(function () {
    return (0, _get_history2.default)();
  });
});
define('frampton-history/signals/location', ['exports', 'frampton-history/utils/get_location', 'frampton-history/signals/history'], function (exports, _get_location, _history) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _get_location2 = _interopRequireDefault(_get_location);

  var _history2 = _interopRequireDefault(_history);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = _history2.default.map(function () {
    return (0, _get_location2.default)();
  });
});
define('frampton-history/signals/path', ['exports', 'frampton-signal/stepper', 'frampton-history/utils/get_location', 'frampton-history/signals/path_base'], function (exports, _stepper, _get_location, _path_base) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _stepper2 = _interopRequireDefault(_stepper);

  var _get_location2 = _interopRequireDefault(_get_location);

  var _path_base2 = _interopRequireDefault(_path_base);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _stepper2.default)((0, _get_location2.default)().pathname, _path_base2.default);
});
define('frampton-history/signals/path_base', ['exports', 'frampton-history/signals/location'], function (exports, _location) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _location2 = _interopRequireDefault(_location);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = _location2.default.map(function (loc) {
    return loc.pathname;
  });
});
define('frampton-history/signals/popstate', ['exports', 'frampton-events/on_event', 'frampton-history/history_stack'], function (exports, _on_event, _history_stack) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _on_event2 = _interopRequireDefault(_on_event);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  if (!window.history || !window.history.pushState) {
    throw new Error('History API is not supported by this browser');
  }

  /**
   * Returns a Signal of popstate events. Also helps to internally keep track of
   * the current depth of the history stack.
   *
   * @name popstateSignal
   * @method
   * @private
   * @memberof Frampton.History
   * @returns {Frampton.Signal.Siganl}
   */
  exports.default = (0, _on_event2.default)('popstate', window).map(function (evt) {
    if (evt.state) {
      if (evt.state.id < _history_stack.stack.currentId) {
        (0, _history_stack.popHistory)();
      } else if (evt.state.id > _history_stack.stack.currentId) {
        (0, _history_stack.pushHistory)(evt.state);
      }
    }
    return evt;
  });
});
define('frampton-history/signals/search', ['exports', 'frampton-signal/stepper', 'frampton-history/utils/get_location', 'frampton-history/utils/parse_search', 'frampton-history/signals/search_base'], function (exports, _stepper, _get_location, _parse_search, _search_base) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _stepper2 = _interopRequireDefault(_stepper);

  var _get_location2 = _interopRequireDefault(_get_location);

  var _parse_search2 = _interopRequireDefault(_parse_search);

  var _search_base2 = _interopRequireDefault(_search_base);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _stepper2.default)((0, _parse_search2.default)((0, _get_location2.default)().search || ''), _search_base2.default);
});
define('frampton-history/signals/search_base', ['exports', 'frampton-history/signals/location', 'frampton-history/utils/parse_search'], function (exports, _location, _parse_search) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _location2 = _interopRequireDefault(_location);

  var _parse_search2 = _interopRequireDefault(_parse_search);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = _location2.default.map(function (loc) {
    return (0, _parse_search2.default)(loc.search || '');
  });
});
define('frampton-history/signals/stack', ['exports', 'frampton-signal/create'], function (exports, _create) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _create2 = _interopRequireDefault(_create);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _create2.default)();
});
define('frampton-history/signals/state', ['exports', 'frampton-signal/stepper', 'frampton-history/utils/get_history', 'frampton-history/signals/state_base'], function (exports, _stepper, _get_history, _state_base) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _stepper2 = _interopRequireDefault(_stepper);

  var _get_history2 = _interopRequireDefault(_get_history);

  var _state_base2 = _interopRequireDefault(_state_base);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _stepper2.default)((0, _get_history2.default)().state, _state_base2.default);
});
define('frampton-history/signals/state_base', ['exports', 'frampton-history/signals/history'], function (exports, _history) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _history2 = _interopRequireDefault(_history);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = _history2.default.map(function (h) {
    return h.state;
  });
});
define('frampton-history/utils/get_history', ['exports', 'frampton/namespace', 'frampton-history/utils/get_location'], function (exports, _namespace, _get_location) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = history_api;

  var _namespace2 = _interopRequireDefault(_namespace);

  var _get_location2 = _interopRequireDefault(_get_location);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  var mockInstance = null;

  function createMockHistory() {
    var stack = [];
    var currentIndex = 0;

    return {
      state: null,
      pushState: function pushState(state, title, url) {
        currentIndex++;
        (0, _get_location2.default)().pathname = url;
        stack.push({
          state: state,
          title: title,
          url: url
        });
      },
      replaceState: function replaceState(state, title, url) {
        (0, _get_location2.default)().pathname = url;
        stack[currentIndex] = {
          state: state,
          title: title,
          url: url
        };
      }
    };
  }

  function getMockHistory() {

    if (mockInstance === null) {
      mockInstance = createMockHistory();
    }

    return mockInstance;
  }

  function history_api() {
    if (_namespace2.default.isTest()) {
      return getMockHistory();
    } else {
      return window.history;
    }
  }
});
define('frampton-history/utils/get_location', ['exports', 'frampton/namespace'], function (exports, _namespace) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = location_api;

  var _namespace2 = _interopRequireDefault(_namespace);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  var instance = null;

  function createMockLocation() {
    return {
      hash: '',
      pathname: '/test/path',
      search: '?test=true'
    };
  }

  function getMockLocation() {
    if (instance === null) {
      instance = createMockLocation();
    }
    return instance;
  }

  function location_api() {
    if (_namespace2.default.isTest()) {
      return getMockLocation();
    } else {
      return window.location;
    }
  }
});
define('frampton-history/utils/parse_search', ['exports', 'frampton-utils/memoize', 'frampton-history/utils/query_unescape'], function (exports, _memoize, _query_unescape) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _memoize2 = _interopRequireDefault(_memoize);

  var _query_unescape2 = _interopRequireDefault(_query_unescape);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function validPair(pair) {
    return pair.length === 2 && pair[0] !== '' && pair[1] !== '';
  }

  /**
   * Takes a URL query string and returns a hash of key/values
   * @name parseSearch
   * @method
   * @private
   * @memberof Frampton.History
   * @param {String} search Query string to parse
   * @returns {Object}
   */
  exports.default = (0, _memoize2.default)(function parse_search(search) {
    var obj = {};
    var parts = search.replace('?', '').split('&');
    parts.forEach(function (part) {
      var pair = part.split('=');
      // check we have a properly-formed key/value pair.
      if (validPair(pair)) {
        obj[(0, _query_unescape2.default)(pair[0])] = (0, _query_unescape2.default)(pair[1]);
      }
    });
    return obj;
  });
});
define('frampton-history/utils/query_unescape', ['exports', 'frampton-utils/memoize', 'frampton-string/join', 'frampton-string/split', 'frampton-history/utils/uri_decode'], function (exports, _memoize, _join, _split, _uri_decode) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _memoize2 = _interopRequireDefault(_memoize);

  var _join2 = _interopRequireDefault(_join);

  var _split2 = _interopRequireDefault(_split);

  var _uri_decode2 = _interopRequireDefault(_uri_decode);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _memoize2.default)(function query_unescape(str) {
    return (0, _join2.default)(' ', (0, _split2.default)('+', (0, _uri_decode2.default)(str)));
  });
});
define('frampton-history/utils/uri_decode', ['exports', 'frampton-utils/memoize'], function (exports, _memoize) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _memoize2 = _interopRequireDefault(_memoize);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _memoize2.default)(function uri_decode(str) {
    return decodeURIComponent(str);
  });
});
require("frampton-history");
})();

(function() {
/*globals Frampton:true */
var define, require;
var global = this;

(function() {

  if (typeof Frampton === 'undefined') {
    throw new Error('Frampton is undefined');
  };

  define = Frampton.__loader.define;
  require = Frampton.__loader.require;

}());
define('frampton-router', ['frampton/namespace', 'frampton-router/parser', 'frampton-router/one_of', 'frampton-router/map', 'frampton-router/app'], function (_namespace, _parser, _one_of, _map, _app) {
  'use strict';

  var _namespace2 = _interopRequireDefault(_namespace);

  var _parser2 = _interopRequireDefault(_parser);

  var _one_of2 = _interopRequireDefault(_one_of);

  var _map2 = _interopRequireDefault(_map);

  var _app2 = _interopRequireDefault(_app);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * @name Router
   * @namespace
   * @memberof Frampton
   */
  _namespace2.default.Router = {};
  _namespace2.default.Router.VERSION = '0.1.1';
  _namespace2.default.Router.parser = _parser2.default;
  _namespace2.default.Router.oneOf = _one_of2.default;
  _namespace2.default.Router.map = _map2.default;
  _namespace2.default.Router.app = _app2.default;
});
define('frampton-router/app', ['exports', 'frampton-list/prepend', 'frampton-list/first', 'frampton-list/second', 'frampton-data/union/create', 'frampton-data/task/execute', 'frampton-signal/create', 'frampton-dom/scene', 'frampton-history/utils/get_location', 'frampton-history/signals/location'], function (exports, _prepend, _first, _second, _create, _execute, _create3, _scene, _get_location, _location) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = routing_app;

  var _prepend2 = _interopRequireDefault(_prepend);

  var _first2 = _interopRequireDefault(_first);

  var _second2 = _interopRequireDefault(_second);

  var _create2 = _interopRequireDefault(_create);

  var _execute2 = _interopRequireDefault(_execute);

  var _create4 = _interopRequireDefault(_create3);

  var _scene2 = _interopRequireDefault(_scene);

  var _get_location2 = _interopRequireDefault(_get_location);

  var _location2 = _interopRequireDefault(_location);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  var Messages = (0, _create2.default)({
    UrlUpdate: ['location'],
    UserAction: ['action']
  });

  /**
   * {
   *   update : Function,
   *   urlUpdate : Function,
   *   urlParser : Function,
   *   view : Function,
   *   init : Function,
   *   inputs : []
   * }
   */
  function routing_app(config) {

    if (typeof _scene2.default !== 'function') {
      throw new Error('Frampton.App.withView requires Frampton.DOM');
    }

    function update(acc, msg) {
      var model = acc[0];
      return Messages.match({
        UserAction: function UserAction(action) {
          return config.update(action, model);
        },
        UrlUpdate: function UrlUpdate(location) {
          return config.urlUpdate(config.urlParser(location), model);
        }
      }, msg);
    }

    var messages = (0, _create4.default)();
    var initialState = config.init(config.urlParser((0, _get_location2.default)()));
    var inputs = config.inputs || [];
    var userInputs = (0, _create3.mergeMany)((0, _prepend2.default)(messages, inputs)).map(Messages.UserAction);
    var locationChange = _location2.default.map(Messages.UrlUpdate);
    var allInputs = userInputs.merge(locationChange);
    var stateAndTasks = allInputs.fold(update, initialState);
    var state = stateAndTasks.map(_first2.default);
    var tasks = stateAndTasks.map(_second2.default);

    var schedule = (0, _scene2.default)(config.rootElement, messages.push);
    var html = state.map(function (next) {
      return config.view(next);
    });

    html.value(schedule);

    // Run tasks and publish any resulting actions back into messages
    (0, _execute2.default)(tasks, messages.push);

    return state;
  }
});
define('frampton-router/int', ['exports', 'frampton-router/parser'], function (exports, _parser) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _parser2 = _interopRequireDefault(_parser);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _parser2.default)(':number');
});
define('frampton-router/map', ['exports', 'frampton-utils/curry'], function (exports, _curry) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function _toConsumableArray(arr) {
    if (Array.isArray(arr)) {
      for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {
        arr2[i] = arr[i];
      }

      return arr2;
    } else {
      return Array.from(arr);
    }
  }

  exports.default = (0, _curry2.default)(function (mapping, parser) {
    return function (path) {
      return parser(path).map(function (match) {
        return mapping.apply(undefined, _toConsumableArray(match));
      });
    };
  });
});
define('frampton-router/one_of', ['exports', 'frampton-data/maybe/just', 'frampton-data/maybe/nothing'], function (exports, _just, _nothing) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _just2 = _interopRequireDefault(_just);

  var _nothing2 = _interopRequireDefault(_nothing);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function _toArray(arr) {
    return Array.isArray(arr) ? arr : Array.from(arr);
  }

  // match : [ Parser ] -> String -> Maybe a
  function match(parsers, path) {
    var _parsers = _toArray(parsers),
        parser = _parsers[0],
        tail = _parsers.slice(1);

    return parser(path).fork(function (val) {
      return (0, _just2.default)(val);
    }, function () {
      if (parsers.length > 1) {
        return match(tail, path);
      } else {
        return (0, _nothing2.default)();
      }
    });
  }

  // oneOf : [ Parser ] -> Parser

  exports.default = function (parsers) {
    return function (path) {
      return match(parsers, path);
    };
  };
});
define('frampton-router/parser', ['exports', 'frampton-router/utils/split_path', 'frampton-router/utils/match'], function (exports, _split_path, _match) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _split_path2 = _interopRequireDefault(_split_path);

  var _match2 = _interopRequireDefault(_match);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = function (format) {
    var formatParts = (0, _split_path2.default)(format);
    return function (path) {
      var pathParts = (0, _split_path2.default)(path);
      return (0, _match2.default)(formatParts, pathParts);
    };
  };
});
define('frampton-router/string', ['exports', 'frampton-router/parser'], function (exports, _parser) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _parser2 = _interopRequireDefault(_parser);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _parser2.default)(':string');
});
define('frampton-router/utils/dynamic_path', ['exports', 'frampton-utils/memoize', 'frampton-string/replace'], function (exports, _memoize, _replace) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _memoize2 = _interopRequireDefault(_memoize);

  var _replace2 = _interopRequireDefault(_replace);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _memoize2.default)((0, _replace2.default)('', '/:'));
});
define('frampton-router/utils/is_index', ['exports', 'frampton-string/starts_with'], function (exports, _starts_with) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = is_index;

  var _starts_with2 = _interopRequireDefault(_starts_with);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function is_index(path) {
    return path === '' || path === '/' || (0, _starts_with2.default)('index.', path);
  }
});
define('frampton-router/utils/join_path', ['exports', 'frampton-string/join'], function (exports, _join) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _join2 = _interopRequireDefault(_join);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _join2.default)('/');
});
define('frampton-router/utils/match', ['exports', 'frampton-data/maybe/just', 'frampton-data/maybe/nothing', 'frampton-router/utils/is_index', 'frampton-utils/is_numeric'], function (exports, _just, _nothing, _is_index, _is_numeric) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _just2 = _interopRequireDefault(_just);

  var _nothing2 = _interopRequireDefault(_nothing);

  var _is_index2 = _interopRequireDefault(_is_index);

  var _is_numeric2 = _interopRequireDefault(_is_numeric);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = function (formatParts, pathParts) {
    var pathLen = pathParts.length;
    var formatLen = formatParts.length;
    var tokens = [];

    if (pathLen < formatLen) {
      return (0, _nothing2.default)();
    }

    for (var i = 0; i < pathLen; i++) {
      var path = pathParts[i];
      var format = formatParts[i];
      if (format !== undefined) {
        if (format === ':number' && (0, _is_numeric2.default)(path)) {
          tokens.push(parseInt(path));
        } else if (format === ':string' && !(0, _is_numeric2.default)(path)) {
          tokens.push(path);
        } else if (format !== path) {
          return (0, _nothing2.default)();
        }
      } else {
        if ((0, _is_index2.default)(pathParts[i])) {
          return (0, _just2.default)(tokens);
        } else {
          return (0, _nothing2.default)();
        }
      }
    }

    return (0, _just2.default)(tokens);
  };
});
define('frampton-router/utils/split_path', ['exports', 'frampton-utils/compose', 'frampton-utils/memoize', 'frampton-string/split', 'frampton-list/filter'], function (exports, _compose, _memoize, _split, _filter) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _compose2 = _interopRequireDefault(_compose);

  var _memoize2 = _interopRequireDefault(_memoize);

  var _split2 = _interopRequireDefault(_split);

  var _filter2 = _interopRequireDefault(_filter);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  var notEmpty = function notEmpty(str) {
    return str.trim() !== '';
  };

  /**
   * @name splitPath
   * @method
   * @private
   * @memberof Frampton.Router
   * @param {String} path A path string to split
   * @returns {Array}
   */
  exports.default = (0, _memoize2.default)((0, _compose2.default)((0, _filter2.default)(notEmpty), (0, _split2.default)('/')));
});
require("frampton-router");
})();

(function() {
/*globals Frampton:true */
var define, require;
var global = this;

(function() {

  if (typeof Frampton === 'undefined') {
    throw new Error('Frampton is undefined');
  };

  define = Frampton.__loader.define;
  require = Frampton.__loader.require;

}());
define('frampton-motion', ['frampton/namespace', 'frampton-motion/transition', 'frampton-motion/sequence', 'frampton-motion/when'], function (_namespace, _transition, _sequence, _when) {
  'use strict';

  var _namespace2 = _interopRequireDefault(_namespace);

  var _sequence2 = _interopRequireDefault(_sequence);

  var _when2 = _interopRequireDefault(_when);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * @name Motion
   * @namespace
   * @memberof Frampton
   */
  _namespace2.default.Motion = {};
  _namespace2.default.Motion.VERSION = '0.1.2';
  _namespace2.default.Motion.describe = _transition.describe;
  _namespace2.default.Motion.sequence = _sequence2.default;
  _namespace2.default.Motion.when = _when2.default;
});
define('frampton-motion/data/constants', ['exports'], function (exports) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  var DIRECTION = exports.DIRECTION = { DIR_IN: 'transition-in',
    DIR_OUT: 'transition-out'
  };

  var STATE = exports.STATE = { WAITING: 'waiting',
    STARTED: 'started',
    RUNNING: 'running',
    DONE: 'done',
    CLEANUP: 'cleanup'
  };

  var TYPE = exports.TYPE = { NORMAL: 'normal',
    CHAINED: 'chained',
    WHEN: 'when'
  };
});
define('frampton-motion/data/easing', ['exports'], function (exports) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = {
    'in': 'ease-in',
    'out': 'ease-out',
    'in-out': 'ease-in-out',
    'snap': 'cubic-bezier(0,1,.5,1)',
    'linear': 'cubic-bezier(0.250, 0.250, 0.750, 0.750)',
    'ease-in-quad': 'cubic-bezier(0.550, 0.085, 0.680, 0.530)',
    'ease-in-cubic': 'cubic-bezier(0.550, 0.055, 0.675, 0.190)',
    'ease-in-quart': 'cubic-bezier(0.895, 0.030, 0.685, 0.220)',
    'ease-in-quint': 'cubic-bezier(0.755, 0.050, 0.855, 0.060)',
    'ease-in-sine': 'cubic-bezier(0.470, 0.000, 0.745, 0.715)',
    'ease-in-expo': 'cubic-bezier(0.950, 0.050, 0.795, 0.035)',
    'ease-in-circ': 'cubic-bezier(0.600, 0.040, 0.980, 0.335)',
    'ease-in-back': 'cubic-bezier(0.600, -0.280, 0.735, 0.045)',
    'ease-out-quad': 'cubic-bezier(0.250, 0.460, 0.450, 0.940)',
    'ease-out-cubic': 'cubic-bezier(0.215, 0.610, 0.355, 1.000)',
    'ease-out-quart': 'cubic-bezier(0.165, 0.840, 0.440, 1.000)',
    'ease-out-quint': 'cubic-bezier(0.230, 1.000, 0.320, 1.000)',
    'ease-out-sine': 'cubic-bezier(0.390, 0.575, 0.565, 1.000)',
    'ease-out-expo': 'cubic-bezier(0.190, 1.000, 0.220, 1.000)',
    'ease-out-circ': 'cubic-bezier(0.075, 0.820, 0.165, 1.000)',
    'ease-out-back': 'cubic-bezier(0.175, 0.885, 0.320, 1.275)',
    'ease-in-out-quart': 'cubic-bezier(0.770, 0.000, 0.175, 1.000)',
    'ease-in-out-quint': 'cubic-bezier(0.860, 0.000, 0.070, 1.000)',
    'ease-in-out-sine': 'cubic-bezier(0.445, 0.050, 0.550, 0.950)',
    'ease-in-out-expo': 'cubic-bezier(1.000, 0.000, 0.000, 1.000)',
    'ease-in-out-circ': 'cubic-bezier(0.785, 0.135, 0.150, 0.860)',
    'ease-in-out-back': 'cubic-bezier(0.680, -0.550, 0.265, 1.550)'
  };
});
define("frampton-motion/data/empty_class", ["exports"], function (exports) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = empty_class;
  function empty_class() {
    return {
      add: [],
      remove: []
    };
  }
});
define('frampton-motion/data/empty_description', ['exports', 'frampton-motion/data/empty_transition'], function (exports, _empty_transition) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = empty_description;

  var _empty_transition2 = _interopRequireDefault(_empty_transition);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function empty_description() {
    return {
      from: (0, _empty_transition2.default)(),
      to: (0, _empty_transition2.default)()
    };
  }
});
define('frampton-motion/data/empty_transition', ['exports', 'frampton-motion/data/empty_class'], function (exports, _empty_class) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = empty_transition;

  var _empty_class2 = _interopRequireDefault(_empty_class);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function empty_transition() {
    return {
      style: {},
      class: (0, _empty_class2.default)()
    };
  }
});
define('frampton-motion/data/end_events', ['exports'], function (exports) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = {
    'WebkitTransition': 'webkitTransitionEnd',
    'MozTransition': 'transitionend',
    'transition': 'transitionend'
  };
});
define('frampton-motion/data/transforms', ['exports'], function (exports) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = ['matrix', 'matrix3d', 'translate', 'translate3d', 'translateX', 'translateY', 'translateZ', 'scale', 'scale3d', 'scaleX', 'scaleY', 'scaleZ', 'rotate', 'rotate3d', 'rotateX', 'rotateY', 'rotateZ', 'skew', 'skewX', 'skewY', 'perspective'];
});
define('frampton-motion/data/transitions', ['exports'], function (exports) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = ['transition-delay', 'transition-duration', 'transition-property', 'transition-timing-function'];
});
define("frampton-motion/sequence", ["exports"], function (exports) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = sequence_transitions;
  /**
   * sequence :: [Transition] -> Transition
   *
   * @name sequence
   * @method
   * @memberof Frampton.Motion
   * @param {...Frampton.Motion.Transition} transitions One or more transitions to run
   * @returns {Frampton.Motion.Transition} A new Transition that runs the given tranisitions
   in sequence
   */
  function sequence_transitions() {
    for (var _len = arguments.length, transitions = Array(_len), _key = 0; _key < _len; _key++) {
      transitions[_key] = arguments[_key];
    }

    return transitions.reduce(function (acc, next) {
      return acc.chain(next);
    });
  }
});
define('frampton-motion/transition', ['exports', 'frampton-utils/is_something', 'frampton-utils/is_string', 'frampton-utils/guid', 'frampton-utils/not_implemented', 'frampton-list/add', 'frampton-list/remove', 'frampton-list/reverse', 'frampton-object/merge', 'frampton-motion/sequence', 'frampton-motion/utils/set_state', 'frampton-motion/utils/inverse_direction', 'frampton-motion/utils/default_run', 'frampton-motion/utils/transition_props', 'frampton-motion/utils/parsed_props', 'frampton-motion/utils/parsed_timing', 'frampton-motion/utils/update_transform', 'frampton-motion/utils/validated_transition', 'frampton-motion/data/constants'], function (exports, _is_something, _is_string, _guid, _not_implemented, _add, _remove, _reverse, _merge, _sequence, _set_state, _inverse_direction, _default_run, _transition_props, _parsed_props, _parsed_timing, _update_transform, _validated_transition, _constants) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.describe = exports.Transition = undefined;

  var _is_something2 = _interopRequireDefault(_is_something);

  var _is_string2 = _interopRequireDefault(_is_string);

  var _guid2 = _interopRequireDefault(_guid);

  var _not_implemented2 = _interopRequireDefault(_not_implemented);

  var _add2 = _interopRequireDefault(_add);

  var _remove2 = _interopRequireDefault(_remove);

  var _reverse2 = _interopRequireDefault(_reverse);

  var _merge2 = _interopRequireDefault(_merge);

  var _sequence2 = _interopRequireDefault(_sequence);

  var _set_state2 = _interopRequireDefault(_set_state);

  var _inverse_direction2 = _interopRequireDefault(_inverse_direction);

  var _default_run2 = _interopRequireDefault(_default_run);

  var _transition_props2 = _interopRequireDefault(_transition_props);

  var _parsed_props2 = _interopRequireDefault(_parsed_props);

  var _parsed_timing2 = _interopRequireDefault(_parsed_timing);

  var _update_transform2 = _interopRequireDefault(_update_transform);

  var _validated_transition2 = _interopRequireDefault(_validated_transition);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function withDefaultRun(element, frame, dir) {
    var trans = new Transition(element, frame, dir);
    trans.run = _default_run2.default;
    return trans;
  }

  function withFrame(transition, props) {

    // Makes a copy of the frame
    var frame = (0, _validated_transition2.default)(transition.frame);

    // Add new props to the copy
    for (var key in props) {
      frame.to.style[key] = props[key];
    }

    return withDefaultRun(transition.element, frame, transition.direction);
  }

  /**
   * @name Transition
   * @class
   * @private
   * @memberof Frampton.Motion
   * @param {Object} [element=null]        DomNode to transition
   * @param {Object} [frame={}]            Hash of props to add to element
   * @param {String} [dir='transition-in'] Direction to run transition
   */
  function Transition(element, frame, dir) {

    this.id = (0, _guid2.default)();
    this.list = [this];
    this.name = _constants.TYPE.NORMAL;
    this.element = (0, _is_something2.default)(element) ? element : null;
    this.direction = (0, _is_something2.default)(dir) ? dir : _constants.DIRECTION.DIR_IN;
    this.frame = (0, _validated_transition2.default)(frame);
    this.state = _constants.STATE.WAITING;
    this.supported = (0, _parsed_props2.default)(this.frame.to.style);
    this.config = (0, _merge2.default)((0, _parsed_timing2.default)(this.frame.to.style), (0, _transition_props2.default)(this.supported));

    (0, _set_state2.default)(this, this.state);
  }

  /**
   * Start the transition. Optionally provide a callback for when transition is complete.
   *
   * @name run
   * @method
   * @memberof Frampton.Motion.Transition#
   * @param {Function} resolve Function to call when transition is complete.
   */
  Transition.prototype.run = _not_implemented2.default;

  /**
   * @name delay
   * @method
   * @memberof Frampton.Motion.Transition#
   * @param {Number} time Miliseconds to delay transition
   * @returns {Frampton.Motion.Transition}
   */
  Transition.prototype.delay = function Transition_delay(time) {
    return withFrame(this, {
      'transition-delay': (0, _is_string2.default)(time) ? time : time + 'ms'
    });
  };

  /**
   * @name duration
   * @method
   * @memberof Frampton.Motion.Transition#
   * @param {Number} time Miliseconds for transition to run
   * @returns {Frampton.Motion.Transition}
   */
  Transition.prototype.duration = function Transition_duration(time) {
    return withFrame(this, {
      'transition-duration': (0, _is_string2.default)(time) ? time : time + 'ms'
    });
  };

  /**
   * @name width
   * @method
   * @memberof Frampton.Motion.Transition#
   * @param {Number} width
   * @returns {Frampton.Motion.Transition}
   */
  Transition.prototype.width = function Transition_width(width) {
    return withFrame(this, {
      width: (0, _is_string2.default)(width) ? width : width + 'px'
    });
  };

  /**
   * @name height
   * @method
   * @memberof Frampton.Motion.Transition#
   * @param {Number} height
   * @returns {Frampton.Motion.Transition}
   */
  Transition.prototype.height = function Transition_width(height) {
    return withFrame(this, {
      height: (0, _is_string2.default)(height) ? height : height + 'px'
    });
  };

  /**
   * @name dimensions
   * @method
   * @memberof Frampton.Motion.Transition#
   * @param {Number} width
   * @param {Number} height
   * @returns {Frampton.Motion.Transition}
   */
  Transition.prototype.dimensions = function Transition_width(width, height) {
    return withFrame(this, {
      width: (0, _is_string2.default)(width) ? width : width + 'px',
      height: (0, _is_string2.default)(height) ? height : height + 'px'
    });
  };

  /**
   * @name top
   * @method
   * @memberof Frampton.Motion.Transition#
   * @param {Number} position
   * @returns {Frampton.Motion.Transition}
   */
  Transition.prototype.top = function Transition_top(position) {
    return withFrame(this, {
      top: (0, _is_string2.default)(position) ? position : position + 'px'
    });
  };

  /**
   * @name left
   * @method
   * @memberof Frampton.Motion.Transition#
   * @param {Number} position
   * @returns {Frampton.Motion.Transition}
   */
  Transition.prototype.left = function Transition_left(position) {
    return withFrame(this, {
      left: (0, _is_string2.default)(position) ? position : position + 'px'
    });
  };

  /**
   * @name position
   * @method
   * @memberof Frampton.Motion.Transition#
   * @param {Number} left
   * @param {Number} top
   * @returns {Frampton.Motion.Transition}
   */
  Transition.prototype.position = function Transition_position(left, top) {
    return withFrame(this, {
      top: (0, _is_string2.default)(left) ? left : left + 'px',
      left: (0, _is_string2.default)(top) ? top : top + 'px'
    });
  };

  /**
   * @name opacity
   * @method
   * @memberof Frampton.Motion.Transition#
   * @param {Number} opacity
   * @returns {Frampton.Motion.Transition}
   */
  Transition.prototype.opacity = function Transition_opacity(opacity) {
    return withFrame(this, {
      opacity: opacity
    });
  };

  /**
   * @name translateX
   * @method
   * @memberof Frampton.Motion.Transition#
   * @param {Number} distance
   * @returns {Frampton.Motion.Transition}
   */
  Transition.prototype.translateX = function Transition_translateX(distance) {
    return withFrame(this, {
      transform: (0, _update_transform2.default)((0, _is_something2.default)(this.frame) ? this.frame['transform'] : null, 'translateX', (0, _is_string2.default)(distance) ? distance : distance + 'px')
    });
  };

  /**
   * @name translateY
   * @method
   * @memberof Frampton.Motion.Transition#
   * @param {Number} distance
   * @returns {Frampton.Motion.Transition}
   */
  Transition.prototype.translateY = function Transition_translateY(distance) {
    return withFrame(this, {
      transform: (0, _update_transform2.default)((0, _is_something2.default)(this.frame) ? this.frame['transform'] : null, 'translateY', (0, _is_string2.default)(distance) ? distance : distance + 'px')
    });
  };

  /**
   * @name translateZ
   * @method
   * @memberof Frampton.Motion.Transition#
   * @param {Number} distance
   * @returns {Frampton.Motion.Transition}
   */
  Transition.prototype.translateZ = function Transition_translateZ(distance) {
    return withFrame(this, {
      transform: (0, _update_transform2.default)((0, _is_something2.default)(this.frame) ? this.frame['transform'] : null, 'translateZ', (0, _is_string2.default)(distance) ? distance : distance + 'px')
    });
  };

  /**
   * @name rotate
   * @method
   * @memberof Frampton.Motion.Transition#
   * @param {Number} degrees
   * @returns {Frampton.Motion.Transition}
   */
  Transition.prototype.rotate = function Transition_rotate(degrees) {
    return withFrame(this, {
      transform: (0, _update_transform2.default)((0, _is_something2.default)(this.frame) ? this.frame['transform'] : null, 'rotate', (0, _is_string2.default)(degrees) ? degrees : degrees + 'deg')
    });
  };

  /**
   * @name scale
   * @method
   * @memberof Frampton.Motion.Transition#
   * @param {Number} scale
   * @returns {Frampton.Motion.Transition}
   */
  Transition.prototype.scale = function Transition_scale(scale) {
    return withFrame(this, {
      transform: (0, _update_transform2.default)((0, _is_something2.default)(this.frame) ? this.frame['transform'] : null, 'scale', scale)
    });
  };

  /**
   * @name addClass
   * @method
   * @memberof Frampton.Motion.Transition#
   * @param {String} name Name of class to add
   * @returns {Frampton.Motion.Transition}
   */
  Transition.prototype.addClass = function Transition_addClass(name) {

    var newFrame = (0, _validated_transition2.default)(this.frame);
    newFrame.to.class.add = (0, _add2.default)(newFrame.to.class.add, name);

    return withDefaultRun(this.element, newFrame, this.direction);
  };

  /**
   * @name removeClass
   * @method
   * @memberof Frampton.Motion.Transition#
   * @param {String} name Name of class to remove
   * @returns {Frampton.Motion.Transition}
   */
  Transition.prototype.removeClass = function Transition_removeClass(name) {

    var newFrame = (0, _validated_transition2.default)(this.frame);
    newFrame.to.class.add = (0, _remove2.default)(newFrame.to.class.add, name);

    return withDefaultRun(this.element, newFrame, this.direction);
  };

  /**
   * @name reverse
   * @method
   * @memberof Frampton.Motion.Transition#
   * @returns {Frampton.Motion.Transition}
   */
  Transition.prototype.reverse = function Transition_reverse() {
    return withDefaultRun(this.element, this.frame, (0, _inverse_direction2.default)(this.direction));
  };

  /**
   * @name chain
   * @method
   * @memberof Frampton.Motion.Transition#
   * @param {Frampton.Motion.Transition} child Transition to run after this transition.
   * @returns {Frampton.Motion.Transition}
   */
  Transition.prototype.chain = function Transition_chain(child) {

    var trans = new Transition();
    var saved = this.run.bind(this);

    trans.name = Transition.CHAINED;
    trans.list = (0, _add2.default)(this.list, child);

    trans.run = function chain_run(resolve, next) {
      saved(function () {
        child.run(resolve, next);
      }, child);
    };

    trans.reverse = function chain_reverse() {
      return _sequence2.default.apply(null, (0, _reverse2.default)(trans.list).map(function (next) {
        return next.reverse();
      }));
    };

    return trans;
  };

  /**
   *
   * {
   *   from : {
   *     class : {
   *       add : [],
   *       remove : []
   *     },
   *     style : {}
   *   },
   *   to : {
   *     class : {
   *       add : [],
   *       remove : []
   *     },
   *     style : {}
   *   }
   * }
   *
   * @name describe
   * @method
   * @memberof Frampton.Motion
   * @param {Object}  element DomNode to transition
   * @param {Object}  frame   Hash of CSS properties to add to element
   * @param {Boolean} dir     Director to perform true is transition-in (add classes/props) false is transition-out (remove classes/props)
   * @returns {Frampton.Motion.Transition}
   */
  function describe(element, transition, dir) {
    var direction = dir === false ? _constants.DIRECTION.DIR_OUT : _constants.DIRECTION.DIR_IN;
    return withDefaultRun(element, transition, direction);
  }

  exports.Transition = Transition;
  exports.describe = describe;
});
define('frampton-motion/utils/add_classes', ['exports', 'frampton-utils/curry'], function (exports, _curry) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function add_classes(element, classes) {
    var len = classes.length;
    for (var i = 0; i < len; i++) {
      element.classList.add(classes[i]);
    }
  });
});
define('frampton-motion/utils/animation_end', ['exports', 'frampton-style/supported', 'frampton-motion/data/end_events'], function (exports, _supported, _end_events) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _supported2 = _interopRequireDefault(_supported);

  var _end_events2 = _interopRequireDefault(_end_events);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = _end_events2.default[(0, _supported2.default)('animation')] || null;
});
define('frampton-motion/utils/apply_classes', ['exports', 'frampton-motion/utils/add_classes', 'frampton-motion/utils/remove_classes', 'frampton-motion/data/constants'], function (exports, _add_classes, _remove_classes, _constants) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = apply_classes;

  var _add_classes2 = _interopRequireDefault(_add_classes);

  var _remove_classes2 = _interopRequireDefault(_remove_classes);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function apply_classes(element, classes, dir) {
    // When transitioning out, do the reverse
    if (dir === _constants.DIRECTION.DIR_OUT) {
      (0, _remove_classes2.default)(element, classes.add);
      (0, _add_classes2.default)(element, classes.remove);
    } else {
      (0, _remove_classes2.default)(element, classes.remove);
      (0, _add_classes2.default)(element, classes.add);
    }
  }
});
define('frampton-motion/utils/default_run', ['exports', 'frampton-utils/immediate', 'frampton-utils/noop', 'frampton-style/apply_styles', 'frampton-motion/utils/set_direction', 'frampton-motion/utils/reflow', 'frampton-motion/utils/once', 'frampton-motion/utils/find_child', 'frampton-motion/utils/resolve_styles', 'frampton-motion/utils/set_state', 'frampton-motion/utils/end_once', 'frampton-motion/utils/prepare', 'frampton-motion/utils/apply_classes', 'frampton-motion/data/constants'], function (exports, _immediate, _noop, _apply_styles, _set_direction, _reflow, _once, _find_child, _resolve_styles, _set_state, _end_once, _prepare, _apply_classes, _constants) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = default_run;

  var _immediate2 = _interopRequireDefault(_immediate);

  var _noop2 = _interopRequireDefault(_noop);

  var _apply_styles2 = _interopRequireDefault(_apply_styles);

  var _set_direction2 = _interopRequireDefault(_set_direction);

  var _reflow2 = _interopRequireDefault(_reflow);

  var _once2 = _interopRequireDefault(_once);

  var _find_child2 = _interopRequireDefault(_find_child);

  var _resolve_styles2 = _interopRequireDefault(_resolve_styles);

  var _set_state2 = _interopRequireDefault(_set_state);

  var _end_once2 = _interopRequireDefault(_end_once);

  var _prepare2 = _interopRequireDefault(_prepare);

  var _apply_classes2 = _interopRequireDefault(_apply_classes);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * @name defaultRun
   * @private
   * @method
   * @memberof Frampton.Motion.Transition
   * @param {Function} resolve
   * @param {Frampton.Motion.Transition#}
   */
  function default_run(resolve, child) {
    var _this = this;

    var complete = (0, _once2.default)(function () {
      (0, _set_state2.default)(_this, _constants.STATE.CLEANUP);
      (0, _reflow2.default)(_this.element);
      (0, _set_state2.default)(_this, _constants.STATE.DONE);
      (0, _immediate2.default)(function () {
        (resolve || _noop2.default)(_this.element);
      });
    });

    /**
     * Force a reflow of our element to make sure everything is prestine for us
     * to start things up. Without doing this, some browsers will not have
     * the correct current state of our element in which to start the transition
     * from.
     */
    (0, _prepare2.default)(this.element, this.frame.from);

    this.element.setAttribute('data-transition-id', this.id);

    (0, _end_once2.default)(this, complete);

    (0, _set_direction2.default)(this, this.direction);

    (0, _immediate2.default)(function () {
      (0, _apply_classes2.default)(_this.element, _this.frame.to.class, _this.direction);
      if (_this.direction === _constants.DIRECTION.DIR_IN) {
        (0, _apply_styles2.default)(_this.element, _this.config);
        (0, _reflow2.default)(_this.element);
        (0, _apply_styles2.default)(_this.element, _this.supported);
      } else {
        (0, _apply_styles2.default)(_this.element, _this.config);
        (0, _reflow2.default)(_this.element);
        (0, _resolve_styles2.default)(_this.element, _this.supported, (0, _find_child2.default)(child, _this.element));
      }
    });

    (0, _set_state2.default)(this, _constants.STATE.RUNNING);
  }
});
define('frampton-motion/utils/end_once', ['exports', 'frampton-events/on_event', 'frampton-motion/utils/transition_end'], function (exports, _on_event, _transition_end) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = end_once;

  var _on_event2 = _interopRequireDefault(_on_event);

  var _transition_end2 = _interopRequireDefault(_transition_end);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function end_once(transition, fn) {
    (0, _on_event2.default)(_transition_end2.default, transition.element).filter(function (evt) {
      var dataId = evt.target.getAttribute('data-transition-id');
      var testId = (dataId || '').trim();
      return testId === transition.id;
    }).take(1).next(fn);
  }
});
define('frampton-motion/utils/find_child', ['exports', 'frampton-motion/data/constants'], function (exports, _constants) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = find_child;


  /**
   *
   */
  function find_child(child, element) {
    if (child && child.element) {
      return child;
    } else if (child) {
      if (child.name === _constants.TYPE.WHEN) {
        var len = child.list.length;
        for (var i = 0; i < len; i++) {
          if (child.list[i].element === element) {
            return child.list[i];
          }
        }
      } else if (child.name === _constants.TYPE.CHAINED) {
        if (child.list[0].element === element) {
          return child.list[0];
        }
      }
    }
    return null;
  }
});
define('frampton-motion/utils/inverse_direction', ['exports', 'frampton-motion/data/constants'], function (exports, _constants) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = inverse_direction;
  function inverse_direction(dir) {
    return dir === _constants.DIRECTION.DIR_IN ? _constants.DIRECTION.DIR_OUT : _constants.DIRECTION.DIR_IN;
  }
});
define('frampton-motion/utils/is_valid_direction', ['exports', 'frampton-motion/data/constants', 'frampton-motion/utils/is_value_of'], function (exports, _constants, _is_value_of) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _is_value_of2 = _interopRequireDefault(_is_value_of);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _is_value_of2.default)(_constants.DIRECTION);
});
define('frampton-motion/utils/is_valid_state', ['exports', 'frampton-motion/data/constants', 'frampton-motion/utils/is_value_of'], function (exports, _constants, _is_value_of) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _is_value_of2 = _interopRequireDefault(_is_value_of);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _is_value_of2.default)(_constants.STATE);
});
define('frampton-motion/utils/is_value_of', ['exports', 'frampton-motion/utils/object_values'], function (exports, _object_values) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = is_value_of;

  var _object_values2 = _interopRequireDefault(_object_values);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * @name isValueOf
   * @memberof Frampton.Motion.Utils
   * @private
   * @param {Object} obj Object to test value against
   * @returns {Function} Function that tests values
   */
  function is_value_of(obj) {

    var values = (0, _object_values2.default)(obj);

    return function (val) {
      return values.indexOf(val) !== -1;
    };
  }
});
define('frampton-motion/utils/next_end', ['exports', 'frampton-utils/noop', 'frampton-events/once', 'frampton-motion/utils/transition_end'], function (exports, _noop, _once, _transition_end) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = next_end;

  var _noop2 = _interopRequireDefault(_noop);

  var _once2 = _interopRequireDefault(_once);

  var _transition_end2 = _interopRequireDefault(_transition_end);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * Call the given function the next time the element recieves a transitionend
   *
   * @name nextEnd
   * @method
   * @private
   * @memberof Frampton.Motion
   * @param {Object} element
   * @param {Function} fn
   */
  function next_end(element, fn) {
    (0, _once2.default)(_transition_end2.default, element).next(function (evt) {
      (fn || _noop2.default)(evt);
    });
  }
});
define('frampton-motion/utils/normalized_frame', ['exports', 'frampton-utils/is_number', 'frampton-list/contains', 'frampton-motion/data/easing'], function (exports, _is_number, _contains, _easing) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = normalized_frame;

  var _is_number2 = _interopRequireDefault(_is_number);

  var _contains2 = _interopRequireDefault(_contains);

  var _easing2 = _interopRequireDefault(_easing);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  var alias_mapping = {
    'duration': 'transition-duration',
    'delay': 'transition-delay'
  };

  //+ durations :: String -> Boolean
  var durations = (0, _contains2.default)(['transition-duration', 'transition-delay']);

  //+ pixels :: String -> Boolean
  var pixels = (0, _contains2.default)(['height', 'width', 'left', 'top', 'right', 'bottom']);

  function normalized_frame(frame) {
    var obj = {};
    for (var key in frame || {}) {

      // Handle aliased props
      if (alias_mapping[key]) {
        if ((0, _is_number2.default)(frame[key])) {
          obj[alias_mapping[key]] = frame[key] + 'ms';
        } else {
          obj[alias_mapping[key]] = frame[key];
        }

        // Handle props that default to pixels
      } else if (pixels(key) && (0, _is_number2.default)(frame[key])) {
        obj[key] = frame[key] + 'px';

        // Handle durations default to miliseconds
      } else if (durations(key) && (0, _is_number2.default)(frame[key])) {
        obj[key] = frame[key] + 'ms';

        // Handle aliased timing functions
      } else if (key === 'transition-timing-function') {
        obj[key] = _easing2.default[frame[key]] ? _easing2.default[frame[key]] : frame[key];

        // Otherwise do a direct copy
      } else {
        obj[key] = frame[key];
      }
    }
    return obj;
  }
});
define('frampton-motion/utils/not_empty', ['exports'], function (exports) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = not_emtpy;
  function not_emtpy(str) {
    return str.trim() !== '';
  }
});
define("frampton-motion/utils/object_values", ["exports"], function (exports) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = object_values;
  var hasOwnProp = Object.prototype.hasOwnProperty;

  /**
   * @name objectValues
   * @method
   * @memberof Frampton.Motion.Utils
   * @param {Object} obj Object whose values to get
   * @returns {String[]}
   */
  function object_values(obj) {
    var result = [];
    for (var key in obj) {
      if (hasOwnProp.call(obj, key)) {
        result.push(obj[key]);
      }
    }
    return result;
  }
});
define("frampton-motion/utils/once", ["exports"], function (exports) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = once;
  function once(fn) {
    var triggered = false;
    return function () {
      if (!triggered) {
        triggered = true;
        return fn.apply(undefined, arguments);
      }
    };
  }
});
define('frampton-motion/utils/parsed_props', ['exports', 'frampton-object/reduce', 'frampton-list/contains', 'frampton-style/supported', 'frampton-motion/data/transitions'], function (exports, _reduce, _contains, _supported, _transitions) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = parsed_props;

  var _reduce2 = _interopRequireDefault(_reduce);

  var _contains2 = _interopRequireDefault(_contains);

  var _supported2 = _interopRequireDefault(_supported);

  var _transitions2 = _interopRequireDefault(_transitions);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function parsed_props(props) {
    return (0, _reduce2.default)(function (acc, value, key) {
      if (!(0, _contains2.default)(_transitions2.default, key)) {
        acc[(0, _supported2.default)(key)] = value;
      }
      return acc;
    }, {}, props);
  }
});
define('frampton-motion/utils/parsed_timing', ['exports', 'frampton-style/supported'], function (exports, _supported) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = parsed_timing;

  var _supported2 = _interopRequireDefault(_supported);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function parsed_timing(props) {

    var timing = {};

    if (props['transition-delay']) {
      timing[(0, _supported2.default)('transition-delay')] = props['transition-delay'];
    }

    if (props['transition-duration']) {
      timing[(0, _supported2.default)('transition-duration')] = props['transition-duration'];
    }

    return timing;
  }
});
define('frampton-motion/utils/prepare', ['exports', 'frampton-style/apply_styles', 'frampton-motion/utils/reflow', 'frampton-motion/utils/apply_classes'], function (exports, _apply_styles, _reflow, _apply_classes) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = prepare;

  var _apply_styles2 = _interopRequireDefault(_apply_styles);

  var _reflow2 = _interopRequireDefault(_reflow);

  var _apply_classes2 = _interopRequireDefault(_apply_classes);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * {
   *   from : {
   *     class : {
   *       add : [],
   *       remove : []
   *     },
   *     style : {}
   *   },
   *   to : {
   *     class : {
   *       add : [],
   *       remove : []
   *     },
   *     style : {}
   *   }
   * }
   *
   * @name prepare
   * @param {Element} element
   * @param {Object} frame
   */
  function prepare(element, frame) {
    (0, _apply_classes2.default)(element, frame.class);
    (0, _apply_styles2.default)(element, frame.style);
    return (0, _reflow2.default)(element), true;
  }
});
define("frampton-motion/utils/reflow", ["exports"], function (exports) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = reflow;
  /**
   * Forces browser reflow by reading the offsetHeight of given element
   *
   * @name reflow
   * @method
   * @private
   * @memberof Frampton.Motion
   * @param {Object} element DomNode to reflow
   */
  function reflow(element) {
    return element.offsetWidth;
  }
});
define('frampton-motion/utils/remove_classes', ['exports', 'frampton-utils/curry'], function (exports, _curry) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _curry2 = _interopRequireDefault(_curry);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _curry2.default)(function remove_classes(element, classes) {
    var len = classes.length;
    for (var i = 0; i < len; i++) {
      element.classList.remove(classes[i]);
    }
  });
});
define('frampton-motion/utils/reset_state', ['exports', 'frampton-motion/data/constants'], function (exports, _constants) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = reset_state;
  function reset_state(transition) {
    transition.element.classList.remove('transition-' + _constants.STATE.WAITING);
    transition.element.classList.remove('transition-' + _constants.STATE.STARTED);
    transition.element.classList.remove('transition-' + _constants.STATE.RUNNING);
    transition.element.classList.remove('transition-' + _constants.STATE.CLEANUP);
    transition.element.classList.remove('transition-' + _constants.STATE.DONE);
  }
});
define('frampton-motion/utils/resolve_styles', ['exports', 'frampton-style/set_style', 'frampton-style/remove_style', 'frampton-style/remove_styles', 'frampton-motion/data/constants'], function (exports, _set_style, _remove_style, _remove_styles, _constants) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = resolve_styles;

  var _set_style2 = _interopRequireDefault(_set_style);

  var _remove_style2 = _interopRequireDefault(_remove_style);

  var _remove_styles2 = _interopRequireDefault(_remove_styles);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * If a child of this transition manipulates the same element we need to prepare
   * for that. Usually we would just remove styles here, however, it the child
   * transition is moving in the out direction it needs the styles as a starting
   * point. That is the reverse of a transition has the end point of a forward
   * transition be the start point of reversed transition.
   *
   * @name resolveStyles
   * @function
   * @param {Element} element
   * @param {Object} frame
   * @param {Frampton.Motion.Transition}
   */
  function resolve_styles(element, frame, child) {
    if (child && child.direction === _constants.DIRECTION.DIR_OUT && child.element === element) {
      for (var key in frame) {
        // The child is modifying this style
        if (child.frame.to.style[key]) {
          (0, _set_style2.default)(element, key, child.frame.to.style[key]);

          // The child is not modifying this style... remove
        } else {
          (0, _remove_style2.default)(element, key);
        }
      }

      // No matching child we are safe to remove styles
    } else {
      (0, _remove_styles2.default)(element, frame);
    }
  }
});
define('frampton-motion/utils/set_direction', ['exports', 'frampton-motion/utils/inverse_direction', 'frampton-motion/utils/is_valid_direction'], function (exports, _inverse_direction, _is_valid_direction) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = set_direction;

  var _inverse_direction2 = _interopRequireDefault(_inverse_direction);

  var _is_valid_direction2 = _interopRequireDefault(_is_valid_direction);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * @name setDirection
   * @memberof Frampton.Motion.Utils
   * @param {Frampton.Motion.Transition#} transition
   * @param {String} dir
   */
  function set_direction(transition, dir) {
    if ((0, _is_valid_direction2.default)(dir)) {
      if (transition.element) {
        transition.element.classList.remove((0, _inverse_direction2.default)(dir));
        transition.element.classList.add(dir);
      }
      transition.direction = dir;
    } else {
      throw new Error('Transition received an invalid directino: ' + dir);
    }
  }
});
define('frampton-motion/utils/set_state', ['exports', 'frampton-motion/utils/reset_state', 'frampton-motion/utils/is_valid_state'], function (exports, _reset_state, _is_valid_state) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = set_state;

  var _reset_state2 = _interopRequireDefault(_reset_state);

  var _is_valid_state2 = _interopRequireDefault(_is_valid_state);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * @name setState
   * @memberof Frampton.Motion.Utils
   * @private
   * @param {Frampton.Motion.Transition} transition
   * @param {String} state
   */
  function set_state(transition, state) {
    if ((0, _is_valid_state2.default)(state)) {
      if (transition.element) {
        (0, _reset_state2.default)(transition);
        transition.element.classList.add('transition-' + state);
        transition.element.setAttribute('data-transition-state', state);
      }
      transition.state = state;
    } else {
      throw new Error('Transition received an invalid state: ' + state);
    }
  }
});
define('frampton-motion/utils/transform_object', ['exports', 'frampton-motion/data/transforms'], function (exports, _transforms) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = transform_object;

  var _transforms2 = _interopRequireDefault(_transforms);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * Give a string representing a CSS transform it returns an object representation
   * of the transform.
   *
   * EXAMPLE:
   *
   * transformObject('rotate(80deg) translate(100px, 50px) scale(0.5)');
   *
   * returns:
   * {
   *   rotate : '80deg',
   *   translate : '100px, 50px',
   *   scale : '0.5'
   * }
   *
   * @name transformObject
   * @method
   * @private
   * @memberof Frampton.Motion.Utils
   * @param {String} transform
   * @returns {Object}
   */
  function transform_object(transform) {
    var obj = {};
    var len = _transforms2.default.length;
    for (var i = 0; i < len; i++) {
      var prop = _transforms2.default[i];
      var cap = new RegExp(prop + "\\(([^)]+)\\)");
      var matches = cap.exec(transform);
      if (matches && matches.length) {
        obj[prop] = matches[0].replace(prop + '(', '').replace(')', '');
      }
    }
    return obj;
  }
});
define('frampton-motion/utils/transition_end', ['exports', 'frampton-style/supported', 'frampton-motion/data/end_events'], function (exports, _supported, _end_events) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _supported2 = _interopRequireDefault(_supported);

  var _end_events2 = _interopRequireDefault(_end_events);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = _end_events2.default[(0, _supported2.default)('transition')] || null;
});
define('frampton-motion/utils/transition_props', ['exports', 'frampton-style/supported'], function (exports, _supported) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = transition_props;

  var _supported2 = _interopRequireDefault(_supported);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * Returns an object of properties to animate in this transition
   *
   * {
   *    height : 0px,
   *    opacity : 0
   * }
   *
   * {
   *    transition-property : 'height, opacity'
   * }
   *
   * @name transitionProps
   * @method
   * @private
   * @memberof Frampton.Motion.Utils
   * @param {Object} props
   * @returns {Object}
   */
  function transition_props(props) {
    var trans = {};
    trans[(0, _supported2.default)('transition-property')] = Object.keys(props).join(', ');
    return trans;
  }
});
define('frampton-motion/utils/update_transform', ['exports', 'frampton-utils/is_string', 'frampton-string/contains'], function (exports, _is_string, _contains) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = updateTransform;

  var _is_string2 = _interopRequireDefault(_is_string);

  var _contains2 = _interopRequireDefault(_contains);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function propValue(prop, value) {
    return prop + '(' + value + ')';
  }

  /**
   * Updates the value of a transform in a CSS string.
   *
   * updateTransform('rotate(90deg) scale(0.5)', 'scale', '0.8');
   * // -> 'rotate(90deg) scale(0.8)'
   *
   * // Delete a prop from the transform
   * updateTransform('rotate(90deg) scale(0.5)', 'scale', null);
   * // -> 'rotate(90deg)'
   *
   * @name updateTransform
   * @method
   * @private
   * @memberof Frampton.Motion
   * @param {String} transform
   * @param {String} prop
   * @param {String|Number} value
   * @returns {String}
   */
  function updateTransform(transform, prop, value) {

    transform = ((0, _is_string2.default)(transform) ? transform : '').trim();

    // Updating an existing prop
    if ((0, _contains2.default)(prop, transform)) {
      var reg = new RegExp(prop + "\\([^)]*\\)");
      if ((0, _is_string2.default)(value) && value.trim() !== '') {
        transform = transform.replace(reg, propValue(prop, value));
      } else {
        transform = transform.replace(reg, '').replace('  ', ' ');
      }

      // Adding a new prop
    } else {
      if (transform.length > 0) {
        transform = transform + ' ';
      }
      transform = transform + propValue(prop, value);
    }

    return transform.trim();
  }
});
define('frampton-motion/utils/validated_class', ['exports', 'frampton-utils/is_array', 'frampton-utils/is_string', 'frampton-utils/is_object', 'frampton-motion/utils/not_empty', 'frampton-motion/data/empty_class'], function (exports, _is_array, _is_string, _is_object, _not_empty, _empty_class) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = validated_class;

  var _is_array2 = _interopRequireDefault(_is_array);

  var _is_string2 = _interopRequireDefault(_is_string);

  var _is_object2 = _interopRequireDefault(_is_object);

  var _not_empty2 = _interopRequireDefault(_not_empty);

  var _empty_class2 = _interopRequireDefault(_empty_class);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * @name validatedClass
   * @memberof Frampton.Motion.Utils
   * @private
   * @param {String|Object} toValidate
   * @returns {Object}
   */
  function validated_class(toValidate) {

    if ((0, _is_string2.default)(toValidate)) {

      return {
        add: toValidate.split(' ').filter(_not_empty2.default),
        remove: []
      };
    } else if ((0, _is_object2.default)(toValidate)) {

      var newClass = (0, _empty_class2.default)();

      if ((0, _is_array2.default)(toValidate.add)) {
        for (var i = 0; i < toValidate.add.length; i++) {
          newClass.add.push(toValidate.add[i]);
        }
      }

      if ((0, _is_array2.default)(toValidate.remove)) {
        for (var _i = 0; _i < toValidate.remove.length; _i++) {
          newClass.remove.push(toValidate.remove[_i]);
        }
      }

      return newClass;
    } else {
      return (0, _empty_class2.default)();
    }
  }
});
define('frampton-motion/utils/validated_transition', ['exports', 'frampton-utils/is_nothing', 'frampton-utils/is_string', 'frampton-motion/utils/normalized_frame', 'frampton-motion/utils/validated_class', 'frampton-motion/data/empty_description'], function (exports, _is_nothing, _is_string, _normalized_frame, _validated_class, _empty_description) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = validated_transition;

  var _is_nothing2 = _interopRequireDefault(_is_nothing);

  var _is_string2 = _interopRequireDefault(_is_string);

  var _normalized_frame2 = _interopRequireDefault(_normalized_frame);

  var _validated_class2 = _interopRequireDefault(_validated_class);

  var _empty_description2 = _interopRequireDefault(_empty_description);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * @name validatedTransition
   * @memberof Frampton.Motion.Utils
   * @private
   * @param {String|Object} desc A description of the transition
   * @returns {Object} An object representing a transition.
   */
  function validated_transition(desc) {

    var newTransition = (0, _empty_description2.default)();

    if ((0, _is_nothing2.default)(desc)) {

      return newTransition;
    } else if ((0, _is_string2.default)(desc)) {

      newTransition.to.class = (0, _validated_class2.default)(desc);
      return newTransition;
    } else {

      if (desc.from || desc.to || desc.style || desc.class) {
        if (desc.from && (desc.from.style || desc.from.class)) {
          newTransition.from.class = (0, _validated_class2.default)(desc.from.class);
          newTransition.from.style = (0, _normalized_frame2.default)(desc.from.style);
        } else {
          newTransition.from.style = (0, _normalized_frame2.default)(desc.from);
        }

        if (desc.to && (desc.to.style || desc.to.class)) {
          newTransition.to.class = (0, _validated_class2.default)(desc.to.class);
          newTransition.to.style = (0, _normalized_frame2.default)(desc.to.style);
        } else {
          newTransition.to.style = (0, _normalized_frame2.default)(desc.to);
        }

        if (desc.class) {
          newTransition.to.class = (0, _validated_class2.default)(desc.class);
        }

        if (desc.style) {
          newTransition.to.style = (0, _normalized_frame2.default)(desc.style);
        }
      } else {
        newTransition.to.style = (0, _normalized_frame2.default)(desc);
      }

      return newTransition;
    }
  }
});
define('frampton-motion/when', ['exports', 'frampton-utils/noop', 'frampton-motion/transition'], function (exports, _noop, _transition) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = when;

  var _noop2 = _interopRequireDefault(_noop);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * when :: [Transition] -> Transition
   *
   * Takes one or more Transitions and returns a new Transition that represents
   * all of the given Transitions running in parallel. The new Transition completes
   * once all of its child Transitions have completed.
   *
   * @name when
   * @method
   * @memberof Frampton.Motion
   * @param {...Frampton.Motion.Transition} transitions One or more transitions to run
   * @returns {Frampton.Motion.Transition} A new Transition that runs the given tranisitions
   in parallel
   */
  function when() {
    for (var _len = arguments.length, transitions = Array(_len), _key = 0; _key < _len; _key++) {
      transitions[_key] = arguments[_key];
    }

    var transition = new _transition.Transition();
    transition.name = _transition.Transition.WHEN;
    transition.list = transitions;

    transition.reverse = function when_reverse() {
      return when.apply(null, transitions.map(function (trans) {
        return trans.reverse();
      }));
    };

    transition.run = function when_run(resolve, child) {

      var count = 0;
      var len = transitions.length;

      function handleComplete() {
        count += 1;
        if (count === len) {
          (resolve || _noop2.default)();
        }
      }

      for (var i = 0; i < len; i++) {
        transitions[i].run(handleComplete, child);
      }
    };

    return transition;
  }
});
require("frampton-motion");
})();

(function() {
/*globals Frampton:true */
var define, require;
var global = this;

(function() {

  if (typeof Frampton === 'undefined') {
    throw new Error('Frampton is undefined');
  }

  define = Frampton.__loader.define;
  require = Frampton.__loader.require;

  if (typeof Frampton.DOM === 'undefined') {
    Frampton.__loader.registry['frampton-dom/scene'] = {
      deps : [],
      callback : function() {}
    };
  }

}());

define('frampton-app', ['frampton/namespace', 'frampton-app/basic', 'frampton-app/with_view'], function (_namespace, _basic, _with_view) {
  'use strict';

  var _namespace2 = _interopRequireDefault(_namespace);

  var _basic2 = _interopRequireDefault(_basic);

  var _with_view2 = _interopRequireDefault(_with_view);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * @name App
   * @namespace
   * @memberof Frampton
   */
  _namespace2.default.App = {};
  _namespace2.default.App.VERSION = '0.0.8';
  _namespace2.default.App.basic = _basic2.default;
  _namespace2.default.App.withView = _with_view2.default;
});
define('frampton-app/basic', ['exports', 'frampton-list/prepend', 'frampton-list/first', 'frampton-list/second', 'frampton-data/task/execute', 'frampton-signal/create', 'frampton-app/utils/basic_config', 'frampton-app/utils/with_valid_config'], function (exports, _prepend, _first, _second, _execute, _create, _basic_config, _with_valid_config) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _prepend2 = _interopRequireDefault(_prepend);

  var _first2 = _interopRequireDefault(_first);

  var _second2 = _interopRequireDefault(_second);

  var _execute2 = _interopRequireDefault(_execute);

  var _create2 = _interopRequireDefault(_create);

  var _basic_config2 = _interopRequireDefault(_basic_config);

  var _with_valid_config2 = _interopRequireDefault(_with_valid_config);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _with_valid_config2.default)(_basic_config2.default, function basic_app(config) {

    function update(acc, next) {
      var model = acc[0];
      return config.update(next, model);
    }

    var messages = (0, _create2.default)();
    var initialState = config.init();
    var inputs = config.inputs || [];
    var allInputs = (0, _create.mergeMany)((0, _prepend2.default)(messages, inputs));
    var stateAndTasks = allInputs.fold(update, initialState);
    var state = stateAndTasks.map(_first2.default);
    var tasks = stateAndTasks.map(_second2.default);

    // Run tasks and publish any resulting actions back into messages
    (0, _execute2.default)(tasks, messages.push);

    return state;
  });
});
define("frampton-app/utils/array_equal", ["exports"], function (exports) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = array_equal;
  function array_equal(xs, ys) {
    var xsLen = xs.length;
    var ysLen = ys.length;

    if (xsLen !== ysLen) {
      return false;
    } else {
      for (var i = 0; i < xsLen; i++) {
        if (xs[i] !== ys[i]) {
          return false;
        }
      }
    }

    return true;
  }
});
define('frampton-app/utils/basic_config', ['exports', 'frampton-utils/is_function', 'frampton-utils/is_array'], function (exports, _is_function, _is_array) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _is_function2 = _interopRequireDefault(_is_function);

  var _is_array2 = _interopRequireDefault(_is_array);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = {
    init: _is_function2.default,
    update: _is_function2.default,
    inputs: _is_array2.default
  };
});
define("frampton-app/utils/is_valid_config", ["exports"], function (exports) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = is_valid_config;
  /**
   * @name isValidConfig
   * @method
   * @private
   * @memberof Frampton.App.Utils
   * @param {Object} rules A hash of functions to validate config
   * @param {Object} config The config to validate
   * @returns {Boolean} Is the config valid
   */
  function is_valid_config(rules, config) {
    for (var key in rules) {
      var validator = rules[key];
      var next = config[key];
      if (!next) {
        return false;
      } else if (!validator(next)) {
        return false;
      }
    }

    return true;
  }
});
define('frampton-app/utils/with_valid_config', ['exports', 'frampton-app/utils/is_valid_config'], function (exports, _is_valid_config) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = with_valid_config;

  var _is_valid_config2 = _interopRequireDefault(_is_valid_config);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  /**
   * @name withValidConfig
   * @method
   * @private
   * @memberof Frampton.App.Utils
   * @param {Object} rules An object containing validator functions
   * @param {Function} fn The function to gate
   * @returns {Function} A function that will only be called if rules are met
   */
  function with_valid_config(rules, fn) {
    return function (config) {
      if ((0, _is_valid_config2.default)(rules, config)) {
        return fn(config);
      } else {
        throw new Error('App config is invalid');
      }
    };
  }
});
define('frampton-app/utils/with_view_config', ['exports', 'frampton-utils/is_function', 'frampton-utils/is_array', 'frampton-utils/is_node'], function (exports, _is_function, _is_array, _is_node) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _is_function2 = _interopRequireDefault(_is_function);

  var _is_array2 = _interopRequireDefault(_is_array);

  var _is_node2 = _interopRequireDefault(_is_node);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = {
    init: _is_function2.default,
    update: _is_function2.default,
    view: _is_function2.default,
    inputs: _is_array2.default,
    rootElement: _is_node2.default
  };
});
define('frampton-app/with_view', ['exports', 'frampton-list/prepend', 'frampton-list/first', 'frampton-list/second', 'frampton-data/task/execute', 'frampton-signal/create', 'frampton-dom/scene', 'frampton-app/utils/with_view_config', 'frampton-app/utils/with_valid_config'], function (exports, _prepend, _first, _second, _execute, _create, _scene, _with_view_config, _with_valid_config) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _prepend2 = _interopRequireDefault(_prepend);

  var _first2 = _interopRequireDefault(_first);

  var _second2 = _interopRequireDefault(_second);

  var _execute2 = _interopRequireDefault(_execute);

  var _create2 = _interopRequireDefault(_create);

  var _scene2 = _interopRequireDefault(_scene);

  var _with_view_config2 = _interopRequireDefault(_with_view_config);

  var _with_valid_config2 = _interopRequireDefault(_with_valid_config);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  exports.default = (0, _with_valid_config2.default)(_with_view_config2.default, function with_view_app(config) {

    if (typeof _scene2.default !== 'function') {
      throw new Error('Frampton.App.withView requires Frampton.DOM');
    }

    function update(acc, next) {
      var model = acc[0];
      return config.update(next, model);
    }

    var messages = (0, _create2.default)();
    var initialState = config.init();
    var inputs = config.inputs || [];
    var allInputs = (0, _create.mergeMany)((0, _prepend2.default)(messages, inputs));
    var stateAndTasks = allInputs.fold(update, initialState);
    var state = stateAndTasks.map(_first2.default);
    var tasks = stateAndTasks.map(_second2.default);

    var schedule = (0, _scene2.default)(config.rootElement, messages.push);
    var html = state.map(function (next) {
      return config.view(next);
    });

    html.value(function (tree) {
      schedule(tree);
    });

    // Run tasks and publish any resulting actions back into messages
    (0, _execute2.default)(tasks, messages.push);

    return state;
  });
});
require("frampton-app");
})();

(function(global) {
  const Fr = global.Frampton;
  const warn = Fr.Utils.warn;

  const store = {
    ENTER_DESKTOP: [],
    ENTER_TABLET: [],
    ENTER_MOBILE: [],
    MODAL_OPENING: [],
    MODAL_CLOSING: [],
    CLOSE_MODAL: [],
    CLEAR_ATTACHMENTS: [],
    NEW_NOTIFICATION: [],
    FORM_SUBMIT: [],
    RESET_FORM: [],
    ENABLE_CHAT_IN_POPULAR_ACTIONS: [],
    ENABLE_CLICK_TO_CALL_IN_POPULAR_ACTIONS: [],
    SMART_ASSIST_CLOSE: [],
    CONTACT_SUBMIT: [],
    DYNAFORM_EXTERNAL_VALIDATION: [],
    SMART_ASSIST_RESULTS_DISPLAYED: [],
    SHOW_ELEMENT: [],
    HIDE_ELEMENT: [],
    CAPTCHA_INIT: [],
    HIDE_LOADER: [],
    PROCESS_HAS_SEARCH_ERROR: [],
    HELPFULNESS_RATING: [],
    CLICK_DROPDOWN_MENU_BUTTON: []
  };

  global.Messenger = {
    on: function(name, fn) {
      if (!store[name]) {
        warn('Unrecognized event name: ' + name);
      } else if (store[name].indexOf(fn) === -1) {
        store[name].push(fn);
      }
    },

    off: function(name, fn) {
      const listeners = store[name];
      if (listeners) {
        store[name] = listeners.filter(function(next) {
          return next !== fn;
        });
      } else {
        warn('Unrecognized event name: ' + name);
      }
    },

    trigger: function(name, data) {
      const listeners = store[name];
      if (listeners) {
        listeners.forEach(function(fn) {
          fn(typeof data === 'undefined' ? null : data);
        });
      } else {
        warn('Unrecognized event name: ' + name);
      }
    }
  };
})(this);