(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 = {},
        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];
          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],
          deps     = mod.deps,
          callback = mod.callback,
          reified  = [],
          len      = deps.length,
          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('/'),
          parentBase = name.split('/').slice(0, -1),
          len        = parts.length,
          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', ['exports', 'frampton/namespace', 'frampton-data/task/create', 'frampton-data/task/fail', 'frampton-data/task/never', 'frampton-data/task/sequence', 'frampton-data/task/succeed', 'frampton-data/task/when', 'frampton-data/task/execute', 'frampton-data/union/create', 'frampton-data/record/create'], function (exports, _framptonNamespace, _framptonDataTaskCreate, _framptonDataTaskFail, _framptonDataTaskNever, _framptonDataTaskSequence, _framptonDataTaskSucceed, _framptonDataTaskWhen, _framptonDataTaskExecute, _framptonDataUnionCreate, _framptonDataRecordCreate) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _Frampton = _interopRequire(_framptonNamespace);

  var _createTask = _interopRequire(_framptonDataTaskCreate);

  var _fail = _interopRequire(_framptonDataTaskFail);

  var _never = _interopRequire(_framptonDataTaskNever);

  var _sequence = _interopRequire(_framptonDataTaskSequence);

  var _succeed = _interopRequire(_framptonDataTaskSucceed);

  var _when = _interopRequire(_framptonDataTaskWhen);

  var _execute = _interopRequire(_framptonDataTaskExecute);

  var _createUnion = _interopRequire(_framptonDataUnionCreate);

  var _createRecord = _interopRequire(_framptonDataRecordCreate);

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

  /**
   * @name Task
   * @memberof Frampton.Data
   * @class A data type for wrapping impure computations
   * @constructor Should not be called by the user.
   */
  _Frampton.Data.Task = {};
  _Frampton.Data.Task.create = _createTask;
  _Frampton.Data.Task.fail = _fail;
  _Frampton.Data.Task.succeed = _succeed;
  _Frampton.Data.Task.never = _never;
  _Frampton.Data.Task.sequence = _sequence;
  _Frampton.Data.Task.when = _when;
  _Frampton.Data.Task.execute = _execute;

  /**
   * @name Union
   * @memberof Frampton.Data
   * @class
   */
  _Frampton.Data.Union = {};
  _Frampton.Data.Union.create = _createUnion;

  /**
   * @name Record
   * @memberof Frampton.Data
   * @class
   */
  _Frampton.Data.Record = {};
  _Frampton.Data.Record.create = _createRecord;
});
define('frampton-data/record/create', ['exports', 'module', 'frampton/namespace', 'frampton-utils/guid', 'frampton-utils/warn', 'frampton-utils/is_nothing', 'frampton-utils/is_something', 'frampton-record/merge', 'frampton-record/keys'], function (exports, module, _framptonNamespace, _framptonUtilsGuid, _framptonUtilsWarn, _framptonUtilsIs_nothing, _framptonUtilsIs_something, _framptonRecordMerge, _framptonRecordKeys) {
  'use strict';

  module.exports = create_record;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _Frampton = _interopRequire(_framptonNamespace);

  var _guid = _interopRequire(_framptonUtilsGuid);

  var _warn = _interopRequire(_framptonUtilsWarn);

  var _isNothing = _interopRequire(_framptonUtilsIs_nothing);

  var _isSomething = _interopRequire(_framptonUtilsIs_something);

  var _merge = _interopRequire(_framptonRecordMerge);

  var _keys = _interopRequire(_framptonRecordKeys);

  function create_record(data, id, props) {

    var _id = id || (0, _guid)();
    var _props = props || (0, _keys)(data);

    var model = function model(update) {
      if ((0, _isNothing)(update) && _Frampton.isDev()) {
        return Object.freeze(data);
      } else if ((0, _isSomething)(update)) {
        return create_record((0, _merge)(data, update), _id, _props);
      }
    };

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

    // public
    for (var i = 0; i < _props.length; i++) {
      model[_props[i]] = data[_props[i]];
    }

    // In dev mode verify object properties
    if (_Frampton.isDev()) {
      for (var key in data) {
        if (_props.indexOf(key) === -1) {
          (0, _warn)('Frampton.Data.Record received unknown key: ' + key);
        }
      }
    }

    return Object.freeze(model);
  }
});
define('frampton-data/task/create', ['exports', 'module', 'frampton-utils/immediate', 'frampton-utils/is_function', 'frampton-utils/noop', 'frampton-utils/of_value', 'frampton-utils/is_equal'], function (exports, module, _framptonUtilsImmediate, _framptonUtilsIs_function, _framptonUtilsNoop, _framptonUtilsOf_value, _framptonUtilsIs_equal) {
  'use strict';

  /**
   * 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}
   */
  module.exports = create_task;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _immediate = _interopRequire(_framptonUtilsImmediate);

  var _isFunction = _interopRequire(_framptonUtilsIs_function);

  var _noop = _interopRequire(_framptonUtilsNoop);

  var _ofValue = _interopRequire(_framptonUtilsOf_value);

  var _isEqual = _interopRequire(_framptonUtilsIs_equal);

  function Task(task) {
    this.fn = task;
  }

  /**
   * 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}
   */
  Task.of = function (val) {
    return new Task(function (sinks) {
      sinks.resolve(val);
    });
  };

  /**
   * 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}
   */
  Task.prototype.of = function (val) {
    return new Task(function (sinks) {
      sinks.resolve(val);
    });
  };

  /**
   * 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.
   */
  Task.prototype.run = function (sinks) {
    var _this = this;

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

  /**
   * 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}
   */
  Task.prototype.join = function () {
    var source = this;
    return new Task(function (sinks) {
      source.run({
        reject: sinks.reject,
        resolve: function resolve(val) {
          val.run(sinks);
        },
        progress: _noop
      });
    });
  };

  /**
   * 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}
   */
  Task.prototype.concat = function (task) {
    var source = this;
    return new Task(function (sinks) {
      source.run({
        reject: sinks.reject,
        resolve: function resolve(val) {
          task.run(sinks);
        },
        progress: _noop
      });
    });
  };

  /**
   * 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}
   */
  Task.prototype.chain = function (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}
   */
  Task.prototype.ap = function (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}
   */
  Task.prototype.recover = function (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}
   */
  Task.prototype['default'] = function (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}
   */
  Task.prototype.progress = function (mapping) {
    var source = this;
    var mappingFn = (0, _isFunction)(mapping) ? mapping : (0, _ofValue)(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}
   */
  Task.prototype.map = function (mapping) {
    var source = this;
    var mappingFn = (0, _isFunction)(mapping) ? mapping : (0, _ofValue)(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}
   */
  Task.prototype.success = Task.prototype.map;

  /**
   * 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}
   */
  Task.prototype.filter = function (predicate) {
    var source = this;
    var filterFn = (0, _isFunction)(predicate) ? predicate : (0, _isEqual)(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}
   */
  Task.prototype.validate = Task.prototype.filter;
  function create_task(computation) {
    return new Task(computation);
  }
});
define('frampton-data/task/execute', ['exports', 'module', 'frampton-utils/log', 'frampton-utils/warn'], function (exports, module, _framptonUtilsLog, _framptonUtilsWarn) {
  'use strict';

  /**
   * 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
   */
  module.exports = execute;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _log = _interopRequire(_framptonUtilsLog);

  var _warn = _interopRequire(_framptonUtilsWarn);

  function execute(tasks, value) {
    tasks.value(function (task) {
      task.run({
        reject: function reject(err) {
          (0, _warn)('Error running task: ', err);
        },
        resolve: function resolve(val) {
          value(val);
        },
        progress: function progress(val) {
          (0, _log)('Task progress: ', val);
        }
      });
    });
  }
});
define('frampton-data/task/fail', ['exports', 'module', 'frampton-data/task/create'], function (exports, module, _framptonDataTaskCreate) {
  'use strict';

  /**
   * 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}
   */
  module.exports = fail;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _create = _interopRequire(_framptonDataTaskCreate);

  function fail(err) {
    return (0, _create)(function (sinks) {
      return sinks.reject(err);
    });
  }
});
define('frampton-data/task/never', ['exports', 'module', 'frampton-data/task/create'], function (exports, module, _framptonDataTaskCreate) {
  'use strict';

  /**
   * never :: Task x a
   *
   * Creates a Task that never resolves.
   *
   * @name never
   * @method
   * @memberof Frampton.Data.Task
   * @returns {Frampton.Data.Task}
   */
  module.exports = never;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _create = _interopRequire(_framptonDataTaskCreate);

  function never() {
    return (0, _create)(function () {});
  }
});
define("frampton-data/task/sequence", ["exports", "module"], function (exports, module) {
  /**
   * 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[]} tassk - The Tasks to wait for
   * @returns {Frampton.Data.Task}
   */
  "use strict";

  module.exports = sequence;

  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', 'module', 'frampton-data/task/create'], function (exports, module, _framptonDataTaskCreate) {
  'use strict';

  /**
   * 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}
   */
  module.exports = succeed;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _create = _interopRequire(_framptonDataTaskCreate);

  function succeed(val) {
    return (0, _create)(function (sinks) {
      return sinks.resolve(val);
    });
  }
});
define('frampton-data/task/when', ['exports', 'module', 'frampton-data/task/create'], function (exports, module, _framptonDataTaskCreate) {
  'use strict';

  /**
   * 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}
   */
  module.exports = when;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _create = _interopRequire(_framptonDataTaskCreate);

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

    return (0, _create)(function (sinks) {

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

      function logError(err) {}
      function logProgress(val) {}

      tasks.forEach(function (task) {
        var index = idx++;
        task.run({
          reject: logError,
          resolve: function resolve(val) {
            count = count + 1;
            valueArray[index] = val;
            if (count === len) {
              sinks.resolve(valueArray);
            }
          },
          progress: logProgress
        });
      });
    });
  }
});
define('frampton-data/union/create', ['exports', 'module', 'frampton-utils/curry_n', 'frampton-utils/is_nothing', 'frampton-utils/is_something', 'frampton-utils/is_array', 'frampton-record/keys', 'frampton-data/union/validator', 'frampton-data/union/validate_args', 'frampton-data/union/validate_options', 'frampton-data/union/wildcard', 'frampton-data/union/validate_case'], function (exports, module, _framptonUtilsCurry_n, _framptonUtilsIs_nothing, _framptonUtilsIs_something, _framptonUtilsIs_array, _framptonRecordKeys, _framptonDataUnionValidator, _framptonDataUnionValidate_args, _framptonDataUnionValidate_options, _framptonDataUnionWildcard, _framptonDataUnionValidate_case) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curryN = _interopRequire(_framptonUtilsCurry_n);

  var _isNothing = _interopRequire(_framptonUtilsIs_nothing);

  var _isSomething = _interopRequire(_framptonUtilsIs_something);

  var _isArray = _interopRequire(_framptonUtilsIs_array);

  var _getKeys = _interopRequire(_framptonRecordKeys);

  var _validator = _interopRequire(_framptonDataUnionValidator);

  var _validateArgs = _interopRequire(_framptonDataUnionValidate_args);

  var _validateOptions = _interopRequire(_framptonDataUnionValidate_options);

  var _wildcard = _interopRequire(_framptonDataUnionWildcard);

  var _validateCase = _interopRequire(_framptonDataUnionValidate_case);

  var caseOf = function caseOf(parent, cases, val) {

    (0, _validateCase)(parent, val);
    (0, _validateOptions)(parent, cases);
    var match = (0, _isSomething)(cases[val.ctor]) ? cases[val.ctor] : cases[_wildcard];

    if ((0, _isNothing)(match)) {
      throw new Error('No match for value with name: ' + val.ctor);
    }

    // Destructure arguments for passing to callback
    return match.apply(null, val.values);
  };

  var createType = function createType(parent, name, fields) {

    var len = fields.length;
    var validators = fields.map(function (field) {
      return (0, _validator)(parent, field);
    });

    if (!(0, _isArray)(fields)) {
      throw new TypeError('Union must receive an array of fields for each type');
    }

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

      var child = {};
      child.constructor = parent;
      if (!(0, _validateArgs)(validators, args)) {
        throw new TypeError('Union type ' + name + ' recieved an unknown argument');
      }
      child.ctor = name;
      child.values = args;
      return Object.freeze(child);
    };

    return len > 0 ? (0, _curryN)(len, constructor) : constructor;
  };

  // Creates constructors for each type described in config

  module.exports = function (config) {
    var obj = {};
    var keys = (0, _getKeys)(config);
    obj.prototype = {};
    obj.ctor = 'Union';
    obj.keys = keys;
    obj.match = (0, _curryN)(3, caseOf, obj);
    for (var key in config) {
      obj[key] = createType(obj, key, config[key]);
    }
    return Object.freeze(obj);
  };
});
define('frampton-data/union/object_validator', ['exports', 'module', 'frampton-utils/curry'], function (exports, module, _framptonUtilsCurry) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  module.exports = (0, _curry)(function object_validator(parent, child) {
    return child.constructor === parent;
  });
});
define('frampton-data/union/validate_args', ['exports', 'module', 'frampton-utils/is_undefined'], function (exports, module, _framptonUtilsIs_undefined) {
  'use strict';

  module.exports = validate_args;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _isUndefined = _interopRequire(_framptonUtilsIs_undefined);

  function validate_args(validators, args) {
    for (var i = 0; i < validators.length; i++) {
      if ((0, _isUndefined)(args[i]) || !validators[i](args[i])) {
        return false;
      }
    }
    return true;
  }
});
define('frampton-data/union/validate_case', ['exports', 'module', 'frampton-utils/curry', 'frampton-utils/is_object', 'frampton-data/union/object_validator'], function (exports, module, _framptonUtilsCurry, _framptonUtilsIs_object, _framptonDataUnionObject_validator) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  var _isObject = _interopRequire(_framptonUtilsIs_object);

  var _objectValidator = _interopRequire(_framptonDataUnionObject_validator);

  module.exports = (0, _curry)(function validate_case(parent, child) {
    if (!(0, _objectValidator)(parent, child)) {
      if ((0, _isObject)(child) && child.ctor) {
        throw new TypeError('Match received unrecognized type: ' + child.ctor);
      } else {
        throw new TypeError('Match received unrecognized type');
      }
    }
  });
});
define('frampton-data/union/validate_options', ['exports', 'module', 'frampton-utils/warn', 'frampton-data/union/wildcard'], function (exports, module, _framptonUtilsWarn, _framptonDataUnionWildcard) {
  'use strict';

  module.exports = validate_options;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _warn = _interopRequire(_framptonUtilsWarn);

  var _wildcard = _interopRequire(_framptonDataUnionWildcard);

  function validate_options(obj, cases) {
    for (var i = 0; i < obj.keys.length; i++) {
      if (!cases.hasOwnProperty(_wildcard) && !cases.hasOwnProperty(obj.keys[i])) {
        (0, _warn)('Non-exhaustive pattern match for case: ', obj.keys[i]);
      }
    }
  }
});
define('frampton-data/union/validator', ['exports', 'module', 'frampton-utils/is_boolean', 'frampton-utils/is_array', 'frampton-utils/is_number', 'frampton-utils/is_string', 'frampton-utils/is_function', 'frampton-utils/is_node', 'frampton-data/union/object_validator'], function (exports, module, _framptonUtilsIs_boolean, _framptonUtilsIs_array, _framptonUtilsIs_number, _framptonUtilsIs_string, _framptonUtilsIs_function, _framptonUtilsIs_node, _framptonDataUnionObject_validator) {
  'use strict';

  module.exports = get_validator;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _isBoolean = _interopRequire(_framptonUtilsIs_boolean);

  var _isArray = _interopRequire(_framptonUtilsIs_array);

  var _isNumber = _interopRequire(_framptonUtilsIs_number);

  var _isString = _interopRequire(_framptonUtilsIs_string);

  var _isFunction = _interopRequire(_framptonUtilsIs_function);

  var _isNode = _interopRequire(_framptonUtilsIs_node);

  var _objectValidator = _interopRequire(_framptonDataUnionObject_validator);

  function get_validator(parent, type) {

    switch (type) {
      case String:
        return _isString;

      case Number:
        return _isNumber;

      case Function:
        return _isFunction;

      case Boolean:
        return _isBoolean;

      case Array:
        return _isArray;

      case Element:
        return _isNode;

      case Node:
        return _isNode;

      case undefined:
        return (0, _objectValidator)(parent);

      default:
        return (0, _objectValidator)(type);
    }

    return false;
  }
});
define('frampton-data/union/wildcard', ['exports', 'module'], function (exports, module) {
  'use strict';

  module.exports = '_';
});
define('frampton-events', ['exports', '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 (exports, _framptonNamespace, _framptonEventsOn_event, _framptonEventsOn_selector, _framptonEventsContains, _framptonEventsEvent_target, _framptonEventsEvent_value, _framptonEventsGet_position, _framptonEventsGet_position_relative, _framptonEventsHas_selector, _framptonEventsContains_selector, _framptonEventsSelector_contains, _framptonEventsClosest_to_event, _framptonEventsPrevent_default) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _Frampton = _interopRequire(_framptonNamespace);

  var _onEvent = _interopRequire(_framptonEventsOn_event);

  var _onSelector = _interopRequire(_framptonEventsOn_selector);

  var _contains = _interopRequire(_framptonEventsContains);

  var _eventTarget = _interopRequire(_framptonEventsEvent_target);

  var _eventValue = _interopRequire(_framptonEventsEvent_value);

  var _getPosition = _interopRequire(_framptonEventsGet_position);

  var _getPositionRelative = _interopRequire(_framptonEventsGet_position_relative);

  var _hasSelector = _interopRequire(_framptonEventsHas_selector);

  var _containsSelector = _interopRequire(_framptonEventsContains_selector);

  var _selectorContains = _interopRequire(_framptonEventsSelector_contains);

  var _closestToEvent = _interopRequire(_framptonEventsClosest_to_event);

  var _preventDefault = _interopRequire(_framptonEventsPrevent_default);

  /**
   * @name Events
   * @namespace
   * @memberof Frampton
   */
  _Frampton.Events = {};
  _Frampton.Events.onEvent = _onEvent;
  _Frampton.Events.onSelector = _onSelector;
  _Frampton.Events.contains = _contains;
  _Frampton.Events.eventTarget = _eventTarget;
  _Frampton.Events.eventValue = _eventValue;
  _Frampton.Events.hasSelector = _hasSelector;
  _Frampton.Events.containsSelector = _containsSelector;
  _Frampton.Events.selectorContains = _selectorContains;
  _Frampton.Events.getPosition = _getPosition;
  _Frampton.Events.getPositionRelative = _getPositionRelative;
  _Frampton.Events.closestToEvent = _closestToEvent;
  _Frampton.Events.preventDefault = _preventDefault;
});
define('frampton-events/closest_to_event', ['exports', 'module', 'frampton-utils/curry', 'frampton-utils/compose', 'frampton-style/closest', 'frampton-events/event_target'], function (exports, module, _framptonUtilsCurry, _framptonUtilsCompose, _framptonStyleClosest, _framptonEventsEvent_target) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  var _compose = _interopRequire(_framptonUtilsCompose);

  var _closest = _interopRequire(_framptonStyleClosest);

  var _eventTarget = _interopRequire(_framptonEventsEvent_target);

  /**
   * closestToEvent :: String -> DomEvent -> DomNode
   *
   * @name closestToEvent
   * @memberof Frampton.Events
   * @static
   * @param {String} selector
   * @param {Object} evt
   * @returns {Object} A DomNode matching the given selector
   */
  module.exports = (0, _curry)(function closest_to_event(selector, evt) {
    return (0, _compose)((0, _closest)(selector), _eventTarget)(evt);
  });
});
define('frampton-events/contains', ['exports', 'module', 'frampton-utils/curry', 'frampton-utils/compose', 'frampton-html/contains', 'frampton-events/event_target'], function (exports, module, _framptonUtilsCurry, _framptonUtilsCompose, _framptonHtmlContains, _framptonEventsEvent_target) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  var _compose = _interopRequire(_framptonUtilsCompose);

  var _contains = _interopRequire(_framptonHtmlContains);

  var _eventTarget = _interopRequire(_framptonEventsEvent_target);

  /**
   * contains :: DomNode -> DomEvent -> Boolean
   *
   * @name contains
   * @memberof Frampton.Events
   * @static
   * @param {Object} element
   * @param {Object} evt
   * @returns {Boolean}
   */
  module.exports = (0, _curry)(function curried_contains(element, evt) {
    return (0, _compose)((0, _contains)(element), _eventTarget)(evt);
  });
});
define('frampton-events/contains_selector', ['exports', 'module', 'frampton-utils/curry', 'frampton-utils/compose', 'frampton-style/contains', 'frampton-events/event_target'], function (exports, module, _framptonUtilsCurry, _framptonUtilsCompose, _framptonStyleContains, _framptonEventsEvent_target) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  var _compose = _interopRequire(_framptonUtilsCompose);

  var _contains = _interopRequire(_framptonStyleContains);

  var _eventTarget = _interopRequire(_framptonEventsEvent_target);

  /**
   * containsSelector :: String -> DomEvent -> Boolean
   *
   * @name containsSelector
   * @static
   * @memberof Frampton.Events
   * @param {String} selector A selector to test
   * @param {Object} evt      An event object whose target will be tested against
   * @returns {Boolean}       Does the event target, or one of its children, have the given selector
   */
  module.exports = (0, _curry)(function contains_selector(selector, evt) {
    return (0, _compose)((0, _contains)(selector), _eventTarget)(evt);
  });
});
define('frampton-events/document_cache', ['exports', 'module', 'frampton-events/simple_cache'], function (exports, module, _framptonEventsSimple_cache) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _simpleCahce = _interopRequire(_framptonEventsSimple_cache);

  module.exports = (0, _simpleCahce)();
});
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, _framptonUtilsAssert, _framptonUtilsIs_function, _framptonUtilsIs_defined, _framptonUtilsLazy, _framptonEventsEvent_map) {
  'use strict';

  exports.__esModule = true;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _assert = _interopRequire(_framptonUtilsAssert);

  var _isFunction = _interopRequire(_framptonUtilsIs_function);

  var _isDefined = _interopRequire(_framptonUtilsIs_defined);

  var _lazy = _interopRequire(_framptonUtilsLazy);

  var _EVENT_MAP = _interopRequire(_framptonEventsEvent_map);

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

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

    (0, _assert)('addListener received an unknown type as target', (0, _isFunction)(listen));

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

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

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

    (0, _assert)('removeListener received an unknown type as target', (0, _isFunction)(remove));

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

  function addListener(eventName, target, callback) {

    if ((0, _isDefined)(_EVENT_MAP[eventName]) && (0, _isFunction)(target.addEventListener)) {
      addDomEvent(eventName, target, callback);
    } else {
      addCustomEvent(eventName, target, callback);
    }

    return (0, _lazy)(removeListener, [eventName, target, callback]);
  }

  function removeListener(eventName, target, callback) {
    if ((0, _isDefined)(_EVENT_MAP[eventName]) && (0, _isFunction)(target.removeEventListener)) {
      removeDomEvent(eventName, target, callback);
    } else {
      removeCustomEvent(eventName, target, callback);
    }
  }

  exports.addListener = addListener;
  exports.removeListener = removeListener;
});
define("frampton-events/event_map", ["exports", "module"], function (exports, module) {
  "use strict";

  module.exports = {

    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', 'module', 'frampton-utils/is_function', 'frampton-utils/memoize'], function (exports, module, _framptonUtilsIs_function, _framptonUtilsMemoize) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _isFunction = _interopRequire(_framptonUtilsIs_function);

  var _memoize = _interopRequire(_framptonUtilsMemoize);

  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
   */
  module.exports = (0, _memoize)(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, _isFunction)(el[eventName]);
    }
    el = null;
    return !!isSupported;
  });
});
define("frampton-events/event_target", ["exports", "module"], function (exports, module) {
  /**
   * eventTarget :: DomEvent -> Object
   *
   * @name eventTarget
   * @memberof Frampton.Events
   * @static
   * @param {Object} evt
   * @returns {Object} The target value of the event object, usually a DomNode
   */
  "use strict";

  module.exports = event_target;

  function event_target(evt) {
    return evt.target;
  }
});
define('frampton-events/event_value', ['exports', 'module', 'frampton-utils/compose', 'frampton-html/element_value', 'frampton-events/event_target'], function (exports, module, _framptonUtilsCompose, _framptonHtmlElement_value, _framptonEventsEvent_target) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _compose = _interopRequire(_framptonUtilsCompose);

  var _elementValue = _interopRequire(_framptonHtmlElement_value);

  var _eventTarget = _interopRequire(_framptonEventsEvent_target);

  /**
   * eventValue :: DomEvent -> String
   *
   * @name eventValue
   * @memberof Frampton.Events
   * @static
   * @param {Object} evt
   * @returns {String} The value property of the event target
   */
  module.exports = (0, _compose)(_elementValue, _eventTarget);
});
define('frampton-events/get_document_signal', ['exports', 'module', 'frampton-events/document_cache', 'frampton-events/get_event_signal'], function (exports, module, _framptonEventsDocument_cache, _framptonEventsGet_event_signal) {
  'use strict';

  /**
   * @name getDocumentSignal
   * @memberof Frampton.Events
   * @static
   * @private
   * @param {String} name Event name to look up
   * @returns {Frampton.Signal.Signal}
   */
  module.exports = get_document_signal;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _documentCache = _interopRequire(_framptonEventsDocument_cache);

  var _getEventSignal = _interopRequire(_framptonEventsGet_event_signal);

  function get_document_signal(name) {
    return (0, _documentCache)(name, function () {
      return (0, _getEventSignal)(name, document);
    });
  }
});
define('frampton-events/get_event_signal', ['exports', 'module', 'frampton-utils/is_empty', 'frampton-signal/create', 'frampton-events/event_dispatcher'], function (exports, module, _framptonUtilsIs_empty, _framptonSignalCreate, _framptonEventsEvent_dispatcher) {
  'use strict';

  module.exports = get_event_signal;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _isEmpty = _interopRequire(_framptonUtilsIs_empty);

  var _createSignal = _interopRequire(_framptonSignalCreate);

  function get_event_signal(name, target) {
    var parts = name.split(' ').filter(function (val) {
      return !(0, _isEmpty)(val);
    });
    var len = parts.length;
    var sigs = [];
    var temp;
    for (var i = 0; i < len; i++) {
      temp = (0, _createSignal)();
      (0, _framptonEventsEvent_dispatcher.addListener)(parts[i], target, temp);
      sigs.push(temp);
    }
    return (0, _framptonSignalCreate.mergeMany)(sigs);
  }
});
define("frampton-events/get_position", ["exports", "module"], function (exports, module) {
  /**
   * 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
   */
  "use strict";

  module.exports = get_position;

  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', 'module', 'frampton-utils/curry', 'frampton-events/get_position'], function (exports, module, _framptonUtilsCurry, _framptonEventsGet_position) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  var _getPosition = _interopRequire(_framptonEventsGet_position);

  /**
   * getPositionRelative :: DomNode -> DomEvent -> [Number, Number]
   *
   * @name getPositionRelative
   * @memberof Frampton.Events
   * @static
   * @param {Object} node
   * @param {Object} evt
   * @returns {Array} A pair where the 0 index is the x coord and the 1 index is the y coord
   */
  module.exports = (0, _curry)(function get_position_relative(node, evt) {

    var position = (0, _getPosition)(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', 'module', 'frampton-utils/curry', 'frampton-utils/compose', 'frampton-style/matches', 'frampton-events/event_target'], function (exports, module, _framptonUtilsCurry, _framptonUtilsCompose, _framptonStyleMatches, _framptonEventsEvent_target) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  var _compose = _interopRequire(_framptonUtilsCompose);

  var _matches = _interopRequire(_framptonStyleMatches);

  var _eventTarget = _interopRequire(_framptonEventsEvent_target);

  /**
   * hasSelector :: String -> DomEvent -> Boolean
   *
   * @name hasSelector
   * @memberof Frampton.Events
   * @static
   * @param {String} selector
   * @param {Object} evt
   * @returns {Boolean}
   */
  module.exports = (0, _curry)(function has_selector(selector, evt) {
    return (0, _compose)((0, _matches)(selector), _eventTarget)(evt);
  });
});
define('frampton-events/on_event', ['exports', 'module', '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, module, _framptonUtilsIs_function, _framptonUtilsIs_nothing, _framptonEventsContains, _framptonEventsEvent_map, _framptonEventsGet_document_signal, _framptonEventsGet_event_signal) {
  'use strict';

  /**
   * 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
   */
  module.exports = on_event;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _isFunction = _interopRequire(_framptonUtilsIs_function);

  var _isNothing = _interopRequire(_framptonUtilsIs_nothing);

  var _contains = _interopRequire(_framptonEventsContains);

  var _EVENT_MAP = _interopRequire(_framptonEventsEvent_map);

  var _getDocumentSignal = _interopRequire(_framptonEventsGet_document_signal);

  var _getEventSignal = _interopRequire(_framptonEventsGet_event_signal);

  function on_event(eventName, target) {
    if (_EVENT_MAP[eventName] && ((0, _isNothing)(target) || (0, _isFunction)(target.addEventListener))) {
      if ((0, _isNothing)(target)) {
        return (0, _getDocumentSignal)(eventName);
      } else {
        return (0, _getDocumentSignal)(eventName).filter((0, _contains)(target));
      }
    } else {
      return (0, _getEventSignal)(eventName, target);
    }
  }
});
define('frampton-events/on_selector', ['exports', 'module', '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, module, _framptonUtilsIs_something, _framptonUtilsIs_string, _framptonUtilsIs_empty, _framptonEventsClosest_to_event, _framptonEventsSelector_contains, _framptonEventsEvent_map, _framptonEventsGet_document_signal, _framptonEventsSelector_cache) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _isSomething = _interopRequire(_framptonUtilsIs_something);

  var _isString = _interopRequire(_framptonUtilsIs_string);

  var _isEmpty = _interopRequire(_framptonUtilsIs_empty);

  var _closestToEvent = _interopRequire(_framptonEventsClosest_to_event);

  var _selectorContains = _interopRequire(_framptonEventsSelector_contains);

  var _EVENT_MAP = _interopRequire(_framptonEventsEvent_map);

  var _getDocumentSignal = _interopRequire(_framptonEventsGet_document_signal);

  var _selectorCache = _interopRequire(_framptonEventsSelector_cache);

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

  function mouseEnterSelector(selector) {
    var previousElement = null;
    return (0, _getDocumentSignal)('mouseover').filter(function (evt) {
      var current = (0, _closestToEvent)(selector, evt);
      if ((0, _isSomething)(current) && current !== previousElement) {
        previousElement = current;
        return true;
      } else {
        return false;
      }
    });
  }

  function mouseLeaveSelector(selector) {
    var previousElement = null;
    return (0, _getDocumentSignal)('mouseleave').filter(function (evt) {
      var current = (0, _closestToEvent)(selector, evt);
      if ((0, _isSomething)(current) && current !== previousElement) {
        previousElement = current;
        return true;
      } else if ((0, _isSomething)(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, _isString)(selector)) {
      return (0, _selectorCache)(eventName + ' | ' + selector, function () {
        if (eventName === 'mouseenter') {
          return mouseEnterSelector(selector);
        } else if (eventName === 'mouseleave') {
          return mouseLeaveSelector(selector);
        } else {
          return (0, _getDocumentSignal)(eventName).filter(function (evt) {
            return (0, _selectorContains)(selector, evt);
          });
        }
      });
    } else {
      throw new Error('Frampton.Events.onSelector given unexpected arguments name: ' + eventName + ', selector: ' + selector);
    }
  }

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

  module.exports = once;

  function once(eventName, target) {
    return (0, _framptonEventsListen.listen)(eventName, target).take(1);
  }
});
define('frampton-events/prevent_default', ['exports', 'module', 'frampton-utils/is_function', 'frampton-utils/is_object'], function (exports, module, _framptonUtilsIs_function, _framptonUtilsIs_object) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _isFunction = _interopRequire(_framptonUtilsIs_function);

  var _isObject = _interopRequire(_framptonUtilsIs_object);

  module.exports = function (evt) {
    if ((0, _isObject)(evt) && (0, _isFunction)(evt.preventDefault) && (0, _isFunction)(evt.stopPropagation)) {
      evt.preventDefault();
      evt.stopPropagation();
    }
    return evt;
  };
});
define('frampton-events/selector_cache', ['exports', 'module', 'frampton-events/simple_cache'], function (exports, module, _framptonEventsSimple_cache) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _simpleCahce = _interopRequire(_framptonEventsSimple_cache);

  module.exports = (0, _simpleCahce)();
});
define('frampton-events/selector_contains', ['exports', 'module', 'frampton-utils/curry', 'frampton-utils/is_something', 'frampton-events/closest_to_event'], function (exports, module, _framptonUtilsCurry, _framptonUtilsIs_something, _framptonEventsClosest_to_event) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  var _isSomething = _interopRequire(_framptonUtilsIs_something);

  var _closestToEvent = _interopRequire(_framptonEventsClosest_to_event);

  /**
   * selectorContains :: String -> DomEvent -> Boolean
   *
   * Tests if the target of a given event is contained in a node that matches
   * the given selector.
   *
   * @name selectorContains
   * @memberof Frampton.Events
   * @static
   * @param {String} selector
   * @param {Object} evt
   * @returns {Boolean} Is the event contained in a node that matches the given selector
   */
  module.exports = (0, _curry)(function selector_contains(selector, evt) {
    return (0, _isSomething)((0, _closestToEvent)(selector, evt));
  });
});
define('frampton-events/simple_cache', ['exports', 'module', 'frampton-utils/is_nothing'], function (exports, module, _framptonUtilsIs_nothing) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _isNothing = _interopRequire(_framptonUtilsIs_nothing);

  module.exports = function () {

    var store = {};

    return function (name, fn) {
      if ((0, _isNothing)(store[name])) {
        store[name] = fn();
      }
      return store[name];
    };
  };
});
define('frampton-html', ['exports', 'frampton/namespace', 'frampton-html/attribute', 'frampton-html/contains', 'frampton-html/element_value', 'frampton-html/data', 'frampton-html/set_html'], function (exports, _framptonNamespace, _framptonHtmlAttribute, _framptonHtmlContains, _framptonHtmlElement_value, _framptonHtmlData, _framptonHtmlSet_html) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _Frampton = _interopRequire(_framptonNamespace);

  var _attribute = _interopRequire(_framptonHtmlAttribute);

  var _contains = _interopRequire(_framptonHtmlContains);

  var _elementValue = _interopRequire(_framptonHtmlElement_value);

  var _data = _interopRequire(_framptonHtmlData);

  var _set = _interopRequire(_framptonHtmlSet_html);

  /**
   * @name Html
   * @namespace
   * @memberof Frampton
   */
  _Frampton.Html = {};
  _Frampton.Html.attribute = _attribute;
  _Frampton.Html.contains = _contains;
  _Frampton.Html.elementValue = _elementValue;
  _Frampton.Html.data = _data;
  _Frampton.Html.set = _set;
});
define('frampton-html/attribute', ['exports', 'module', 'frampton-utils/curry'], function (exports, module, _framptonUtilsCurry) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  // attribute :: String -> Dom -> String
  module.exports = (0, _curry)(function (name, dom) {
    return dom.getAttribute(name);
  });
});
define('frampton-html/contains', ['exports', 'module', 'frampton-utils/curry', 'frampton-utils/is_function'], function (exports, module, _framptonUtilsCurry, _framptonUtilsIs_function) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  var _isFunction = _interopRequire(_framptonUtilsIs_function);

  // contains :: Dom -> Dom -> Boolean
  module.exports = (0, _curry)(function (parent, child) {
    if (parent === child) {
      return true;
    } else if ((0, _isFunction)(parent.contains)) {
      return parent.contains(child);
    } else {
      while (child = child.parentNode) {
        if (parent === child) {
          return true;
        }
        return false;
      }
    }
  });
});
define('frampton-html/data', ['exports', 'module', 'frampton-utils/curry', 'frampton-html/attribute'], function (exports, module, _framptonUtilsCurry, _framptonHtmlAttribute) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  var _attribute = _interopRequire(_framptonHtmlAttribute);

  // data :: String -> Dom -> String
  module.exports = (0, _curry)(function (name, dom) {
    return (0, _attribute)('data-' + name, dom);
  });
});
define("frampton-html/element_value", ["exports", "module"], function (exports, module) {
  /**
   * elementValue :: Object -> Any
   *
   * @name elementValue
   * @method
   * @memberof Frampton.Html
   * @param {Object} element
   * @returns {*}
   */
  "use strict";

  module.exports = element_value;

  function element_value(element) {
    return element.value || null;
  }
});
define('frampton-html/set_html', ['exports', 'module', 'frampton-utils/curry'], function (exports, module, _framptonUtilsCurry) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  module.exports = (0, _curry)(function (element, html) {
    element.innerHTML = html;
  });
});
define('frampton-keyboard', ['exports', 'frampton/namespace', 'frampton-keyboard/keyboard', 'frampton-keyboard/key_code', 'frampton-keyboard/is_key', 'frampton-keyboard/is_enter', 'frampton-keyboard/is_esc', 'frampton-keyboard/is_up', 'frampton-keyboard/is_down', 'frampton-keyboard/is_left', 'frampton-keyboard/is_right', 'frampton-keyboard/is_space', 'frampton-keyboard/is_ctrl', 'frampton-keyboard/is_shift'], function (exports, _framptonNamespace, _framptonKeyboardKeyboard, _framptonKeyboardKey_code, _framptonKeyboardIs_key, _framptonKeyboardIs_enter, _framptonKeyboardIs_esc, _framptonKeyboardIs_up, _framptonKeyboardIs_down, _framptonKeyboardIs_left, _framptonKeyboardIs_right, _framptonKeyboardIs_space, _framptonKeyboardIs_ctrl, _framptonKeyboardIs_shift) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _Frampton = _interopRequire(_framptonNamespace);

  var _Keyboard = _interopRequire(_framptonKeyboardKeyboard);

  var _keyCode = _interopRequire(_framptonKeyboardKey_code);

  var _isKey = _interopRequire(_framptonKeyboardIs_key);

  var _isEnter = _interopRequire(_framptonKeyboardIs_enter);

  var _isEsc = _interopRequire(_framptonKeyboardIs_esc);

  var _isUp = _interopRequire(_framptonKeyboardIs_up);

  var _isDown = _interopRequire(_framptonKeyboardIs_down);

  var _isLeft = _interopRequire(_framptonKeyboardIs_left);

  var _isRight = _interopRequire(_framptonKeyboardIs_right);

  var _isSpace = _interopRequire(_framptonKeyboardIs_space);

  var _isCtrl = _interopRequire(_framptonKeyboardIs_ctrl);

  var _isShift = _interopRequire(_framptonKeyboardIs_shift);

  /**
   * @name Keyboard
   * @namespace
   * @memberof Frampton
   */
  _Frampton.Keyboard = _Keyboard;
  _Frampton.Keyboard.keyCode = _keyCode;
  _Frampton.Keyboard.isKey = _isKey;
  _Frampton.Keyboard.isEnter = _isEnter;
  _Frampton.Keyboard.isEsc = _isEsc;
  _Frampton.Keyboard.isUp = _isUp;
  _Frampton.Keyboard.isDown = _isDown;
  _Frampton.Keyboard.isLeft = _isLeft;
  _Frampton.Keyboard.isRight = _isRight;
  _Frampton.Keyboard.isShift = _isShift;
  _Frampton.Keyboard.isSpace = _isSpace;
  _Frampton.Keyboard.isCtrl = _isCtrl;
});
define('frampton-keyboard/is_ctrl', ['exports', 'module', 'frampton-keyboard/is_key', 'frampton-keyboard/key_map'], function (exports, module, _framptonKeyboardIs_key, _framptonKeyboardKey_map) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _isKey = _interopRequire(_framptonKeyboardIs_key);

  var _KEY_MAP = _interopRequire(_framptonKeyboardKey_map);

  // is_ctrl :: KeyCode -> Boolean
  module.exports = (0, _isKey)(_KEY_MAP.CTRL);
});
define('frampton-keyboard/is_down', ['exports', 'module', 'frampton-keyboard/is_key', 'frampton-keyboard/key_map'], function (exports, module, _framptonKeyboardIs_key, _framptonKeyboardKey_map) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _isKey = _interopRequire(_framptonKeyboardIs_key);

  var _KEY_MAP = _interopRequire(_framptonKeyboardKey_map);

  // is_down :: KeyCode -> Boolean
  module.exports = (0, _isKey)(_KEY_MAP.DOWN);
});
define('frampton-keyboard/is_enter', ['exports', 'module', 'frampton-keyboard/is_key', 'frampton-keyboard/key_map'], function (exports, module, _framptonKeyboardIs_key, _framptonKeyboardKey_map) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _isKey = _interopRequire(_framptonKeyboardIs_key);

  var _KEY_MAP = _interopRequire(_framptonKeyboardKey_map);

  // is_enter :: KeyCode -> Boolean
  module.exports = (0, _isKey)(_KEY_MAP.ENTER);
});
define('frampton-keyboard/is_esc', ['exports', 'module', 'frampton-keyboard/is_key', 'frampton-keyboard/key_map'], function (exports, module, _framptonKeyboardIs_key, _framptonKeyboardKey_map) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _isKey = _interopRequire(_framptonKeyboardIs_key);

  var _KEY_MAP = _interopRequire(_framptonKeyboardKey_map);

  // is_esc :: KeyCode -> Boolean
  module.exports = (0, _isKey)(_KEY_MAP.ESC);
});
define('frampton-keyboard/is_key', ['exports', 'module', 'frampton-utils/curry'], function (exports, module, _framptonUtilsCurry) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  // isKey :: KeyCode -> KeyCode -> Boolean
  module.exports = (0, _curry)(function is_key(key, keyCode) {
    return key === keyCode;
  });
});
define('frampton-keyboard/is_left', ['exports', 'module', 'frampton-keyboard/is_key', 'frampton-keyboard/key_map'], function (exports, module, _framptonKeyboardIs_key, _framptonKeyboardKey_map) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _isKey = _interopRequire(_framptonKeyboardIs_key);

  var _KEY_MAP = _interopRequire(_framptonKeyboardKey_map);

  // is_left :: KeyCode -> Boolean
  module.exports = (0, _isKey)(_KEY_MAP.LEFT);
});
define('frampton-keyboard/is_right', ['exports', 'module', 'frampton-keyboard/is_key', 'frampton-keyboard/key_map'], function (exports, module, _framptonKeyboardIs_key, _framptonKeyboardKey_map) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _isKey = _interopRequire(_framptonKeyboardIs_key);

  var _KEY_MAP = _interopRequire(_framptonKeyboardKey_map);

  // is_right :: KeyCode -> Boolean
  module.exports = (0, _isKey)(_KEY_MAP.RIGHT);
});
define('frampton-keyboard/is_shift', ['exports', 'module', 'frampton-keyboard/is_key', 'frampton-keyboard/key_map'], function (exports, module, _framptonKeyboardIs_key, _framptonKeyboardKey_map) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _isKey = _interopRequire(_framptonKeyboardIs_key);

  var _KEY_MAP = _interopRequire(_framptonKeyboardKey_map);

  // is_shift :: KeyCode -> Boolean
  module.exports = (0, _isKey)(_KEY_MAP.SHIFT);
});
define('frampton-keyboard/is_space', ['exports', 'module', 'frampton-keyboard/is_key', 'frampton-keyboard/key_map'], function (exports, module, _framptonKeyboardIs_key, _framptonKeyboardKey_map) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _isKey = _interopRequire(_framptonKeyboardIs_key);

  var _KEY_MAP = _interopRequire(_framptonKeyboardKey_map);

  // is_space :: KeyCode -> Boolean
  module.exports = (0, _isKey)(_KEY_MAP.SPACE);
});
define('frampton-keyboard/is_up', ['exports', 'module', 'frampton-keyboard/is_key', 'frampton-keyboard/key_map'], function (exports, module, _framptonKeyboardIs_key, _framptonKeyboardKey_map) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _isKey = _interopRequire(_framptonKeyboardIs_key);

  var _KEY_MAP = _interopRequire(_framptonKeyboardKey_map);

  // is_up :: KeyCode -> Boolean
  module.exports = (0, _isKey)(_KEY_MAP.UP);
});
define('frampton-keyboard/key_code', ['exports', 'module', 'frampton-utils/get'], function (exports, module, _framptonUtilsGet) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _get = _interopRequire(_framptonUtilsGet);

  // key_code :: DomEvent -> KeyCode
  module.exports = (0, _get)('keyCode');
});
define("frampton-keyboard/key_map", ["exports", "module"], function (exports, module) {
  "use strict";

  module.exports = {
    ENTER: 13,
    ESC: 27,
    SPACE: 32,
    CTRL: 17,
    SHIFT: 16,
    UP: 38,
    DOWN: 40,
    LEFT: 37,
    RIGHT: 39
  };
});
define('frampton-keyboard/keyboard', ['exports', 'module', 'frampton-utils/curry', 'frampton-list/contains', 'frampton-list/append', 'frampton-list/remove', 'frampton-events/on_event', 'frampton-signal/stepper', 'frampton-keyboard/key_map', 'frampton-keyboard/key_code'], function (exports, module, _framptonUtilsCurry, _framptonListContains, _framptonListAppend, _framptonListRemove, _framptonEventsOn_event, _framptonSignalStepper, _framptonKeyboardKey_map, _framptonKeyboardKey_code) {
  'use strict';

  module.exports = Keyboard;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  var _contains = _interopRequire(_framptonListContains);

  var _append = _interopRequire(_framptonListAppend);

  var _remove = _interopRequire(_framptonListRemove);

  var _onEvent = _interopRequire(_framptonEventsOn_event);

  var _stepper = _interopRequire(_framptonSignalStepper);

  var _KEY_MAP = _interopRequire(_framptonKeyboardKey_map);

  var _keyCode = _interopRequire(_framptonKeyboardKey_code);

  //+ keyUp :: Signal DomEvent
  var keyUp = (0, _onEvent)('keyup');

  //+ keyDown :: Signal DomEvent
  var keyDown = (0, _onEvent)('keydown');

  //+ keyPress :: Signal DomEvent
  var keyPress = (0, _onEvent)('keypress');

  //+ keyUpCodes :: Signal KeyCode
  var keyUpCodes = keyUp.map(_keyCode);

  //+ keyDownCodes :: Signal KeyCode
  var keyDownCodes = keyDown.map(_keyCode);

  var addKey = function addKey(keyCode) {
    return function (arr) {
      if (!(0, _contains)(arr, keyCode)) {
        return (0, _append)(arr, keyCode);
      }
      return arr;
    };
  };

  var removeKey = function removeKey(keyCode) {
    return function (arr) {
      return (0, _remove)(keyCode, arr);
    };
  };

  var update = function update(acc, fn) {
    return fn(acc);
  };

  //+ rawEvents :: Signal Function
  var rawEvents = keyUpCodes.map(removeKey).merge(keyDownCodes.map(addKey));

  //+ keysDown :: Signal []
  var keysDown = rawEvents.fold(update, []);

  //+ keyIsDown :: KeyCode -> Signal Boolean
  var keyIsDown = function keyIsDown(keyCode) {
    return keysDown.map(function (arr) {
      return (0, _contains)(arr, keyCode);
    });
  };

  //+ direction :: KeyCode -> [KeyCode] -> Boolean
  var direction = (0, _curry)(function (keyCode, arr) {
    return (0, _contains)(arr, keyCode) ? 1 : 0;
  });

  //+ isUp :: [KeyCode] -> Boolean
  var isUp = direction(_KEY_MAP.UP);

  //+ isDown :: [KeyCode] -> Boolean
  var isDown = direction(_KEY_MAP.DOWN);

  //+ isRight :: [KeyCode] -> Boolean
  var isRight = direction(_KEY_MAP.RIGHT);

  //+ isLeft :: [KeyCode] -> Boolean
  var isLeft = direction(_KEY_MAP.LEFT);

  //+ arrows :: Signal [horizontal, vertical]
  var arrows = keysDown.map(function (arr) {
    return [isRight(arr) - isLeft(arr), isUp(arr) - isDown(arr)];
  });

  var defaultKeyboard = {
    downs: keyDown,
    ups: keyUp,
    presses: keyPress,
    codes: keyUpCodes,
    arrows: (0, _stepper)([0, 0], arrows),
    shift: (0, _stepper)(false, keyIsDown(_KEY_MAP.SHIFT)),
    ctrl: (0, _stepper)(false, keyIsDown(_KEY_MAP.CTRL)),
    escape: (0, _stepper)(false, keyIsDown(_KEY_MAP.ESC)),
    enter: (0, _stepper)(false, keyIsDown(_KEY_MAP.ENTER)),
    space: (0, _stepper)(false, keyIsDown(_KEY_MAP.SPACE))
  };

  function Keyboard() {
    return defaultKeyboard;
  }
});
define('frampton-list', ['exports', 'frampton/namespace', 'frampton-list/add', 'frampton-list/append', '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 (exports, _framptonNamespace, _framptonListAdd, _framptonListAppend, _framptonListContains, _framptonListCopy, _framptonListDiff, _framptonListDrop, _framptonListEach, _framptonListFilter, _framptonListFind, _framptonListFirst, _framptonListFoldl, _framptonListFoldr, _framptonListInit, _framptonListLast, _framptonListLength, _framptonListMax, _framptonListMin, _framptonListPrepend, _framptonListProduct, _framptonListRemove, _framptonListRemove_index, _framptonListReplace, _framptonListReplace_index, _framptonListReverse, _framptonListSecond, _framptonListSplit, _framptonListSum, _framptonListTail, _framptonListTake, _framptonListThird, _framptonListZip) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _Frampton = _interopRequire(_framptonNamespace);

  var _add = _interopRequire(_framptonListAdd);

  var _append = _interopRequire(_framptonListAppend);

  var _contains = _interopRequire(_framptonListContains);

  var _copy = _interopRequire(_framptonListCopy);

  var _diff = _interopRequire(_framptonListDiff);

  var _drop = _interopRequire(_framptonListDrop);

  var _each = _interopRequire(_framptonListEach);

  var _filter = _interopRequire(_framptonListFilter);

  var _find = _interopRequire(_framptonListFind);

  var _first = _interopRequire(_framptonListFirst);

  var _foldl = _interopRequire(_framptonListFoldl);

  var _foldr = _interopRequire(_framptonListFoldr);

  var _init = _interopRequire(_framptonListInit);

  var _last = _interopRequire(_framptonListLast);

  var _length = _interopRequire(_framptonListLength);

  var _max = _interopRequire(_framptonListMax);

  var _min = _interopRequire(_framptonListMin);

  var _prepend = _interopRequire(_framptonListPrepend);

  var _product = _interopRequire(_framptonListProduct);

  var _remove = _interopRequire(_framptonListRemove);

  var _removeAt = _interopRequire(_framptonListRemove_index);

  var _replace = _interopRequire(_framptonListReplace);

  var _replaceAt = _interopRequire(_framptonListReplace_index);

  var _reverse = _interopRequire(_framptonListReverse);

  var _second = _interopRequire(_framptonListSecond);

  var _split = _interopRequire(_framptonListSplit);

  var _sum = _interopRequire(_framptonListSum);

  var _tail = _interopRequire(_framptonListTail);

  var _take = _interopRequire(_framptonListTake);

  var _third = _interopRequire(_framptonListThird);

  var _zip = _interopRequire(_framptonListZip);

  /**
   * @name List
   * @namespace
   * @memberof Frampton
   */
  _Frampton.List = {};
  _Frampton.List.add = _add;
  _Frampton.List.append = _append;
  _Frampton.List.contains = _contains;
  _Frampton.List.copy = _copy;
  _Frampton.List.diff = _diff;
  _Frampton.List.drop = _drop;
  _Frampton.List.each = _each;
  _Frampton.List.filter = _filter;
  _Frampton.List.find = _find;
  _Frampton.List.foldl = _foldl;
  _Frampton.List.foldr = _foldr;
  _Frampton.List.first = _first;
  _Frampton.List.second = _second;
  _Frampton.List.third = _third;
  _Frampton.List.init = _init;
  _Frampton.List.last = _last;
  _Frampton.List.length = _length;
  _Frampton.List.max = _max;
  _Frampton.List.min = _min;
  _Frampton.List.prepend = _prepend;
  _Frampton.List.product = _product;
  _Frampton.List.remove = _remove;
  _Frampton.List.removeAt = _removeAt;
  _Frampton.List.replace = _replace;
  _Frampton.List.replaceAt = _replaceAt;
  _Frampton.List.reverse = _reverse;
  _Frampton.List.split = _split;
  _Frampton.List.sum = _sum;
  _Frampton.List.tail = _tail;
  _Frampton.List.take = _take;
  _Frampton.List.zip = _zip;
});
define('frampton-list/add', ['exports', 'module', 'frampton-utils/curry', 'frampton-list/contains', 'frampton-list/append', 'frampton-list/copy'], function (exports, module, _framptonUtilsCurry, _framptonListContains, _framptonListAppend, _framptonListCopy) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  var _contains = _interopRequire(_framptonListContains);

  var _append = _interopRequire(_framptonListAppend);

  var _copy = _interopRequire(_framptonListCopy);

  /**
   * @name addToList
   * @method
   * @memberof Frampton.List
   * @param {Array} xs  Array to add object to
   * @param {*}   obj Object to add to array
   * @returns {Array} A new array with the object added
   */
  module.exports = (0, _curry)(function add_to_list(xs, obj) {
    return !(0, _contains)(xs, obj) ? (0, _append)(xs, obj) : (0, _copy)(xs);
  });
});
define('frampton-list/append', ['exports', 'module', 'frampton-utils/curry', 'frampton-utils/is_something', 'frampton-list/length'], function (exports, module, _framptonUtilsCurry, _framptonUtilsIs_something, _framptonListLength) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  var _isSomething = _interopRequire(_framptonUtilsIs_something);

  var _length = _interopRequire(_framptonListLength);

  /**
   * @name append
   * @method
   * @memberof Frampton.List
   * @param {Array} xs
   * @param {*} obj
   * @returns {Array}
   */
  module.exports = (0, _curry)(function (xs, obj) {
    if ((0, _isSomething)(obj)) {
      var len = (0, _length)(xs);
      var newArray = new Array(len + 1);
      for (var i = 0; i < len; i++) {
        newArray[i] = xs[i];
      }
      newArray[len] = obj;
      return Object.freeze(newArray);
    } else {
      return xs;
    }
  });
});
define('frampton-list/at', ['exports', 'module', 'frampton-utils/curry', 'frampton-utils/assert', 'frampton-utils/is_defined', 'frampton-utils/is_array'], function (exports, module, _framptonUtilsCurry, _framptonUtilsAssert, _framptonUtilsIs_defined, _framptonUtilsIs_array) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  var _assert = _interopRequire(_framptonUtilsAssert);

  var _isDefined = _interopRequire(_framptonUtilsIs_defined);

  var _isArray = _interopRequire(_framptonUtilsIs_array);

  /**
   * @name at
   * @method
   * @memberof Frampton.List
   */
  module.exports = (0, _curry)(function at(index, xs) {
    (0, _assert)('Frampton.List.at recieved a non-array', (0, _isArray)(xs));
    return (0, _isDefined)(xs[index]) ? xs[index] : null;
  });
});
define('frampton-list/contains', ['exports', 'module', 'frampton-utils/curry'], function (exports, module, _framptonUtilsCurry) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  /**
   * @name contains
   * @method
   * @memberof Frampton.List
   * @param {Array} xs
   * @param {*}   obj
   * @retruns {Boolean}
   */
  module.exports = (0, _curry)(function (xs, obj) {
    return xs.indexOf(obj) > -1;
  });
});
define('frampton-list/copy', ['exports', 'module', 'frampton-list/length'], function (exports, module, _framptonListLength) {
  'use strict';

  /**
   * @name copy
   * @method
   * @memberof Frampton.List
   */
  module.exports = copy;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _length = _interopRequire(_framptonListLength);

  function copy(xs, begin, end) {

    var argLen = (0, _length)(xs),
        idx = 0,
        arrLen,
        arr,
        i;

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

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

    return Object.freeze(arr || []);
  }
});
define('frampton-list/diff', ['exports', 'module', 'frampton-utils/curry', 'frampton-list/contains', 'frampton-list/each'], function (exports, module, _framptonUtilsCurry, _framptonListContains, _framptonListEach) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  var _contains = _interopRequire(_framptonListContains);

  var _each = _interopRequire(_framptonListEach);

  /**
   * @name diff
   * @method
   * @memberof Frampton.List
   * @returns {Array}
   */
  module.exports = (0, _curry)(function curried_diff(xs, ys) {

    var diff = [];

    (0, _each)(function (item) {
      if (!(0, _contains)(ys, item)) {
        diff.push(item);
      }
    }, xs);

    return Object.freeze(diff);
  });
});
define('frampton-list/drop', ['exports', 'module', 'frampton-utils/assert', 'frampton-utils/curry', 'frampton-utils/is_array', 'frampton-list/filter'], function (exports, module, _framptonUtilsAssert, _framptonUtilsCurry, _framptonUtilsIs_array, _framptonListFilter) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _assert = _interopRequire(_framptonUtilsAssert);

  var _curry = _interopRequire(_framptonUtilsCurry);

  var _isArray = _interopRequire(_framptonUtilsIs_array);

  var _filter = _interopRequire(_framptonListFilter);

  /**
   * @name drop
   * @method
   * @memberof Frampton.List
   */
  module.exports = (0, _curry)(function curried_drop(n, xs) {
    (0, _assert)('Frampton.List.drop recieved a non-array', (0, _isArray)(xs));
    return (0, _filter)(function (next) {
      if (n === 0) {
        return true;
      } else {
        n--;
      }
      return false;
    }, xs);
  });
});
define('frampton-list/each', ['exports', 'module', 'frampton-utils/curry'], function (exports, module, _framptonUtilsCurry) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  /**
   * @name each
   * @method
   * @memberof Frampton.List
   * @param {Functino} fn Function to run on each element
   * @param {Array} xs Array to
   */
  module.exports = (0, _curry)(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', 'module', 'frampton-utils/curry', 'frampton-list/length'], function (exports, module, _framptonUtilsCurry, _framptonListLength) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  var _length = _interopRequire(_framptonListLength);

  /**
   * @name filter
   * @method
   * @memberof Frampton.List
   * @param {Function} predicate
   * @param {Array} xs
   * @returns {Array} A new array
   */
  module.exports = (0, _curry)(function filter(predicate, xs) {

    var len = (0, _length)(xs);
    var newList = [];

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

    return Object.freeze(newList);
  });
});
define('frampton-list/find', ['exports', 'module', 'frampton-utils/curry'], function (exports, module, _framptonUtilsCurry) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  module.exports = (0, _curry)(function (obj, xs) {
    return xs.indexOf(obj);
  });
});
define('frampton-list/first', ['exports', 'module', 'frampton-list/at'], function (exports, module, _framptonListAt) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _at = _interopRequire(_framptonListAt);

  /**
   * @name first
   * @method
   * @memberof Frampton.List
   */
  module.exports = (0, _at)(0);
});
define('frampton-list/foldl', ['exports', 'module', 'frampton-utils/assert', 'frampton-utils/curry', 'frampton-utils/is_array'], function (exports, module, _framptonUtilsAssert, _framptonUtilsCurry, _framptonUtilsIs_array) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _assert = _interopRequire(_framptonUtilsAssert);

  var _curry = _interopRequire(_framptonUtilsCurry);

  var _isArray = _interopRequire(_framptonUtilsIs_array);

  /**
   * @name foldl
   * @method
   * @memberof Frampton.List
   */
  module.exports = (0, _curry)(function curried_foldl(fn, acc, xs) {
    (0, _assert)('Frampton.List.foldl recieved a non-array', (0, _isArray)(xs));
    var len = xs.length;
    for (var i = 0; i < len; i++) {
      acc = fn(acc, xs[i]);
    }
    return acc;
  });
});
define('frampton-list/foldr', ['exports', 'module', 'frampton-utils/assert', 'frampton-utils/curry', 'frampton-utils/is_array'], function (exports, module, _framptonUtilsAssert, _framptonUtilsCurry, _framptonUtilsIs_array) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _assert = _interopRequire(_framptonUtilsAssert);

  var _curry = _interopRequire(_framptonUtilsCurry);

  var _isArray = _interopRequire(_framptonUtilsIs_array);

  /**
   * @name foldr
   * @method
   * @memberof Frampton.List
   */
  module.exports = (0, _curry)(function curried_foldr(fn, acc, xs) {
    (0, _assert)('Frampton.List.foldr recieved a non-array', (0, _isArray)(xs));
    var len = xs.length;
    while (len--) {
      acc = fn(acc, xs[len]);
    }
    return acc;
  });
});
define('frampton-list/init', ['exports', 'module', 'frampton-utils/assert', 'frampton-utils/is_array'], function (exports, module, _framptonUtilsAssert, _framptonUtilsIs_array) {
  'use strict';

  /**
   * @name init
   * @method
   * @memberof Frampton.List
   */
  module.exports = init;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _assert = _interopRequire(_framptonUtilsAssert);

  var _isArray = _interopRequire(_framptonUtilsIs_array);

  function init(xs) {
    (0, _assert)('Frampton.List.init recieved a non-array', (0, _isArray)(xs));
    switch (xs.length) {

      case 0:
        return Object.freeze([]);

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

  /**
   * @name last
   * @method
   * @memberof Frampton.List
   */
  module.exports = last;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _assert = _interopRequire(_framptonUtilsAssert);

  var _isArray = _interopRequire(_framptonUtilsIs_array);

  function last(xs) {
    (0, _assert)('Frampton.List.last recieved a non-array', (0, _isArray)(xs));
    switch (xs.length) {

      case 0:
        return null;

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

  /**
   * @name length
   * @method
   * @memberof Frampton.List
   */
  module.exports = length;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _isSomething = _interopRequire(_framptonUtilsIs_something);

  var _isDefined = _interopRequire(_framptonUtilsIs_defined);

  function length(xs) {
    return (0, _isSomething)(xs) && (0, _isDefined)(xs.length) ? xs.length : 0;
  }
});
define('frampton-list/max', ['exports', 'module', 'frampton-list/foldl', 'frampton-utils/is_nothing'], function (exports, module, _framptonListFoldl, _framptonUtilsIs_nothing) {
  'use strict';

  /**
   * @name maximum
   * @method
   * @memberof Frampton.List
   * @param {Array} xs
   */
  module.exports = maximum;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _foldl = _interopRequire(_framptonListFoldl);

  var _isNothing = _interopRequire(_framptonUtilsIs_nothing);

  function maximum(xs) {
    return (0, _foldl)(function (acc, next) {
      if ((0, _isNothing)(acc) || next > acc) {
        acc = next;
      }
      return acc;
    }, null, xs);
  }
});
define('frampton-list/min', ['exports', 'module', 'frampton-list/foldl', 'frampton-utils/is_nothing'], function (exports, module, _framptonListFoldl, _framptonUtilsIs_nothing) {
  'use strict';

  /**
   * @name min
   * @method
   * @memberof Frampton.List
   * @param {Array} xs
   */
  module.exports = min;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _foldl = _interopRequire(_framptonListFoldl);

  var _isNothing = _interopRequire(_framptonUtilsIs_nothing);

  function min(xs) {
    return (0, _foldl)(function (acc, next) {
      if ((0, _isNothing)(acc) || next < acc) {
        acc = next;
      }
      return acc;
    }, null, xs);
  }
});
define('frampton-list/prepend', ['exports', 'module', 'frampton-utils/curry'], function (exports, module, _framptonUtilsCurry) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  /**
   * @name prepend
   * @method
   * @memberof Frampton.List
   * @param {Array} xs
   * @param {*} obj
   */
  module.exports = (0, _curry)(function (xs, obj) {
    return Object.freeze([].concat(obj).concat(xs));
  });
});
define('frampton-list/product', ['exports', 'module', 'frampton-list/foldl'], function (exports, module, _framptonListFoldl) {
  'use strict';

  /**
   * @name product
   * @method
   * @memberof Frampton.List
   * @param {Array} xs
   */
  module.exports = product;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _foldl = _interopRequire(_framptonListFoldl);

  function product(xs) {
    return (0, _foldl)(function (acc, next) {
      return acc * next;
    }, 1, xs);
  }
});
define('frampton-list/remove', ['exports', 'module', 'frampton-utils/curry', 'frampton-list/filter'], function (exports, module, _framptonUtilsCurry, _framptonListFilter) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  var _filter = _interopRequire(_framptonListFilter);

  /**
   * remove :: List a -> Any a -> List a
   *
   * @name remove
   * @method
   * @memberof Frampton.List
   * @param {Array} xs
   * @param {Object} obj
   */
  module.exports = (0, _curry)(function curried_remove(obj, xs) {
    return (0, _filter)(function (next) {
      return next !== obj;
    }, xs);
  });
});
define('frampton-list/remove_index', ['exports', 'module', 'frampton-list/length'], function (exports, module, _framptonListLength) {
  'use strict';

  /**
   * @name removeIndex
   * @method
   * @memberof Frampton.List
   * @param {Number} index
   * @param {Array} xs
   * @returns {Array} A new array
   */
  module.exports = remove_index;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _length = _interopRequire(_framptonListLength);

  function remove_index(index, xs) {

    var len = (0, _length)(xs);
    var newList = [];

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

    return Object.freeze(newList);
  }
});
define('frampton-list/replace', ['exports', 'module', 'frampton-utils/curry', 'frampton-list/find', 'frampton-list/replace_index'], function (exports, module, _framptonUtilsCurry, _framptonListFind, _framptonListReplace_index) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  var _find = _interopRequire(_framptonListFind);

  var _replaceIndex = _interopRequire(_framptonListReplace_index);

  module.exports = (0, _curry)(function replace(oldObj, newObj, xs) {
    var index = (0, _find)(oldObj, xs);
    if (index > -1) {
      return (0, _replaceIndex)(index, newObj, xs);
    } else {
      return xs;
    }
  });
});
define('frampton-list/replace_index', ['exports', 'module', 'frampton-utils/curry', 'frampton-list/length'], function (exports, module, _framptonUtilsCurry, _framptonListLength) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  var _length = _interopRequire(_framptonListLength);

  module.exports = (0, _curry)(function replace_index(index, obj, xs) {
    var len = (0, _length)(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 Object.freeze(newArray);
  });
});
define('frampton-list/reverse', ['exports', 'module', 'frampton-list/foldr'], function (exports, module, _framptonListFoldr) {
  'use strict';

  /**
   * reverse :: List a -> List a
   *
   * @name reverse
   * @method
   * @memberof Frampton.List
   */
  module.exports = reverse;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _foldr = _interopRequire(_framptonListFoldr);

  function reverse(xs) {
    return Object.freeze((0, _foldr)(function (acc, next) {
      acc.push(next);
      return acc;
    }, [], xs));
  }
});
define('frampton-list/second', ['exports', 'module', 'frampton-list/at'], function (exports, module, _framptonListAt) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _at = _interopRequire(_framptonListAt);

  /**
   * @name second
   * @method
   * @memberof Frampton.List
   */
  module.exports = (0, _at)(1);
});
define('frampton-list/split', ['exports', 'module', 'frampton-utils/curry'], function (exports, module, _framptonUtilsCurry) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  /**
   * split :: Number -> List a -> (List a, List a)
   *
   * @name split
   * @method
   * @memberof Frampton.List
   */
  module.exports = (0, _curry)(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 Object.freeze([ys, zs]);
  });
});
define('frampton-list/sum', ['exports', 'module', 'frampton-list/foldl'], function (exports, module, _framptonListFoldl) {
  'use strict';

  /**
   * + sum :: Number a => List a -> a
   *
   * @name sum
   * @method
   * @memberof Frampton.List
   * @param {Array} xs
   */
  module.exports = sum;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _foldl = _interopRequire(_framptonListFoldl);

  function sum(xs) {
    return (0, _foldl)(function (acc, next) {
      return acc + next;
    }, 0, xs);
  }
});
define('frampton-list/tail', ['exports', 'module', 'frampton-utils/assert', 'frampton-utils/is_array'], function (exports, module, _framptonUtilsAssert, _framptonUtilsIs_array) {
  /**
   * @name tail
   * @method
   * @memberof Frampton.List
   */
  'use strict';

  module.exports = tail;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _assert = _interopRequire(_framptonUtilsAssert);

  var _isArray = _interopRequire(_framptonUtilsIs_array);

  function tail(xs) {
    (0, _assert)('Frampton.List.tail recieved a non-array', (0, _isArray)(xs));
    switch (xs.length) {
      case 0:
        return Object.freeze([]);
      default:
        return Object.freeze(xs.slice(1));
    }
  }
});
define('frampton-list/take', ['exports', 'module', 'frampton-utils/assert', 'frampton-utils/curry', 'frampton-utils/is_array', 'frampton-math/min'], function (exports, module, _framptonUtilsAssert, _framptonUtilsCurry, _framptonUtilsIs_array, _framptonMathMin) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _assert = _interopRequire(_framptonUtilsAssert);

  var _curry = _interopRequire(_framptonUtilsCurry);

  var _isArray = _interopRequire(_framptonUtilsIs_array);

  var _min = _interopRequire(_framptonMathMin);

  module.exports = (0, _curry)(function take(num, xs) {
    (0, _assert)('Frampton.List.take recieved a non-array', (0, _isArray)(xs));
    var newList = [];
    var len = (0, _min)(xs.length, num);
    for (var i = 0; i < len; i++) {
      newList.push(xs[i]);
    }
    return newList;
  });
});
define('frampton-list/third', ['exports', 'module', 'frampton-list/at'], function (exports, module, _framptonListAt) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _at = _interopRequire(_framptonListAt);

  /**
   * @name third
   * @method
   * @memberof Frampton.List
   */
  module.exports = (0, _at)(2);
});
define('frampton-list/zip', ['exports', 'module', 'frampton-utils/curry'], function (exports, module, _framptonUtilsCurry) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  /**
   * zip :: List a -> List b - List (a, b)
   *
   * @name zip
   * @method
   * @memberof Frampton.List
   * @param {Array} xs
   * @param {Array} ys
   */
  module.exports = (0, _curry)(function (xs, ys) {

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

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

    return Object.freeze(zs);
  });
});
define('frampton-math', ['exports', 'frampton/namespace', 'frampton-math/add', 'frampton-math/subtract', 'frampton-math/multiply', 'frampton-math/divide', 'frampton-math/modulo', 'frampton-math/max', 'frampton-math/min'], function (exports, _framptonNamespace, _framptonMathAdd, _framptonMathSubtract, _framptonMathMultiply, _framptonMathDivide, _framptonMathModulo, _framptonMathMax, _framptonMathMin) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _Frampton = _interopRequire(_framptonNamespace);

  var _add = _interopRequire(_framptonMathAdd);

  var _subtract = _interopRequire(_framptonMathSubtract);

  var _multiply = _interopRequire(_framptonMathMultiply);

  var _divide = _interopRequire(_framptonMathDivide);

  var _modulo = _interopRequire(_framptonMathModulo);

  var _max = _interopRequire(_framptonMathMax);

  var _min = _interopRequire(_framptonMathMin);

  /**
   * @name Math
   * @namespace
   * @memberof Frampton
   */
  _Frampton.Math = {};
  _Frampton.Math.add = _add;
  _Frampton.Math.subtract = _subtract;
  _Frampton.Math.multiply = _multiply;
  _Frampton.Math.divide = _divide;
  _Frampton.Math.modulo = _modulo;
  _Frampton.Math.max = _max;
  _Frampton.Math.min = _min;
});
define('frampton-math/add', ['exports', 'module', 'frampton-utils/curry'], function (exports, module, _framptonUtilsCurry) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  /**
   * @name add
   * @method
   * @memberof Frampton.Math
   * @param {Number} left
   * @param {Number} right
   * @returns {Number}
   */
  module.exports = (0, _curry)(function add(left, right) {
    return left + right;
  });
});
define('frampton-math/divide', ['exports', 'module', 'frampton-utils/curry'], function (exports, module, _framptonUtilsCurry) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  /**
   * @name divide
   * @method
   * @memberof Frampton.Math
   * @param {Number} left
   * @param {Number} right
   * @returns {Number}
   */
  module.exports = (0, _curry)(function divide(left, right) {
    return left / right;
  });
});
define('frampton-math/max', ['exports', 'module', 'frampton-utils/curry'], function (exports, module, _framptonUtilsCurry) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  /**
   * @name max
   * @method
   * @memberof Frampton.Math
   * @param {Number} left - First number to test
   * @param {Number} right - Second number to test
   * @returns {Number} The larger of the two numbers
   */
  module.exports = (0, _curry)(function max(left, right) {
    return left > right ? left : right;
  });
});
define('frampton-math/min', ['exports', 'module', 'frampton-utils/curry'], function (exports, module, _framptonUtilsCurry) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  /**
   * @name min
   * @method
   * @memberof Frampton.Math
   * @param {Number} left - First number to test
   * @param {Number} right - Second number to test
   * @returns {Number} The smaller of the two numbers
   */
  module.exports = (0, _curry)(function min(left, right) {
    return left < right ? left : right;
  });
});
define('frampton-math/modulo', ['exports', 'module', 'frampton-utils/curry'], function (exports, module, _framptonUtilsCurry) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  /**
   * @name modulo
   * @method
   * @memberof Frampton.Math
   * @param {Number} left
   * @param {Number} right
   * @returns {Number}
   */
  module.exports = (0, _curry)(function modulo(left, right) {
    return left % right;
  });
});
define('frampton-math/multiply', ['exports', 'module', 'frampton-utils/curry'], function (exports, module, _framptonUtilsCurry) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  /**
   * @name multiply
   * @method
   * @memberof Frampton.Math
   * @param {Number} a
   * @param {Number} b
   * @returns {Number}
   */
  module.exports = (0, _curry)(function multiply(a, b) {
    return a * b;
  });
});
define('frampton-math/subtract', ['exports', 'module', 'frampton-utils/curry'], function (exports, module, _framptonUtilsCurry) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  /**
   * @name subtract
   * @method
   * @memberof Frampton.Math
   * @param {Number} left
   * @param {Number} right
   * @returns {Number}
   */
  module.exports = (0, _curry)(function (left, right) {
    return left - right;
  });
});
define('frampton-mouse', ['exports', 'frampton/namespace', 'frampton-mouse/mouse'], function (exports, _framptonNamespace, _framptonMouseMouse) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _Frampton = _interopRequire(_framptonNamespace);

  var _Mouse = _interopRequire(_framptonMouseMouse);

  _Frampton.Mouse = _Mouse;
});
define('frampton-mouse/mouse', ['exports', 'module', 'frampton-signal/stepper', 'frampton-events/on_event', 'frampton-events/contains', 'frampton-events/get_position', 'frampton-events/get_position_relative'], function (exports, module, _framptonSignalStepper, _framptonEventsOn_event, _framptonEventsContains, _framptonEventsGet_position, _framptonEventsGet_position_relative) {
  'use strict';

  /**
   * @name Mouse
   * @memberof Frampton
   * @class
   */
  module.exports = Mouse;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _stepper = _interopRequire(_framptonSignalStepper);

  var _onEvent = _interopRequire(_framptonEventsOn_event);

  var _contains = _interopRequire(_framptonEventsContains);

  var _getPosition = _interopRequire(_framptonEventsGet_position);

  var _getPositionRelative = _interopRequire(_framptonEventsGet_position_relative);

  var clicks = (0, _onEvent)('click');
  var downs = (0, _onEvent)('mousedown');
  var ups = (0, _onEvent)('mouseup');
  var moves = (0, _onEvent)('mousemove');
  var isDown = (0, _stepper)(false, downs.map(true).merge(ups.map(false)));

  var defaultMouse = {
    clicks: clicks,
    downs: downs,
    ups: ups,
    position: (0, _stepper)([0, 0], moves.map(_getPosition)),
    isDown: isDown
  };
  function Mouse(element) {
    if (!element) {
      return defaultMouse;
    } else {
      return {
        clicks: clicks.filter((0, _contains)(element)),
        downs: downs.filter((0, _contains)(element)),
        ups: ups.filter((0, _contains)(element)),
        position: (0, _stepper)([0, 0], moves.filter((0, _contains)(element)).map((0, _getPositionRelative)(element))),
        isDown: isDown
      };
    }
  }
});
define('frampton-record', ['exports', 'frampton/namespace', 'frampton-record/filter', 'frampton-record/reduce', 'frampton-record/map', 'frampton-record/merge', 'frampton-record/for_each', 'frampton-record/as_list', 'frampton-record/copy', 'frampton-record/update'], function (exports, _framptonNamespace, _framptonRecordFilter, _framptonRecordReduce, _framptonRecordMap, _framptonRecordMerge, _framptonRecordFor_each, _framptonRecordAs_list, _framptonRecordCopy, _framptonRecordUpdate) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _Frampton = _interopRequire(_framptonNamespace);

  var _filter = _interopRequire(_framptonRecordFilter);

  var _reduce = _interopRequire(_framptonRecordReduce);

  var _map = _interopRequire(_framptonRecordMap);

  var _merge = _interopRequire(_framptonRecordMerge);

  var _forEach = _interopRequire(_framptonRecordFor_each);

  var _asList = _interopRequire(_framptonRecordAs_list);

  var _copy = _interopRequire(_framptonRecordCopy);

  var _update = _interopRequire(_framptonRecordUpdate);

  /**
   * @name Record
   * @namespace
   * @memberof Frampton
   */
  _Frampton.Record = {};
  _Frampton.Record.copy = _copy;
  _Frampton.Record.update = _update;
  _Frampton.Record.filter = _filter;
  _Frampton.Record.reduce = _reduce;
  _Frampton.Record.map = _map;
  _Frampton.Record.each = _forEach;
  _Frampton.Record.asList = _asList;
  _Frampton.Record.merge = _merge;
});
define('frampton-record/as_list', ['exports', 'module', 'frampton-record/reduce'], function (exports, module, _framptonRecordReduce) {
  'use strict';

  // as_list :: Object -> Array [String, *]
  /**
   * @name as_list
   * @method
   * @memberof Frampton.Record
   * @param {Object} obj Object to transform
   * @returns {Array}
   */
  module.exports = as_list;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _reduce = _interopRequire(_framptonRecordReduce);

  function as_list(obj) {
    return Object.freeze((0, _reduce)(function (acc, nextValue, nextKey) {
      acc.push([nextKey, nextValue]);
      return acc;
    }, [], obj));
  }
});
define('frampton-record/copy', ['exports', 'module', 'frampton-record/for_each'], function (exports, module, _framptonRecordFor_each) {
  'use strict';

  /**
   * copy :: Object -> Object
   *
   * @name copy
   * @method
   * @memberof Frampton.Object
   * @param {Object} obj object to copy
   * @returns {Object}
   */
  module.exports = copy_object;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _forEach = _interopRequire(_framptonRecordFor_each);

  function copy_object(obj) {

    var newObj = {};

    (0, _forEach)(function (value, key) {
      newObj[key] = value;
    }, obj);

    return Object.freeze(newObj);
  }
});
define('frampton-record/filter', ['exports', 'module', 'frampton-utils/curry', 'frampton-record/for_each'], function (exports, module, _framptonUtilsCurry, _framptonRecordFor_each) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  var _forEach = _interopRequire(_framptonRecordFor_each);

  /**
   * @name filter
   * @method
   * @memberof Frampton.Record
   * @param {Function} predicate A function to filter the object. The functino recieves the
   * value and key as arguments to make its decision
   * @returns {Object}
   */
  module.exports = (0, _curry)(function curried_filter(predicate, obj) {

    var newObj = {};

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

    return Object.freeze(newObj);
  });
});
define('frampton-record/for_each', ['exports', 'module', 'frampton-utils/curry'], function (exports, module, _framptonUtilsCurry) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  /**
   * @name forEach
   * @method
   * @memberof Frampton.Record
   * @param {Function} fn Function to call for each key/value pair
   * @param {Object} obj Object to iterate over
   */
  module.exports = (0, _curry)(function curried_for_each(fn, obj) {
    for (var key in obj) {
      if (obj.hasOwnProperty(key)) {
        fn(obj[key], key);
      }
    }
  });
});
define('frampton-record/keys', ['exports', 'module', 'frampton-utils/is_function'], function (exports, module, _framptonUtilsIs_function) {
  'use strict';

  /**
   * @name keys
   * @method
   * @memberof Frampton.Record
   * @param {Object} obj Object whose keys to get
   * @returns {String[]}
   */
  module.exports = keys;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _isFunction = _interopRequire(_framptonUtilsIs_function);

  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;
  }
  function keys(obj) {
    if ((0, _isFunction)(Object.keys)) {
      return Object.keys(obj).filter(function (key) {
        return hasOwnProp.call(obj, key);
      });
    } else {
      return getKeys(obj);
    }
  }
});
define('frampton-record/map', ['exports', 'module', 'frampton-utils/curry', 'frampton-record/for_each'], function (exports, module, _framptonUtilsCurry, _framptonRecordFor_each) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  var _forEach = _interopRequire(_framptonRecordFor_each);

  /**
   * @name map
   * @method
   * @memberof Frampton.Record
   * @param {Function} fn Function used to map the object
   * @param {Object} obj Object to map
   * @returns {Object} A new object with its values mapped using the given function
   */
  module.exports = (0, _curry)(function curried_map(fn, obj) {

    var newObj = {};

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

    return Object.freeze(newObj);
  });
});
define('frampton-record/merge', ['exports', 'module', 'frampton-utils/curry', 'frampton-utils/extend'], function (exports, module, _framptonUtilsCurry, _framptonUtilsExtend) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  var _extend = _interopRequire(_framptonUtilsExtend);

  /**
   * Merges two objects into one. Priority is given to the keys on the second object.
   *
   * @name merge
   * @method
   * @memberof Frampton.Record
   * @param {Object} obj1 First object to merge
   * @param {Object} obj2 Second object to merge
   * @returns {Object}
   */
  module.exports = (0, _curry)(function curried_merge(obj1, obj2) {
    return Object.freeze((0, _extend)({}, obj1, obj2));
  });
});
define('frampton-record/of', ['exports', 'module', 'frampton-record/copy'], function (exports, module, _framptonRecordCopy) {
  'use strict';

  /**
   * of :: Object -> Object
   *
   * @name of
   * @method
   * @memberof Frampton.Record
   * @param {Object} obj object to copy
   * @returns {Object}
   */
  module.exports = of_record;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _copy = _interopRequire(_framptonRecordCopy);

  function of_record(obj) {
    return (0, _copy)(obj);
  }
});
define('frampton-record/reduce', ['exports', 'module', 'frampton-utils/curry', 'frampton-record/for_each'], function (exports, module, _framptonUtilsCurry, _framptonRecordFor_each) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  var _forEach = _interopRequire(_framptonRecordFor_each);

  /**
   * reduce :: Function -> Any -> Object -> Object
   *
   * @name reduce
   * @method
   * @memberof Frampton.Record
   * @param {Function} fn Function used to reduce the object
   * @param {*} acc Initial value of reduce operation
   * @param {Object} obj Object to iterate over for the reduce
   * @returns {*}
   */
  module.exports = (0, _curry)(function curried_reduce(fn, acc, obj) {

    (0, _forEach)(function (value, key) {
      acc = fn(acc, value, key);
    }, obj);

    return acc;
  });
});
define('frampton-record/update', ['exports', 'module', 'frampton-record/for_each'], function (exports, module, _framptonRecordFor_each) {
  'use strict';

  /**
   * update :: Object -> Object -> Object
   *
   * @name update
   * @method
   * @memberof Frampton.Record
   * @param {Object} base   object to copy
   * @param {Object} update object describing desired udpate
   * @returns {Object}
   */
  module.exports = update_object;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _forEach = _interopRequire(_framptonRecordFor_each);

  function update_object(base, update) {

    var newObj = {};

    (0, _forEach)(function (value, key) {
      if (update[key]) {
        newObj[key] = update[key];
      } else {
        newObj[key] = value;
      }
    }, base);

    return Object.freeze(newObj);
  }
});
define('frampton-signal', ['exports', '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 (exports, _framptonNamespace, _framptonSignalCreate, _framptonSignalStepper, _framptonSignalCombine, _framptonSignalSwap, _framptonSignalToggle, _framptonSignalIs_signal, _framptonSignalForward) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _Frampton = _interopRequire(_framptonNamespace);

  var _create = _interopRequire(_framptonSignalCreate);

  var _stepper = _interopRequire(_framptonSignalStepper);

  var _combine = _interopRequire(_framptonSignalCombine);

  var _swap = _interopRequire(_framptonSignalSwap);

  var _toggle = _interopRequire(_framptonSignalToggle);

  var _isSignal = _interopRequire(_framptonSignalIs_signal);

  var _forward = _interopRequire(_framptonSignalForward);

  /**
   * @name Signal
   * @class
   * @memberof Frampton
   */
  _Frampton.Signal = {};
  _Frampton.Signal.create = _create;
  _Frampton.Signal.stepper = _stepper;
  _Frampton.Signal.combine = _combine;
  _Frampton.Signal.merge = _framptonSignalCreate.mergeMany;
  _Frampton.Signal.swap = _swap;
  _Frampton.Signal.toggle = _toggle;
  _Frampton.Signal.isSignal = _isSignal;
  _Frampton.Signal.forward = _forward;
});
define('frampton-signal/combine', ['exports', 'module', 'frampton-signal/create'], function (exports, module, _framptonSignalCreate) {
  'use strict';

  /**
   * 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
   */
  module.exports = combine;

  function combine(mapping, parents) {
    return (0, _framptonSignalCreate.createSignal)(function (self) {
      self(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, _framptonUtilsGuid, _framptonUtilsIs_defined, _framptonUtilsIs_promise, _framptonUtilsIs_function, _framptonUtilsIs_equal, _framptonUtilsOf_value, _framptonUtilsNoop, _framptonUtilsLog) {
  'use strict';

  exports.__esModule = true;

  /**
   * @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}
   */
  exports.createSignal = createSignal;

  /**
   * @name mergeMany
   * @memberof Frampton.Signal
   * @method
   * @param {Frampton.Signal.Signal[]} parents - Signals to merge
   */
  exports.mergeMany = mergeMany;

  /**
   * 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}
   */
  exports['default'] = create;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _guid = _interopRequire(_framptonUtilsGuid);

  var _isDefined = _interopRequire(_framptonUtilsIs_defined);

  var _isPromise = _interopRequire(_framptonUtilsIs_promise);

  var _isFunction = _interopRequire(_framptonUtilsIs_function);

  var _isEqual = _interopRequire(_framptonUtilsIs_equal);

  var _ofValue = _interopRequire(_framptonUtilsOf_value);

  var _noop = _interopRequire(_framptonUtilsNoop);

  var _log = _interopRequire(_framptonUtilsLog);

  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, _isPromise)(val)) {
      val.then(sig);
    } 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(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(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(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
   * should return 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(fn(self._value, parent._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, _isFunction)(predicate) ? predicate : (0, _isEqual)(predicate);
    var initial = parent._hasValue && filterFn(parent._value) ? parent._value : undefined;
    return createSignal(function (self) {
      if (filterFn(parent._value)) {
        self(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(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(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(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, _isFunction)(mapping) ? mapping : (0, _ofValue)(mapping);
    var initial = parent._hasValue ? mappingFn(parent._value) : undefined;
    return createSignal(function (self) {
      self(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) {
        timer = setTimeout(function () {
          self(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(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, _log)(msg);
      } else {
        (0, _log)(parent._value);
      }
      self(parent._value);
    }, [parent], parent._value);
  }
  function createSignal(update, parents, initial) {

    var signal = function signal(val) {
      return (0, _isDefined)(val) ? (updateValue(signal, val), signal) : signal._value;
    };

    // Constructor
    signal.ctor = 'Signal';

    // Private
    signal._id = (0, _guid)();
    signal._value = initial;
    signal._hasValue = (0, _isDefined)(initial);
    signal._queued = false;
    signal._updater = null;
    signal._parents = parents || [];
    signal._children = [];
    signal._update = update || _noop;

    // Public
    signal.debounce = debounce;
    signal.delay = delay;
    signal.ap = ap;
    signal.merge = merge;
    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);
  }

  function mergeMany(parents) {
    var initial = parents.length > 0 ? parents[0]._value : undefined;
    return createSignal(function (self) {
      self(self._updater._value);
    }, parents, initial);
  }

  function create(initial) {
    return createSignal(null, null, initial);
  }
});
define("frampton-signal/forward", ["exports", "module"], function (exports, module) {
  "use strict";

  module.exports = forward;

  function forward(signal, mapping) {
    return function (val) {
      signal(mapping(val));
    };
  }
});
define('frampton-signal/is_signal', ['exports', 'module', 'frampton-utils/is_function', 'frampton-utils/is_string'], function (exports, module, _framptonUtilsIs_function, _framptonUtilsIs_string) {
  'use strict';

  module.exports = is_signal;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _isFunction = _interopRequire(_framptonUtilsIs_function);

  var _isString = _interopRequire(_framptonUtilsIs_string);

  function is_signal(obj) {
    return (0, _isFunction)(obj) && (0, _isString)(obj.ctor) && obj.ctor === 'Signal';
  }
});
define('frampton-signal/stepper', ['exports', 'module', 'frampton-utils/curry', 'frampton-signal/create'], function (exports, module, _framptonUtilsCurry, _framptonSignalCreate) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  var _createSignal = _interopRequire(_framptonSignalCreate);

  // stepper :: a -> Signal a -> Signal a
  module.exports = (0, _curry)(function (initial, updater) {
    var sig = (0, _createSignal)(initial);
    return sig.merge(updater.dropRepeats());
  });
});
define('frampton-signal/swap', ['exports', 'module', 'frampton-utils/curry', 'frampton-signal/stepper'], function (exports, module, _framptonUtilsCurry, _framptonSignalStepper) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  var _stepper = _interopRequire(_framptonSignalStepper);

  /**
   * swap :: Signal a -> Signal b -> Signal Boolean
   *
   * @name swap
   * @method
   * @memberof Frampton.Signal
   * @param {Frampton.Signal.Signal} sig1
   * @param {Frampton.Signal.Signal} sig2
   * @returns {Frampton.Signal.Signal}
   */
  module.exports = (0, _curry)(function toggle(sig1, sig2) {
    return (0, _stepper)(false, sig1.map(true).merge(sig2.map(false)));
  });
});
define('frampton-signal/toggle', ['exports', 'module', 'frampton-utils/assert', 'frampton-utils/curry', 'frampton-utils/is_boolean', 'frampton-signal/create'], function (exports, module, _framptonUtilsAssert, _framptonUtilsCurry, _framptonUtilsIs_boolean, _framptonSignalCreate) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _assert = _interopRequire(_framptonUtilsAssert);

  var _curry = _interopRequire(_framptonUtilsCurry);

  var _isBoolean = _interopRequire(_framptonUtilsIs_boolean);

  var _createSignal = _interopRequire(_framptonSignalCreate);

  /**
   * toggle :: Boolean -> Signal a -> Signal Boolean
   *
   * Creates a signal that emits alternating Boolean values on occurences of input signal.
   *
   * @name toggle
   * @method
   * @memberof Frampton.Signal
   * @param {Boolean} initial Value to initialize toggle to
   * @param {Frampton.Signal.Signal} updater Signal to update toggle to
   * @returns {Frampton.Signal.Signal}
   */
  module.exports = (0, _curry)(function (initial, updater) {
    (0, _assert)('Frampton.Signal.toggle must be initialized with a Boolean', (0, _isBoolean)(initial));
    var sig = (0, _createSignal)(initial);
    var current = initial;
    return sig.merge(updater.map(function () {
      current = !current;
      return current;
    }));
  });
});
define('frampton-string', ['exports', 'frampton/namespace', 'frampton-string/replace', 'frampton-string/trim', 'frampton-string/join', 'frampton-string/split', 'frampton-string/lines', 'frampton-string/words', 'frampton-string/starts_with', 'frampton-string/ends_with', 'frampton-string/contains', 'frampton-string/capitalize', 'frampton-string/dash_to_camel', 'frampton-string/length', 'frampton-string/normalize_newline'], function (exports, _framptonNamespace, _framptonStringReplace, _framptonStringTrim, _framptonStringJoin, _framptonStringSplit, _framptonStringLines, _framptonStringWords, _framptonStringStarts_with, _framptonStringEnds_with, _framptonStringContains, _framptonStringCapitalize, _framptonStringDash_to_camel, _framptonStringLength, _framptonStringNormalize_newline) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _Frampton = _interopRequire(_framptonNamespace);

  var _replace = _interopRequire(_framptonStringReplace);

  var _trim = _interopRequire(_framptonStringTrim);

  var _join = _interopRequire(_framptonStringJoin);

  var _split = _interopRequire(_framptonStringSplit);

  var _lines = _interopRequire(_framptonStringLines);

  var _words = _interopRequire(_framptonStringWords);

  var _startsWith = _interopRequire(_framptonStringStarts_with);

  var _endsWith = _interopRequire(_framptonStringEnds_with);

  var _contains = _interopRequire(_framptonStringContains);

  var _capitalize = _interopRequire(_framptonStringCapitalize);

  var _dashToCamel = _interopRequire(_framptonStringDash_to_camel);

  var _length = _interopRequire(_framptonStringLength);

  var _normalizeNewline = _interopRequire(_framptonStringNormalize_newline);

  /**
   * @name String
   * @namespace
   * @memberof Frampton
   */
  _Frampton.String = {};
  _Frampton.String.replace = _replace;
  _Frampton.String.trim = _trim;
  _Frampton.String.join = _join;
  _Frampton.String.split = _split;
  _Frampton.String.lines = _lines;
  _Frampton.String.words = _words;
  _Frampton.String.startsWith = _startsWith;
  _Frampton.String.endsWith = _endsWith;
  _Frampton.String.contains = _contains;
  _Frampton.String.capitalize = _capitalize;
  _Frampton.String.dashToCamel = _dashToCamel;
  _Frampton.String.length = _length;
  _Frampton.String.normalizeNewline = _normalizeNewline;
});
define("frampton-string/capitalize", ["exports", "module"], function (exports, module) {
  "use strict";

  module.exports = capitalize;

  function capitalize(str) {
    return str.charAt(0).toUpperCase() + str.slice(1);
  }
});
define('frampton-string/contains', ['exports', 'module', 'frampton-utils/curry'], function (exports, module, _framptonUtilsCurry) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

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

  module.exports = 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', 'module', 'frampton-utils/curry'], function (exports, module, _framptonUtilsCurry) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

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

  module.exports = is_empty;

  function is_empty(str) {
    return str.trim() === '';
  }
});
define('frampton-string/join', ['exports', 'module', 'frampton-utils/curry'], function (exports, module, _framptonUtilsCurry) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  /**
   * join :: String -> Array String -> String
   * @name join
   * @method
   * @memberof Frampton.String
   * @param {String} sep
   * @param {Array} strs
   * @returns {String}
   */
  module.exports = (0, _curry)(function join(sep, strs) {
    return strs.join(sep);
  });
});
define('frampton-string/length', ['exports', 'module', 'frampton-utils/is_something', 'frampton-utils/is_defined', 'frampton-string/normalize_newline'], function (exports, module, _framptonUtilsIs_something, _framptonUtilsIs_defined, _framptonStringNormalize_newline) {
  'use strict';

  /**
   * @name length
   * @memberof Frampton.String
   * @static
   * @param {String}
   * @returns {Number}
   */
  module.exports = length;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _isSomething = _interopRequire(_framptonUtilsIs_something);

  var _isDefined = _interopRequire(_framptonUtilsIs_defined);

  var _normalizeNewline = _interopRequire(_framptonStringNormalize_newline);

  function length(str) {
    return (0, _isSomething)(str) && (0, _isDefined)(str.length) ? (0, _normalizeNewline)(str).length : 0;
  }
});
define("frampton-string/lines", ["exports", "module"], function (exports, module) {
  // lines :: String -> Array String
  "use strict";

  module.exports = lines;

  function lines(str) {
    return str.split(/\r\n|\r|\n/g);
  }
});
define('frampton-string/normalize_newline', ['exports', 'module'], function (exports, module) {
  /**
   * 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}
   */
  'use strict';

  module.exports = normalize_newline;

  function normalize_newline(str) {
    return str.replace(/\r\n/g, '\n');
  }
});
define('frampton-string/replace', ['exports', 'module', 'frampton-utils/curry'], function (exports, module, _framptonUtilsCurry) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  /**
   * replace :: String -> String -> String -> String
   * @name replace
   * @method
   * @memberof Frampton.String
   * @param {String} newSubStr
   * @param {String} oldSubStr
   * @param {String} str
   * @returns {String}
   */
  module.exports = (0, _curry)(function replace(newSubStr, oldSubStr, str) {
    return str.replace(oldSubStr, newSubStr);
  });
});
define('frampton-string/split', ['exports', 'module', 'frampton-utils/curry'], function (exports, module, _framptonUtilsCurry) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  // split :: String -> String -> Array String
  module.exports = (0, _curry)(function join(sep, str) {
    return str.split(sep);
  });
});
define('frampton-string/starts_with', ['exports', 'module', 'frampton-utils/curry'], function (exports, module, _framptonUtilsCurry) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  // starts_with :: String -> String -> Boolean
  module.exports = (0, _curry)(function starts_with(sub, str) {
    return str.indexOf(sub) === 0;
  });
});
define("frampton-string/trim", ["exports", "module"], function (exports, module) {
  "use strict";

  module.exports = trim;

  function trim(str) {
    return str.trim();
  }
});
define("frampton-string/words", ["exports", "module"], function (exports, module) {
  // words :: String -> Array String
  "use strict";

  module.exports = words;

  function words(str) {
    return str.trim().split(/\s+/g);
  }
});
define('frampton-style', ['exports', 'frampton/namespace', 'frampton-style/add_class', 'frampton-style/remove_class', 'frampton-style/has_class', 'frampton-style/matches', 'frampton-style/current_value', 'frampton-style/set_style', 'frampton-style/remove_style', 'frampton-style/apply_styles', 'frampton-style/remove_styles', 'frampton-style/closest', 'frampton-style/contains', 'frampton-style/selector_contains', 'frampton-style/supported', 'frampton-style/supported_props'], function (exports, _framptonNamespace, _framptonStyleAdd_class, _framptonStyleRemove_class, _framptonStyleHas_class, _framptonStyleMatches, _framptonStyleCurrent_value, _framptonStyleSet_style, _framptonStyleRemove_style, _framptonStyleApply_styles, _framptonStyleRemove_styles, _framptonStyleClosest, _framptonStyleContains, _framptonStyleSelector_contains, _framptonStyleSupported, _framptonStyleSupported_props) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _Frampton = _interopRequire(_framptonNamespace);

  var _addClass = _interopRequire(_framptonStyleAdd_class);

  var _removeClass = _interopRequire(_framptonStyleRemove_class);

  var _hasClass = _interopRequire(_framptonStyleHas_class);

  var _matches = _interopRequire(_framptonStyleMatches);

  var _current = _interopRequire(_framptonStyleCurrent_value);

  var _setStyle = _interopRequire(_framptonStyleSet_style);

  var _removeStyle = _interopRequire(_framptonStyleRemove_style);

  var _applyStyles = _interopRequire(_framptonStyleApply_styles);

  var _removeStyles = _interopRequire(_framptonStyleRemove_styles);

  var _closest = _interopRequire(_framptonStyleClosest);

  var _contains = _interopRequire(_framptonStyleContains);

  var _selectorContains = _interopRequire(_framptonStyleSelector_contains);

  var _supported = _interopRequire(_framptonStyleSupported);

  var _supportedProps = _interopRequire(_framptonStyleSupported_props);

  /**
   * @name Style
   * @namespace
   * @memberof Frampton
   */
  _Frampton.Style = {};
  _Frampton.Style.addClass = _addClass;
  _Frampton.Style.closest = _closest;
  _Frampton.Style.removeClass = _removeClass;
  _Frampton.Style.hasClass = _hasClass;
  _Frampton.Style.matches = _matches;
  _Frampton.Style.current = _current;
  _Frampton.Style.setStyle = _setStyle;
  _Frampton.Style.removeStyle = _removeStyle;
  _Frampton.Style.applyStyles = _applyStyles;
  _Frampton.Style.removeStyles = _removeStyles;
  _Frampton.Style.contains = _contains;
  _Frampton.Style.selectorContains = _selectorContains;
  _Frampton.Style.supported = _supported;
  _Frampton.Style.supportedProps = _supportedProps;
});
define('frampton-style/add_class', ['exports', 'module', 'frampton-utils/curry'], function (exports, module, _framptonUtilsCurry) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  /**
   * @name addClass
   * @method
   * @memberof Frampton.Style
   * @param {Object} element
   * @param {String} name
   */
  module.exports = (0, _curry)(function add_class(element, name) {
    element.classList.add(name);
  });
});
define('frampton-style/apply_styles', ['exports', 'module', 'frampton-utils/curry', 'frampton-utils/is_something', 'frampton-style/remove_style', 'frampton-style/set_style'], function (exports, module, _framptonUtilsCurry, _framptonUtilsIs_something, _framptonStyleRemove_style, _framptonStyleSet_style) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  var _isSomething = _interopRequire(_framptonUtilsIs_something);

  var _removeStyle = _interopRequire(_framptonStyleRemove_style);

  var _setStyle = _interopRequire(_framptonStyleSet_style);

  /**
   * @name applyStyles
   * @method
   * @memberof Frampton.Style
   * @param {Object} element DomNode to add styles to
   * @param {Object} props   Has of props to add
   */
  module.exports = (0, _curry)(function apply_styles(element, props) {
    for (var key in props) {
      var value = props[key];
      if ((0, _isSomething)(value)) {
        (0, _setStyle)(element, key, value);
      } else {
        (0, _removeStyle)(element, key, value);
      }
    }
  });
});
define('frampton-style/closest', ['exports', 'module', 'frampton-utils/curry', 'frampton-style/matches'], function (exports, module, _framptonUtilsCurry, _framptonStyleMatches) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  var _matches = _interopRequire(_framptonStyleMatches);

  /**
   * Searches up the Dom Tree from a given node and returns the first element
   * that matches the selector. If no match is found, null is returned.
   *
   * @name closest
   * @method
   * @memberof Frampton.Style
   * @param {String} selector Selector to search for
   * @param {Object} element  DomNode to start search from
   * @returns {Object} The first DomNode matching the selector or null.
   */
  module.exports = (0, _curry)(function closest(selector, element) {

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

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

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  var _matches = _interopRequire(_framptonStyleMatches);

  /**
   * Searches inside the given element and returns true if the given element, or
   * one of its children matches the given selector, false otherwise.
   *
   * @name contains
   * @method
   * @memberof Frampton.Style
   * @param {String} selector Selector to search for
   * @param {Object} element  DomNode to search inside of
   * @returns {Boolean} Is there a match for the selector?
   */
  module.exports = (0, _curry)(function contains(selector, element) {
    return (0, _matches)(selector, element) || element.querySelectorAll(selector).length > 0;
  });
});
define('frampton-style/current_value', ['exports', 'module', 'frampton-utils/curry', 'frampton-style/supported'], function (exports, module, _framptonUtilsCurry, _framptonStyleSupported) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  var _supported = _interopRequire(_framptonStyleSupported);

  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
   */
  module.exports = (0, _curry)(function current(element, prop) {
    return style(element).getPropertyValue((0, _supported)(prop));
  });
});
define('frampton-style/has_class', ['exports', 'module', 'frampton-utils/curry'], function (exports, module, _framptonUtilsCurry) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  /**
   * Returns a Boolean indicated if the given DomNode has the given class.
   *
   * @name hasClass
   * @method
   * @memberof Frampton.Style
   * @param {String} name    Class to test for
   * @param {Object} element DomNode to test
   * @returns {Boolean}
   */
  module.exports = (0, _curry)(function has_class(name, element) {
    return element.classList.contains(name);
  });
});
define('frampton-style/matches', ['exports', 'module', 'frampton-utils/curry', 'frampton-utils/is_function'], function (exports, module, _framptonUtilsCurry, _framptonUtilsIs_function) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  var _isFunction = _interopRequire(_framptonUtilsIs_function);

  /**
   * @name matches
   * @method
   * @memberof Frampton.Style
   * @param {String} selector
   * @param {Object} element
   * @returns {Boolean}
   */
  module.exports = (0, _curry)(function matches(selector, element) {

    if ((0, _isFunction)(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', 'module', 'frampton-utils/curry'], function (exports, module, _framptonUtilsCurry) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  /**
   * @name removeClass
   * @method
   * @memberof Frampton.Style
   * @param {Object} element
   * @param {String} name
   */
  module.exports = (0, _curry)(function remove_class(element, name) {
    element.classList.remove(name);
  });
});
define('frampton-style/remove_style', ['exports', 'module', 'frampton-utils/curry', 'frampton-style/supported'], function (exports, module, _framptonUtilsCurry, _framptonStyleSupported) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  var _supported = _interopRequire(_framptonStyleSupported);

  /**
   * @name removeStyle
   * @method
   * @memberof Frampton.Style
   * @param {Object} element
   * @param {String} key
   */
  module.exports = (0, _curry)(function remove_style(element, key) {
    element.style.removeProperty((0, _supported)(key));
  });
});
define('frampton-style/remove_styles', ['exports', 'module', 'frampton-utils/curry'], function (exports, module, _framptonUtilsCurry) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  /**
   * removeStyles :: DomNode -> Object -> ()
   *
   * @name removeStyles
   * @method
   * @memberof Frampton.Style
   * @param {Object} element A dom node to remove styles from
   * @param {Object} props   A hash of properties to remove
   */
  module.exports = (0, _curry)(function remove_styles(element, props) {
    for (var key in props) {
      element.style.removeProperty(key);
    }
  });
});
define('frampton-style/selector_contains', ['exports', 'module', 'frampton-utils/curry', 'frampton-html/contains'], function (exports, module, _framptonUtilsCurry, _framptonHtmlContains) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  var _contains = _interopRequire(_framptonHtmlContains);

  /**
   * Searches inside all elements with the given selector and returns if one of them
   * contains the given element.
   *
   * @name selectorContains
   * @method
   * @memberof Frampton.Style
   * @param {String} selector Selector to search inside of
   * @param {Object} element  DomNode to search for
   * @returns {Boolean} Is there a match for the element?
   */
  module.exports = (0, _curry)(function selector_contains(selector, element) {

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

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

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

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  var _supported = _interopRequire(_framptonStyleSupported);

  /**
   * @name setStyle
   * @method
   * @memberof Frampton.Style
   * @param {Object} element
   * @param {String} key
   * @param {String} value
   */
  module.exports = (0, _curry)(function set_style(element, key, value) {
    element.style.setProperty((0, _supported)(key), value, '');
  });
});
define('frampton-style/supported', ['exports', 'module', 'frampton-utils/memoize', 'frampton-style/supported_by_element'], function (exports, module, _framptonUtilsMemoize, _framptonStyleSupported_by_element) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _memoize = _interopRequire(_framptonUtilsMemoize);

  var _supportedByElement = _interopRequire(_framptonStyleSupported_by_element);

  /**
   * supported :: String -> String
   *
   * @name supported
   * @method
   * @memberof Frampton.Style
   * @param {String} prop A standard CSS property name
   * @returns {String} The property name with any vendor prefixes required by the browser, or null if the property is not supported
   */
  module.exports = (0, _memoize)((0, _supportedByElement)(document.createElement('div')));
});
define('frampton-style/supported_by_element', ['exports', 'module', 'frampton-utils/curry', 'frampton-utils/is_something', 'frampton-string/capitalize', 'frampton-string/dash_to_camel'], function (exports, module, _framptonUtilsCurry, _framptonUtilsIs_something, _framptonStringCapitalize, _framptonStringDash_to_camel) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  var _isSomething = _interopRequire(_framptonUtilsIs_something);

  var _capitalize = _interopRequire(_framptonStringCapitalize);

  var _dashToCamel = _interopRequire(_framptonStringDash_to_camel);

  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}
   */
  module.exports = (0, _curry)(function supported_by_element(element, prop) {

    var camelProp = (0, _dashToCamel)(prop);

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

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

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

  /**
   * @name supportedProps
   * @method
   * @memberof Frampton.Style
   * @param {Object} props
   * @returns {Object}
   */
  module.exports = supported_props;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _warn = _interopRequire(_framptonUtilsWarn);

  var _supported = _interopRequire(_framptonStyleSupported);

  function supported_props(props) {
    var obj = {};
    var temp;
    for (var key in props) {
      temp = (0, _supported)(key);
      if (temp) {
        obj[(0, _supported)(key)] = props[key];
      } else {
        (0, _warn)('style prop ' + key + ' is not supported by this browser');
      }
    }
    return obj;
  }
});
define('frampton-utils', ['exports', '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/get', '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/log', 'frampton-utils/lazy', 'frampton-utils/memoize', 'frampton-utils/noop', 'frampton-utils/not', 'frampton-utils/of_value', 'frampton-utils/once', 'frampton-utils/warn'], function (exports, _framptonNamespace, _framptonUtilsAlways, _framptonUtilsApply, _framptonUtilsAssert, _framptonUtilsCompose, _framptonUtilsCurry, _framptonUtilsCurry_n, _framptonUtilsEqual, _framptonUtilsError, _framptonUtilsExtend, _framptonUtilsGet, _framptonUtilsHas_length, _framptonUtilsHas_prop, _framptonUtilsIdentity, _framptonUtilsImmediate, _framptonUtilsIs_array, _framptonUtilsIs_boolean, _framptonUtilsIs_defined, _framptonUtilsIs_empty, _framptonUtilsIs_equal, _framptonUtilsIs_false, _framptonUtilsIs_function, _framptonUtilsIs_node, _framptonUtilsIs_nothing, _framptonUtilsIs_null, _framptonUtilsIs_number, _framptonUtilsIs_numeric, _framptonUtilsIs_object, _framptonUtilsIs_primitive, _framptonUtilsIs_promise, _framptonUtilsIs_something, _framptonUtilsIs_string, _framptonUtilsIs_true, _framptonUtilsIs_undefined, _framptonUtilsIs_value, _framptonUtilsLog, _framptonUtilsLazy, _framptonUtilsMemoize, _framptonUtilsNoop, _framptonUtilsNot, _framptonUtilsOf_value, _framptonUtilsOnce, _framptonUtilsWarn) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _Frampton = _interopRequire(_framptonNamespace);

  var _always = _interopRequire(_framptonUtilsAlways);

  var _apply = _interopRequire(_framptonUtilsApply);

  var _assert = _interopRequire(_framptonUtilsAssert);

  var _compose = _interopRequire(_framptonUtilsCompose);

  var _curry = _interopRequire(_framptonUtilsCurry);

  var _curryN = _interopRequire(_framptonUtilsCurry_n);

  var _equal = _interopRequire(_framptonUtilsEqual);

  var _error = _interopRequire(_framptonUtilsError);

  var _extend = _interopRequire(_framptonUtilsExtend);

  var _get = _interopRequire(_framptonUtilsGet);

  var _hasLength = _interopRequire(_framptonUtilsHas_length);

  var _hasProp = _interopRequire(_framptonUtilsHas_prop);

  var _identity = _interopRequire(_framptonUtilsIdentity);

  var _immediate = _interopRequire(_framptonUtilsImmediate);

  var _isArray = _interopRequire(_framptonUtilsIs_array);

  var _isBoolean = _interopRequire(_framptonUtilsIs_boolean);

  var _isDefined = _interopRequire(_framptonUtilsIs_defined);

  var _isEmpty = _interopRequire(_framptonUtilsIs_empty);

  var _isEqual = _interopRequire(_framptonUtilsIs_equal);

  var _isFalse = _interopRequire(_framptonUtilsIs_false);

  var _isFunction = _interopRequire(_framptonUtilsIs_function);

  var _isNode = _interopRequire(_framptonUtilsIs_node);

  var _isNothing = _interopRequire(_framptonUtilsIs_nothing);

  var _isNull = _interopRequire(_framptonUtilsIs_null);

  var _isNumber = _interopRequire(_framptonUtilsIs_number);

  var _isNumeric = _interopRequire(_framptonUtilsIs_numeric);

  var _isObject = _interopRequire(_framptonUtilsIs_object);

  var _isPrimitive = _interopRequire(_framptonUtilsIs_primitive);

  var _isPromise = _interopRequire(_framptonUtilsIs_promise);

  var _isSomething = _interopRequire(_framptonUtilsIs_something);

  var _isString = _interopRequire(_framptonUtilsIs_string);

  var _isTrue = _interopRequire(_framptonUtilsIs_true);

  var _isUndefined = _interopRequire(_framptonUtilsIs_undefined);

  var _isValue = _interopRequire(_framptonUtilsIs_value);

  var _log = _interopRequire(_framptonUtilsLog);

  var _lazy = _interopRequire(_framptonUtilsLazy);

  var _memoize = _interopRequire(_framptonUtilsMemoize);

  var _noop = _interopRequire(_framptonUtilsNoop);

  var _not = _interopRequire(_framptonUtilsNot);

  var _ofValue = _interopRequire(_framptonUtilsOf_value);

  var _once = _interopRequire(_framptonUtilsOnce);

  var _warn = _interopRequire(_framptonUtilsWarn);

  /**
   * @name Utils
   * @namespace
   * @memberof Frampton
   */
  _Frampton.Utils = {};
  _Frampton.Utils.always = _always;
  _Frampton.Utils.apply = _apply;
  _Frampton.Utils.assert = _assert;
  _Frampton.Utils.compose = _compose;
  _Frampton.Utils.curry = _curry;
  _Frampton.Utils.curryN = _curryN;
  _Frampton.Utils.equal = _equal;
  _Frampton.Utils.error = _error;
  _Frampton.Utils.extend = _extend;
  _Frampton.Utils.get = _get;
  _Frampton.Utils.hasLength = _hasLength;
  _Frampton.Utils.hasProp = _hasProp;
  _Frampton.Utils.identity = _identity;
  _Frampton.Utils.immediate = _immediate;
  _Frampton.Utils.isArray = _isArray;
  _Frampton.Utils.isBoolean = _isBoolean;
  _Frampton.Utils.isDefined = _isDefined;
  _Frampton.Utils.isEmpty = _isEmpty;
  _Frampton.Utils.isEqual = _isEqual;
  _Frampton.Utils.isFalse = _isFalse;
  _Frampton.Utils.isFunction = _isFunction;
  _Frampton.Utils.isNode = _isNode;
  _Frampton.Utils.isNothing = _isNothing;
  _Frampton.Utils.isNull = _isNull;
  _Frampton.Utils.isNumber = _isNumber;
  _Frampton.Utils.isNumeric = _isNumeric;
  _Frampton.Utils.isObject = _isObject;
  _Frampton.Utils.isPrimitive = _isPrimitive;
  _Frampton.Utils.isPromise = _isPromise;
  _Frampton.Utils.isSomething = _isSomething;
  _Frampton.Utils.isString = _isString;
  _Frampton.Utils.isTrue = _isTrue;
  _Frampton.Utils.isUndefined = _isUndefined;
  _Frampton.Utils.isValue = _isValue;
  _Frampton.Utils.log = _log;
  _Frampton.Utils.lazy = _lazy;
  _Frampton.Utils.memoize = _memoize;
  _Frampton.Utils.noop = _noop;
  _Frampton.Utils.not = _not;
  _Frampton.Utils.ofValue = _ofValue;
  _Frampton.Utils.once = _once;
  _Frampton.Utils.warn = _warn;
});
define('frampton-utils/always', ['exports', 'module', 'frampton-utils/curry_n'], function (exports, module, _framptonUtilsCurry_n) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curryN = _interopRequire(_framptonUtilsCurry_n);

  /**
   * Create a function that always returns the same value every time
   * it is called
   *
   * @name always
   * @method
   * @memberof Frampton.Utils
   * @param {Function} fn The function to wrap.
   * @param {*} args The arguments to pass to the function.
   */
  module.exports = (0, _curryN)(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(null, args);
      }
      return value;
    };
  });
});
define("frampton-utils/apply", ["exports", "module"], function (exports, module) {
  /**
   * 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.
   */
  "use strict";

  module.exports = apply;

  function apply(fn, thisArg) {
    return fn.call(thisArg || null);
  }
});
define('frampton-utils/assert', ['exports', 'module'], function (exports, module) {
  /**
   * 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 {*}    cond - A condition that evaluates to a Boolean. If false, an error is thrown.
   */
  'use strict';

  module.exports = assert;

  function assert(msg, cond) {
    if (!cond) {
      throw new Error(msg || 'An error occured'); // Boom!
    }
  }
});
define('frampton-utils/compose', ['exports', 'module', 'frampton-utils/assert', 'frampton-list/foldr', 'frampton-list/first'], function (exports, module, _framptonUtilsAssert, _framptonListFoldr, _framptonListFirst) {
  'use strict';

  /**
   * 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
   */
  module.exports = compose;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _assert = _interopRequire(_framptonUtilsAssert);

  var _foldr = _interopRequire(_framptonListFoldr);

  var _first = _interopRequire(_framptonListFirst);

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

    (0, _assert)('Compose did not receive any arguments. You can\'t compose nothing. Stoopid.', 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, _first)((0, _foldr)(function (args, fn) {
        return [fn.apply(this, args)];
      }, args, fns));
    };
  }
});
define('frampton-utils/curry', ['exports', 'module', 'frampton-utils/curry_n'], function (exports, module, _framptonUtilsCurry_n) {
  'use strict';

  /**
   * 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.
   */
  module.exports = curry;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curryN = _interopRequire(_framptonUtilsCurry_n);

  function curry(fn) {
    return (0, _curryN)(fn.length, fn);
  }
});
define('frampton-utils/curry_n', ['exports', 'module', 'frampton-utils/assert', 'frampton-utils/is_function'], function (exports, module, _framptonUtilsAssert, _framptonUtilsIs_function) {
  'use strict';

  /**
   * 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} curry Function to curry.
   * @returns {Function} A curried version of the function passed in.
   */
  module.exports = curry_n;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _assert = _interopRequire(_framptonUtilsAssert);

  var _isFunction = _interopRequire(_framptonUtilsIs_function);

  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, _assert)('Argument passed to curry is not a function', (0, _isFunction)(fn));

    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 (locals.length >= arity) {
        return fn.apply(null, locals);
      } else {
        return curry_n.apply(null, [arity, fn].concat(locals));
      }
    }

    return args.length >= arity ? curried() : curried;
  }
});
define('frampton-utils/equal', ['exports', 'module', 'frampton-utils/is_object', 'frampton-utils/is_array'], function (exports, module, _framptonUtilsIs_object, _framptonUtilsIs_array) {
  'use strict';

  /**
   * equal :: Object -> Object -> Boolean
   *
   * @name equal
   * @memberof Frampton.Utils
   * @method
   * @param {*} obj1
   * @param {*} obj2
   * @returns {Boolean}
   */
  module.exports = deep_equal;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _isObject = _interopRequire(_framptonUtilsIs_object);

  var _isArray = _interopRequire(_framptonUtilsIs_array);

  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, _isObject)(obj1) || (0, _isArray)(obj1)) && ((0, _isObject)(obj2) || (0, _isArray)(obj2))) {

        var key = null;

        for (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', 'module', 'frampton/namespace', 'frampton-utils/is_something'], function (exports, module, _framptonNamespace, _framptonUtilsIs_something) {
  'use strict';

  module.exports = error;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _Frampton = _interopRequire(_framptonNamespace);

  var _isSomething = _interopRequire(_framptonUtilsIs_something);

  function error(msg, data) {

    if (_Frampton.isDev()) {

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

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

  /**
   * Extends one object with one or more other objects
   *
   * @name extend
   * @memberof Frampton.Utils
   * @method
   * @param {Object} base
   * @param {Object} args
   * @returns {Object}
   */
  module.exports = extend;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _foldl = _interopRequire(_framptonListFoldl);

  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, _foldl)(function (acc, next) {
      var key;
      for (key in next) {
        acc[key] = next[key];
      }
      return acc;
    }, base, args);
  }
});
define('frampton-utils/get', ['exports', 'module', 'frampton-utils/curry', 'frampton-utils/is_nothing', 'frampton-utils/is_string', 'frampton-utils/is_primitive'], function (exports, module, _framptonUtilsCurry, _framptonUtilsIs_nothing, _framptonUtilsIs_string, _framptonUtilsIs_primitive) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  var _isNothing = _interopRequire(_framptonUtilsIs_nothing);

  var _isString = _interopRequire(_framptonUtilsIs_string);

  var _isPrimitive = _interopRequire(_framptonUtilsIs_primitive);

  /**
   * get :: String -> Object -> Any
   *
   * @name get
   * @method
   * @memberof Frampton.Utils
   * @param {String} prop
   * @param {Object} obj
   * @returns {*}
   */
  module.exports = (0, _curry)(function get(_x, _x2) {
    var _again = true;

    _function: while (_again) {
      var prop = _x,
          obj = _x2;
      parts = head = tail = sub = undefined;
      _again = false;

      if ((0, _isPrimitive)(obj) || (0, _isNothing)(obj)) {
        return null;
      } else if ((0, _isString)(prop)) {
        var parts = (prop || '').split('.').filter(function (val) {
          return val.trim() !== '';
        });

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

          var sub = obj[head];
          if (!(0, _isPrimitive)(sub)) {
            _x = tail.join('.');
            _x2 = sub;
            _again = true;
            continue _function;
          } else {
            return null;
          }
        } else {
          return obj[parts[0]] || null;
        }
      } else {
        return obj[prop] || null;
      }
    }
  });
});
define("frampton-utils/guid", ["exports", "module"], function (exports, module) {
  "use strict";

  module.exports = guid;
  var id = 0;

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

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  /**
   * hasLength :: Int -> [a] -> Boolean
   *
   * @name hasLength
   * @method
   * @memberof Frampton.Utils
   * @param {Number} len
   * @param {Object} obj
   * @returns {Boolean}
   */
  module.exports = (0, _curry)(function has_length(len, obj) {
    return obj && obj.length && obj.length >= len ? true : false;
  });
});
define('frampton-utils/has_prop', ['exports', 'module', 'frampton-utils/curry', 'frampton-utils/get', 'frampton-utils/is_something'], function (exports, module, _framptonUtilsCurry, _framptonUtilsGet, _framptonUtilsIs_something) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  var _get = _interopRequire(_framptonUtilsGet);

  var _isSomething = _interopRequire(_framptonUtilsIs_something);

  /**
   * hasProp :: String -> Object -> Boolean
   *
   * @name hasProp
   * @method
   * @memberof Frampton.Utils
   * @param {String} prop
   * @param {Object} obj
   * @returns {Boolean}
   */
  module.exports = (0, _curry)(function has_prop(prop, obj) {
    return (0, _isSomething)((0, _get)(prop, obj));
  });
});
define("frampton-utils/identity", ["exports", "module"], function (exports, module) {
  /**
   * identity :: a -> a
   *
   * @name identity
   * @method
   * @memberof Frampton.Utils
   * @param {*} x
   * @returns {*}
   */
  "use strict";

  module.exports = identity;

  function identity(x) {
    return x;
  }
});
define("frampton-utils/immediate", ["exports", "module"], function (exports, module) {
  /**
   * immediate :: Function -> ()
   *
   * @name immediate
   * @method
   * @memberof Frampton.Utils
   * @param {Function} fn
   * @param {Object}   [context]
   */
  "use strict";

  module.exports = immediate;

  function immediate(fn, context) {
    setTimeout(fn.bind(context || null), 0);
  }
});
define("frampton-utils/inherits", ["exports", "module"], function (exports, module) {
  /**
   * Similar to class extension in other languages. The child recieves all the
   * static and prototype methods/properties of the parent object.
   */
  "use strict";

  module.exports = inherits;

  function inherits(child, parent) {

    for (var key in parent) {
      if (parent.hasOwnProperty(key)) {
        child[key] = parent[key];
      }
    }

    function Class() {
      this.constructor = child;
    }

    Class.prototype = parent.prototype;
    child.prototype = new Class();
    child.__super__ = parent.prototype;

    return child;
  }
});
define("frampton-utils/is_array", ["exports", "module"], function (exports, module) {
  /**
   * Returns a boolean telling us if a given object is an array
   *
   * @name isArray
   * @method
   * @memberof Frampton.Utils
   * @param {Object} arr
   * @returns {Boolean}
   */
  "use strict";

  module.exports = is_array;

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

  module.exports = is_boolean;

  function is_boolean(obj) {
    return typeof obj === 'boolean';
  }
});
define('frampton-utils/is_defined', ['exports', 'module', 'frampton-utils/is_undefined'], function (exports, module, _framptonUtilsIs_undefined) {
  'use strict';

  /**
   * Returns a boolean telling us if a given value is defined
   *
   * @name isDefined
   * @method
   * @memberof Frampton.Utils
   * @param {*} obj
   * @returns {Boolean}
   */
  module.exports = is_defined;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _isUndefined = _interopRequire(_framptonUtilsIs_undefined);

  function is_defined(obj) {
    return !(0, _isUndefined)(obj);
  }
});
define('frampton-utils/is_empty', ['exports', 'module', 'frampton-utils/is_nothing'], function (exports, module, _framptonUtilsIs_nothing) {
  'use strict';

  /**
   * 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}
   */
  module.exports = is_empty;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _isNothing = _interopRequire(_framptonUtilsIs_nothing);

  function is_empty(obj) {
    return (0, _isNothing)(obj) || !obj.length || 0 === obj.length;
  }
});
define('frampton-utils/is_equal', ['exports', 'module', 'frampton-utils/curry'], function (exports, module, _framptonUtilsCurry) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  /**
   * (===) equality between two values
   *
   * @name isEqual
   * @method
   * @memberof Frampton.Utils
   * @param {*} a
   * @param {*} b
   * @returns {Boolean}
   */
  module.exports = (0, _curry)(function is_equal(a, b) {
    return a === b;
  });
});
define("frampton-utils/is_false", ["exports", "module"], function (exports, module) {
  /**
   * isFalse :: a -> Boolean
   *
   * @name isFalse
   * @method
   * @memberof Frampton.Utils
   * @param {*} obj
   * @returns {Boolean}
   */
  "use strict";

  module.exports = is_false;

  function is_false(obj) {
    return obj === false;
  }
});
define('frampton-utils/is_function', ['exports', 'module'], function (exports, module) {
  /**
   * Returns true/false is the object a fucntion
   *
   * @name isFunction
   * @method
   * @memberof Frampton.Utils
   * @param {*} fn
   * @returns {Boolean}
   */
  'use strict';

  module.exports = is_function;

  function is_function(fn) {
    return typeof fn === 'function';
  }
});
define('frampton-utils/is_node', ['exports', 'module', 'frampton-utils/is_something', 'frampton-utils/is_object', 'frampton-utils/is_defined'], function (exports, module, _framptonUtilsIs_something, _framptonUtilsIs_object, _framptonUtilsIs_defined) {
  'use strict';

  /**
   * Returns true/false is the object a DomNode
   *
   * @name isNode
   * @method
   * @memberof Frampton.Utils
   * @param {*} obj
   * @returns {Boolean}
   */
  module.exports = is_node;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _isSomething = _interopRequire(_framptonUtilsIs_something);

  var _isObject = _interopRequire(_framptonUtilsIs_object);

  var _isDefined = _interopRequire(_framptonUtilsIs_defined);

  function is_node(obj) {
    return (0, _isSomething)(obj) && (0, _isObject)(obj) && (0, _isDefined)(obj.nodeType) && (0, _isDefined)(obj.nodeName);
  }
});
define('frampton-utils/is_nothing', ['exports', 'module', 'frampton-utils/is_undefined', 'frampton-utils/is_null'], function (exports, module, _framptonUtilsIs_undefined, _framptonUtilsIs_null) {
  'use strict';

  /**
   * Returns true/false is the object null or undefined
   *
   * @name isNothing
   * @method
   * @memberof Frampton.Utils
   * @param {*} obj
   * @returns {Boolean}
   */
  module.exports = is_nothing;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _isUndefined = _interopRequire(_framptonUtilsIs_undefined);

  var _isNull = _interopRequire(_framptonUtilsIs_null);

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

  module.exports = is_null;

  function is_null(obj) {
    return obj === null;
  }
});
define('frampton-utils/is_number', ['exports', 'module'], function (exports, module) {
  /**
   * Returns true/false is the object a number
   *
   * @name isNumber
   * @method
   * @memberof Frampton.Utils
   * @param {*} obj
   * @returns {Boolean}
   */
  'use strict';

  module.exports = is_number;

  function is_number(obj) {
    return typeof obj === 'number';
  }
});
define("frampton-utils/is_numeric", ["exports", "module"], function (exports, module) {
  "use strict";

  module.exports = is_numeric;

  function is_numeric(val) {
    return !isNaN(val);
  }
});
define('frampton-utils/is_object', ['exports', 'module', 'frampton-utils/is_something', 'frampton-utils/is_array'], function (exports, module, _framptonUtilsIs_something, _framptonUtilsIs_array) {
  'use strict';

  /**
   * Returns true/false is the object a regular Object
   *
   * @name isObject
   * @method
   * @memberof Frampton.Utils
   * @param {*} obj
   * @returns {Boolean}
   */
  module.exports = isObject;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _isSomething = _interopRequire(_framptonUtilsIs_something);

  var _isArray = _interopRequire(_framptonUtilsIs_array);

  function isObject(obj) {
    return (0, _isSomething)(obj) && !(0, _isArray)(obj) && typeof obj === 'object';
  }
});
define('frampton-utils/is_primitive', ['exports', 'module', 'frampton-utils/is_number', 'frampton-utils/is_boolean', 'frampton-utils/is_string'], function (exports, module, _framptonUtilsIs_number, _framptonUtilsIs_boolean, _framptonUtilsIs_string) {
  'use strict';

  /**
   * Returns true/false is the value a primitive value
   *
   * @name isPrimitive
   * @method
   * @memberof Frampton.Utils
   * @param {*} obj
   * @returns {Boolean}
   */
  module.exports = is_primitive;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _isNumber = _interopRequire(_framptonUtilsIs_number);

  var _isBoolean = _interopRequire(_framptonUtilsIs_boolean);

  var _isString = _interopRequire(_framptonUtilsIs_string);

  function is_primitive(obj) {
    return (0, _isNumber)(obj) || (0, _isBoolean)(obj) || (0, _isString)(obj);
  }
});
define('frampton-utils/is_promise', ['exports', 'module', 'frampton-utils/is_object', 'frampton-utils/is_function'], function (exports, module, _framptonUtilsIs_object, _framptonUtilsIs_function) {
  'use strict';

  /**
   * Returns true/false indicating if object appears to be a Promise
   *
   * @name isPromise
   * @method
   * @memberof Frampton.Utils
   * @param {*} obj
   * @returns {Boolean}
   */
  module.exports = is_promise;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _isObject = _interopRequire(_framptonUtilsIs_object);

  var _isFunction = _interopRequire(_framptonUtilsIs_function);

  function is_promise(obj) {
    return (0, _isObject)(obj) && (0, _isFunction)(obj.then);
  }
});
define('frampton-utils/is_something', ['exports', 'module', 'frampton-utils/is_nothing'], function (exports, module, _framptonUtilsIs_nothing) {
  'use strict';

  /**
   * Returns true/false indicating if object is not null or undefined
   *
   * @name isSomething
   * @method
   * @memberof Frampton.Utils
   * @param {*} obj
   * @returns {Boolean}
   */
  module.exports = is_something;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _isNothing = _interopRequire(_framptonUtilsIs_nothing);

  function is_something(obj) {
    return !(0, _isNothing)(obj);
  }
});
define('frampton-utils/is_string', ['exports', 'module'], function (exports, module) {
  /**
   * Returns true/false indicating if object is a String
   *
   * @name isString
   * @method
   * @memberof Frampton.Utils
   * @param {*} obj
   * @returns {Boolean}
   */
  'use strict';

  module.exports = is_string;

  function is_string(obj) {
    return typeof obj === 'string';
  }
});
define("frampton-utils/is_true", ["exports", "module"], function (exports, module) {
  /**
   * isTrue :: a -> Boolean
   *
   * @name isTrue
   * @method
   * @memberof Frampton.Utils
   * @param {*} obj
   * @returns {Boolean}
   */
  "use strict";

  module.exports = is_true;

  function is_true(obj) {
    return obj === true;
  }
});
define('frampton-utils/is_undefined', ['exports', 'module'], function (exports, module) {
  /**
   * Returns true/false indicating if object is undefined
   *
   * @name isUndefined
   * @method
   * @memberof Frampton.Utils
   * @param {*} obj
   * @returns {Boolean}
   */
  'use strict';

  module.exports = is_undefined;

  function is_undefined(obj) {
    return typeof obj === 'undefined';
  }
});
define("frampton-utils/is_value", ["exports", "module"], function (exports, module) {
  "use strict";

  module.exports = is_value;

  function is_value(test) {
    return function (val) {
      return val === test;
    };
  }
});
define('frampton-utils/lazy', ['exports', 'module', 'frampton-utils/curry'], function (exports, module, _framptonUtilsCurry) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _curry = _interopRequire(_framptonUtilsCurry);

  /**
   * Takes a function and warps it to be called at a later time.
   *
   * @name lazy
   * @method
   * @memberof Frampton.Utils
   * @param {Function} fn The function to wrap.
   * @param {Array} args Array of arguments to pass to the function when called.
   */
  module.exports = (0, _curry)(function lazy(fn, args) {
    return function () {
      return fn.apply(null, args);
    };
  });
});
define('frampton-utils/log', ['exports', 'module', 'frampton/namespace', 'frampton-utils/is_something'], function (exports, module, _framptonNamespace, _framptonUtilsIs_something) {
  'use strict';

  module.exports = log;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _Frampton = _interopRequire(_framptonNamespace);

  var _isSomething = _interopRequire(_framptonUtilsIs_something);

  function log(msg, data) {

    if (_Frampton.isDev() && (0, _isSomething)(console.log)) {
      if ((0, _isSomething)(data)) {
        console.log(msg, data);
      } else {
        console.log(msg);
      }
    }

    return msg;
  }
});
define('frampton-utils/memoize', ['exports', 'module', 'frampton-utils/is_string', 'frampton-utils/is_number'], function (exports, module, _framptonUtilsIs_string, _framptonUtilsIs_number) {
  'use strict';

  /**
   * @name memoize
   * @method
   * @memberof Frampton.Utils
   * @param {Function} fn
   * @param {Object}   [context]
   * @returns {Function}
   */
  module.exports = memoize;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _isString = _interopRequire(_framptonUtilsIs_string);

  var _isNumber = _interopRequire(_framptonUtilsIs_number);

  function memoize(fn, context) {

    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, _isString)(args[0]) || (0, _isNumber)(args[0])) ? args[0] : JSON.stringify(args);

      if (key in store) {
        return store[key];
      } else {
        return store[key] = fn.apply(context || null, args);
      }
    };
  }
});
define("frampton-utils/noop", ["exports", "module"], function (exports, module) {
  /**
   * @name noop
   * @method
   * @memberof Frampton.Utils
   */
  "use strict";

  module.exports = noop;

  function noop() {}
});
define("frampton-utils/not", ["exports", "module"], function (exports, module) {
  /**
   * not :: Function -> a -> Boolean
   *
   * @name not
   * @method
   * @memberof Frampton.Utils
   * @param {Function} fn
   * @returns {Boolean}
   */
  "use strict";

  module.exports = not;

  function not(fn) {
    return function (arg) {
      return !fn(arg);
    };
  }
});
define('frampton-utils/not_implemented', ['exports', 'module'], function (exports, module) {
  'use strict';

  module.exports = function () {
    throw new Error('This method has not been implemented');
  };
});
define("frampton-utils/of_value", ["exports", "module"], function (exports, module) {
  /**
   * Creates a function that always returns the specified value.
   *
   * @name ofValue
   * @method
   * @memberof Frampton.Utils
   * @param {*} value
   * @returns {Function}
   */
  "use strict";

  module.exports = of_value;

  function of_value(value) {
    return function () {
      return value;
    };
  }
});
define('frampton-utils/once', ['exports', 'module', 'frampton-utils/warn'], function (exports, module, _framptonUtilsWarn) {
  'use strict';

  /**
   * Create a function that can only be called once.
   *
   * @name once
   * @method
   * @memberof Frampton.Utils
   * @param {Function} fn
   * @returns {Function}
   */
  module.exports = once;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _warn = _interopRequire(_framptonUtilsWarn);

  function once(fn) {
    var called = false;
    return function () {
      for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      if (called === false) {
        called = true;
        return fn.apply(null, args);
      } else {
        (0, _warn)('Once function called multiple times');
      }
    };
  }
});
define('frampton-utils/warn', ['exports', 'module', 'frampton/namespace', 'frampton-utils/is_something'], function (exports, module, _framptonNamespace, _framptonUtilsIs_something) {
  'use strict';

  module.exports = warn;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _Frampton = _interopRequire(_framptonNamespace);

  var _isSomething = _interopRequire(_framptonUtilsIs_something);

  function warn(msg, data) {

    if (_Frampton.isDev()) {

      if ((0, _isSomething)(console.warn)) {
        if ((0, _isSomething)(data)) {
          console.warn(msg, data);
        } else {
          console.warn(msg);
        }
      } else if ((0, _isSomething)(console.log)) {
        if ((0, _isSomething)(data)) {
          console.log(msg, data);
        } else {
          console.log(msg);
        }
      }
    }

    return msg;
  }
});
define('frampton-window', ['exports', 'frampton/namespace', 'frampton-window/window'], function (exports, _framptonNamespace, _framptonWindowWindow) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _Frampton = _interopRequire(_framptonNamespace);

  var _Window = _interopRequire(_framptonWindowWindow);

  _Frampton.Window = _Window;
});
define('frampton-window/window', ['exports', 'module', 'frampton-signal/stepper', 'frampton-events/on_event', 'frampton-utils/get', 'frampton-utils/is_something'], function (exports, module, _framptonSignalStepper, _framptonEventsOn_event, _framptonUtilsGet, _framptonUtilsIs_something) {
  'use strict';

  /**
   * @typedef Window
   * @type Object
   * @property {Frampton.Signal} dimensions - A Signal of the window dimensions
   * @property {Frampton.Signal} width      - A Signal of with window width
   * @property {Frampton.Signal} height     - A Signal of the window height
   * @property {Frampton.Signal} resize     - A Signal of window resize events
   */

  /**
   * @name Window
   * @method
   * @namespace
   * @memberof Frampton
   * @param {Object} [element] - DomNode to act as applicaton window
   * @returns {Window}
   */
  module.exports = Window;

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _stepper = _interopRequire(_framptonSignalStepper);

  var _onEvent = _interopRequire(_framptonEventsOn_event);

  var _get = _interopRequire(_framptonUtilsGet);

  var _isSomething = _interopRequire(_framptonUtilsIs_something);

  var element = null;
  var resize = (0, _onEvent)('resize', window);
  var dimensions = (0, _stepper)([getWidth(), getHeight()], resize.map(update));
  var width = (0, _stepper)(getWidth(), dimensions.map((0, _get)(0)));
  var height = (0, _stepper)(getHeight(), dimensions.map((0, _get)(1)));

  function getWidth() {
    return (0, _isSomething)(element) ? element.clientWidth : window.innerWidth;
  }

  function getHeight() {
    return (0, _isSomething)(element) ? element.clientHeight : window.innerHeight;
  }

  function update() {
    var w = getWidth();
    var h = getHeight();
    return [w, h];
  }
  function Window(element) {
    element = element;
    return {
      dimensions: dimensions,
      width: width,
      height: height,
      resize: resize
    };
  }
});
define('frampton', ['exports', 'module', 'frampton/namespace', 'frampton-utils', 'frampton-list', 'frampton-record', 'frampton-string', 'frampton-math', 'frampton-events', 'frampton-data', 'frampton-signal', 'frampton-mouse', 'frampton-keyboard', 'frampton-window', 'frampton-html', 'frampton-style'], function (exports, module, _framptonNamespace, _framptonUtils, _framptonList, _framptonRecord, _framptonString, _framptonMath, _framptonEvents, _framptonData, _framptonSignal, _framptonMouse, _framptonKeyboard, _framptonWindow, _framptonHtml, _framptonStyle) {
  'use strict';

  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

  var _Frampton = _interopRequire(_framptonNamespace);

  module.exports = _Frampton;
});
define('frampton/namespace', ['exports', 'module'], function (exports, module) {
  /*globals Frampton:true */

  /**
   * The parent namespace for everything else in Frampton
   *
   * @name Frampton
   * @namespace
   */
  'use strict';

  Frampton.VERSION = '0.1.5';

  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;
  };

  module.exports = 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-io', ['exports', 'frampton/namespace', 'frampton-io/response', 'frampton-io/http/request', 'frampton-io/http/send', '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 (exports, _framptonNamespace, _framptonIoResponse, _framptonIoHttpRequest, _framptonIoHttpSend, _framptonIoHttpGet, _framptonIoHttpPost, _framptonIoHttpPost_json, _framptonIoHttpPost_string, _framptonIoHttpUpload, _framptonIoHttpUtilsUrl, _framptonIoHttpUtilsQuery_pair, _framptonIoHttpUtilsQuery_escape, _framptonIoHttpUtilsQuery_string, _framptonIoHttpUtilsUri_encode, _framptonIoHttpUtilsUri_decode, _framptonIoFileRead, _framptonIoFileData_url, _framptonIoFileBinary_string, _framptonIoFileArray_buffer, _framptonIoFileText) {
  'use strict';

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

  var _Frampton = _interopRequireDefault(_framptonNamespace);

  var _Response = _interopRequireDefault(_framptonIoResponse);

  var _Request = _interopRequireDefault(_framptonIoHttpRequest);

  var _send = _interopRequireDefault(_framptonIoHttpSend);

  var _get = _interopRequireDefault(_framptonIoHttpGet);

  var _post = _interopRequireDefault(_framptonIoHttpPost);

  var _postJson = _interopRequireDefault(_framptonIoHttpPost_json);

  var _postString = _interopRequireDefault(_framptonIoHttpPost_string);

  var _upload = _interopRequireDefault(_framptonIoHttpUpload);

  var _url = _interopRequireDefault(_framptonIoHttpUtilsUrl);

  var _queryPair = _interopRequireDefault(_framptonIoHttpUtilsQuery_pair);

  var _queryEscape = _interopRequireDefault(_framptonIoHttpUtilsQuery_escape);

  var _queryString = _interopRequireDefault(_framptonIoHttpUtilsQuery_string);

  var _uriEncode = _interopRequireDefault(_framptonIoHttpUtilsUri_encode);

  var _uriDecode = _interopRequireDefault(_framptonIoHttpUtilsUri_decode);

  var _read = _interopRequireDefault(_framptonIoFileRead);

  var _dataUrl = _interopRequireDefault(_framptonIoFileData_url);

  var _binaryString = _interopRequireDefault(_framptonIoFileBinary_string);

  var _arrayBuffer = _interopRequireDefault(_framptonIoFileArray_buffer);

  var _text = _interopRequireDefault(_framptonIoFileText);

  /**
   * @name IO
   * @namespace
   * @memberof Frampton
   */
  _Frampton['default'].IO = {};
  _Frampton['default'].IO.VERSION = '0.1.0';
  _Frampton['default'].IO.Response = _Response['default'];

  /**
   * @name Http
   * @memberof Frampton.IO
   * @namespace
   */
  _Frampton['default'].IO.Http = {};
  _Frampton['default'].IO.Http.Request = _Request['default'];
  _Frampton['default'].IO.Http.send = _send['default'];
  _Frampton['default'].IO.Http.get = _get['default'];
  _Frampton['default'].IO.Http.post = _post['default'];
  _Frampton['default'].IO.Http.postJson = _postJson['default'];
  _Frampton['default'].IO.Http.postString = _postString['default'];
  _Frampton['default'].IO.Http.upload = _upload['default'];

  /**
   * @name Utils
   * @memberof Frampton.IO.Http
   * @namespace
   */
  _Frampton['default'].IO.Http.Utils = {};
  _Frampton['default'].IO.Http.Utils.url = _url['default'];
  _Frampton['default'].IO.Http.Utils.queryPair = _queryPair['default'];
  _Frampton['default'].IO.Http.Utils.queryEscape = _queryEscape['default'];
  _Frampton['default'].IO.Http.Utils.queryString = _queryString['default'];
  _Frampton['default'].IO.Http.Utils.uriEncode = _uriEncode['default'];
  _Frampton['default'].IO.Http.Utils.uriDecode = _uriDecode['default'];

  /**
   * @name File
   * @memberof Frampton.IO
   * @namespace
   */
  _Frampton['default'].IO.File = {};
  _Frampton['default'].IO.File.read = _read['default'];
  _Frampton['default'].IO.File.dataUrl = _dataUrl['default'];
  _Frampton['default'].IO.File.binaryString = _binaryString['default'];
  _Frampton['default'].IO.File.arrayBuffer = _arrayBuffer['default'];
  _Frampton['default'].IO.File.text = _text['default'];
});
define('frampton-io/file/array_buffer', ['exports', 'module', 'frampton-io/file/read'], function (exports, module, _framptonIoFileRead) {
  'use strict';

  module.exports = array_buffer;

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

  var _read = _interopRequireDefault(_framptonIoFileRead);

  function array_buffer(file) {
    return _read['default']('ARRAY_BUFFER', file);
  }
});
define('frampton-io/file/binary_string', ['exports', 'module', 'frampton-io/file/read'], function (exports, module, _framptonIoFileRead) {
  'use strict';

  module.exports = binary_string;

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

  var _read = _interopRequireDefault(_framptonIoFileRead);

  function binary_string(file) {
    return _read['default']('BINARY_STRING', file);
  }
});
define('frampton-io/file/data_url', ['exports', 'module', 'frampton-io/file/read'], function (exports, module, _framptonIoFileRead) {
  'use strict';

  module.exports = data_url;

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

  var _read = _interopRequireDefault(_framptonIoFileRead);

  function data_url(file) {
    return _read['default']('DATA_URL', file);
  }
});
define('frampton-io/file/read_api', ['exports', 'module', 'frampton/namespace', 'frampton-utils/apply'], function (exports, module, _framptonNamespace, _framptonUtilsApply) {
  'use strict';

  module.exports = ajax;

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

  var _Frampton = _interopRequireDefault(_framptonNamespace);

  var _apply = _interopRequireDefault(_framptonUtilsApply);

  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(_apply['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 (_Frampton['default'].isTest()) {
      return new MockReader();
    } else {
      return new FileReader();
    }
  }
});
define('frampton-io/file/read', ['exports', 'module', 'frampton-data/task/create', 'frampton-io/response', 'frampton-io/file/read_api'], function (exports, module, _framptonDataTaskCreate, _framptonIoResponse, _framptonIoFileRead_api) {
  'use strict';

  module.exports = read_file;

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

  var _createTask = _interopRequireDefault(_framptonDataTaskCreate);

  var _Response = _interopRequireDefault(_framptonIoResponse);

  var _ReadApi = _interopRequireDefault(_framptonIoFileRead_api);

  // read_file :: String -> File -> Task Response

  function read_file(method, file) {

    return _createTask['default'](function (sinks) {

      var reader = _ReadApi['default']();

      if (sinks.start) {
        reader.addEventListener('loadstart', function (evt) {
          sinks.start(_Response['default']('start', 0, null));
        });
      }

      if (sinks.progress) {
        reader.addEventListener('progress', function (evt) {
          sinks.progress(_Response['default']('progress', evt.loaded / evt.total, null));
        });
      }

      reader.addEventListener('load', function (evt) {
        sinks.resolve(_Response['default']('success', 1, evt.target.result));
      });

      reader.addEventListener('error', function (err) {
        sinks.reject(_Response['default']('error', 0, err.message));
      });

      reader.addEventListener('abort', function (evt) {
        sinks.reject(_Response['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/text', ['exports', 'module', 'frampton-io/file/read'], function (exports, module, _framptonIoFileRead) {
  'use strict';

  module.exports = text;

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

  var _read = _interopRequireDefault(_framptonIoFileRead);

  function text(file) {
    return _read['default']('TEXT', file);
  }
});
define('frampton-io/http/ajax_api', ['exports', 'module', 'frampton/namespace', 'frampton-utils/apply'], function (exports, module, _framptonNamespace, _framptonUtilsApply) {
  'use strict';

  module.exports = ajax_api;

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

  var _Frampton = _interopRequireDefault(_framptonNamespace);

  var _apply = _interopRequireDefault(_framptonUtilsApply);

  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 () {

      if (_this.progressInterval) {
        clearInterval(_this.progressInterval);
        _this.progressInterval = null;
      }

      if (_this.listeners['load']) {
        _this.listeners['load'].forEach(function (next) {
          next({
            target: {
              response: _Frampton['default'].mock(_this.url) || 'test',
              status: 200
            },
            total: 500,
            loaded: 500
          });
        });
      }
    }, this.requestTime);

    if (this.listeners['start']) {
      this.listeners['start'].forEach(_apply['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 (_Frampton['default'].isTest()) {
      return new MockAjax();
    } else {
      return new XMLHttpRequest();
    }
  }
});
define("frampton-io/http/default_settings", ["exports", "module"], function (exports, module) {
  "use strict";

  module.exports = Object.freeze({
    timeout: 30 * 1000
  });
});
define('frampton-io/http/delete', ['exports', 'module', 'frampton-io/http/request', 'frampton-io/http/send', 'frampton-io/http/default_settings'], function (exports, module, _framptonIoHttpRequest, _framptonIoHttpSend, _framptonIoHttpDefault_settings) {
  'use strict';

  module.exports = delete_request;

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

  var _Request = _interopRequireDefault(_framptonIoHttpRequest);

  var _send = _interopRequireDefault(_framptonIoHttpSend);

  var _defaultSettings = _interopRequireDefault(_framptonIoHttpDefault_settings);

  /**
   * 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 _send['default'](_defaultSettings['default'], _Request['default'](url, 'DELETE', data || null));
  }
});
define('frampton-io/http/get', ['exports', 'module', 'frampton-io/http/request', 'frampton-io/http/utils/url', 'frampton-io/http/send', 'frampton-io/http/default_settings'], function (exports, module, _framptonIoHttpRequest, _framptonIoHttpUtilsUrl, _framptonIoHttpSend, _framptonIoHttpDefault_settings) {
  'use strict';

  module.exports = get_request;

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

  var _Request = _interopRequireDefault(_framptonIoHttpRequest);

  var _urlBuilder = _interopRequireDefault(_framptonIoHttpUtilsUrl);

  var _send = _interopRequireDefault(_framptonIoHttpSend);

  var _defaultSettings = _interopRequireDefault(_framptonIoHttpDefault_settings);

  /**
   * 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 _send['default'](_defaultSettings['default'], _Request['default'](_urlBuilder['default'](url, data)));
  }
});
define('frampton-io/http/patch', ['exports', 'module', 'frampton-io/http/request', 'frampton-io/http/send', 'frampton-io/http/default_settings'], function (exports, module, _framptonIoHttpRequest, _framptonIoHttpSend, _framptonIoHttpDefault_settings) {
  'use strict';

  module.exports = patch_request;

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

  var _Request = _interopRequireDefault(_framptonIoHttpRequest);

  var _send = _interopRequireDefault(_framptonIoHttpSend);

  var _defaultSettings = _interopRequireDefault(_framptonIoHttpDefault_settings);

  /**
   * 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 _send['default'](_defaultSettings['default'], _Request['default'](url, 'PATCH', data || null));
  }
});
define('frampton-io/http/post_json', ['exports', 'module', 'frampton-utils/curry', 'frampton-utils/is_object', 'frampton-io/http/post'], function (exports, module, _framptonUtilsCurry, _framptonUtilsIs_object, _framptonIoHttpPost) {
  'use strict';

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

  var _curry = _interopRequireDefault(_framptonUtilsCurry);

  var _isObject = _interopRequireDefault(_framptonUtilsIs_object);

  var _post = _interopRequireDefault(_framptonIoHttpPost);

  /**
   * Perform an AJAX POST request and return an EventStream that reports the progress.
   *
   * @name postJson
   * @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}
   */
  module.exports = _curry['default'](function post_json(url, data) {

    if (_isObject['default'](data)) {
      data = JSON.stringify(data);
    }

    return _post['default'](url, data || null, {
      'Content-Type': 'application/json'
    });
  });
});
define('frampton-io/http/post_string', ['exports', 'module', 'frampton-utils/curry', 'frampton-utils/is_object', 'frampton-io/http/post', 'frampton-io/http/utils/query_string'], function (exports, module, _framptonUtilsCurry, _framptonUtilsIs_object, _framptonIoHttpPost, _framptonIoHttpUtilsQuery_string) {
  'use strict';

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

  var _curry = _interopRequireDefault(_framptonUtilsCurry);

  var _isObject = _interopRequireDefault(_framptonUtilsIs_object);

  var _post = _interopRequireDefault(_framptonIoHttpPost);

  var _queryString = _interopRequireDefault(_framptonIoHttpUtilsQuery_string);

  /**
   * Perform an AJAX POST request and return an EventStream that reports the progress.
   *
   * @name postString
   * @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}
   */
  module.exports = _curry['default'](function post_string(url, data) {

    if (_isObject['default'](data)) {
      data = _queryString['default'](data);
    }

    return _post['default'](url, data || null, {
      'Content-Type': 'application/x-www-form-urlencoded'
    });
  });
});
define('frampton-io/http/post', ['exports', 'module', 'frampton-io/http/request', 'frampton-io/http/send', 'frampton-io/http/default_settings'], function (exports, module, _framptonIoHttpRequest, _framptonIoHttpSend, _framptonIoHttpDefault_settings) {
  'use strict';

  module.exports = post_request;

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

  var _Request = _interopRequireDefault(_framptonIoHttpRequest);

  var _send = _interopRequireDefault(_framptonIoHttpSend);

  var _defaultSettings = _interopRequireDefault(_framptonIoHttpDefault_settings);

  /**
   * 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 _send['default'](_defaultSettings['default'], _Request['default'](url, 'POST', data || null, headers || null));
  }
});
define('frampton-io/http/put', ['exports', 'module', 'frampton-io/http/request', 'frampton-io/http/send', 'frampton-io/http/default_settings'], function (exports, module, _framptonIoHttpRequest, _framptonIoHttpSend, _framptonIoHttpDefault_settings) {
  'use strict';

  module.exports = put_request;

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

  var _Request = _interopRequireDefault(_framptonIoHttpRequest);

  var _send = _interopRequireDefault(_framptonIoHttpSend);

  var _defaultSettings = _interopRequireDefault(_framptonIoHttpDefault_settings);

  /**
   * 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 _send['default'](_defaultSettings['default'], _Request['default'](url, 'PUT', data || null));
  }
});
define('frampton-io/http/request', ['exports', 'module'], function (exports, module) {
  /**
   * @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}
   */
  'use strict';

  module.exports = Request;

  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', 'module', 'frampton-utils/error', 'frampton-data/task/create', 'frampton-io/http/ajax_api', 'frampton-io/response'], function (exports, module, _framptonUtilsError, _framptonDataTaskCreate, _framptonIoHttpAjax_api, _framptonIoResponse) {
  'use strict';

  module.exports = send;

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

  var _error = _interopRequireDefault(_framptonUtilsError);

  var _createTask = _interopRequireDefault(_framptonDataTaskCreate);

  var _AjaxApi = _interopRequireDefault(_framptonIoHttpAjax_api);

  var _Response = _interopRequireDefault(_framptonIoResponse);

  /**
   * 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 = _AjaxApi['default']();

    return _createTask['default'](function (sinks) {

      xhr.open(request.method, request.url, true);

      if (sinks.start) {
        xhr.addEventListener('loadstart', function (evt) {
          sinks.start(_Response['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(_Response['default']('progress', progress, null));
        });
      }

      xhr.addEventListener('error', function (err) {
        _error['default']('Processing ' + request.method + ' for: ' + request.url);
        sinks.reject(_Response['default']('error', 0, err.message));
      });

      xhr.addEventListener('timeout', function (err) {
        _error['default']('Timeout ' + request.method + ' for: ' + request.url);
        sinks.reject(_Response['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(_Response['default']('success', 1, response));
        } else {
          _error['default']('Non-200 response ' + request.method + ' for: ' + request.url);
          sinks.reject(_Response['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_many', ['exports', 'module', 'frampton-utils/curry', 'frampton-io/http/post'], function (exports, module, _framptonUtilsCurry, _framptonIoHttpPost) {
  'use strict';

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

  var _curry = _interopRequireDefault(_framptonUtilsCurry);

  var _post = _interopRequireDefault(_framptonIoHttpPost);

  module.exports = _curry['default'](function upload(url, files) {
    var formData = new FormData();
    for (var i = 0; i < files.length; i++) {
      formData.append('file-' + i, files[i]);
    }
    return _post['default'](url, formData);
  });
});
define('frampton-io/http/upload', ['exports', 'module', 'frampton-utils/curry', 'frampton-io/http/post'], function (exports, module, _framptonUtilsCurry, _framptonIoHttpPost) {
  'use strict';

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

  var _curry = _interopRequireDefault(_framptonUtilsCurry);

  var _post = _interopRequireDefault(_framptonIoHttpPost);

  module.exports = _curry['default'](function upload(url, file) {
    var formData = new FormData();
    formData.append('file-0', file);
    return _post['default'](url, formData);
  });
});
define('frampton-io/http/utils/query_escape', ['exports', 'module', 'frampton-utils/memoize', 'frampton-io/http/utils/uri_encode', 'frampton-string/join', 'frampton-string/split'], function (exports, module, _framptonUtilsMemoize, _framptonIoHttpUtilsUri_encode, _framptonStringJoin, _framptonStringSplit) {
  'use strict';

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

  var _memoize = _interopRequireDefault(_framptonUtilsMemoize);

  var _uriEncode = _interopRequireDefault(_framptonIoHttpUtilsUri_encode);

  var _join = _interopRequireDefault(_framptonStringJoin);

  var _split = _interopRequireDefault(_framptonStringSplit);

  module.exports = _memoize['default'](function query_escape(str) {
    return _join['default']('+', _split['default']('%20', _uriEncode['default'](str)));
  });
});
define('frampton-io/http/utils/query_pair', ['exports', 'module', 'frampton-io/http/utils/query_escape'], function (exports, module, _framptonIoHttpUtilsQuery_escape) {
  'use strict';

  module.exports = query_pair;

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

  var _queryEscape = _interopRequireDefault(_framptonIoHttpUtilsQuery_escape);

  // query_pair :: [String, String] -> String

  function query_pair(pair) {
    return _queryEscape['default'](pair[0]) + '=' + _queryEscape['default'](pair[1]);
  }
});
define('frampton-io/http/utils/query_string', ['exports', 'module', 'frampton-utils/is_array', 'frampton-utils/is_object', 'frampton-utils/is_something', 'frampton-string/join', 'frampton-io/http/utils/query_escape'], function (exports, module, _framptonUtilsIs_array, _framptonUtilsIs_object, _framptonUtilsIs_something, _framptonStringJoin, _framptonIoHttpUtilsQuery_escape) {
  'use strict';

  module.exports = query_string;

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

  var _isArray = _interopRequireDefault(_framptonUtilsIs_array);

  var _isObject = _interopRequireDefault(_framptonUtilsIs_object);

  var _isSomething = _interopRequireDefault(_framptonUtilsIs_something);

  var _join = _interopRequireDefault(_framptonStringJoin);

  var _queryEscape = _interopRequireDefault(_framptonIoHttpUtilsQuery_escape);

  function encode(prefix, obj, add) {

    if (_isArray['default'](obj)) {

      for (var i = 0; i < obj.length; i++) {

        encode(prefix + '[]', obj[i], add);
      }
    } else if (_isObject['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 (_isSomething['default'](value)) {
        params[params.length] = _queryEscape['default'](key) + '=' + _queryEscape['default'](value);
      }
    }

    for (var key in args) {
      encode(key, args[key], add);
    }

    return _join['default']('&', params);
  }
});
define('frampton-io/http/utils/query_unescape', ['exports', 'module', 'frampton-utils/memoize', 'frampton-io/http/utils/uri_decode', 'frampton-string/join', 'frampton-string/split'], function (exports, module, _framptonUtilsMemoize, _framptonIoHttpUtilsUri_decode, _framptonStringJoin, _framptonStringSplit) {
  'use strict';

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

  var _memoize = _interopRequireDefault(_framptonUtilsMemoize);

  var _uriDecode = _interopRequireDefault(_framptonIoHttpUtilsUri_decode);

  var _join = _interopRequireDefault(_framptonStringJoin);

  var _split = _interopRequireDefault(_framptonStringSplit);

  module.exports = _memoize['default'](function query_unescape(str) {
    return _join['default'](' ', _split['default']('+', _uriDecode['default'](str)));
  });
});
define('frampton-io/http/utils/uri_decode', ['exports', 'module', 'frampton-utils/memoize'], function (exports, module, _framptonUtilsMemoize) {
  'use strict';

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

  var _memoize = _interopRequireDefault(_framptonUtilsMemoize);

  module.exports = _memoize['default'](function uri_decode(str) {
    return decodeURIComponent(str);
  });
});
define('frampton-io/http/utils/uri_encode', ['exports', 'module', 'frampton-utils/memoize'], function (exports, module, _framptonUtilsMemoize) {
  'use strict';

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

  var _memoize = _interopRequireDefault(_framptonUtilsMemoize);

  module.exports = _memoize['default'](function uri_encode(str) {
    return encodeURIComponent(str);
  });
});
define('frampton-io/http/utils/url', ['exports', 'module', 'frampton-utils/curry', 'frampton-io/http/utils/query_string'], function (exports, module, _framptonUtilsCurry, _framptonIoHttpUtilsQuery_string) {
  'use strict';

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

  var _curry = _interopRequireDefault(_framptonUtilsCurry);

  var _queryString = _interopRequireDefault(_framptonIoHttpUtilsQuery_string);

  /**
   * url_builder :: String -> Object -> String
   *
   * @name url
   * @method
   * @memberof Frampton.IO.Http
   * @param {String} domain
   * @param {Object} args
   * @returns {String}
   */
  module.exports = _curry['default'](function url_builder(domain, args) {
    if (!args) return domain;
    return domain + '?' + _queryString['default'](args);
  });
});
define("frampton-io/response", ["exports", "module"], function (exports, module) {
  /**
   * @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}
   */
  "use strict";

  module.exports = Response;

  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', ['exports', 'frampton/namespace', 'frampton-history/set_hash', 'frampton-history/push_state', 'frampton-history/replace_state', 'frampton-history/history_change', 'frampton-history/depth', 'frampton-history/state', 'frampton-history/search', 'frampton-history/hash', 'frampton-history/path'], function (exports, _framptonNamespace, _framptonHistorySet_hash, _framptonHistoryPush_state, _framptonHistoryReplace_state, _framptonHistoryHistory_change, _framptonHistoryDepth, _framptonHistoryState, _framptonHistorySearch, _framptonHistoryHash, _framptonHistoryPath) {
  'use strict';

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

  var _Frampton = _interopRequireDefault(_framptonNamespace);

  var _setHash = _interopRequireDefault(_framptonHistorySet_hash);

  var _pushState = _interopRequireDefault(_framptonHistoryPush_state);

  var _replaceState = _interopRequireDefault(_framptonHistoryReplace_state);

  var _change = _interopRequireDefault(_framptonHistoryHistory_change);

  var _depth = _interopRequireDefault(_framptonHistoryDepth);

  var _state = _interopRequireDefault(_framptonHistoryState);

  var _search = _interopRequireDefault(_framptonHistorySearch);

  var _hash = _interopRequireDefault(_framptonHistoryHash);

  var _path = _interopRequireDefault(_framptonHistoryPath);

  /**
   * @name History
   * @namespace
   * @memberof Frampton
   */
  _Frampton['default'].History = {};
  _Frampton['default'].History.VERSION = '0.0.2';
  _Frampton['default'].History.pushState = _pushState['default'];
  _Frampton['default'].History.replaceState = _replaceState['default'];
  _Frampton['default'].History.setHash = _setHash['default'];
  _Frampton['default'].History.depth = _depth['default'];
  _Frampton['default'].History.state = _state['default'];
  _Frampton['default'].History.hash = _hash['default'];
  _Frampton['default'].History.path = _path['default'];
  _Frampton['default'].History.search = _search['default'];
  _Frampton['default'].History.change = _change['default'];
});
define('frampton-history/depth', ['exports', 'module', 'frampton-signal/create'], function (exports, module, _framptonSignalCreate) {
  'use strict';

  module.exports = depth;

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

  var _create = _interopRequireDefault(_framptonSignalCreate);

  var instance = null;

  /**
   * A Behavior representing the current depth of application history
   *
   * @name depth
   * @method
   * @memberof Frampton.History
   * @returns {Frampton.Signal.Signal}
   */

  function depth() {
    if (!instance) {
      instance = _create['default'](0);
    }
    return instance;
  }
});
define('frampton-history/get_history', ['exports', 'module', 'frampton/namespace'], function (exports, module, _framptonNamespace) {
  'use strict';

  module.exports = ajax_api;

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

  var _Frampton = _interopRequireDefault(_framptonNamespace);

  function createMockHistory() {

    return {
      state: null,
      pushState: function pushState(state, title, url) {},
      replaceState: function replaceState(state, title, url) {}
    };
  }

  function ajax_api() {
    if (_Frampton['default'].isTest()) {
      return createMockHistory();
    } else {
      return window.history;
    }
  }
});
define('frampton-history/get_location', ['exports', 'module', 'frampton/namespace'], function (exports, module, _framptonNamespace) {
  'use strict';

  module.exports = ajax_api;

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

  var _Frampton = _interopRequireDefault(_framptonNamespace);

  function ajax_api() {
    if (_Frampton['default'].isTest()) {
      return {
        pathname: '/test/path',
        search: '?test=true'
      };
    } else {
      return window.location;
    }
  }
});
define('frampton-history/hash_signal', ['exports', 'module', 'frampton-utils/is_nothing', 'frampton-history/location_signal'], function (exports, module, _framptonUtilsIs_nothing, _framptonHistoryLocation_signal) {
  'use strict';

  module.exports = hash_stream;

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

  var _isNothing = _interopRequireDefault(_framptonUtilsIs_nothing);

  var _location = _interopRequireDefault(_framptonHistoryLocation_signal);

  var instance = null;

  /**
   * Returns an Signal of the current location.hash
   *
   * @name hashStream
   * @method
   * @private
   * @memberof Frampton.History
   * @returns {Frampton.Signal.Signal}
   */

  function hash_stream() {
    if (_isNothing['default'](instance)) {
      instance = _location['default']().map(function (loc) {
        return loc.hash.replace('#', '');
      });
    }
    return instance;
  }
});
define('frampton-history/hash', ['exports', 'module', 'frampton-signal/stepper', 'frampton-history/get_location', 'frampton-history/hash_signal'], function (exports, module, _framptonSignalStepper, _framptonHistoryGet_location, _framptonHistoryHash_signal) {
  'use strict';

  module.exports = hash;

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

  var _stepper = _interopRequireDefault(_framptonSignalStepper);

  var _location = _interopRequireDefault(_framptonHistoryGet_location);

  var _hashSignal = _interopRequireDefault(_framptonHistoryHash_signal);

  var instance = null;

  /**
   * A Signal representing the current location.hash
   *
   * @name hash
   * @method
   * @memberof Frampton.History
   * @returns {Frampton.Signal.Signal}
   */

  function hash() {
    if (!instance) {
      instance = _stepper['default'](_location['default']().hash, _hashSignal['default']());
    }
    return instance;
  }
});
define('frampton-history/history_change', ['exports', 'module', 'frampton-history/history_signal'], function (exports, module, _framptonHistoryHistory_signal) {
  'use strict';

  module.exports = history_change;

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

  var _history = _interopRequireDefault(_framptonHistoryHistory_signal);

  /**
   * @name historyChange
   * @method
   * @memberof Frampton.History
   * @param {Function} fn A function to call when history changes
   * @return {Function} A function to unsubscribe from changes
   */

  function history_change(fn) {
    return _history['default']().next(fn);
  }
});
define('frampton-history/history_signal', ['exports', 'module', 'frampton-utils/is_nothing', 'frampton-history/get_history', 'frampton-history/stack_signal', 'frampton-history/popstate_signal'], function (exports, module, _framptonUtilsIs_nothing, _framptonHistoryGet_history, _framptonHistoryStack_signal, _framptonHistoryPopstate_signal) {
  'use strict';

  module.exports = history_signal;

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

  var _isNothing = _interopRequireDefault(_framptonUtilsIs_nothing);

  var _history = _interopRequireDefault(_framptonHistoryGet_history);

  var _stack = _interopRequireDefault(_framptonHistoryStack_signal);

  var _popstate = _interopRequireDefault(_framptonHistoryPopstate_signal);

  var instance = null;

  /**
   * Returns a Signal of the current window.history
   *
   * @name historySignal
   * @method
   * @private
   * @memberof Frampton.History
   * @returns {Frampton.Signal.Signal}
   */

  function history_signal() {

    if (_isNothing['default'](instance)) {
      instance = _stack['default']().merge(_popstate['default']()).map(function () {
        return _history['default']();
      });
    }

    return instance;
  }
});
define('frampton-history/history_stack', ['exports', 'frampton-list/last', 'frampton-history/depth', 'frampton-history/stack_signal'], function (exports, _framptonListLast, _framptonHistoryDepth, _framptonHistoryStack_signal) {
  'use strict';

  exports.__esModule = true;

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

  var _last = _interopRequireDefault(_framptonListLast);

  var _depth = _interopRequireDefault(_framptonHistoryDepth);

  var _stack = _interopRequireDefault(_framptonHistoryStack_signal);

  var depthSignal = _depth['default']();
  var stackSignal = _stack['default']();

  /**
   * 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;
    depthSignal(state._store.length);
    stackSignal(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;
    stackSignal(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 = _last['default'](state._store);
    state.currentId = state.currentState ? state.currentState.id : 0;
    depthSignal(state._store.length);
    stackSignal(null);
  };

  exports.stack = state;
  exports.pushHistory = pushHistory;
  exports.replaceHistory = replaceHistory;
  exports.popHistory = popHistory;
});
define('frampton-history/location_signal', ['exports', 'module', 'frampton-utils/is_nothing', 'frampton-history/history_signal', 'frampton-history/get_location'], function (exports, module, _framptonUtilsIs_nothing, _framptonHistoryHistory_signal, _framptonHistoryGet_location) {
  'use strict';

  module.exports = location_signal;

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

  var _isNothing = _interopRequireDefault(_framptonUtilsIs_nothing);

  var _history = _interopRequireDefault(_framptonHistoryHistory_signal);

  var _location = _interopRequireDefault(_framptonHistoryGet_location);

  var instance = null;

  /**
   * @name locationSignal
   * @method
   * @private
   * @memberof Frampton.History
   * @returns {Frampton.Signal.Signal}
   */

  function location_signal() {
    if (_isNothing['default'](instance)) {
      instance = _history['default']().map(function () {
        return _location['default']();
      });
    }
    return instance;
  }
});
define('frampton-history/parse_search', ['exports', 'module', 'frampton-utils/memoize', 'frampton-io/http/utils/query_unescape'], function (exports, module, _framptonUtilsMemoize, _framptonIoHttpUtilsQuery_unescape) {
  'use strict';

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

  var _memoize = _interopRequireDefault(_framptonUtilsMemoize);

  var _queryUnescape = _interopRequireDefault(_framptonIoHttpUtilsQuery_unescape);

  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}
   */
  module.exports = _memoize['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[_queryUnescape['default'](pair[0])] = _queryUnescape['default'](pair[1]);
      }
    });
    return obj;
  });
});
define('frampton-history/path_signal', ['exports', 'module', 'frampton-history/location_signal'], function (exports, module, _framptonHistoryLocation_signal) {
  'use strict';

  module.exports = path_signal;

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

  var _location = _interopRequireDefault(_framptonHistoryLocation_signal);

  var instance = null;

  /**
   * Returns an Signal of updates to location.pathname
   *
   * @name pathSignal
   * @method
   * @private
   * @memberof Frampton.History
   * @returns {Frampton.Signal.Signal}
   */

  function path_signal() {
    if (!instance) {
      instance = _location['default']().map(function (loc) {
        return loc.pathname;
      });
    }
    return instance;
  }
});
define('frampton-history/path', ['exports', 'module', 'frampton-signal/stepper', 'frampton-history/get_location', 'frampton-history/path_signal'], function (exports, module, _framptonSignalStepper, _framptonHistoryGet_location, _framptonHistoryPath_signal) {
  'use strict';

  module.exports = path;

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

  var _stepper = _interopRequireDefault(_framptonSignalStepper);

  var _location = _interopRequireDefault(_framptonHistoryGet_location);

  var _pathSignal = _interopRequireDefault(_framptonHistoryPath_signal);

  var instance = null;

  /**
   * A Signal representing the current location.pathname
   *
   * @name path
   * @method
   * @memberof Frampton.History
   * @returns {Frampton.Signal.Signal}
   */

  function path() {
    if (!instance) {
      instance = _stepper['default'](_location['default']().pathname, _pathSignal['default']());
    }
    return instance;
  }
});
define('frampton-history/popstate_signal', ['exports', 'module', 'frampton-utils/is_nothing', 'frampton-events/on_event', 'frampton-history/history_stack'], function (exports, module, _framptonUtilsIs_nothing, _framptonEventsOn_event, _framptonHistoryHistory_stack) {
  'use strict';

  module.exports = popstate_signal;

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

  var _isNothing = _interopRequireDefault(_framptonUtilsIs_nothing);

  var _onEvent = _interopRequireDefault(_framptonEventsOn_event);

  var instance = null;

  /**
   * 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}
   */

  function popstate_signal() {

    if (!window.history || !window.history.pushState) {
      throw new Error('History API is not supported by this browser');
    }

    if (_isNothing['default'](instance)) {
      instance = _onEvent['default']('popstate', window).map(function (evt) {
        if (evt.state) {
          if (evt.state.id < _framptonHistoryHistory_stack.stack.currentId) {
            _framptonHistoryHistory_stack.popHistory();
          } else if (evt.state.id > _framptonHistoryHistory_stack.stack.currentId) {
            _framptonHistoryHistory_stack.pushHistory(evt.state);
          }
        }
        return evt;
      });
    }

    return instance;
  }
});
define('frampton-history/push_state', ['exports', 'module', 'frampton-utils/guid', 'frampton-history/get_history', 'frampton-history/with_valid_state', 'frampton-history/history_stack'], function (exports, module, _framptonUtilsGuid, _framptonHistoryGet_history, _framptonHistoryWith_valid_state, _framptonHistoryHistory_stack) {
  'use strict';

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

  var _guid = _interopRequireDefault(_framptonUtilsGuid);

  var _history = _interopRequireDefault(_framptonHistoryGet_history);

  var _withValidState = _interopRequireDefault(_framptonHistoryWith_valid_state);

  /**
   * @name pushState
   * @method
   * @memberof Frampton.History
   * @param {Object} state A state to replace the current state
   */
  module.exports = _withValidState['default'](function push_state(state) {
    state.id = _guid['default']();
    _history['default']().pushState(state, state.name, state.path);
    _framptonHistoryHistory_stack.pushHistory(state);
  });
});
define('frampton-history/replace_state', ['exports', 'module', 'frampton-utils/guid', 'frampton-history/get_history', 'frampton-history/with_valid_state', 'frampton-history/history_stack'], function (exports, module, _framptonUtilsGuid, _framptonHistoryGet_history, _framptonHistoryWith_valid_state, _framptonHistoryHistory_stack) {
  'use strict';

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

  var _guid = _interopRequireDefault(_framptonUtilsGuid);

  var _history = _interopRequireDefault(_framptonHistoryGet_history);

  var _withValidState = _interopRequireDefault(_framptonHistoryWith_valid_state);

  /**
   * @name replaceState
   * @method
   * @memberof Frampton.History
   * @param {Object} state A state to replace the current state
   */
  module.exports = _withValidState['default'](function replace_state(state) {
    state.id = _guid['default']();
    _history['default']().replaceState(state, state.name, state.path);
    _framptonHistoryHistory_stack.replaceHistory(state);
  });
});
define('frampton-history/search_signal', ['exports', 'module', 'frampton-utils/is_nothing', 'frampton-history/location_signal', 'frampton-history/parse_search'], function (exports, module, _framptonUtilsIs_nothing, _framptonHistoryLocation_signal, _framptonHistoryParse_search) {
  'use strict';

  module.exports = hash_signal;

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

  var _isNothing = _interopRequireDefault(_framptonUtilsIs_nothing);

  var _location = _interopRequireDefault(_framptonHistoryLocation_signal);

  var _parseSearch = _interopRequireDefault(_framptonHistoryParse_search);

  var instance = null;

  /**
   * Returns an Signal of updates to location.search
   *
   * @name searchSignal
   * @method
   * @private
   * @memberof Frampton.History
   * @returns {Frampton.Signal.Signal}
   */

  function hash_signal() {
    if (_isNothing['default'](instance)) {
      instance = _location['default']().map(function (loc) {
        return _parseSearch['default'](loc.search || '');
      });
    }
    return instance;
  }
});
define('frampton-history/search', ['exports', 'module', 'frampton-signal/stepper', 'frampton-history/get_location', 'frampton-history/search_signal', 'frampton-history/parse_search'], function (exports, module, _framptonSignalStepper, _framptonHistoryGet_location, _framptonHistorySearch_signal, _framptonHistoryParse_search) {
  'use strict';

  module.exports = search;

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

  var _stepper = _interopRequireDefault(_framptonSignalStepper);

  var _location = _interopRequireDefault(_framptonHistoryGet_location);

  var _searchSignal = _interopRequireDefault(_framptonHistorySearch_signal);

  var _parseSearch = _interopRequireDefault(_framptonHistoryParse_search);

  var instance = null;

  /**
   * A Signal representing the current location.search
   *
   * @name search
   * @method
   * @memberof Frampton.History
   * @returns {Frampton.Signal.Signal}
   */

  function search() {
    if (!instance) {
      instance = _stepper['default'](_parseSearch['default'](_location['default']().search || ''), _searchSignal['default']());
    }
    return instance;
  }
});
define('frampton-history/set_hash', ['exports', 'module', 'frampton-history/history_stack'], function (exports, module, _framptonHistoryHistory_stack) {
  'use strict';

  module.exports = set_hash;

  /**
   * @name setHash
   * @method
   * @memberof Frampton.History
   * @param {String} hash
   */

  function set_hash(hash) {
    _framptonHistoryHistory_stack.pushState({
      name: 'hash',
      path: '#' + hash
    });
  }
});
define('frampton-history/stack_signal', ['exports', 'module', 'frampton-utils/is_nothing', 'frampton-signal/create'], function (exports, module, _framptonUtilsIs_nothing, _framptonSignalCreate) {
  'use strict';

  module.exports = stack_signal;

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

  var _isNothing = _interopRequireDefault(_framptonUtilsIs_nothing);

  var _create = _interopRequireDefault(_framptonSignalCreate);

  var instance = null;

  /**
   * Signal of changes to the history stack
   *
   * @name stackSignal
   * @method
   * @private
   * @memberof Frampton.History
   * @returns {Frampton.Signal.Signal}
   */

  function stack_signal() {

    if (_isNothing['default'](instance)) {
      instance = _create['default']();
    }

    return instance;
  }
});
define('frampton-history/state_signal', ['exports', 'module', 'frampton-utils/is_nothing', 'frampton-history/history_signal'], function (exports, module, _framptonUtilsIs_nothing, _framptonHistoryHistory_signal) {
  'use strict';

  module.exports = state_signal;

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

  var _isNothing = _interopRequireDefault(_framptonUtilsIs_nothing);

  var _history = _interopRequireDefault(_framptonHistoryHistory_signal);

  var instance = null;

  /**
   * Returns an Signal of updates to history.state
   *
   * @name stateSignal
   * @method
   * @private
   * @memberof Frampton.History
   * @returns {Frampton.Signal.Signal}
   */

  function state_signal() {
    if (_isNothing['default'](instance)) {
      instance = _history['default']().map(function (h) {
        return h.state;
      });
    }
    return instance;
  }
});
define('frampton-history/state', ['exports', 'module', 'frampton-utils/is_nothing', 'frampton-signal/stepper', 'frampton-history/get_history', 'frampton-history/state_signal'], function (exports, module, _framptonUtilsIs_nothing, _framptonSignalStepper, _framptonHistoryGet_history, _framptonHistoryState_signal) {
  'use strict';

  module.exports = state;

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

  var _isNothing = _interopRequireDefault(_framptonUtilsIs_nothing);

  var _stepper = _interopRequireDefault(_framptonSignalStepper);

  var _history = _interopRequireDefault(_framptonHistoryGet_history);

  var _stateSignal = _interopRequireDefault(_framptonHistoryState_signal);

  var instance = null;

  /**
   * A Signal representing the current history.state
   *
   * @name state
   * @method
   * @memberof Frampton.History
   * @returns {Frampton.Signal.Signal}
   */

  function state() {
    if (_isNothing['default'](instance)) {
      instance = _stepper['default'](_history['default']().state, _stateSignal['default']());
    }
    return instance;
  }
});
define("frampton-history/valid_state", ["exports", "module"], function (exports, module) {
  /**
   * Internally we require all state objects to have a name and path. This
   * checks a state object to ensure it meets those requirements.
   *
   * @name validState
   * @method
   * @private
   * @memberof Frampton.History
   * @param {Object} state
   * @returns {Boolean}
   */
  "use strict";

  module.exports = valid_state;

  function valid_state(state) {
    return !!(state.name && state.path);
  }
});
define('frampton-history/with_valid_state', ['exports', 'module', 'frampton-utils/assert', 'frampton-history/valid_state'], function (exports, module, _framptonUtilsAssert, _framptonHistoryValid_state) {
  'use strict';

  module.exports = with_valid_state;

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

  var _assert = _interopRequireDefault(_framptonUtilsAssert);

  var _validState = _interopRequireDefault(_framptonHistoryValid_state);

  /**
   * Validates that the given function recieves a valid state object as its
   * sole argument.
   *
   * @name withValidState
   * @method
   * @private
   * @memberof Frampton.History
   * @param {Function} fn Function whose argument to validate
   * @returns {Function} A function that will throw an error if it is not
   * passed a valid state.
   */

  function with_valid_state(fn) {
    return function (state) {
      _assert['default']('State not valid', _validState['default'](state));
      fn(state);
    };
  }
});
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', ['exports', 'frampton/namespace', 'frampton-router/router', 'frampton-router/route', 'frampton-router/match'], function (exports, _framptonNamespace, _framptonRouterRouter, _framptonRouterRoute, _framptonRouterMatch) {
  'use strict';

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

  var _Frampton = _interopRequireDefault(_framptonNamespace);

  var _router = _interopRequireDefault(_framptonRouterRouter);

  var _route = _interopRequireDefault(_framptonRouterRoute);

  var _match = _interopRequireDefault(_framptonRouterMatch);

  /**
   * @name Router
   * @namespace
   * @memberof Frampton
   */
  _Frampton['default'].Router = {};
  _Frampton['default'].Router.VERSION = '0.0.3';
  _Frampton['default'].Router.match = _match['default'];
  _Frampton['default'].Router.create = _router['default'];
  _Frampton['default'].Router.route = _route['default'];
});
define('frampton-router/dynamic_path', ['exports', 'module', 'frampton-utils/memoize', 'frampton-string/replace'], function (exports, module, _framptonUtilsMemoize, _framptonStringReplace) {
  'use strict';

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

  var _memoize = _interopRequireDefault(_framptonUtilsMemoize);

  var _replace = _interopRequireDefault(_framptonStringReplace);

  module.exports = _memoize['default'](_replace['default']('', '/:'));
});
define('frampton-router/is_dynamic_path', ['exports', 'module', 'frampton-utils/memoize', 'frampton-string/starts_with'], function (exports, module, _framptonUtilsMemoize, _framptonStringStarts_with) {
  'use strict';

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

  var _memoize = _interopRequireDefault(_framptonUtilsMemoize);

  var _startsWith = _interopRequireDefault(_framptonStringStarts_with);

  module.exports = _memoize['default'](_startsWith['default'](':'));
});
define('frampton-router/is_index', ['exports', 'module', 'frampton-string/starts_with'], function (exports, module, _framptonStringStarts_with) {
  'use strict';

  module.exports = is_index;

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

  var _startsWith = _interopRequireDefault(_framptonStringStarts_with);

  function is_index(routePath, currentPath) {
    return routePath === '/' && (currentPath === '/' || _startsWith['default']('index.', currentPath));
  }
});
define('frampton-router/join_path', ['exports', 'module', 'frampton-string/join'], function (exports, module, _framptonStringJoin) {
  'use strict';

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

  var _join = _interopRequireDefault(_framptonStringJoin);

  module.exports = _join['default']('/');
});
define('frampton-router/match_route', ['exports', 'module', 'frampton-router/split_path', 'frampton-router/is_index', 'frampton-router/is_dynamic_path'], function (exports, module, _framptonRouterSplit_path, _framptonRouterIs_index, _framptonRouterIs_dynamic_path) {
  'use strict';

  module.exports = match_route;

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

  var _splitPath = _interopRequireDefault(_framptonRouterSplit_path);

  var _isIndex = _interopRequireDefault(_framptonRouterIs_index);

  var _isDynamicPath = _interopRequireDefault(_framptonRouterIs_dynamic_path);

  function match_route(route, path) {

    var routeParts = _splitPath['default'](route);
    var pathParts = _splitPath['default'](path);
    var rLen = routeParts.length;
    var pLen = pathParts.length;
    var len = rLen > pLen ? rLen : pLen;
    var tokens = [];

    for (var j = 0; j < len; j++) {

      var currentRoutePart = routeParts[j] || '';
      var currentPathPart = pathParts[j];

      if (currentRoutePart && currentPathPart) {
        if (_isDynamicPath['default'](currentRoutePart)) {
          if (currentRoutePart === ':number' && isNaN(parseInt(currentPathPart))) {
            return null;
          } else if (currentRoutePart === ':string' && !isNaN(parseInt(currentPathPart))) {
            return null;
          }
          tokens.push(currentPathPart);
        } else if (currentRoutePart !== currentPathPart) {
          return null;
        }
      } else if (_isIndex['default'](currentRoutePart, currentPathPart)) {
        return tokens;
      } else {
        tokens.length = 0;
        return null;
      }
    }

    return tokens;
  }
});
define('frampton-router/match', ['exports', 'module', 'frampton-utils/curry', 'frampton-router/match_route'], function (exports, module, _framptonUtilsCurry, _framptonRouterMatch_route) {
  'use strict';

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

  var _curry = _interopRequireDefault(_framptonUtilsCurry);

  var _matchRoute = _interopRequireDefault(_framptonRouterMatch_route);

  /**
   * match :: Route[] -> String -> a
   * @name match
   * @method
   * @memberof Frampton.Router
   * @param {Array} routes
   * @param {String} path
   */
  module.exports = _curry['default'](function (routes, path) {
    for (var i = 0; i < routes.length; i++) {
      var route = routes[i];
      var tokens = _matchRoute['default'](route.path, path);
      if (tokens) {
        return route.fn.apply(null, tokens);
      }
    }
  });
});
define("frampton-router/route", ["exports", "module"], function (exports, module) {
  /**
   * @name route
   * @method
   * @memberof Frampton.Router
   * @param {String} path
   * @param {Function} fn
   * @returns {Object}
   */
  "use strict";

  module.exports = create_route;

  function create_route(path, _fn) {
    return {
      path: path,
      fn: function fn() {
        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
          args[_key] = arguments[_key];
        }

        return _fn.apply(null, args);
      },
      _isRoute: true
    };
  }
});
define('frampton-router/router', ['exports', 'module', 'frampton-utils/curry', 'frampton-router/match'], function (exports, module, _framptonUtilsCurry, _framptonRouterMatch) {
  'use strict';

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

  var _curry = _interopRequireDefault(_framptonUtilsCurry);

  var _match = _interopRequireDefault(_framptonRouterMatch);

  module.exports = _curry['default'](function create_router(base, routes, path) {
    return _match['default'](routes, path.replace(base, ''));
  });
});
define('frampton-router/split_path', ['exports', 'module', 'frampton-utils/compose', 'frampton-utils/memoize', 'frampton-string/split', 'frampton-list/filter'], function (exports, module, _framptonUtilsCompose, _framptonUtilsMemoize, _framptonStringSplit, _framptonListFilter) {
  'use strict';

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

  var _compose = _interopRequireDefault(_framptonUtilsCompose);

  var _memoize = _interopRequireDefault(_framptonUtilsMemoize);

  var _split = _interopRequireDefault(_framptonStringSplit);

  var _filter = _interopRequireDefault(_framptonListFilter);

  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}
   */
  module.exports = _memoize['default'](_compose['default'](_filter['default'](notEmpty), _split['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', ['exports', 'frampton/namespace', 'frampton-motion/prepare', 'frampton-motion/transition', 'frampton-motion/sequence', 'frampton-motion/when', 'frampton-motion/reflow'], function (exports, _framptonNamespace, _framptonMotionPrepare, _framptonMotionTransition, _framptonMotionSequence, _framptonMotionWhen, _framptonMotionReflow) {
  'use strict';

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

  var _Frampton = _interopRequireDefault(_framptonNamespace);

  var _prepare = _interopRequireDefault(_framptonMotionPrepare);

  var _sequence = _interopRequireDefault(_framptonMotionSequence);

  var _when = _interopRequireDefault(_framptonMotionWhen);

  var _reflow = _interopRequireDefault(_framptonMotionReflow);

  /**
   * @name Motion
   * @namespace
   * @memberof Frampton
   */
  _Frampton['default'].Motion = {};
  _Frampton['default'].Motion.VERSION = '0.0.9';
  _Frampton['default'].Motion.prepare = _prepare['default'];
  _Frampton['default'].Motion.describe = _framptonMotionTransition.describe;
  _Frampton['default'].Motion.sequence = _sequence['default'];
  _Frampton['default'].Motion.reflow = _reflow['default'];
  _Frampton['default'].Motion.when = _when['default'];
});
define('frampton-motion/animation_end', ['exports', 'module', 'frampton-style/supported'], function (exports, module, _framptonStyleSupported) {
  'use strict';

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

  var _supported = _interopRequireDefault(_framptonStyleSupported);

  var eventMap = {
    'WebkitAnimation': 'webkitAnimationEnd',
    'MozAnimation': 'animationend',
    'animation': 'animationend'
  };

  function animationEnd() {
    return eventMap[_supported['default']('animation')] || null;
  }

  module.exports = animationEnd();
});
define('frampton-motion/easing', ['exports', 'module'], function (exports, module) {
  'use strict';

  module.exports = {
    '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/next_end', ['exports', 'module', 'frampton-utils/noop', 'frampton-events/once', 'frampton-motion/transition_end'], function (exports, module, _framptonUtilsNoop, _framptonEventsOnce, _framptonMotionTransition_end) {
  'use strict';

  module.exports = next_end;

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

  var _noop = _interopRequireDefault(_framptonUtilsNoop);

  var _once = _interopRequireDefault(_framptonEventsOnce);

  var _transitionend = _interopRequireDefault(_framptonMotionTransition_end);

  /**
   * 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) {
    _once['default'](_transitionend['default'], element).next(function (evt) {
      (fn || _noop['default'])(evt);
    });
  }
});
define('frampton-motion/normalized_frame', ['exports', 'module', 'frampton-utils/is_number', 'frampton-list/contains', 'frampton-motion/easing'], function (exports, module, _framptonUtilsIs_number, _framptonListContains, _framptonMotionEasing) {
  'use strict';

  module.exports = normalized_frame;

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

  var _isNumber = _interopRequireDefault(_framptonUtilsIs_number);

  var _contains = _interopRequireDefault(_framptonListContains);

  var _easing = _interopRequireDefault(_framptonMotionEasing);

  var alias_mapping = {
    'duration': 'transition-duration',
    'delay': 'transition-delay'
  };

  var durations = _contains['default'](['transition-duration', 'transition-delay']);

  var pixels = _contains['default'](['height', 'width', 'left', 'top', 'right', 'bottom']);

  function normalized_frame(frame) {
    var obj = {};
    for (var key in frame) {
      if (alias_mapping[key]) {
        if (_isNumber['default'](frame[key])) {
          obj[alias_mapping[key]] = frame[key] + 'ms';
        } else {
          obj[alias_mapping[key]] = frame[key];
        }
      } else if (pixels(key) && _isNumber['default'](frame[key])) {
        obj[key] = frame[key] + 'px';
      } else if (durations(key) && _isNumber['default'](frame[key])) {
        obj[key] = frame[key] + 'ms';
      } else if (key === 'transition-timing-function') {
        obj[key] = _easing['default'][frame[key]] ? _easing['default'][frame[key]] : frame[key];
      } else {
        obj[key] = frame[key];
      }
    }
    return obj;
  }
});
define('frampton-motion/parsed_props', ['exports', 'module', 'frampton-record/reduce', 'frampton-list/contains', 'frampton-style/supported', 'frampton-motion/transitions'], function (exports, module, _framptonRecordReduce, _framptonListContains, _framptonStyleSupported, _framptonMotionTransitions) {
  'use strict';

  module.exports = parsed_props;

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

  var _reduceObj = _interopRequireDefault(_framptonRecordReduce);

  var _contains = _interopRequireDefault(_framptonListContains);

  var _supported = _interopRequireDefault(_framptonStyleSupported);

  var _transitions = _interopRequireDefault(_framptonMotionTransitions);

  function parsed_props(props) {
    return _reduceObj['default'](function (acc, value, key) {
      if (!_contains['default'](_transitions['default'], key)) {
        acc[_supported['default'](key)] = value;
      }
      return acc;
    }, {}, props);
  }
});
define('frampton-motion/parsed_timing', ['exports', 'module', 'frampton-style/supported'], function (exports, module, _framptonStyleSupported) {
  'use strict';

  module.exports = parsed_timing;

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

  var _supported = _interopRequireDefault(_framptonStyleSupported);

  function parsed_timing(props) {

    var timing = {};

    if (props['transition-delay']) {
      timing[_supported['default']('transition-delay')] = props['transition-delay'];
    }

    if (props['transition-duration']) {
      timing[_supported['default']('transition-duration')] = props['transition-duration'];
    }

    return timing;
  }
});
define('frampton-motion/prepare', ['exports', 'module', 'frampton-utils/is_object', 'frampton-style/add_class', 'frampton-style/apply_styles', 'frampton-motion/normalized_frame', 'frampton-motion/reflow'], function (exports, module, _framptonUtilsIs_object, _framptonStyleAdd_class, _framptonStyleApply_styles, _framptonMotionNormalized_frame, _framptonMotionReflow) {
  'use strict';

  module.exports = prepare;

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

  var _isObject = _interopRequireDefault(_framptonUtilsIs_object);

  var _addClass = _interopRequireDefault(_framptonStyleAdd_class);

  var _applyStyles = _interopRequireDefault(_framptonStyleApply_styles);

  var _normalizedFrame = _interopRequireDefault(_framptonMotionNormalized_frame);

  var _reflow = _interopRequireDefault(_framptonMotionReflow);

  function prepare(element, classes, props) {
    if (_isObject['default'](classes)) {
      _applyStyles['default'](element, _normalizedFrame['default'](classes));
    } else {
      classes.split(' ').forEach(_addClass['default'](element));
      _applyStyles['default'](element, _normalizedFrame['default'](props));
    }
    return (_reflow['default'](element), true);
  }
});
define("frampton-motion/reflow", ["exports", "module"], function (exports, module) {
  /**
   * Forces browser reflow by reading the offsetHeight of given element
   *
   * @name reflow
   * @method
   * @private
   * @memberof Frampton.Motion
   * @param {Object} element DomNode to reflow
   */
  "use strict";

  module.exports = reflow;

  function reflow(element) {
    return element.offsetWidth;
  }
});
define("frampton-motion/sequence", ["exports", "module"], function (exports, module) {
  /**
   * 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
   */
  "use strict";

  module.exports = sequence_transitions;

  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/transform_object', ['exports', 'module', 'frampton-motion/transforms'], function (exports, module, _framptonMotionTransforms) {
  'use strict';

  module.exports = transform_object;

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

  var _transforms = _interopRequireDefault(_framptonMotionTransforms);

  /**
   * 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
   * @param {String} transform
   * @returns {Object}
   */

  function transform_object(transform) {
    var obj = {};
    for (var i = 0; i < _transforms['default'].length; i++) {
      var prop = _transforms['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/transforms', ['exports', 'module'], function (exports, module) {
  'use strict';

  module.exports = ['matrix', 'matrix3d', 'translate', 'translate3d', 'translateX', 'translateY', 'translateZ', 'scale', 'scale3d', 'scaleX', 'scaleY', 'scaleZ', 'rotate', 'rotate3d', 'rotateX', 'rotateY', 'rotateZ', 'skew', 'skewX', 'skewY', 'perspective'];
});
define('frampton-motion/transition_end', ['exports', 'module', 'frampton-style/supported'], function (exports, module, _framptonStyleSupported) {
  'use strict';

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

  var _supported = _interopRequireDefault(_framptonStyleSupported);

  var eventMap = {
    'WebkitTransition': 'webkitTransitionEnd',
    'MozTransition': 'transitionend',
    'transition': 'transitionend'
  };

  function transitionEnd() {
    return eventMap[_supported['default']('transition')] || null;
  }

  module.exports = transitionEnd();
});
define('frampton-motion/transition_props', ['exports', 'module', 'frampton-style/supported'], function (exports, module, _framptonStyleSupported) {
  'use strict';

  module.exports = transition_props;

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

  var _supported = _interopRequireDefault(_framptonStyleSupported);

  /**
   * Returns an objec
   * @name transitionProps
   * @method
   * @private
   * @memberof Frampton.Motion
   * @param {Object} props
   * @returns {Object}
   */

  function transition_props(props) {
    var trans = {};
    trans[_supported['default']('transition-property')] = Object.keys(props).join(', ');
    return trans;
  }
});
define('frampton-motion/transition', ['exports', 'frampton-utils/assert', 'frampton-utils/immediate', 'frampton-utils/not', 'frampton-utils/is_empty', 'frampton-utils/is_something', 'frampton-utils/is_string', 'frampton-utils/is_object', 'frampton-utils/guid', 'frampton-utils/noop', 'frampton-utils/not_implemented', 'frampton-list/add', 'frampton-list/copy', 'frampton-list/remove', 'frampton-list/reverse', 'frampton-record/merge', 'frampton-style/set_style', 'frampton-style/apply_styles', 'frampton-style/remove_style', 'frampton-style/remove_styles', 'frampton-style/add_class', 'frampton-style/remove_class', 'frampton-events/on_event', 'frampton-motion/sequence', 'frampton-motion/transition_end', 'frampton-motion/reflow', 'frampton-motion/transition_props', 'frampton-motion/parsed_props', 'frampton-motion/parsed_timing', 'frampton-motion/update_transform', 'frampton-motion/normalized_frame'], function (exports, _framptonUtilsAssert, _framptonUtilsImmediate, _framptonUtilsNot, _framptonUtilsIs_empty, _framptonUtilsIs_something, _framptonUtilsIs_string, _framptonUtilsIs_object, _framptonUtilsGuid, _framptonUtilsNoop, _framptonUtilsNot_implemented, _framptonListAdd, _framptonListCopy, _framptonListRemove, _framptonListReverse, _framptonRecordMerge, _framptonStyleSet_style, _framptonStyleApply_styles, _framptonStyleRemove_style, _framptonStyleRemove_styles, _framptonStyleAdd_class, _framptonStyleRemove_class, _framptonEventsOn_event, _framptonMotionSequence, _framptonMotionTransition_end, _framptonMotionReflow, _framptonMotionTransition_props, _framptonMotionParsed_props, _framptonMotionParsed_timing, _framptonMotionUpdate_transform, _framptonMotionNormalized_frame) {
  'use strict';

  exports.__esModule = true;

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

  var _assert = _interopRequireDefault(_framptonUtilsAssert);

  var _immediate = _interopRequireDefault(_framptonUtilsImmediate);

  var _not = _interopRequireDefault(_framptonUtilsNot);

  var _isEmpty = _interopRequireDefault(_framptonUtilsIs_empty);

  var _isSomething = _interopRequireDefault(_framptonUtilsIs_something);

  var _isString = _interopRequireDefault(_framptonUtilsIs_string);

  var _isObject = _interopRequireDefault(_framptonUtilsIs_object);

  var _guid = _interopRequireDefault(_framptonUtilsGuid);

  var _noop = _interopRequireDefault(_framptonUtilsNoop);

  var _notImplemented = _interopRequireDefault(_framptonUtilsNot_implemented);

  var _add = _interopRequireDefault(_framptonListAdd);

  var _copyList = _interopRequireDefault(_framptonListCopy);

  var _remove = _interopRequireDefault(_framptonListRemove);

  var _reverse = _interopRequireDefault(_framptonListReverse);

  var _merge = _interopRequireDefault(_framptonRecordMerge);

  var _setStyle = _interopRequireDefault(_framptonStyleSet_style);

  var _applyStyles = _interopRequireDefault(_framptonStyleApply_styles);

  var _removeStyle = _interopRequireDefault(_framptonStyleRemove_style);

  var _removeStyles = _interopRequireDefault(_framptonStyleRemove_styles);

  var _addClass = _interopRequireDefault(_framptonStyleAdd_class);

  var _removeClass = _interopRequireDefault(_framptonStyleRemove_class);

  var _onEvent = _interopRequireDefault(_framptonEventsOn_event);

  var _sequence = _interopRequireDefault(_framptonMotionSequence);

  var _transitionend = _interopRequireDefault(_framptonMotionTransition_end);

  var _reflow = _interopRequireDefault(_framptonMotionReflow);

  var _transitionProps = _interopRequireDefault(_framptonMotionTransition_props);

  var _parsedProps = _interopRequireDefault(_framptonMotionParsed_props);

  var _parsedTiming = _interopRequireDefault(_framptonMotionParsed_timing);

  var _updateTransform = _interopRequireDefault(_framptonMotionUpdate_transform);

  var _normalizedFrame = _interopRequireDefault(_framptonMotionNormalized_frame);

  function inverseDirection(dir) {
    return dir === Transition.DIR_IN ? Transition.DIR_OUT : Transition.DIR_IN;
  }

  function resetState(transition) {
    transition.element.classList.remove('transition-' + Transition.WAITING);
    transition.element.classList.remove('transition-' + Transition.STARTED);
    transition.element.classList.remove('transition-' + Transition.RUNNING);
    transition.element.classList.remove('transition-' + Transition.CLEANUP);
    transition.element.classList.remove('transition-' + Transition.DONE);
  }

  function setState(transition, state) {
    if (transition.element) {
      resetState(transition);
      transition.element.classList.add('transition-' + state);
      transition.element.setAttribute('data-transition-state', state);
    }
    transition.state = state;
  }

  function setDirection(transition, dir) {
    if (transition.element) {
      transition.element.classList.remove(inverseDirection(dir));
      transition.element.classList.add(dir);
    }
    transition.direction = dir;
  }

  function once(fn) {
    var triggered = false;
    return function () {
      if (!triggered) {
        triggered = true;

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

        return fn.apply(null, args);
      }
    };
  }

  function endOnce(transition, fn) {
    _onEvent['default'](_transitionend['default'], transition.element).filter(function (evt) {
      return parseInt(evt.target.getAttribute('data-transition-id')) === transition.id;
    }).take(1).next(fn);
  }

  function defaultRun(resolve, child) {
    var _this = this;

    var complete = once(function () {
      setState(_this, Transition.CLEANUP);
      _reflow['default'](_this.element);
      setState(_this, Transition.DONE);
      _immediate['default'](function () {
        (resolve || _noop['default'])(_this.element);
      });
    });

    /**
     * Force a reflow of our element to make sure everything is prestine for us
     * to start fuckin' things up. Without doing this, some browsers will not have
     * the correct current state of our element in which to start the transition
     * from.
     */
    _reflow['default'](this.element);

    this.element.setAttribute('data-transition-id', this.id);

    endOnce(this, complete);

    setDirection(this, this.direction);

    _immediate['default'](function () {
      if (_this.direction === Transition.DIR_IN) {
        _this.classList.forEach(_addClass['default'](_this.element));
        if (_isSomething['default'](_this.frame)) {
          _applyStyles['default'](_this.element, _this.config);
          _reflow['default'](_this.element);
          _applyStyles['default'](_this.element, _this.supported);
        }
      } else {
        _this.classList.forEach(_removeClass['default'](_this.element));
        if (_isSomething['default'](_this.frame)) {
          _applyStyles['default'](_this.element, _this.config);
          _reflow['default'](_this.element);
          resolveStyles(_this.element, _this.supported, findChild(child, _this.element));
        }
      }
    });

    setState(this, Transition.RUNNING);
  }

  function findChild(child, element) {
    if (child && child.element) {
      return child;
    } else if (child) {
      if (child.name === Transition.WHEN) {
        for (var i = 0; i < child.list.length; i++) {
          if (child.list[i].element === element) {
            return child.list[i];
          }
        }
      } else if (child.name === Transition.CHAINED) {
        if (child.list[0].element === element) {
          return child.list[0];
        }
      }
    }
    return null;
  }

  function resolveStyles(element, frame, child) {
    if (child && child.direction === Transition.DIR_OUT && child.element === element) {
      for (var key in frame) {
        if (child.frame && child.frame[key]) {
          _setStyle['default'](element, key, child.frame[key]);
        } else {
          _removeStyle['default'](element, key);
        }
      }
    } else {
      _removeStyles['default'](element, frame);
    }
  }

  function withDefaultRun(element, list, frame, dir) {
    var trans = new Transition(element, list, frame, dir);
    trans.run = defaultRun;
    return trans;
  }

  function withFrame(transition, props) {

    var frame = _isSomething['default'](transition.frame) ? transition.frame : {};

    for (var key in props) {
      frame[key] = props[key];
    }

    return withDefaultRun(transition.element, _copyList['default'](transition.classList), frame, transition.direction);
  }

  /**
   * @name Transition
   * @class
   * @private
   * @memberof Frampton.Motion
   * @param {Object} [element=null]        DomNode to transition
   * @param {String} [list='']             Space-separated list of classes to add
   * @param {Object} [frame={}]            Hash of props to add to element
   * @param {String} [dir='transition-in'] Direction to run transition
   */
  function Transition(element, list, frame, dir) {

    _assert['default']('Browser does not support CSS transitions', _isSomething['default'](_transitionend['default']));

    this.id = _guid['default']();
    this.name = Transition.NORMAL;
    this.element = _isSomething['default'](element) ? element : null;
    this.direction = _isSomething['default'](dir) ? dir : Transition.DIR_IN;
    this.frame = _isSomething['default'](frame) ? _normalizedFrame['default'](frame) : null;
    this.config = null;
    this.supported = null;
    this.classList = (_isSomething['default'](list) ? list : []).filter(_not['default'](_isEmpty['default']));
    this.state = Transition.WAITING;
    this.list = [this];

    if (_isObject['default'](this.frame)) {
      this.supported = _parsedProps['default'](this.frame);
      this.config = _merge['default'](_parsedTiming['default'](this.frame), _transitionProps['default'](this.supported));
    }

    setState(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 = _notImplemented['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': _isString['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': _isString['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: _isString['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: _isString['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: _isString['default'](width) ? width : width + 'px',
      height: _isString['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: _isString['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: _isString['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: _isString['default'](left) ? left : left + 'px',
      left: _isString['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: _updateTransform['default'](_isSomething['default'](this.frame) ? this.frame['transform'] : null, 'translateX', _isString['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: _updateTransform['default'](_isSomething['default'](this.frame) ? this.frame['transform'] : null, 'translateY', _isString['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: _updateTransform['default'](_isSomething['default'](this.frame) ? this.frame['transform'] : null, 'translateZ', _isString['default'](distance) ? distance : distance + 'px')
    });
  };

  /**
   * @name rotate
   * @method
   * @memberof Frampton.Motion.Transition#
   * @param {Number} degrees
   * @returns {Frampton.Motion.Transition}
   */
  Transition.prototype.rotate = function Transition_translateZ(degrees) {
    return withFrame(this, {
      transform: _updateTransform['default'](_isSomething['default'](this.frame) ? this.frame['transform'] : null, 'rotate', _isString['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: _updateTransform['default'](_isSomething['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) {
    return withDefaultRun(this.element, _add['default'](this.classList, name), _isSomething['default'](this.frame) ? this.frame : null, 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) {
    return withDefaultRun(this.element, _remove['default'](this.classList, name), _isSomething['default'](this.frame) ? this.frame : null, this.direction);
  };

  /**
   * @name reverse
   * @method
   * @memberof Frampton.Motion.Transition#
   * @returns {Frampton.Motion.Transition}
   */
  Transition.prototype.reverse = function Transition_reverse() {
    return withDefaultRun(this.element, _copyList['default'](this.classList), _isSomething['default'](this.frame) ? this.frame : null, inverseDirection(this.direction));
  };

  /**
   * @name reverse
   * @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 = _add['default'](this.list, child);

    trans.run = function chain_run(resolve, next) {
      saved(function () {
        child.run(resolve, next);
      }, child);
    };

    trans.reverse = function chain_reverse() {
      return _sequence['default'].apply(null, _reverse['default'](trans.list).map(function (next) {
        return next.reverse();
      }));
    };

    return trans;
  };

  Transition.WAITING = 'waiting';
  Transition.STARTED = 'started';
  Transition.RUNNING = 'running';
  Transition.DONE = 'done';
  Transition.CLEANUP = 'cleanup';
  Transition.DIR_IN = 'transition-in';
  Transition.DIR_OUT = 'transition-out';
  Transition.NORMAL = 'normal';
  Transition.CHAINED = 'chained';
  Transition.WHEN = 'when';

  /**
   * @name describe
   * @method
   * @memberof Frampton.Motion
   * @param {Object}  element DomNode to transition
   * @param {String}  name    Class name to add for transition, separate multiple classes with spaces ('class1 class2')
   * @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, name, frame, dir) {

    if (_isObject['default'](name)) {
      dir = frame;
      frame = name;
      name = null;
    }

    return withDefaultRun(element, _isString['default'](name) ? name.split(' ') : null, _isObject['default'](frame) ? frame : null, dir === false ? Transition.DIR_OUT : Transition.DIR_IN);
  }

  exports.Transition = Transition;
  exports.describe = describe;
});
define('frampton-motion/transitions', ['exports', 'module'], function (exports, module) {
  'use strict';

  module.exports = ['transition-delay', 'transition-duration', 'transition-property', 'transition-timing-function'];
});
define('frampton-motion/update_transform', ['exports', 'module', 'frampton-utils/is_string', 'frampton-string/contains'], function (exports, module, _framptonUtilsIs_string, _framptonStringContains) {
  'use strict';

  module.exports = updateTransform;

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

  var _isString = _interopRequireDefault(_framptonUtilsIs_string);

  var _contains = _interopRequireDefault(_framptonStringContains);

  function propValue(prop, value) {
    return prop + '(' + value + ')';
  }

  /**
   * @name updateTransform
   * @method
   * @private
   * @memberof Frampton.Motion
   * @param {String} transform
   * @param {String} prop
   * @param {String|Number} value
   * @returns {String}
   */

  function updateTransform(transform, prop, value) {
    var reg;
    transform = (_isString['default'](transform) ? transform : '').trim();

    if (_contains['default'](prop, transform)) {
      reg = new RegExp(prop + "\\([^)]*\\)");
      if (_isString['default'](value) && value.trim() !== '') {
        transform = transform.replace(reg, propValue(prop, value));
      } else {
        transform = transform.replace(reg, '').replace('  ', ' ');
      }
    } else {
      if (transform.length > 0) {
        transform = transform + ' ';
      }
      transform = transform + propValue(prop, value);
    }
    return transform.trim();
  }
});
define('frampton-motion/when', ['exports', 'module', 'frampton-utils/noop', 'frampton-motion/transition'], function (exports, module, _framptonUtilsNoop, _framptonMotionTransition) {
  'use strict';

  module.exports = when;

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

  var _noop = _interopRequireDefault(_framptonUtilsNoop);

  /**
   * 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 _framptonMotionTransition.Transition();
    transition.name = _framptonMotionTransition.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 len = transitions.length;

      var _loop = function (i) {
        transitions[i].run(function () {
          if (i === len - 1) {
            (resolve || _noop['default'])();
          }
        }, child);
      };

      for (var i = 0; i < len; i++) {
        _loop(i);
      }
    };

    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;

}());
define('frampton-dom', ['exports', 'frampton/namespace', 'frampton-dom/diff', 'frampton-dom/update', 'frampton-dom/html/dom'], function (exports, _framptonNamespace, _framptonDomDiff, _framptonDomUpdate, _framptonDomHtmlDom) {
  'use strict';

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

  var _Frampton = _interopRequireDefault(_framptonNamespace);

  var _diff = _interopRequireDefault(_framptonDomDiff);

  var _update = _interopRequireDefault(_framptonDomUpdate);

  /**
   * @name DOM
   * @namespace
   * @memberof Frampton
   */
  _Frampton['default'].DOM = {};
  _Frampton['default'].DOM.VERSION = '0.0.5';
  _Frampton['default'].DOM.diff = _diff['default'];
  _Frampton['default'].DOM.update = _update['default'];

  /**
   * @name Html
   * @namespace
   * @memberof Frampton.DOM
   */
  _Frampton['default'].DOM.Html = {};
  // PRIMITIVES
  _Frampton['default'].DOM.Html.node = _framptonDomHtmlDom.node;
  _Frampton['default'].DOM.Html.text = _framptonDomHtmlDom.text;
  // BASICS
  _Frampton['default'].DOM.Html.div = _framptonDomHtmlDom.div;
  _Frampton['default'].DOM.Html.span = _framptonDomHtmlDom.span;
  _Frampton['default'].DOM.Html.p = _framptonDomHtmlDom.p;
  _Frampton['default'].DOM.Html.a = _framptonDomHtmlDom.a;
  // SEMANTIC
  _Frampton['default'].DOM.Html.header = _framptonDomHtmlDom.header;
  _Frampton['default'].DOM.Html.footer = _framptonDomHtmlDom.footer;
  _Frampton['default'].DOM.Html.article = _framptonDomHtmlDom.article;
  _Frampton['default'].DOM.Html.section = _framptonDomHtmlDom.section;
  _Frampton['default'].DOM.Html.aside = _framptonDomHtmlDom.aside;
  _Frampton['default'].DOM.Html.main = _framptonDomHtmlDom.main;
  _Frampton['default'].DOM.Html.nav = _framptonDomHtmlDom.nav;
  _Frampton['default'].DOM.Html.menu = _framptonDomHtmlDom.menu;
  _Frampton['default'].DOM.Html.menuitem = _framptonDomHtmlDom.menuitem;
  _Frampton['default'].DOM.Html.address = _framptonDomHtmlDom.address;
  _Frampton['default'].DOM.Html.summary = _framptonDomHtmlDom.summary;
  _Frampton['default'].DOM.Html.details = _framptonDomHtmlDom.details;
  _Frampton['default'].DOM.Html.progress = _framptonDomHtmlDom.progress;
  // LISTS
  _Frampton['default'].DOM.Html.ul = _framptonDomHtmlDom.ul;
  _Frampton['default'].DOM.Html.ol = _framptonDomHtmlDom.ol;
  _Frampton['default'].DOM.Html.li = _framptonDomHtmlDom.li;
  // DESCRIPTION LISTS
  _Frampton['default'].DOM.Html.dl = _framptonDomHtmlDom.dl;
  _Frampton['default'].DOM.Html.dt = _framptonDomHtmlDom.dt;
  _Frampton['default'].DOM.Html.dd = _framptonDomHtmlDom.dd;
  // HEADINGS
  _Frampton['default'].DOM.Html.h1 = _framptonDomHtmlDom.h1;
  _Frampton['default'].DOM.Html.h2 = _framptonDomHtmlDom.h2;
  _Frampton['default'].DOM.Html.h3 = _framptonDomHtmlDom.h3;
  _Frampton['default'].DOM.Html.h4 = _framptonDomHtmlDom.h4;
  _Frampton['default'].DOM.Html.h5 = _framptonDomHtmlDom.h5;
  _Frampton['default'].DOM.Html.h6 = _framptonDomHtmlDom.h6;
  // FORMATTING
  _Frampton['default'].DOM.Html.strong = _framptonDomHtmlDom.strong;
  _Frampton['default'].DOM.Html.em = _framptonDomHtmlDom.em;
  _Frampton['default'].DOM.Html.pre = _framptonDomHtmlDom.pre;
  _Frampton['default'].DOM.Html.code = _framptonDomHtmlDom.code;
  // FORMS
  _Frampton['default'].DOM.Html.legend = _framptonDomHtmlDom.legend;
  _Frampton['default'].DOM.Html.fieldset = _framptonDomHtmlDom.fieldset;
  _Frampton['default'].DOM.Html.input = _framptonDomHtmlDom.input;
  _Frampton['default'].DOM.Html.button = _framptonDomHtmlDom.button;
  _Frampton['default'].DOM.Html.textarea = _framptonDomHtmlDom.textarea;
  _Frampton['default'].DOM.Html.option = _framptonDomHtmlDom.option;
  _Frampton['default'].DOM.Html.optgroup = _framptonDomHtmlDom.optgroup;
  _Frampton['default'].DOM.Html.select = _framptonDomHtmlDom.select;
  // MEDIA
  _Frampton['default'].DOM.Html.figure = _framptonDomHtmlDom.figure;
  _Frampton['default'].DOM.Html.img = _framptonDomHtmlDom.img;
  _Frampton['default'].DOM.Html.video = _framptonDomHtmlDom.video;
  _Frampton['default'].DOM.Html.audio = _framptonDomHtmlDom.audio;
  _Frampton['default'].DOM.Html.source = _framptonDomHtmlDom.source;
  _Frampton['default'].DOM.Html.figcaption = _framptonDomHtmlDom.figcaption;
  // TABLES
  _Frampton['default'].DOM.Html.table = _framptonDomHtmlDom.table;
  _Frampton['default'].DOM.Html.thead = _framptonDomHtmlDom.thead;
  _Frampton['default'].DOM.Html.tbody = _framptonDomHtmlDom.tbody;
  _Frampton['default'].DOM.Html.tfoot = _framptonDomHtmlDom.tfoot;
  _Frampton['default'].DOM.Html.tr = _framptonDomHtmlDom.tr;
  _Frampton['default'].DOM.Html.td = _framptonDomHtmlDom.td;
  _Frampton['default'].DOM.Html.col = _framptonDomHtmlDom.col;
  _Frampton['default'].DOM.Html.colgroup = _framptonDomHtmlDom.colgroup;
  _Frampton['default'].DOM.Html.caption = _framptonDomHtmlDom.caption;
});
define('frampton-dom/diff', ['exports', 'module', '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, module, _framptonUtilsIs_defined, _framptonUtilsIs_undefined, _framptonUtilsIs_something, _framptonUtilsWarn, _framptonMathMax, _framptonDomVirtualPatch, _framptonDomUtilsIs_node, _framptonDomUtilsIs_text, _framptonDomUtilsProps_diff, _framptonDomUtilsIs_same_node) {
  'use strict';

  module.exports = diff;

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

  var _isDefined = _interopRequireDefault(_framptonUtilsIs_defined);

  var _isUndefined = _interopRequireDefault(_framptonUtilsIs_undefined);

  var _isSomething = _interopRequireDefault(_framptonUtilsIs_something);

  var _warn = _interopRequireDefault(_framptonUtilsWarn);

  var _max = _interopRequireDefault(_framptonMathMax);

  var _isNode = _interopRequireDefault(_framptonDomUtilsIs_node);

  var _isText = _interopRequireDefault(_framptonDomUtilsIs_text);

  var _propsDiff = _interopRequireDefault(_framptonDomUtilsProps_diff);

  var _isSameNode = _interopRequireDefault(_framptonDomUtilsIs_same_node);

  function indexesMatch(oldIndex, newIndex) {
    return _isDefined['default'](oldIndex) && _isDefined['default'](newIndex) && oldIndex === newIndex;
  }

  function diffTrees(oldTree, newTree) {
    var patch, newPatch;
    if (oldTree === newTree) {
      return;
    } else if (_isNode['default'](newTree)) {
      if (_isNode['default'](oldTree)) {
        if (_isSameNode['default'](oldTree, newTree)) {
          var pDiff = _propsDiff['default'](oldTree, newTree);
          if (_isSomething['default'](pDiff)) {
            newPatch = _framptonDomVirtualPatch.props(null, pDiff);
          }
          patch = diffChildren(oldTree, newTree);
        } else {
          newPatch = _framptonDomVirtualPatch.replace(oldTree, newTree);
        }
      } else {
        newPatch = _framptonDomVirtualPatch.insert(null, newTree);
      }
    } 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 nLength = newChildren.length;
    var oLength = oldChildren.length;
    var len = _max['default'](oLength, nLength);
    var orderMap = [];
    var inserts = [];
    var newKeys = {};
    var oldKeys = {};
    var dirty = false;
    var parentPatch = undefined;

    // Create a map of keys to their new index
    for (var i = 0; i < nLength; i++) {
      var child = newChildren[i];
      if (_isNode['default'](child)) {
        var key = child.key;
        if (key) {
          newKeys[key] = i;
        }
      }
    }

    // Create a map of keys to their old index
    for (var i = 0; i < oLength; i++) {
      var child = oldChildren[i];
      if (_isNode['default'](child)) {
        var key = child.key;
        if (key) {
          oldKeys[key] = i;
        }
      }
    }

    for (var i = 0; i < len; i++) {
      var oldChild = oldChildren[i];
      var newChild = newChildren[i];
      var newIndex = undefined;
      var oldIndex = undefined;
      var newPatch = undefined;
      var patch = undefined;

      // We have a new node
      if (_isNode['default'](newChild)) {

        // Index of new node in previous DOM
        oldIndex = oldKeys[newChild.key];

        // We have an old node
        if (_isNode['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[i] = i;
            var pDiff = _propsDiff['default'](oldChild, newChild);
            if (_isSomething['default'](pDiff)) {
              newPatch = _framptonDomVirtualPatch.props(null, pDiff);
            }
            patch = diffChildren(oldChild, newChild);
          } else {

            // Old node has no new index, delete it
            if (_isUndefined['default'](newIndex)) {
              dirty = true;
              if (oldChild.attributes.transitionOut) {
                orderMap[i] = _framptonDomVirtualPatch.remove(null, oldChild.attributes.transitionOut);
              } else {
                orderMap[i] = undefined;
              }

              // The index changed, we have a move
            } else if (newIndex !== i) {
                dirty = true;
                orderMap[i] = newIndex;
                var pDiff = _propsDiff['default'](oldChild, newChildren[newIndex]);
                if (_isSomething['default'](pDiff)) {
                  newPatch = _framptonDomVirtualPatch.props(null, pDiff);
                }
                patch = diffChildren(oldChild, newChildren[newIndex]);
              }

            // The new node is an insert
            if (_isUndefined['default'](oldIndex)) {
              inserts[i] = _framptonDomVirtualPatch.insert(null, newChild);
            }
          }

          // We have no old node, or it is text
        } else if (_isUndefined['default'](oldIndex)) {
            dirty = true;
            orderMap[i] = undefined;
            inserts[i] = _framptonDomVirtualPatch.insert(null, newChild);
          }

        // New node is text
      } else if (_isText['default'](newChild)) {

          // Old node was text
          if (_isText['default'](oldChild)) {

            // Text nodes are the same if they have same text, duh.
            if (oldChild.text !== newChild.text) {
              orderMap[i] = i;
              newPatch = _framptonDomVirtualPatch.text(oldChild, newChild.text);

              // Yup, the same.
            } else {
                orderMap[i] = i;
              }

            // Old node was a node
          } else if (_isNode['default'](oldChild)) {
              dirty = true;
              newIndex = newKeys[oldChild.key];

              // Old node was deleted
              if (_isUndefined['default'](newIndex)) {
                if (oldChild.attributes.transitionOut) {
                  orderMap[i] = _framptonDomVirtualPatch.remove(null, oldChild.attributes.transitionOut);
                } else {
                  orderMap[i] = undefined;
                }

                // Old node was moved
              } else if (newIndex !== i) {
                  orderMap[i] = newIndex;
                  var pDiff = _propsDiff['default'](oldChild, newChildren[newIndex]);
                  if (_isSomething['default'](pDiff)) {
                    newPatch = _framptonDomVirtualPatch.props(null, pDiff);
                  }
                  patch = diffChildren(oldChild, newChildren[newIndex]);

                  // Shouldn't happen
                } else {
                    _warn['default']('Should not get here, new node is text');
                  }

              inserts[i] = _framptonDomVirtualPatch.insert(null, newChild);

              // No old node, straight insert
            } else {
                inserts[i] = _framptonDomVirtualPatch.insert(null, newChild);
              }

          // If there is no new node here, index is vacant
        } else {

            // This is going to be dirty somehow
            dirty = true;

            if (_isDefined['default'](newKeys)) {
              // Index of old node in new DOM
              newIndex = newKeys[oldChild.key];

              if (_isDefined['default'](newIndex)) {
                dirty = true;
                orderMap[i] = newIndex;
                var pDiff = _propsDiff['default'](oldChild, newChildren[newIndex]);
                if (_isSomething['default'](pDiff)) {
                  newPatch = _framptonDomVirtualPatch.props(null, pDiff);
                }
                patch = diffChildren(oldChild, newChildren[newIndex]);
              } else {
                if (oldChild.attributes.transitionOut) {
                  orderMap[i] = _framptonDomVirtualPatch.remove(null, oldChild.attributes.transitionOut);
                } else {
                  orderMap[i] = undefined;
                }
              }
            } else {
              if (oldChild.attributes.transitionOut) {
                orderMap[i] = _framptonDomVirtualPatch.remove(null, oldChild.attributes.transitionOut);
              } else {
                orderMap[i] = undefined;
              }
            }
          }

      if (newPatch) {
        patch = patch || [];
        patch._p = newPatch;
      }

      if (patch) {
        parentPatch = parentPatch || [];
        parentPatch[i] = patch;
      }
    }

    if (dirty) {
      parentPatch = parentPatch || [];
      parentPatch._o = _framptonDomVirtualPatch.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/event_dispatcher', ['exports', 'frampton-utils/immediate', 'frampton-dom/events/event_map', 'frampton-dom/events/utils/node_gate'], function (exports, _framptonUtilsImmediate, _framptonDomEventsEvent_map, _framptonDomEventsUtilsNode_gate) {
  'use strict';

  exports.__esModule = true;
  exports.addEvent = addEvent;
  exports.removeEvent = removeEvent;

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

  var _immediate = _interopRequireDefault(_framptonUtilsImmediate);

  var _EVENT_MAP = _interopRequireDefault(_framptonDomEventsEvent_map);

  var _nodeGate = _interopRequireDefault(_framptonDomEventsUtilsNode_gate);

  /**
   * @name addEvent
   * @method
   * @memberof Frampton.DOM.events
   * @private
   * @param {String} name
   * @param {Element} node
   * @param {Function} handler
   */

  function addEvent(name, node, handler) {
    name = _EVENT_MAP['default'][name] || name;
    _immediate['default'](function () {

      // Transitionend events will not be fired for child nodes. The event must occur on this node.
      if (name === 'transitionend') {
        handler = _nodeGate['default'](node, handler);
      }

      node['on' + name] = handler;
    });
  }

  /**
   * @name removeEvent
   * @method
   * @memberof Frampton.DOM.events
   * @private
   * @param {String} name
   * @param {Element} node
   */

  function removeEvent(name, node) {
    name = _EVENT_MAP['default'][name] || name;
    _immediate['default'](function () {
      node['on' + name] = null;
    });
  }
});
define('frampton-dom/events/event_map', ['exports', 'module'], function (exports, module) {
  /**
   * Mappind of attribute handlers to event name.
   * @name eventMap
   */
  'use strict';

  module.exports = {
    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/utils/is_event', ['exports', 'module', 'frampton-utils/is_something', 'frampton-dom/events/event_map'], function (exports, module, _framptonUtilsIs_something, _framptonDomEventsEvent_map) {
  'use strict';

  module.exports = is_event;

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

  var _isSomething = _interopRequireDefault(_framptonUtilsIs_something);

  var _EVENT_MAP = _interopRequireDefault(_framptonDomEventsEvent_map);

  function is_event(name) {
    return _isSomething['default'](_EVENT_MAP['default'][name]);
  }
});
define("frampton-dom/events/utils/node_gate", ["exports", "module"], function (exports, module) {
  /**
   *  Only allow an event through if it's target is the given node
   */
  "use strict";

  module.exports = node_gate;

  function node_gate(node, fn) {
    return function (evt) {
      if (evt.target === node) {
        fn(evt);
      }
    };
  }
});
define('frampton-dom/html/dom', ['exports', 'frampton-dom/virtual/node', 'frampton-dom/virtual/text'], function (exports, _framptonDomVirtualNode, _framptonDomVirtualText) {
  'use strict';

  exports.__esModule = true;

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

  var _vnode = _interopRequireDefault(_framptonDomVirtualNode);

  var _vtext = _interopRequireDefault(_framptonDomVirtualText);

  // GENERIC DOM NODE

  var node = function node(name, attrs, children) {
    return _vnode['default'](name, attrs, children);
  };

  exports.node = node;
  // TEXT NODE

  var text = function text(value) {
    return _vtext['default'](value);
  };

  exports.text = text;
  // BASIC TAGS

  var div = function div(attrs, children) {
    return _vnode['default']('div', attrs, children);
  };

  exports.div = div;
  var span = function span(attrs, children) {
    return _vnode['default']('span', attrs, children);
  };

  exports.span = span;
  var p = function p(attrs, children) {
    return _vnode['default']('p', attrs, children);
  };

  exports.p = p;
  var a = function a(attrs, children) {
    return _vnode['default']('a', attrs, children);
  };

  exports.a = a;
  // SEMANTIC

  var header = function header(attrs, children) {
    return _vnode['default']('header', attrs, children);
  };

  exports.header = header;
  var footer = function footer(attrs, children) {
    return _vnode['default']('footer', attrs, children);
  };

  exports.footer = footer;
  var article = function article(attrs, children) {
    return _vnode['default']('article', attrs, children);
  };

  exports.article = article;
  var section = function section(attrs, children) {
    return _vnode['default']('section', attrs, children);
  };

  exports.section = section;
  var aside = function aside(attrs, children) {
    return _vnode['default']('aside', attrs, children);
  };

  exports.aside = aside;
  var main = function main(attrs, children) {
    return _vnode['default']('main', attrs, children);
  };

  exports.main = main;
  var nav = function nav(attrs, children) {
    return _vnode['default']('nav', attrs, children);
  };

  exports.nav = nav;
  var menu = function menu(attrs, children) {
    return _vnode['default']('menu', attrs, children);
  };

  exports.menu = menu;
  var menuitem = function menuitem(attrs, children) {
    return _vnode['default']('menuitem', attrs, children);
  };

  exports.menuitem = menuitem;
  var address = function address(attrs, children) {
    return _vnode['default']('address', attrs, children);
  };

  exports.address = address;
  var summary = function summary(attrs, children) {
    return _vnode['default']('summary', attrs, children);
  };

  exports.summary = summary;
  var details = function details(attrs, children) {
    return _vnode['default']('details', attrs, children);
  };

  exports.details = details;
  var progress = function progress(attrs, children) {
    return _vnode['default']('progress', attrs, children);
  };

  exports.progress = progress;
  // HEADINGS

  var h1 = function h1(attrs, children) {
    return _vnode['default']('h1', attrs, children);
  };

  exports.h1 = h1;
  var h2 = function h2(attrs, children) {
    return _vnode['default']('h2', attrs, children);
  };

  exports.h2 = h2;
  var h3 = function h3(attrs, children) {
    return _vnode['default']('h3', attrs, children);
  };

  exports.h3 = h3;
  var h4 = function h4(attrs, children) {
    return _vnode['default']('h4', attrs, children);
  };

  exports.h4 = h4;
  var h5 = function h5(attrs, children) {
    return _vnode['default']('h5', attrs, children);
  };

  exports.h5 = h5;
  var h6 = function h6(attrs, children) {
    return _vnode['default']('h6', attrs, children);
  };

  exports.h6 = h6;
  // LISTS

  var ul = function ul(attrs, children) {
    return _vnode['default']('ul', attrs, children);
  };

  exports.ul = ul;
  var ol = function ol(attrs, children) {
    return _vnode['default']('ol', attrs, children);
  };

  exports.ol = ol;
  var li = function li(attrs, children) {
    return _vnode['default']('li', attrs, children);
  };

  exports.li = li;
  // DESCRIPTION LISTS

  var dl = function dl(attrs, children) {
    return _vnode['default']('dl', attrs, children);
  };

  exports.dl = dl;
  var dt = function dt(attrs, children) {
    return _vnode['default']('dt', attrs, children);
  };

  exports.dt = dt;
  var dd = function dd(attrs, children) {
    return _vnode['default']('dd', attrs, children);
  };

  exports.dd = dd;
  // MEDIA

  var img = function img(attrs, children) {
    return _vnode['default']('img', attrs, children);
  };

  exports.img = img;
  var video = function video(attrs, children) {
    return _vnode['default']('video', attrs, children);
  };

  exports.video = video;
  var audio = function audio(attrs, children) {
    return _vnode['default']('audio', attrs, children);
  };

  exports.audio = audio;
  var source = function source(attrs, children) {
    return _vnode['default']('source', attrs, children);
  };

  exports.source = source;
  var figure = function figure(attrs, children) {
    return _vnode['default']('figure', attrs, children);
  };

  exports.figure = figure;
  var figcaption = function figcaption(attrs, children) {
    return _vnode['default']('figcaption', attrs, children);
  };

  exports.figcaption = figcaption;
  // FORMS

  var legend = function legend(attrs, children) {
    return _vnode['default']('legend', attrs, children);
  };

  exports.legend = legend;
  var fieldset = function fieldset(attrs, children) {
    return _vnode['default']('fieldset', attrs, children);
  };

  exports.fieldset = fieldset;
  var option = function option(attrs, children) {
    return _vnode['default']('option', attrs, children);
  };

  exports.option = option;
  var optgroup = function optgroup(attrs, children) {
    return _vnode['default']('optgroup', attrs, children);
  };

  exports.optgroup = optgroup;
  var label = function label(attrs, children) {
    return _vnode['default']('label', attrs, children);
  };

  exports.label = label;
  var button = function button(attrs, children) {
    return _vnode['default']('button', attrs, children);
  };

  exports.button = button;
  var select = function select(attrs, children) {
    return _vnode['default']('select', attrs, children);
  };

  exports.select = select;
  var input = function input(attrs, children) {
    return _vnode['default']('input', attrs, children);
  };

  exports.input = input;
  var textarea = function textarea(attrs, children) {
    return _vnode['default']('textarea', attrs, children);
  };

  exports.textarea = textarea;
  // FORMATTING

  var pre = function pre(attrs, children) {
    return _vnode['default']('pre', attrs, children);
  };

  exports.pre = pre;
  var code = function code(attrs, children) {
    return _vnode['default']('code', attrs, children);
  };

  exports.code = code;
  var strong = function strong(attrs, children) {
    return _vnode['default']('strong', attrs, children);
  };

  exports.strong = strong;
  var em = function em(attrs, children) {
    return _vnode['default']('em', attrs, children);
  };

  exports.em = em;
  // TABLES

  var table = function table(attrs, children) {
    return _vnode['default']('table', attrs, children);
  };

  exports.table = table;
  var caption = function caption(attrs, children) {
    return _vnode['default']('caption', attrs, children);
  };

  exports.caption = caption;
  var tbody = function tbody(attrs, children) {
    return _vnode['default']('tbody', attrs, children);
  };

  exports.tbody = tbody;
  var thead = function thead(attrs, children) {
    return _vnode['default']('thead', attrs, children);
  };

  exports.thead = thead;
  var tfoot = function tfoot(attrs, children) {
    return _vnode['default']('tfoot', attrs, children);
  };

  exports.tfoot = tfoot;
  var col = function col(attrs, children) {
    return _vnode['default']('col', attrs, children);
  };

  exports.col = col;
  var colgroup = function colgroup(attrs, children) {
    return _vnode['default']('colgroup', attrs, children);
  };

  exports.colgroup = colgroup;
  var th = function th(attrs, children) {
    return _vnode['default']('th', attrs, children);
  };

  exports.th = th;
  var tr = function tr(attrs, children) {
    return _vnode['default']('tr', attrs, children);
  };

  exports.tr = tr;
  var td = function td(attrs, children) {
    return _vnode['default']('td', attrs, children);
  };
  exports.td = td;
});
define('frampton-dom/ops/apply_attributes', ['exports', 'module', 'frampton-utils/is_nothing', 'frampton-utils/is_object', 'frampton-utils/warn', 'frampton-list/contains', 'frampton-style/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/event_dispatcher'], function (exports, module, _framptonUtilsIs_nothing, _framptonUtilsIs_object, _framptonUtilsWarn, _framptonListContains, _framptonStyleApply_styles, _framptonDomOpsApply_classes, _framptonDomUtilsValidated_class, _framptonDomUtilsValidated_transition, _framptonDomOpsApply_transition, _framptonDomEventsUtilsIs_event, _framptonDomEventsEvent_dispatcher) {
  'use strict';

  module.exports = apply_attributes;

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

  var _isNothing = _interopRequireDefault(_framptonUtilsIs_nothing);

  var _isObject = _interopRequireDefault(_framptonUtilsIs_object);

  var _warn = _interopRequireDefault(_framptonUtilsWarn);

  var _contains = _interopRequireDefault(_framptonListContains);

  var _applyStyles = _interopRequireDefault(_framptonStyleApply_styles);

  var _applyClasses = _interopRequireDefault(_framptonDomOpsApply_classes);

  var _validatedClass = _interopRequireDefault(_framptonDomUtilsValidated_class);

  var _validatedTransition = _interopRequireDefault(_framptonDomUtilsValidated_transition);

  var _applyTransition = _interopRequireDefault(_framptonDomOpsApply_transition);

  var _isEvent = _interopRequireDefault(_framptonDomEventsUtilsIs_event);

  // Properties to not add to DOM node
  var properties = ['key', 'transitionIn', 'transitionOut'];

  /**
   * @name applyAttributes
   * @param {Element} node Dom element to apply attributes to
   * @param {Object} attrs Hash of attributes to apply
   */

  function apply_attributes(node, attrs) {
    for (var _name in attrs) {
      var value = attrs[_name];
      if (_isNothing['default'](value)) {
        if (_isEvent['default'](_name)) {
          _framptonDomEventsEvent_dispatcher.removeEvent(_name, node);
        } else {
          node.removeAttribute(_name);
        }
      } else {
        if (_name === 'style') {
          if (_isObject['default'](value)) {
            _applyStyles['default'](node, value);
          } else {
            _warn['default']('Style attribute is not an object');
          }
        } else if (_name === 'transition') {
          _applyTransition['default'](node, _validatedTransition['default'](value));
        } else if (_name === 'class') {
          _applyClasses['default'](node, _validatedClass['default'](value));
        } else if (_isEvent['default'](_name)) {
          _framptonDomEventsEvent_dispatcher.addEvent(_name, node, value);
        } else if (!_contains['default'](properties, _name)) {
          node.setAttribute(_name, value);
        }
      }
    }
  }
});
define("frampton-dom/ops/apply_classes", ["exports", "module"], function (exports, module) {
  "use strict";

  module.exports = apply_classes;

  function apply_classes(node, diff) {
    if (diff.remove && diff.remove.length > 0) {
      var _node$classList;

      (_node$classList = node.classList).remove.apply(_node$classList, diff.remove);
    }

    if (diff.add && diff.add.length > 0) {
      var _node$classList2;

      (_node$classList2 = node.classList).add.apply(_node$classList2, diff.add);
    }
  }
});
define('frampton-dom/ops/apply_patch', ['exports', 'module', 'frampton-utils/is_defined', 'frampton-dom/virtual/patch_types', 'frampton-dom/ops/apply_attributes', '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'], function (exports, module, _framptonUtilsIs_defined, _framptonDomVirtualPatch_types, _framptonDomOpsApply_attributes, _framptonDomOpsRemove_node, _framptonDomOpsReplace_node, _framptonDomOpsReorder_nodes, _framptonDomOpsInsert_node, _framptonDomOpsUpdate_text) {
  'use strict';

  module.exports = apply_patch;

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

  var _isDefined = _interopRequireDefault(_framptonUtilsIs_defined);

  var _PATCHES = _interopRequireDefault(_framptonDomVirtualPatch_types);

  var _applyAttributes = _interopRequireDefault(_framptonDomOpsApply_attributes);

  var _removeNode = _interopRequireDefault(_framptonDomOpsRemove_node);

  var _replaceNode = _interopRequireDefault(_framptonDomOpsReplace_node);

  var _reorderNodes = _interopRequireDefault(_framptonDomOpsReorder_nodes);

  var _insertNode = _interopRequireDefault(_framptonDomOpsInsert_node);

  var _updateText = _interopRequireDefault(_framptonDomOpsUpdate_text);

  function executePatch(patch, parentNode, currentNode) {
    var type = patch.type;
    var update = patch.update;
    switch (patch.type) {
      case _PATCHES['default'].NONE:
        break;
      case _PATCHES['default'].APPEND:
        return _insertNode['default'](parentNode, null, update);
      case _PATCHES['default'].INSERT:
        return _insertNode['default'](parentNode, currentNode, update);
      case _PATCHES['default'].REMOVE:
        return _removeNode['default'](currentNode);
      case _PATCHES['default'].REPLACE:
        return _replaceNode['default'](currentNode, update);
      case _PATCHES['default'].PROPS:
        return _applyAttributes['default'](currentNode, update);
      case _PATCHES['default'].TEXT:
        return _updateText['default'](currentNode, update);
      case _PATCHES['default'].REORDER:
        return _reorderNodes['default'](parentNode, currentNode, update);
      default:
        throw new Error('Unrecognized patch type: ' + type);
    }
  }

  function isNumeric(obj) {
    return !isNaN(obj);
  }

  function nodeAtIndex(node, index) {
    if (node && node.childNodes) {
      return node.childNodes[index] || null;
    } else {
      return null;
    }
  }

  /**
   * Nodes that are transitioning out should just be removed to get us in a good
   * state before performing the next set of updates.
   */
  function resetChildState(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 (_isDefined['default'](child) && child.nodeType === 1 && child.getAttribute('data-transition-out') === 'true') {
          _removeNode['default'](child);
        }
      }
    }
  }

  function performInserts(current, patches) {

    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 (!isNaN(key)) {
        var update = patches[key];
        executePatch(update, current, arr[key - cursor]);
        if (update.type === _PATCHES['default'].INSERT) {
          cursor += 1;
        }
      }
    }
  }

  /**
   * @name applyPatch
   * @param {Array} patch
   * @param {Element} parent
   * @param {Element} current
   */

  function apply_patch(patch, parent, current) {

    resetChildState(current);

    // Apply patches to child nodes
    for (var key in patch) {
      if (isNumeric(key)) {
        var child = nodeAtIndex(current, key);
        apply_patch(patch[key], current, child);
      }
    }

    // Reorder child nodes
    if (patch._o) {
      executePatch(patch._o, parent, current);
    }

    // Insert new nodes
    if (patch._i) {
      performInserts(current, patch._i);
    }

    // Patch props and text
    if (patch._p) {
      executePatch(patch._p, parent, current);
    }
  }
});
define('frampton-dom/ops/apply_transition', ['exports', 'module', 'frampton-style/apply_styles', 'frampton-motion/reflow', 'frampton-motion/normalized_frame', 'frampton-utils/immediate', 'frampton-dom/ops/apply_classes', 'frampton-dom/utils/validated_class'], function (exports, module, _framptonStyleApply_styles, _framptonMotionReflow, _framptonMotionNormalized_frame, _framptonUtilsImmediate, _framptonDomOpsApply_classes, _framptonDomUtilsValidated_class) {
  'use strict';

  module.exports = apply_transition;

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

  var _applyStyles = _interopRequireDefault(_framptonStyleApply_styles);

  var _reflow = _interopRequireDefault(_framptonMotionReflow);

  var _normalizedFrame = _interopRequireDefault(_framptonMotionNormalized_frame);

  var _immediate = _interopRequireDefault(_framptonUtilsImmediate);

  var _applyClasses = _interopRequireDefault(_framptonDomOpsApply_classes);

  var _validatedClass = _interopRequireDefault(_framptonDomUtilsValidated_class);

  /**
   * @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) {

    var startClasses = _validatedClass['default'](desc.from['class']);
    var startFrame = _normalizedFrame['default'](desc.from.style);
    _applyClasses['default'](node, startClasses);
    _applyStyles['default'](node, startFrame);

    _immediate['default'](function () {
      var endClasses = _validatedClass['default'](desc.to['class']);
      var endFrame = _normalizedFrame['default'](desc.to.style || {});
      // Force a reflow to make sure we're in a good state
      _reflow['default'](node);
      _applyClasses['default'](node, endClasses);
      _applyStyles['default'](node, endFrame);
    });
  }
});
define('frampton-dom/ops/create_element', ['exports', 'module', 'frampton-dom/utils/is_text', 'frampton-dom/ops/apply_attributes'], function (exports, module, _framptonDomUtilsIs_text, _framptonDomOpsApply_attributes) {
  'use strict';

  module.exports = create_element;

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

  var _isText = _interopRequireDefault(_framptonDomUtilsIs_text);

  var _applyAttributes = _interopRequireDefault(_framptonDomOpsApply_attributes);

  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) {

    if (_isText['default'](vnode)) {
      return doc.createTextNode(vnode.text);
    }

    var children = vnode.children;
    var len = children.length;
    var node = doc.createElement(vnode.tagName);
    _applyAttributes['default'](node, vnode.attributes);

    for (var i = 0; i < len; i++) {
      var childNode = create_element(children[i]);
      if (childNode) {
        node.appendChild(childNode);
      }
    }

    return node;
  }
});
define('frampton-dom/ops/insert_node', ['exports', 'module', 'frampton-dom/ops/create_element', 'frampton-dom/utils/transition_in'], function (exports, module, _framptonDomOpsCreate_element, _framptonDomUtilsTransition_in) {
  'use strict';

  module.exports = insert_node;

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

  var _createElement = _interopRequireDefault(_framptonDomOpsCreate_element);

  var _transitionIn = _interopRequireDefault(_framptonDomUtilsTransition_in);

  /*
   * @name insertNode
   * @memberOf Frampton.DOM
   * @method
   * @private
   * @param {Element} parent
   * @param {Element} current
   * @param {VirtualNode} vnode
   */

  function insert_node(parent, current, vnode) {
    var child = _createElement['default'](vnode);
    if (vnode.attributes.transitionIn) {
      _transitionIn['default'](child, vnode.attributes.transitionIn);
    }
    if (parent) {
      if (current) {
        parent.insertBefore(child, current);
      } else {
        parent.appendChild(child);
      }
    }
  }
});
define("frampton-dom/ops/remove_node", ["exports", "module"], function (exports, module) {
  /*
   * @name removeNode
   * @memberOf Frampton.DOM
   * @method
   * @private
   * @param {Element} node
   */
  "use strict";

  module.exports = remove_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', 'module', 'frampton-dom/utils/is_patch', 'frampton-dom/ops/remove_node', 'frampton-dom/utils/transition_out'], function (exports, module, _framptonDomUtilsIs_patch, _framptonDomOpsRemove_node, _framptonDomUtilsTransition_out) {
  'use strict';

  module.exports = reorder_nodes;

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

  var _isPatch = _interopRequireDefault(_framptonDomUtilsIs_patch);

  var _removeNode = _interopRequireDefault(_framptonDomOpsRemove_node);

  var _transitionOut = _interopRequireDefault(_framptonDomUtilsTransition_out);

  /*
   * @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 = [];

    // Child nodes in 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 (var i = 0; i < remove.length; i++) {
      var child = remove[i];
      _removeNode['default'](child);
    }

    // Easy look up for what new indexes should be
    for (var i = 0; i < order.length; i++) {
      var next = order[i];
      if (next !== undefined && !_isPatch['default'](next)) {
        map[next] = i;
      }
    }

    /**
     * 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 i = 0; i < len; i++) {

      var oldChild = arr[i];

      if (oldChild && order[i] === undefined) {
        _removeNode['default'](oldChild);
      }

      if (_isPatch['default'](order[i])) {
        _transitionOut['default'](oldChild, order[i].update);
        cursor += 1;
      }

      var newChildIndex = map[i];
      var ref = current.childNodes[i + cursor];

      if (newChildIndex !== undefined) {
        var node = arr[newChildIndex];
        if (node && !ref) {
          current.appendChild(node);
        } else if (node && ref !== node) {
          current.insertBefore(node, ref);
        } else if (node && ref === node) {
          /* No move */
        }
      }
    }
  }
});
define('frampton-dom/ops/replace_node', ['exports', 'module', 'frampton-dom/ops/create_element', 'frampton-dom/events/event_dispatcher'], function (exports, module, _framptonDomOpsCreate_element, _framptonDomEventsEvent_dispatcher) {
  'use strict';

  module.exports = replace_node;

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

  var _createElement = _interopRequireDefault(_framptonDomOpsCreate_element);

  /*
   * @name replaceNode
   * @memberOf Frampton.DOM
   * @method
   * @private
   * @param {Element} oldNode Node to replace
   * @param {VirtualNode} vnode VirtualNode representing replacement
   */

  function replace_node(oldNode, vnode) {
    if (oldNode) {
      var _parent = oldNode.parentNode;
      var newNode = _createElement['default'](vnode);
      if (_parent) {
        _framptonDomEventsEvent_dispatcher.removeEvents(oldNode);
        _parent.replaceChild(newNode, oldNode);
      }
    }
  }
});
define("frampton-dom/ops/update_text", ["exports", "module"], function (exports, module) {
  /*
   * @name updateText
   * @memberOf Frampton.DOM
   * @method
   * @private
   * @param {Element} node Node to update
   * @param {String} text New text to display
   */
  "use strict";

  module.exports = update_text;

  function update_text(node, text) {
    if (node && node.textContent) {
      node.textContent = text;
    }
  }
});
define('frampton-dom/update', ['exports', 'module', 'frampton-dom/diff', 'frampton-dom/ops/apply_patch'], function (exports, module, _framptonDomDiff, _framptonDomOpsApply_patch) {
  'use strict';

  module.exports = run_update;

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

  var _diff = _interopRequireDefault(_framptonDomDiff);

  var _applyPatch = _interopRequireDefault(_framptonDomOpsApply_patch);

  /**
   * @param {Elemnt} rootNode The element to attach this update
   * @param {Frampton.DOM.VirtualNode} oldTree The old virtual dom
   * @param {Frampton.DOM.VirtualNode} newTree The new virtual dom
   */

  function run_update(rootNode, oldTree, newTree) {
    var patch = _diff['default'](oldTree, newTree);
    _applyPatch['default'](patch, rootNode, rootNode);
  }
});
define('frampton-dom/utils/diff_class', ['exports', 'module', 'frampton-list/length', 'frampton-dom/utils/validated_class'], function (exports, module, _framptonListLength, _framptonDomUtilsValidated_class) {
  'use strict';

  module.exports = diff_class;

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

  var _length = _interopRequireDefault(_framptonListLength);

  var _validatedClass = _interopRequireDefault(_framptonDomUtilsValidated_class);

  function diff_class(oldClass, newClass) {
    oldClass = _validatedClass['default'](oldClass);
    newClass = _validatedClass['default'](newClass);
    var oLen = _length['default'](oldClass.add);
    var nLen = _length['default'](newClass.add);
    var diff;

    for (var i = 0; i < oLen; i++) {
      if (newClass.add.indexOf(oldClass.add[i]) === -1) {
        diff = diff || { add: [], remove: [] };
        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 || { add: [], remove: [] };
        diff.add = diff.add || [];
        diff.add.push(newClass.add[i]);
      }
    }

    return diff;
  }
});
define('frampton-dom/utils/diff_props', ['exports', 'module', 'frampton-utils/is_object', 'frampton-utils/is_undefined', 'frampton-dom/utils/diff_class', 'frampton-dom/utils/validated_transition'], function (exports, module, _framptonUtilsIs_object, _framptonUtilsIs_undefined, _framptonDomUtilsDiff_class, _framptonDomUtilsValidated_transition) {
  'use strict';

  module.exports = diff_props;

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

  var _isObject = _interopRequireDefault(_framptonUtilsIs_object);

  var _isUndefined = _interopRequireDefault(_framptonUtilsIs_undefined);

  var _diffClass = _interopRequireDefault(_framptonDomUtilsDiff_class);

  var _validatedTransition = _interopRequireDefault(_framptonDomUtilsValidated_transition);

  function diff_props(oldProps, newProps) {

    var diff;

    for (var key in oldProps) {

      var oldValue = oldProps[key];
      var newValue = newProps[key];

      if (_isUndefined['default'](newValue)) {
        diff = diff || {};
        diff[key] = undefined;
      }

      if (key === 'style') {
        newValue = newValue || {};
      }

      if (key === 'transition') {
        oldValue = _validatedTransition['default'](oldValue);
        newValue = _validatedTransition['default'](newValue);
        var tempDiff = diff_props(oldValue, newValue);
        if (tempDiff) {
          diff = diff || {};
          diff[key] = tempDiff;
        }
      } else if (key === 'class') {
        newValue = newValue || '';
        var tempDiff = _diffClass['default'](oldValue, newValue);
        if (tempDiff) {
          diff = diff || {};
          diff[key] = tempDiff;
        }
      } else if (_isObject['default'](oldValue) && _isObject['default'](newValue)) {
        var tempDiff = diff_props(oldValue, newValue);
        if (tempDiff) {
          diff = diff || {};
          diff[key] = tempDiff;
        }
      } else if (oldValue !== newValue) {
        diff = diff || {};
        diff[key] = newValue;
      }
    }

    for (var key in newProps) {
      if (_isUndefined['default'](oldProps[key])) {
        var newValue = newProps[key];
        if (key === 'class') {
          var tempDiff = _diffClass['default']('', newValue);
          if (tempDiff) {
            diff = diff || {};
            diff[key] = tempDiff;
          }
        } else {
          diff = diff || {};
          diff[key] = newValue;
        }
      }
    }

    return diff;
  }
});
define("frampton-dom/utils/empty_class", ["exports", "module"], function (exports, module) {
  "use strict";

  module.exports = empty_class;

  function empty_class() {
    return {
      add: [],
      remove: []
    };
  }
});
define('frampton-dom/utils/is_node', ['exports', 'module', 'frampton-utils/is_object'], function (exports, module, _framptonUtilsIs_object) {
  'use strict';

  module.exports = is_text;

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

  var _isObject = _interopRequireDefault(_framptonUtilsIs_object);

  function is_text(node) {
    return _isObject['default'](node) && node.ctor === 'VirtualNode';
  }
});
define('frampton-dom/utils/is_patch', ['exports', 'module', 'frampton-utils/is_object'], function (exports, module, _framptonUtilsIs_object) {
  'use strict';

  module.exports = is_patch;

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

  var _isObject = _interopRequireDefault(_framptonUtilsIs_object);

  function is_patch(node) {
    return _isObject['default'](node) && node.ctor === 'VirtualPatch';
  }
});
define('frampton-dom/utils/is_same_node', ['exports', 'module', 'frampton-utils/is_defined'], function (exports, module, _framptonUtilsIs_defined) {
  'use strict';

  module.exports = is_same_node;

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

  var _isDefined = _interopRequireDefault(_framptonUtilsIs_defined);

  function keysMatch(oldKey, newKey) {
    return _isDefined['default'](oldKey) && _isDefined['default'](newKey) && oldKey === newKey;
  }

  function is_same_node(oldNode, newNode) {
    return _isDefined['default'](oldNode) && _isDefined['default'](newNode) && oldNode.tagName === newNode.tagName && keysMatch(oldNode.key, newNode.key);
  }
});
define('frampton-dom/utils/is_text', ['exports', 'module', 'frampton-utils/is_object'], function (exports, module, _framptonUtilsIs_object) {
  'use strict';

  module.exports = is_text;

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

  var _isObject = _interopRequireDefault(_framptonUtilsIs_object);

  function is_text(node) {
    return _isObject['default'](node) && node.ctor === 'VirtualText';
  }
});
define('frampton-dom/utils/not_empty', ['exports', 'module'], function (exports, module) {
  'use strict';

  module.exports = notEmtpy;

  function notEmtpy(str) {
    return str.trim() !== '';
  }
});
define('frampton-dom/utils/props_diff', ['exports', 'module', 'frampton-dom/utils/diff_props'], function (exports, module, _framptonDomUtilsDiff_props) {
  'use strict';

  module.exports = props_diff;

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

  var _diffProps = _interopRequireDefault(_framptonDomUtilsDiff_props);

  function props_diff(oldNode, newNode) {
    return _diffProps['default'](oldNode.attributes, newNode.attributes);
  }
});
define('frampton-dom/utils/transition_in', ['exports', 'module', 'frampton-dom/ops/apply_transition', 'frampton-dom/utils/validated_transition'], function (exports, module, _framptonDomOpsApply_transition, _framptonDomUtilsValidated_transition) {
  'use strict';

  module.exports = transitionIn;

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

  var _applyTransition = _interopRequireDefault(_framptonDomOpsApply_transition);

  var _validatedTransition = _interopRequireDefault(_framptonDomUtilsValidated_transition);

  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) {
    node.setAttribute('data-transition-in', 'true');
    _applyTransition['default'](node, _validatedTransition['default'](transition));
    handleTransition(node);
  }
});
define('frampton-dom/utils/transition_out', ['exports', 'module', 'frampton-dom/ops/remove_node', 'frampton-dom/ops/apply_transition', 'frampton-dom/utils/validated_transition'], function (exports, module, _framptonDomOpsRemove_node, _framptonDomOpsApply_transition, _framptonDomUtilsValidated_transition) {
  'use strict';

  module.exports = transitionOut;

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

  var _removeNode = _interopRequireDefault(_framptonDomOpsRemove_node);

  var _applyTransition = _interopRequireDefault(_framptonDomOpsApply_transition);

  var _validatedTransition = _interopRequireDefault(_framptonDomUtilsValidated_transition);

  function handleTransition(node) {
    function eventHandler(evt) {
      if (evt.target === node) {
        node.removeEventListener('transitionend', eventHandler);
        _removeNode['default'](node);
      }
    }
    node.addEventListener('transitionend', eventHandler);
  }

  function transitionOut(node, transition) {
    node.removeAttribute('data-transition-in');
    node.setAttribute('data-transition-out', 'true');
    _applyTransition['default'](node, _validatedTransition['default'](transition));
    handleTransition(node);
  }
});
define('frampton-dom/utils/validated_class', ['exports', 'module', 'frampton-utils/is_string', 'frampton-dom/utils/not_empty', 'frampton-dom/utils/empty_class'], function (exports, module, _framptonUtilsIs_string, _framptonDomUtilsNot_empty, _framptonDomUtilsEmpty_class) {
  'use strict';

  module.exports = validated_class;

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

  var _isString = _interopRequireDefault(_framptonUtilsIs_string);

  var _notEmpty = _interopRequireDefault(_framptonDomUtilsNot_empty);

  var _emptyClass = _interopRequireDefault(_framptonDomUtilsEmpty_class);

  function validated_class(str) {

    if (!str) {
      return _emptyClass['default']();
    }

    if (_isString['default'](str)) {
      return {
        add: str.split(' ').filter(_notEmpty['default']),
        remove: []
      };
    }

    if (!str.add) {
      str.add = [];
    }

    if (!str.remove) {
      str.remove = [];
    }

    return str;
  }
});
define('frampton-dom/utils/validated_transition', ['exports', 'module', 'frampton-motion/normalized_frame', 'frampton-dom/utils/validated_class', 'frampton-dom/utils/empty_class'], function (exports, module, _framptonMotionNormalized_frame, _framptonDomUtilsValidated_class, _framptonDomUtilsEmpty_class) {
  'use strict';

  module.exports = validated_transition;

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

  var _normalizedFrame = _interopRequireDefault(_framptonMotionNormalized_frame);

  var _validatedClass = _interopRequireDefault(_framptonDomUtilsValidated_class);

  var _emptyClass = _interopRequireDefault(_framptonDomUtilsEmpty_class);

  function validated_transition(desc) {

    if (!desc) {
      return {
        from: {
          'class': _emptyClass['default'](),
          style: {}
        },
        to: {
          'class': _emptyClass['default'](),
          style: {}
        }
      };
    } else {

      var temp = {
        from: {},
        to: {}
      };

      if (desc.from) {
        temp.from['class'] = _validatedClass['default'](desc.from['class']);
        temp.from.style = _normalizedFrame['default'](desc.from.style || {});
      }

      if (desc.to) {
        temp.to['class'] = _validatedClass['default'](desc.to['class']);
        temp.to.style = _normalizedFrame['default'](desc.to.style || {});
      }

      if (desc['class']) {
        temp.to['class'] = _validatedClass['default'](desc['class']);
      }

      if (desc.style) {
        temp.to.style = _normalizedFrame['default'](desc.style || {});
      }

      return temp;
    }
  }
});
define('frampton-dom/virtual/node', ['exports', 'module', 'frampton-list/length', 'frampton-utils/is_defined', 'frampton-utils/is_array', 'frampton-utils/is_object', 'frampton-utils/is_string'], function (exports, module, _framptonListLength, _framptonUtilsIs_defined, _framptonUtilsIs_array, _framptonUtilsIs_object, _framptonUtilsIs_string) {
  'use strict';

  module.exports = VirtualNode;

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

  var _length = _interopRequireDefault(_framptonListLength);

  var _isDefined = _interopRequireDefault(_framptonUtilsIs_defined);

  var _isArray = _interopRequireDefault(_framptonUtilsIs_array);

  var _isObject = _interopRequireDefault(_framptonUtilsIs_object);

  var _isString = _interopRequireDefault(_framptonUtilsIs_string);

  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 (!_isString['default'](name)) {
      throw new Error('VirtualNode must have a string name');
    }

    if (_isArray['default'](attrs)) {
      children = attrs;
    }

    attrs = _isObject['default'](attrs) ? attrs : noAttributes;
    children = _isArray['default'](children) ? children : noChildren;

    return {
      ctor: 'VirtualNode',
      id: attrs.id,
      key: _isDefined['default'](attrs.key) ? attrs.key : attrs.id,
      tagName: name,
      attributes: attrs,
      children: children,
      length: _length['default'](children)
    };
  }
});
define("frampton-dom/virtual/patch_types", ["exports", "module"], function (exports, module) {
  "use strict";

  module.exports = {
    NONE: 0,
    INSERT: 1,
    REMOVE: 2,
    REPLACE: 3,
    PROPS: 4,
    REORDER: 5,
    TEXT: 6
  };
});
define('frampton-dom/virtual/patch', ['exports', 'frampton-dom/virtual/patch_types'], function (exports, _framptonDomVirtualPatch_types) {
  'use strict';

  exports.__esModule = true;

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

  var _TYPES = _interopRequireDefault(_framptonDomVirtualPatch_types);

  /**
   * @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 = function none(node, patch) {
    return VirtualPatch(_TYPES['default'].NONE, node, patch);
  };

  exports.none = none;
  var insert = function insert(node, patch) {
    return VirtualPatch(_TYPES['default'].INSERT, node, patch);
  };

  exports.insert = insert;
  var remove = function remove(node, patch) {
    return VirtualPatch(_TYPES['default'].REMOVE, node, patch);
  };

  exports.remove = remove;
  var replace = function replace(node, patch) {
    return VirtualPatch(_TYPES['default'].REPLACE, node, patch);
  };

  exports.replace = replace;
  var props = function props(node, patch) {
    return VirtualPatch(_TYPES['default'].PROPS, node, patch);
  };

  exports.props = props;
  var text = function text(node, patch) {
    return VirtualPatch(_TYPES['default'].TEXT, node, patch);
  };

  exports.text = text;
  var reorder = function reorder(node, patch) {
    return VirtualPatch(_TYPES['default'].REORDER, node, patch);
  };
  exports.reorder = reorder;
});
define('frampton-dom/virtual/text', ['exports', 'module'], function (exports, module) {
  /**
   * @name VirtualText
   * @memberof Frampton.DOM
   * @class
   * @private
   * @param {String} str Text content for new text node
   * @returns {VirtualText} A new VirtualText
   */
  'use strict';

  module.exports = 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-app', ['exports', 'frampton/namespace', 'frampton-app/app', 'frampton-app/scene'], function (exports, _framptonNamespace, _framptonAppApp, _framptonAppScene) {
  'use strict';

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

  var _Frampton = _interopRequireDefault(_framptonNamespace);

  var _app = _interopRequireDefault(_framptonAppApp);

  var _scene = _interopRequireDefault(_framptonAppScene);

  /**
   * @name App
   * @namespace
   * @memberof Frampton
   */
  _Frampton['default'].App = {};
  _Frampton['default'].App.VERSION = '0.0.1';
  _Frampton['default'].App.app = _app['default'];
  _Frampton['default'].App.scene = _scene['default'];
});
define('frampton-app/app', ['exports', 'module', 'frampton-utils/is_something', 'frampton-list/prepend', 'frampton-list/first', 'frampton-list/second', 'frampton-data/task/execute', 'frampton-signal/create', 'frampton-app/scene'], function (exports, module, _framptonUtilsIs_something, _framptonListPrepend, _framptonListFirst, _framptonListSecond, _framptonDataTaskExecute, _framptonSignalCreate, _framptonAppScene) {
  'use strict';

  module.exports = app;

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

  var _isSomething = _interopRequireDefault(_framptonUtilsIs_something);

  var _prepend = _interopRequireDefault(_framptonListPrepend);

  var _first = _interopRequireDefault(_framptonListFirst);

  var _second = _interopRequireDefault(_framptonListSecond);

  var _execute = _interopRequireDefault(_framptonDataTaskExecute);

  var _create = _interopRequireDefault(_framptonSignalCreate);

  var _scene = _interopRequireDefault(_framptonAppScene);

  function app(config) {

    function update(acc, next) {
      var model = acc[0];
      return config.update(next, model);
    }

    var messages = _create['default']();
    var initialState = config.init();
    var inputs = _framptonSignalCreate.mergeMany(_prepend['default'](config.inputs, messages));
    var stateAndTasks = inputs.fold(update, initialState);
    var state = stateAndTasks.map(_first['default']);
    var tasks = stateAndTasks.map(_second['default']);

    // Run tasks and publish any resulting actions back into messages
    _execute['default'](tasks, messages);

    if (config.rootElement && config.view) {
      (function () {
        var schedule = _scene['default'](config.rootElement, messages);
        var html = state.map(function (next) {
          return config.view(messages, next);
        });
        html.filter(_isSomething['default']).value(function (tree) {
          schedule(tree);
        });
      })();
    }

    return state;
  }
});
define('frampton-app/scene', ['exports', 'module', 'frampton-app/utils/request_frame', 'frampton-dom/update'], function (exports, module, _framptonAppUtilsRequest_frame, _framptonDomUpdate) {
  'use strict';

  module.exports = scene;

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

  var _requestFrame = _interopRequireDefault(_framptonAppUtilsRequest_frame);

  var _update = _interopRequireDefault(_framptonDomUpdate);

  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}
   * @returns {Function} A function to schedule updates
   */

  function scene(rootNode, messages) {

    var savedDOM = null;
    var scheduledDOM = null;
    var state = STATES.NOTHING;

    function draw() {
      _update['default'](rootNode, savedDOM, scheduledDOM, messages);
      savedDOM = scheduledDOM;
      state = STATES.NOTHING;
    }

    return function scheduler(dom) {
      scheduledDOM = dom;

      switch (state) {

        case STATES.NOTHING:
          _requestFrame['default'](draw);
          state = STATES.PENDING;
          break;

        default:
          state = STATES.PENDING;
          break;
      }
    };
  }
});
define('frampton-app/utils/request_frame', ['exports', 'module', 'frampton-utils/is_function'], function (exports, module, _framptonUtilsIs_function) {
  'use strict';

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

  var _isFunction = _interopRequireDefault(_framptonUtilsIs_function);

  module.exports = function (callback) {
    if (_isFunction['default'](window.requestAnimationFrame)) {
      window.requestAnimationFrame(callback);
    } else {
      setTimeout(callback, 1000 / 60);
    }
  };
});
require("frampton-app");

})();