deku 0.1.0

data/deps/node_modules/deku/node_modules/fast.js/dist/fast.js

@@ -0,0 +1,1450 @@
+!function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.fast=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(_dereq_,module,exports){
+'use strict';
+
+/**
+ * # Clone Array
+ *
+ * Clone an array or array like object (e.g. `arguments`).
+ * This is the equivalent of calling `Array.prototype.slice.call(arguments)`, but
+ * significantly faster.
+ *
+ * @param  {Array} input The array or array-like object to clone.
+ * @return {Array}       The cloned array.
+ */
+module.exports = function fastCloneArray (input) {
+  var length = input.length,
+      sliced = new Array(length),
+      i;
+  for (i = 0; i < length; i++) {
+    sliced[i] = input[i];
+  }
+  return sliced;
+};
+
+},{}],2:[function(_dereq_,module,exports){
+'use strict';
+
+/**
+ * # Concat
+ *
+ * Concatenate multiple arrays.
+ *
+ * > Note: This function is effectively identical to `Array.prototype.concat()`.
+ *
+ *
+ * @param  {Array|mixed} item, ... The item(s) to concatenate.
+ * @return {Array}                 The array containing the concatenated items.
+ */
+module.exports = function fastConcat () {
+  var length = arguments.length,
+      arr = [],
+      i, item, childLength, j;
+
+  for (i = 0; i < length; i++) {
+    item = arguments[i];
+    if (Array.isArray(item)) {
+      childLength = item.length;
+      for (j = 0; j < childLength; j++) {
+        arr.push(item[j]);
+      }
+    }
+    else {
+      arr.push(item);
+    }
+  }
+  return arr;
+};
+
+},{}],3:[function(_dereq_,module,exports){
+'use strict';
+
+var bindInternal3 = _dereq_('../function/bindInternal3');
+
+/**
+ * # Every
+ *
+ * A fast `.every()` implementation.
+ *
+ * @param  {Array}    subject     The array (or array-like) to iterate over.
+ * @param  {Function} fn          The visitor function.
+ * @param  {Object}   thisContext The context for the visitor.
+ * @return {Boolean}              true if all items in the array passes the truth test.
+ */
+module.exports = function fastEvery (subject, fn, thisContext) {
+  var length = subject.length,
+      iterator = thisContext !== undefined ? bindInternal3(fn, thisContext) : fn,
+      i;
+  for (i = 0; i < length; i++) {
+    if (!iterator(subject[i], i, subject)) {
+      return false;
+    }
+  }
+  return true;
+};
+
+},{"../function/bindInternal3":22}],4:[function(_dereq_,module,exports){
+'use strict';
+
+/**
+ * # Fill
+ * Fill an array with values, optionally starting and stopping at a given index.
+ *
+ * > Note: unlike the specced Array.prototype.fill(), this version does not support
+ * > negative start / end arguments.
+ *
+ * @param  {Array}   subject The array to fill.
+ * @param  {mixed}   value   The value to insert.
+ * @param  {Integer} start   The start position, defaults to 0.
+ * @param  {Integer} end     The end position, defaults to subject.length
+ * @return {Array}           The now filled subject.
+ */
+module.exports = function fastFill (subject, value, start, end) {
+  var length = subject.length,
+      i;
+  if (start === undefined) {
+    start = 0;
+  }
+  if (end === undefined) {
+    end = length;
+  }
+  for (i = start; i < end; i++) {
+    subject[i] = value;
+  }
+  return subject;
+};
+},{}],5:[function(_dereq_,module,exports){
+'use strict';
+
+var bindInternal3 = _dereq_('../function/bindInternal3');
+
+/**
+ * # Filter
+ *
+ * A fast `.filter()` implementation.
+ *
+ * @param  {Array}    subject     The array (or array-like) to filter.
+ * @param  {Function} fn          The filter function.
+ * @param  {Object}   thisContext The context for the filter.
+ * @return {Array}                The array containing the results.
+ */
+module.exports = function fastFilter (subject, fn, thisContext) {
+  var length = subject.length,
+      result = [],
+      iterator = thisContext !== undefined ? bindInternal3(fn, thisContext) : fn,
+      i;
+  for (i = 0; i < length; i++) {
+    if (iterator(subject[i], i, subject)) {
+      result.push(subject[i]);
+    }
+  }
+  return result;
+};
+
+},{"../function/bindInternal3":22}],6:[function(_dereq_,module,exports){
+'use strict';
+
+var bindInternal3 = _dereq_('../function/bindInternal3');
+
+/**
+ * # For Each
+ *
+ * A fast `.forEach()` implementation.
+ *
+ * @param  {Array}    subject     The array (or array-like) to iterate over.
+ * @param  {Function} fn          The visitor function.
+ * @param  {Object}   thisContext The context for the visitor.
+ */
+module.exports = function fastForEach (subject, fn, thisContext) {
+  var length = subject.length,
+      iterator = thisContext !== undefined ? bindInternal3(fn, thisContext) : fn,
+      i;
+  for (i = 0; i < length; i++) {
+    iterator(subject[i], i, subject);
+  }
+};
+
+},{"../function/bindInternal3":22}],7:[function(_dereq_,module,exports){
+'use strict';
+
+exports.clone = _dereq_('./clone');
+exports.concat = _dereq_('./concat');
+exports.every = _dereq_('./every');
+exports.filter = _dereq_('./filter');
+exports.forEach = _dereq_('./forEach');
+exports.indexOf = _dereq_('./indexOf');
+exports.lastIndexOf = _dereq_('./lastIndexOf');
+exports.map = _dereq_('./map');
+exports.pluck = _dereq_('./pluck');
+exports.reduce = _dereq_('./reduce');
+exports.reduceRight = _dereq_('./reduceRight');
+exports.some = _dereq_('./some');
+exports.fill = _dereq_('./fill');
+},{"./clone":1,"./concat":2,"./every":3,"./fill":4,"./filter":5,"./forEach":6,"./indexOf":8,"./lastIndexOf":9,"./map":10,"./pluck":11,"./reduce":12,"./reduceRight":13,"./some":14}],8:[function(_dereq_,module,exports){
+'use strict';
+
+/**
+ * # Index Of
+ *
+ * A faster `Array.prototype.indexOf()` implementation.
+ *
+ * @param  {Array}  subject   The array (or array-like) to search within.
+ * @param  {mixed}  target    The target item to search for.
+ * @param  {Number} fromIndex The position to start searching from, if known.
+ * @return {Number}           The position of the target in the subject, or -1 if it does not exist.
+ */
+module.exports = function fastIndexOf (subject, target, fromIndex) {
+  var length = subject.length,
+      i = 0;
+
+  if (typeof fromIndex === 'number') {
+    i = fromIndex;
+    if (i < 0) {
+      i += length;
+      if (i < 0) {
+        i = 0;
+      }
+    }
+  }
+
+  for (; i < length; i++) {
+    if (subject[i] === target) {
+      return i;
+    }
+  }
+  return -1;
+};
+
+},{}],9:[function(_dereq_,module,exports){
+'use strict';
+
+/**
+ * # Last Index Of
+ *
+ * A faster `Array.prototype.lastIndexOf()` implementation.
+ *
+ * @param  {Array}  subject The array (or array-like) to search within.
+ * @param  {mixed}  target  The target item to search for.
+ * @param  {Number} fromIndex The position to start searching backwards from, if known.
+ * @return {Number}         The last position of the target in the subject, or -1 if it does not exist.
+ */
+module.exports = function fastLastIndexOf (subject, target, fromIndex) {
+  var length = subject.length,
+      i = length - 1;
+
+  if (typeof fromIndex === 'number') {
+    i = fromIndex;
+    if (i < 0) {
+      i += length;
+    }
+  }
+  for (; i >= 0; i--) {
+    if (subject[i] === target) {
+      return i;
+    }
+  }
+  return -1;
+};
+
+},{}],10:[function(_dereq_,module,exports){
+'use strict';
+
+var bindInternal3 = _dereq_('../function/bindInternal3');
+
+/**
+ * # Map
+ *
+ * A fast `.map()` implementation.
+ *
+ * @param  {Array}    subject     The array (or array-like) to map over.
+ * @param  {Function} fn          The mapper function.
+ * @param  {Object}   thisContext The context for the mapper.
+ * @return {Array}                The array containing the results.
+ */
+module.exports = function fastMap (subject, fn, thisContext) {
+  var length = subject.length,
+      result = new Array(length),
+      iterator = thisContext !== undefined ? bindInternal3(fn, thisContext) : fn,
+      i;
+  for (i = 0; i < length; i++) {
+    result[i] = iterator(subject[i], i, subject);
+  }
+  return result;
+};
+
+},{"../function/bindInternal3":22}],11:[function(_dereq_,module,exports){
+'use strict';
+
+/**
+ * # Pluck
+ * Pluck the property with the given name from an array of objects.
+ *
+ * @param  {Array}  input The values to pluck from.
+ * @param  {String} field The name of the field to pluck.
+ * @return {Array}        The plucked array of values.
+ */
+module.exports = function fastPluck (input, field) {
+  var length = input.length,
+      plucked = [],
+      count = 0,
+      value, i;
+
+  for (i = 0; i < length; i++) {
+    value = input[i];
+    if (value != null && value[field] !== undefined) {
+      plucked[count++] = value[field];
+    }
+  }
+  return plucked;
+};
+},{}],12:[function(_dereq_,module,exports){
+'use strict';
+
+var bindInternal4 = _dereq_('../function/bindInternal4');
+
+/**
+ * # Reduce
+ *
+ * A fast `.reduce()` implementation.
+ *
+ * @param  {Array}    subject      The array (or array-like) to reduce.
+ * @param  {Function} fn           The reducer function.
+ * @param  {mixed}    initialValue The initial value for the reducer, defaults to subject[0].
+ * @param  {Object}   thisContext  The context for the reducer.
+ * @return {mixed}                 The final result.
+ */
+module.exports = function fastReduce (subject, fn, initialValue, thisContext) {
+  var length = subject.length,
+      iterator = thisContext !== undefined ? bindInternal4(fn, thisContext) : fn,
+      i, result;
+
+  if (initialValue === undefined) {
+    i = 1;
+    result = subject[0];
+  }
+  else {
+    i = 0;
+    result = initialValue;
+  }
+
+  for (; i < length; i++) {
+    result = iterator(result, subject[i], i, subject);
+  }
+
+  return result;
+};
+
+},{"../function/bindInternal4":23}],13:[function(_dereq_,module,exports){
+'use strict';
+
+var bindInternal4 = _dereq_('../function/bindInternal4');
+
+/**
+ * # Reduce Right
+ *
+ * A fast `.reduceRight()` implementation.
+ *
+ * @param  {Array}    subject      The array (or array-like) to reduce.
+ * @param  {Function} fn           The reducer function.
+ * @param  {mixed}    initialValue The initial value for the reducer, defaults to subject[0].
+ * @param  {Object}   thisContext  The context for the reducer.
+ * @return {mixed}                 The final result.
+ */
+module.exports = function fastReduce (subject, fn, initialValue, thisContext) {
+  var length = subject.length,
+      iterator = thisContext !== undefined ? bindInternal4(fn, thisContext) : fn,
+      i, result;
+
+  if (initialValue === undefined) {
+    i = length - 2;
+    result = subject[length - 1];
+  }
+  else {
+    i = length - 1;
+    result = initialValue;
+  }
+
+  for (; i >= 0; i--) {
+    result = iterator(result, subject[i], i, subject);
+  }
+
+  return result;
+};
+
+},{"../function/bindInternal4":23}],14:[function(_dereq_,module,exports){
+'use strict';
+
+var bindInternal3 = _dereq_('../function/bindInternal3');
+
+/**
+ * # Some
+ *
+ * A fast `.some()` implementation.
+ *
+ * @param  {Array}    subject     The array (or array-like) to iterate over.
+ * @param  {Function} fn          The visitor function.
+ * @param  {Object}   thisContext The context for the visitor.
+ * @return {Boolean}              true if at least one item in the array passes the truth test.
+ */
+module.exports = function fastSome (subject, fn, thisContext) {
+  var length = subject.length,
+      iterator = thisContext !== undefined ? bindInternal3(fn, thisContext) : fn,
+      i;
+  for (i = 0; i < length; i++) {
+    if (iterator(subject[i], i, subject)) {
+      return true;
+    }
+  }
+  return false;
+};
+
+},{"../function/bindInternal3":22}],15:[function(_dereq_,module,exports){
+'use strict';
+
+var cloneArray = _dereq_('./array/clone');
+var cloneObject = _dereq_('./object/clone');
+
+/**
+ * # Clone
+ *
+ * Clone an item. Primitive values will be returned directly,
+ * arrays and objects will be shallow cloned. If you know the
+ * type of input you're dealing with, call `.cloneArray()` or `.cloneObject()`
+ * instead.
+ *
+ * @param  {mixed} input The input to clone.
+ * @return {mixed}       The cloned input.
+ */
+module.exports = function clone (input) {
+  if (!input || typeof input !== 'object') {
+    return input;
+  }
+  else if (Array.isArray(input)) {
+    return cloneArray(input);
+  }
+  else {
+    return cloneObject(input);
+  }
+};
+
+},{"./array/clone":1,"./object/clone":31}],16:[function(_dereq_,module,exports){
+'use strict';
+
+var filterArray = _dereq_('./array/filter'),
+    filterObject = _dereq_('./object/filter');
+
+/**
+ * # Filter
+ *
+ * A fast `.filter()` implementation.
+ *
+ * @param  {Array|Object} subject     The array or object to filter.
+ * @param  {Function}     fn          The filter function.
+ * @param  {Object}       thisContext The context for the filter.
+ * @return {Array|Object}             The array or object containing the filtered results.
+ */
+module.exports = function fastFilter (subject, fn, thisContext) {
+  if (subject instanceof Array) {
+    return filterArray(subject, fn, thisContext);
+  }
+  else {
+    return filterObject(subject, fn, thisContext);
+  }
+};
+},{"./array/filter":5,"./object/filter":32}],17:[function(_dereq_,module,exports){
+'use strict';
+
+var forEachArray = _dereq_('./array/forEach'),
+    forEachObject = _dereq_('./object/forEach');
+
+/**
+ * # ForEach
+ *
+ * A fast `.forEach()` implementation.
+ *
+ * @param  {Array|Object} subject     The array or object to iterate over.
+ * @param  {Function}     fn          The visitor function.
+ * @param  {Object}       thisContext The context for the visitor.
+ */
+module.exports = function fastForEach (subject, fn, thisContext) {
+  if (subject instanceof Array) {
+    return forEachArray(subject, fn, thisContext);
+  }
+  else {
+    return forEachObject(subject, fn, thisContext);
+  }
+};
+},{"./array/forEach":6,"./object/forEach":33}],18:[function(_dereq_,module,exports){
+'use strict';
+
+var applyWithContext = _dereq_('./applyWithContext');
+var applyNoContext = _dereq_('./applyNoContext');
+
+/**
+ * # Apply
+ *
+ * Faster version of `Function::apply()`, optimised for 8 arguments or fewer.
+ *
+ *
+ * @param  {Function} subject   The function to apply.
+ * @param  {Object} thisContext The context for the function, set to undefined or null if no context is required.
+ * @param  {Array} args         The arguments for the function.
+ * @return {mixed}              The result of the function invocation.
+ */
+module.exports = function fastApply (subject, thisContext, args) {
+  return thisContext !== undefined ? applyWithContext(subject, thisContext, args) : applyNoContext(subject, args);
+};
+
+},{"./applyNoContext":19,"./applyWithContext":20}],19:[function(_dereq_,module,exports){
+'use strict';
+
+/**
+ * Internal helper for applying a function without a context.
+ */
+module.exports = function applyNoContext (subject, args) {
+  switch (args.length) {
+    case 0:
+      return subject();
+    case 1:
+      return subject(args[0]);
+    case 2:
+      return subject(args[0], args[1]);
+    case 3:
+      return subject(args[0], args[1], args[2]);
+    case 4:
+      return subject(args[0], args[1], args[2], args[3]);
+    case 5:
+      return subject(args[0], args[1], args[2], args[3], args[4]);
+    case 6:
+      return subject(args[0], args[1], args[2], args[3], args[4], args[5]);
+    case 7:
+      return subject(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
+    case 8:
+      return subject(args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7]);
+    default:
+      return subject.apply(undefined, args);
+  }
+};
+
+},{}],20:[function(_dereq_,module,exports){
+'use strict';
+
+/**
+ * Internal helper for applying a function with a context.
+ */
+module.exports = function applyWithContext (subject, thisContext, args) {
+  switch (args.length) {
+    case 0:
+      return subject.call(thisContext);
+    case 1:
+      return subject.call(thisContext, args[0]);
+    case 2:
+      return subject.call(thisContext, args[0], args[1]);
+    case 3:
+      return subject.call(thisContext, args[0], args[1], args[2]);
+    case 4:
+      return subject.call(thisContext, args[0], args[1], args[2], args[3]);
+    case 5:
+      return subject.call(thisContext, args[0], args[1], args[2], args[3], args[4]);
+    case 6:
+      return subject.call(thisContext, args[0], args[1], args[2], args[3], args[4], args[5]);
+    case 7:
+      return subject.call(thisContext, args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
+    case 8:
+      return subject.call(thisContext, args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7]);
+    default:
+      return subject.apply(thisContext, args);
+  }
+};
+
+},{}],21:[function(_dereq_,module,exports){
+'use strict';
+
+var applyWithContext = _dereq_('./applyWithContext');
+var applyNoContext = _dereq_('./applyNoContext');
+
+/**
+ * # Bind
+ * Analogue of `Function::bind()`.
+ *
+ * ```js
+ * var bind = require('fast.js').bind;
+ * var bound = bind(myfunc, this, 1, 2, 3);
+ *
+ * bound(4);
+ * ```
+ *
+ *
+ * @param  {Function} fn          The function which should be bound.
+ * @param  {Object}   thisContext The context to bind the function to.
+ * @param  {mixed}    args, ...   Additional arguments to pre-bind.
+ * @return {Function}             The bound function.
+ */
+module.exports = function fastBind (fn, thisContext) {
+  var boundLength = arguments.length - 2,
+      boundArgs;
+
+  if (boundLength > 0) {
+    boundArgs = new Array(boundLength);
+    for (var i = 0; i < boundLength; i++) {
+      boundArgs[i] = arguments[i + 2];
+    }
+    if (thisContext !== undefined) {
+      return function () {
+        var length = arguments.length,
+            args = new Array(boundLength + length),
+            i;
+        for (i = 0; i < boundLength; i++) {
+          args[i] = boundArgs[i];
+        }
+        for (i = 0; i < length; i++) {
+          args[boundLength + i] = arguments[i];
+        }
+        return applyWithContext(fn, thisContext, args);
+      };
+    }
+    else {
+      return function () {
+        var length = arguments.length,
+            args = new Array(boundLength + length),
+            i;
+        for (i = 0; i < boundLength; i++) {
+          args[i] = boundArgs[i];
+        }
+        for (i = 0; i < length; i++) {
+          args[boundLength + i] = arguments[i];
+        }
+        return applyNoContext(fn, args);
+      };
+    }
+  }
+  if (thisContext !== undefined) {
+    return function () {
+      return applyWithContext(fn, thisContext, arguments);
+    };
+  }
+  else {
+    return function () {
+      return applyNoContext(fn, arguments);
+    };
+  }
+};
+
+},{"./applyNoContext":19,"./applyWithContext":20}],22:[function(_dereq_,module,exports){
+'use strict';
+
+/**
+ * Internal helper to bind a function known to have 3 arguments
+ * to a given context.
+ */
+module.exports = function bindInternal3 (func, thisContext) {
+  return function (a, b, c) {
+    return func.call(thisContext, a, b, c);
+  };
+};
+
+},{}],23:[function(_dereq_,module,exports){
+'use strict';
+
+/**
+ * Internal helper to bind a function known to have 4 arguments
+ * to a given context.
+ */
+module.exports = function bindInternal4 (func, thisContext) {
+  return function (a, b, c, d) {
+    return func.call(thisContext, a, b, c, d);
+  };
+};
+
+},{}],24:[function(_dereq_,module,exports){
+'use strict';
+
+exports.apply = _dereq_('./apply');
+exports.bind = _dereq_('./bind');
+exports.partial = _dereq_('./partial');
+exports.partialConstructor = _dereq_('./partialConstructor');
+exports.try = _dereq_('./try');
+
+},{"./apply":18,"./bind":21,"./partial":25,"./partialConstructor":26,"./try":27}],25:[function(_dereq_,module,exports){
+'use strict';
+
+var applyWithContext = _dereq_('./applyWithContext');
+
+/**
+ * # Partial Application
+ *
+ * Partially apply a function. This is similar to `.bind()`,
+ * but with one important difference - the returned function is not bound
+ * to a particular context. This makes it easy to add partially
+ * applied methods to objects. If you need to bind to a context,
+ * use `.bind()` instead.
+ *
+ * > Note: This function does not support partial application for
+ * constructors, for that see `partialConstructor()`
+ *
+ *
+ * @param  {Function} fn          The function to partially apply.
+ * @param  {mixed}    args, ...   Arguments to pre-bind.
+ * @return {Function}             The partially applied function.
+ */
+module.exports = function fastPartial (fn) {
+  var boundLength = arguments.length - 1,
+      boundArgs;
+
+  boundArgs = new Array(boundLength);
+  for (var i = 0; i < boundLength; i++) {
+    boundArgs[i] = arguments[i + 1];
+  }
+  return function () {
+    var length = arguments.length,
+        args = new Array(boundLength + length),
+        i;
+    for (i = 0; i < boundLength; i++) {
+      args[i] = boundArgs[i];
+    }
+    for (i = 0; i < length; i++) {
+      args[boundLength + i] = arguments[i];
+    }
+    return applyWithContext(fn, this, args);
+  };
+};
+
+},{"./applyWithContext":20}],26:[function(_dereq_,module,exports){
+'use strict';
+
+var applyWithContext = _dereq_('./applyWithContext');
+
+/**
+ * # Partial Constructor
+ *
+ * Partially apply a constructor function. The returned function
+ * will work with or without the `new` keyword.
+ *
+ *
+ * @param  {Function} fn          The constructor function to partially apply.
+ * @param  {mixed}    args, ...   Arguments to pre-bind.
+ * @return {Function}             The partially applied constructor.
+ */
+module.exports = function fastPartialConstructor (fn) {
+  var boundLength = arguments.length - 1,
+      boundArgs;
+
+  boundArgs = new Array(boundLength);
+  for (var i = 0; i < boundLength; i++) {
+    boundArgs[i] = arguments[i + 1];
+  }
+  return function partialed () {
+    var length = arguments.length,
+        args = new Array(boundLength + length),
+        i;
+    for (i = 0; i < boundLength; i++) {
+      args[i] = boundArgs[i];
+    }
+    for (i = 0; i < length; i++) {
+      args[boundLength + i] = arguments[i];
+    }
+
+    var thisContext = Object.create(fn.prototype),
+        result = applyWithContext(fn, thisContext, args);
+
+    if (result != null && (typeof result === 'object' || typeof result === 'function')) {
+      return result;
+    }
+    else {
+      return thisContext;
+    }
+  };
+};
+
+},{"./applyWithContext":20}],27:[function(_dereq_,module,exports){
+'use strict';
+
+/**
+ * # Try
+ *
+ * Allows functions to be optimised by isolating `try {} catch (e) {}` blocks
+ * outside the function declaration. Returns either the result of the function or an Error
+ * object if one was thrown. The caller should then check for `result instanceof Error`.
+ *
+ * ```js
+ * var result = fast.try(myFunction);
+ * if (result instanceof Error) {
+ *    console.log('something went wrong');
+ * }
+ * else {
+ *   console.log('result:', result);
+ * }
+ * ```
+ *
+ * @param  {Function} fn The function to invoke.
+ * @return {mixed}       The result of the function, or an `Error` object.
+ */
+module.exports = function fastTry (fn) {
+  try {
+    return fn();
+  }
+  catch (e) {
+    if (!(e instanceof Error)) {
+      return new Error(e);
+    }
+    else {
+      return e;
+    }
+  }
+};
+
+},{}],28:[function(_dereq_,module,exports){
+'use strict';
+
+/**
+ * # Constructor
+ *
+ * Provided as a convenient wrapper around Fast functions.
+ *
+ * ```js
+ * var arr = fast([1,2,3,4,5,6]);
+ *
+ * var result = arr.filter(function (item) {
+ *   return item % 2 === 0;
+ * });
+ *
+ * result instanceof Fast; // true
+ * result.length; // 3
+ * ```
+ *
+ *
+ * @param {Array} value The value to wrap.
+ */
+function Fast (value) {
+  if (!(this instanceof Fast)) {
+    return new Fast(value);
+  }
+  this.value = value || [];
+}
+
+module.exports = exports = Fast;
+
+Fast.array = _dereq_('./array');
+Fast['function'] = Fast.fn = _dereq_('./function');
+Fast.object = _dereq_('./object');
+Fast.string = _dereq_('./string');
+
+
+Fast.apply = Fast['function'].apply;
+Fast.bind = Fast['function'].bind;
+Fast.partial = Fast['function'].partial;
+Fast.partialConstructor = Fast['function'].partialConstructor;
+Fast['try'] = Fast.attempt = Fast['function']['try'];
+
+Fast.assign = Fast.object.assign;
+Fast.cloneObject = Fast.object.clone; // @deprecated use fast.object.clone()
+Fast.keys = Fast.object.keys;
+Fast.values = Fast.object.values;
+
+
+Fast.clone = _dereq_('./clone');
+Fast.map = _dereq_('./map');
+Fast.filter = _dereq_('./filter');
+Fast.forEach = _dereq_('./forEach');
+Fast.reduce = _dereq_('./reduce');
+Fast.reduceRight = _dereq_('./reduceRight');
+
+
+Fast.cloneArray = Fast.array.clone; // @deprecated use fast.array.clone()
+
+Fast.concat = Fast.array.concat;
+Fast.some = Fast.array.some;
+Fast.every = Fast.array.every;
+Fast.indexOf = Fast.array.indexOf;
+Fast.lastIndexOf = Fast.array.lastIndexOf;
+Fast.pluck = Fast.array.pluck;
+Fast.fill = Fast.array.fill;
+
+Fast.intern = Fast.string.intern;
+
+
+/**
+ * # Concat
+ *
+ * Concatenate multiple arrays.
+ *
+ * @param  {Array|mixed} item, ... The item(s) to concatenate.
+ * @return {Fast}                  A new Fast object, containing the results.
+ */
+Fast.prototype.concat = function Fast$concat () {
+  var length = this.value.length,
+      arr = new Array(length),
+      i, item, childLength, j;
+
+  for (i = 0; i < length; i++) {
+    arr[i] = this.value[i];
+  }
+
+  length = arguments.length;
+  for (i = 0; i < length; i++) {
+    item = arguments[i];
+    if (Array.isArray(item)) {
+      childLength = item.length;
+      for (j = 0; j < childLength; j++) {
+        arr.push(item[j]);
+      }
+    }
+    else {
+      arr.push(item);
+    }
+  }
+  return new Fast(arr);
+};
+
+/**
+ * Fast Map
+ *
+ * @param  {Function} fn          The visitor function.
+ * @param  {Object}   thisContext The context for the visitor, if any.
+ * @return {Fast}                 A new Fast object, containing the results.
+ */
+Fast.prototype.map = function Fast$map (fn, thisContext) {
+  return new Fast(Fast.map(this.value, fn, thisContext));
+};
+
+/**
+ * Fast Filter
+ *
+ * @param  {Function} fn          The filter function.
+ * @param  {Object}   thisContext The context for the filter function, if any.
+ * @return {Fast}                 A new Fast object, containing the results.
+ */
+Fast.prototype.filter = function Fast$filter (fn, thisContext) {
+  return new Fast(Fast.filter(this.value, fn, thisContext));
+};
+
+/**
+ * Fast Reduce
+ *
+ * @param  {Function} fn           The reducer function.
+ * @param  {mixed}    initialValue The initial value, if any.
+ * @param  {Object}   thisContext  The context for the reducer, if any.
+ * @return {mixed}                 The final result.
+ */
+Fast.prototype.reduce = function Fast$reduce (fn, initialValue, thisContext) {
+  return Fast.reduce(this.value, fn, initialValue, thisContext);
+};
+
+
+/**
+ * Fast Reduce Right
+ *
+ * @param  {Function} fn           The reducer function.
+ * @param  {mixed}    initialValue The initial value, if any.
+ * @param  {Object}   thisContext  The context for the reducer, if any.
+ * @return {mixed}                 The final result.
+ */
+Fast.prototype.reduceRight = function Fast$reduceRight (fn, initialValue, thisContext) {
+  return Fast.reduceRight(this.value, fn, initialValue, thisContext);
+};
+
+/**
+ * Fast For Each
+ *
+ * @param  {Function} fn          The visitor function.
+ * @param  {Object}   thisContext The context for the visitor, if any.
+ * @return {Fast}                 The Fast instance.
+ */
+Fast.prototype.forEach = function Fast$forEach (fn, thisContext) {
+  Fast.forEach(this.value, fn, thisContext);
+  return this;
+};
+
+/**
+ * Fast Some
+ *
+ * @param  {Function} fn          The matcher predicate.
+ * @param  {Object}   thisContext The context for the matcher, if any.
+ * @return {Boolean}              True if at least one element matches.
+ */
+Fast.prototype.some = function Fast$some (fn, thisContext) {
+  return Fast.some(this.value, fn, thisContext);
+};
+
+/**
+ * Fast Every
+ *
+ * @param  {Function} fn          The matcher predicate.
+ * @param  {Object}   thisContext The context for the matcher, if any.
+ * @return {Boolean}              True if at all elements match.
+ */
+Fast.prototype.every = function Fast$every (fn, thisContext) {
+  return Fast.some(this.value, fn, thisContext);
+};
+
+/**
+ * Fast Index Of
+ *
+ * @param  {mixed}  target    The target to lookup.
+ * @param  {Number} fromIndex The index to start searching from, if known.
+ * @return {Number}           The index of the item, or -1 if no match found.
+ */
+Fast.prototype.indexOf = function Fast$indexOf (target, fromIndex) {
+  return Fast.indexOf(this.value, target, fromIndex);
+};
+
+
+/**
+ * Fast Last Index Of
+ *
+ * @param  {mixed}  target    The target to lookup.
+ * @param  {Number} fromIndex The index to start searching from, if known.
+ * @return {Number}           The last index of the item, or -1 if no match found.
+ */
+Fast.prototype.lastIndexOf = function Fast$lastIndexOf (target, fromIndex) {
+  return Fast.lastIndexOf(this.value, target, fromIndex);
+};
+
+/**
+ * Reverse
+ *
+ * @return {Fast} A new Fast instance, with the contents reversed.
+ */
+Fast.prototype.reverse = function Fast$reverse () {
+  return new Fast(this.value.reverse());
+};
+
+/**
+ * Value Of
+ *
+ * @return {Array} The wrapped value.
+ */
+Fast.prototype.valueOf = function Fast$valueOf () {
+  return this.value;
+};
+
+/**
+ * To JSON
+ *
+ * @return {Array} The wrapped value.
+ */
+Fast.prototype.toJSON = function Fast$toJSON () {
+  return this.value;
+};
+
+/**
+ * Item Length
+ */
+Object.defineProperty(Fast.prototype, 'length', {
+  get: function () {
+    return this.value.length;
+  }
+});
+
+},{"./array":7,"./clone":15,"./filter":16,"./forEach":17,"./function":24,"./map":29,"./object":34,"./reduce":40,"./reduceRight":41,"./string":42}],29:[function(_dereq_,module,exports){
+'use strict';
+
+var mapArray = _dereq_('./array/map'),
+    mapObject = _dereq_('./object/map');
+
+/**
+ * # Map
+ *
+ * A fast `.map()` implementation.
+ *
+ * @param  {Array|Object} subject     The array or object to map over.
+ * @param  {Function}     fn          The mapper function.
+ * @param  {Object}       thisContext The context for the mapper.
+ * @return {Array|Object}             The array or object containing the results.
+ */
+module.exports = function fastMap (subject, fn, thisContext) {
+  if (subject instanceof Array) {
+    return mapArray(subject, fn, thisContext);
+  }
+  else {
+    return mapObject(subject, fn, thisContext);
+  }
+};
+},{"./array/map":10,"./object/map":36}],30:[function(_dereq_,module,exports){
+'use strict';
+
+/**
+ * Analogue of Object.assign().
+ * Copies properties from one or more source objects to
+ * a target object. Existing keys on the target object will be overwritten.
+ *
+ * > Note: This differs from spec in some important ways:
+ * > 1. Will throw if passed non-objects, including `undefined` or `null` values.
+ * > 2. Does not support the curious Exception handling behavior, exceptions are thrown immediately.
+ * > For more details, see:
+ * > https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign
+ *
+ *
+ *
+ * @param  {Object} target      The target object to copy properties to.
+ * @param  {Object} source, ... The source(s) to copy properties from.
+ * @return {Object}             The updated target object.
+ */
+module.exports = function fastAssign (target) {
+  var totalArgs = arguments.length,
+      source, i, totalKeys, keys, key, j;
+
+  for (i = 1; i < totalArgs; i++) {
+    source = arguments[i];
+    keys = Object.keys(source);
+    totalKeys = keys.length;
+    for (j = 0; j < totalKeys; j++) {
+      key = keys[j];
+      target[key] = source[key];
+    }
+  }
+  return target;
+};
+
+},{}],31:[function(_dereq_,module,exports){
+'use strict';
+
+/**
+ * # Clone Object
+ *
+ * Shallow clone a simple object.
+ *
+ * > Note: Prototypes and non-enumerable properties will not be copied!
+ *
+ * @param  {Object} input The object to clone.
+ * @return {Object}       The cloned object.
+ */
+module.exports = function fastCloneObject (input) {
+  var keys = Object.keys(input),
+      total = keys.length,
+      cloned = {},
+      i, key;
+
+  for (i = 0; i < total; i++) {
+    key = keys[i];
+    cloned[key] = input[key];
+  }
+
+  return cloned;
+};
+
+},{}],32:[function(_dereq_,module,exports){
+'use strict';
+
+var bindInternal3 = _dereq_('../function/bindInternal3');
+
+/**
+ * # Filter
+ *
+ * A fast object `.filter()` implementation.
+ *
+ * @param  {Object}   subject     The object to filter.
+ * @param  {Function} fn          The filter function.
+ * @param  {Object}   thisContext The context for the filter.
+ * @return {Object}               The new object containing the filtered results.
+ */
+module.exports = function fastFilterObject (subject, fn, thisContext) {
+  var keys = Object.keys(subject),
+      length = keys.length,
+      result = {},
+      iterator = thisContext !== undefined ? bindInternal3(fn, thisContext) : fn,
+      i, key;
+  for (i = 0; i < length; i++) {
+    key = keys[i];
+    if (iterator(subject[key], key, subject)) {
+      result[key] = subject[key];
+    }
+  }
+  return result;
+};
+
+},{"../function/bindInternal3":22}],33:[function(_dereq_,module,exports){
+'use strict';
+
+var bindInternal3 = _dereq_('../function/bindInternal3');
+
+/**
+ * # For Each
+ *
+ * A fast object `.forEach()` implementation.
+ *
+ * @param  {Object}   subject     The object to iterate over.
+ * @param  {Function} fn          The visitor function.
+ * @param  {Object}   thisContext The context for the visitor.
+ */
+module.exports = function fastForEachObject (subject, fn, thisContext) {
+  var keys = Object.keys(subject),
+      length = keys.length,
+      iterator = thisContext !== undefined ? bindInternal3(fn, thisContext) : fn,
+      key, i;
+  for (i = 0; i < length; i++) {
+    key = keys[i];
+    iterator(subject[key], key, subject);
+  }
+};
+
+},{"../function/bindInternal3":22}],34:[function(_dereq_,module,exports){
+'use strict';
+
+exports.assign = _dereq_('./assign');
+exports.clone = _dereq_('./clone');
+exports.filter = _dereq_('./filter');
+exports.forEach = _dereq_('./forEach');
+exports.map = _dereq_('./map');
+exports.reduce = _dereq_('./reduce');
+exports.reduceRight = _dereq_('./reduceRight');
+exports.keys = _dereq_('./keys');
+exports.values = _dereq_('./values');
+},{"./assign":30,"./clone":31,"./filter":32,"./forEach":33,"./keys":35,"./map":36,"./reduce":37,"./reduceRight":38,"./values":39}],35:[function(_dereq_,module,exports){
+'use strict';
+
+/**
+ * Object.keys() shim for ES3 environments.
+ *
+ * @param  {Object} obj The object to get keys for.
+ * @return {Array}      The array of keys.
+ */
+module.exports = typeof Object.keys === "function" ? Object.keys : /* istanbul ignore next */ function fastKeys (obj) {
+  var keys = [];
+  for (var key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      keys.push(key);
+    }
+  }
+  return keys;
+};
+},{}],36:[function(_dereq_,module,exports){
+'use strict';
+
+var bindInternal3 = _dereq_('../function/bindInternal3');
+
+/**
+ * # Map
+ *
+ * A fast object `.map()` implementation.
+ *
+ * @param  {Object}   subject     The object to map over.
+ * @param  {Function} fn          The mapper function.
+ * @param  {Object}   thisContext The context for the mapper.
+ * @return {Object}               The new object containing the results.
+ */
+module.exports = function fastMapObject (subject, fn, thisContext) {
+  var keys = Object.keys(subject),
+      length = keys.length,
+      result = {},
+      iterator = thisContext !== undefined ? bindInternal3(fn, thisContext) : fn,
+      i, key;
+  for (i = 0; i < length; i++) {
+    key = keys[i];
+    result[key] = iterator(subject[key], key, subject);
+  }
+  return result;
+};
+
+},{"../function/bindInternal3":22}],37:[function(_dereq_,module,exports){
+'use strict';
+
+var bindInternal4 = _dereq_('../function/bindInternal4');
+
+/**
+ * # Reduce
+ *
+ * A fast object `.reduce()` implementation.
+ *
+ * @param  {Object}   subject      The object to reduce over.
+ * @param  {Function} fn           The reducer function.
+ * @param  {mixed}    initialValue The initial value for the reducer, defaults to subject[0].
+ * @param  {Object}   thisContext  The context for the reducer.
+ * @return {mixed}                 The final result.
+ */
+module.exports = function fastReduceObject (subject, fn, initialValue, thisContext) {
+  var keys = Object.keys(subject),
+      length = keys.length,
+      iterator = thisContext !== undefined ? bindInternal4(fn, thisContext) : fn,
+      i, key, result;
+
+  if (initialValue === undefined) {
+    i = 1;
+    result = subject[keys[0]];
+  }
+  else {
+    i = 0;
+    result = initialValue;
+  }
+
+  for (; i < length; i++) {
+    key = keys[i];
+    result = iterator(result, subject[key], key, subject);
+  }
+
+  return result;
+};
+
+},{"../function/bindInternal4":23}],38:[function(_dereq_,module,exports){
+'use strict';
+
+var bindInternal4 = _dereq_('../function/bindInternal4');
+
+/**
+ * # Reduce
+ *
+ * A fast object `.reduce()` implementation.
+ *
+ * @param  {Object}   subject      The object to reduce over.
+ * @param  {Function} fn           The reducer function.
+ * @param  {mixed}    initialValue The initial value for the reducer, defaults to subject[0].
+ * @param  {Object}   thisContext  The context for the reducer.
+ * @return {mixed}                 The final result.
+ */
+module.exports = function fastReduceRightObject (subject, fn, initialValue, thisContext) {
+  var keys = Object.keys(subject),
+      length = keys.length,
+      iterator = thisContext !== undefined ? bindInternal4(fn, thisContext) : fn,
+      i, key, result;
+
+  if (initialValue === undefined) {
+    i = length - 2;
+    result = subject[keys[length - 1]];
+  }
+  else {
+    i = length - 1;
+    result = initialValue;
+  }
+
+  for (; i >= 0; i--) {
+    key = keys[i];
+    result = iterator(result, subject[key], key, subject);
+  }
+
+  return result;
+};
+
+},{"../function/bindInternal4":23}],39:[function(_dereq_,module,exports){
+'use strict';
+
+/**
+ * # Values
+ * Return all the (enumerable) property values for an object.
+ * Like Object.keys() but for values.
+ *
+ * @param  {Object} obj The object to retrieve values from.
+ * @return {Array}      An array containing property values.
+ */
+module.exports = function fastValues (obj) {
+  var keys = Object.keys(obj),
+      length = keys.length,
+      values = new Array(length);
+
+  for (var i = 0; i < length; i++) {
+    values[i] = obj[keys[i]];
+  }
+  return values;
+};
+},{}],40:[function(_dereq_,module,exports){
+'use strict';
+
+var reduceArray = _dereq_('./array/reduce'),
+    reduceObject = _dereq_('./object/reduce');
+
+/**
+ * # Reduce
+ *
+ * A fast `.reduce()` implementation.
+ *
+ * @param  {Array|Object} subject      The array or object to reduce over.
+ * @param  {Function}     fn           The reducer function.
+ * @param  {mixed}        initialValue The initial value for the reducer, defaults to subject[0].
+ * @param  {Object}       thisContext  The context for the reducer.
+ * @return {Array|Object}              The array or object containing the results.
+ */
+module.exports = function fastReduce (subject, fn, initialValue, thisContext) {
+  if (subject instanceof Array) {
+    return reduceArray(subject, fn, initialValue, thisContext);
+  }
+  else {
+    return reduceObject(subject, fn, initialValue, thisContext);
+  }
+};
+},{"./array/reduce":12,"./object/reduce":37}],41:[function(_dereq_,module,exports){
+'use strict';
+
+var reduceRightArray = _dereq_('./array/reduceRight'),
+    reduceRightObject = _dereq_('./object/reduceRight');
+
+/**
+ * # Reduce Right
+ *
+ * A fast `.reduceRight()` implementation.
+ *
+ * @param  {Array|Object} subject      The array or object to reduce over.
+ * @param  {Function}     fn           The reducer function.
+ * @param  {mixed}        initialValue The initial value for the reducer, defaults to subject[0].
+ * @param  {Object}       thisContext  The context for the reducer.
+ * @return {Array|Object}              The array or object containing the results.
+ */
+module.exports = function fastReduceRight (subject, fn, initialValue, thisContext) {
+  if (subject instanceof Array) {
+    return reduceRightArray(subject, fn, initialValue, thisContext);
+  }
+  else {
+    return reduceRightObject(subject, fn, initialValue, thisContext);
+  }
+};
+},{"./array/reduceRight":13,"./object/reduceRight":38}],42:[function(_dereq_,module,exports){
+'use strict';
+
+exports.intern = _dereq_('./intern');
+},{"./intern":43}],43:[function(_dereq_,module,exports){
+'use strict';
+
+// Compilers such as V8 use string interning to make string comparison very fast and efficient,
+// as efficient as comparing two references to the same object.
+//
+//
+// V8 does its best to intern strings automatically where it can, for instance:
+// ```js
+//   var greeting = "hello world";
+// ```
+// With this, comparison will be very fast:
+// ```js
+//   if (greeting === "hello world") {}
+// ```
+// However, there are several cases where V8 cannot intern the string, and instead
+// must resort to byte-wise comparison. This can be signficantly slower for long strings.
+// The most common example is string concatenation:
+// ```js
+//   function subject () { return "world"; };
+//   var greeting = "hello " + subject();
+// ```
+// In this case, V8 cannot intern the string. So this comparison is *much* slower:
+// ```js
+//  if (greeting === "hello world") {}
+// ```
+
+
+
+// At the moment, the fastest, safe way of interning a string is to
+// use it as a key in an object, and then use that key.
+//
+// Note: This technique comes courtesy of Petka Antonov - http://jsperf.com/istrn/11
+//
+// We create a container object in hash mode.
+// Most strings being interned will not be valid fast property names,
+// so we ensure hash mode now to avoid transitioning the object mode at runtime.
+var container = {'- ': true};
+delete container['- '];
+
+
+/**
+ * Intern a string to make comparisons faster.
+ *
+ * > Note: This is a relatively expensive operation, you
+ * shouldn't usually do the actual interning at runtime, instead
+ * use this at compile time to make future work faster.
+ *
+ * @param  {String} string The string to intern.
+ * @return {String}        The interned string.
+ */
+module.exports = function fastIntern (string) {
+  container[string] = true;
+  var interned = Object.keys(container)[0];
+  delete container[interned];
+  return interned;
+};
+},{}]},{},[28])
+(28)
+});