text: require=(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})({"FR1krT":[function(require,module,exports){
  'use strict';
  
  var Js = require('./lib/js');
  var Preconditions = require('precondition');
  var _ = require('underscore');
  var PriorityQueue = require('priorityqueuejs');
  require('sugar');
  var util = require('./lib/util');
  
  var group = require('./lib/group');
  var windowReducer = require('./lib/window');
  var transformer = require('./lib/transformer');
  
  exports.GroupingIterator = group.GroupingIterator;
  exports.WindowReducerIterator = windowReducer.WindowReducerIterator;
  exports.TransformerIterator = transformer.TransformerIterator;
  
  /**
   * Build an iterator that iterates over an array once. This skips over any null or undefined elements,
   * and only returns null to indicate end-of-stream.
   *
   * @param content
   * @constructor
   */
  exports.ArrayIterator = function (content) {
    Preconditions.checkType(_.isArray(content), 'Expected array content, but was %s', content);
  
    var i = 0;
  
    this.next = function () {
      while (i < content.length) {
        var item = content[i++];
  
        if (Js.isSomething(item)) {
          return item;
        }
      }
  
      return null;
    };
  };
  
  /**
   * Extending Array with an iterator() factory method, as syntactic sugar for instantiating new
   * iterators that iterate over arrays.
   *
   * @returns {Iterators.ArrayIterator}
   */
  Array.prototype.iterator = function () {
    return new exports.ArrayIterator(this);
  };
  
  exports.ObjectIterator = function (obj) {
    Preconditions.checkType(_.isObject(obj), 'Expected an Object, but was %s', obj);
    var kvPairs = [];
  
    Object.keys(obj, function (key, value) {
      kvPairs.push({key: key, value: value});
    });
  
    var iterator = kvPairs.iterator();
  
    this.next = iterator.next;
  };
  
  exports.toIterator = function (obj) {
    if (_.isArray(obj)) {
      return new exports.ArrayIterator(obj);
    }
  
    if (_.isObject(obj)) {
      return new exports.ObjectIterator(obj);
    }
  
    throw new Error('Expected an array or an object, but was: ' + obj);
  };
  
  /**
   * Reduce contiguous equal objects returned by a delegate iterator.
   * This iterator will call ahead to the delegate iterator, and buffer the next item.
   *
   * @constructor
   */
  exports.IteratorAggregator = function (delegateIterator, reduce, isEqual) {
    util.checkIsIterator(delegateIterator);
    Preconditions.checkType(_.isFunction(reduce), 'Undefined reducer function.');
  
    if (Js.isNothing(isEqual)) {
      isEqual = util.strictEquality;
    } else {
      Preconditions.checkType(_.isFunction(isEqual), 'Expected isEqual function, but was %s', isEqual);
    }
  
    var nextItem;
    var pullCount = 0;
  
    var pullNext = function () {
      var next = delegateIterator.next();
      pullCount++;
      return next;
    };
  
    this.next = function () {
      if (pullCount < 1) {
        nextItem = pullNext();
      }
  
      if (Js.isNothing(nextItem)) {
        return null;
      }
  
      var reduced = nextItem;
  
      var cursorItem = pullNext();
  
      while (isEqual(cursorItem, nextItem)) {
        reduced = reduce(cursorItem, reduced);
        cursorItem = pullNext();
      }
  
      nextItem = cursorItem;
      return reduced;
    };
  };
  
  var naturalComparatorDesc = function (lhs, rhs) {
    if (lhs < rhs) {
      return 1;
    }
  
    if (lhs === rhs) {
      return 0;
    }
  
    return -1;
  };
  
  var reverseComparator = function (comparator) {
    return function (lhs, rhs) {
      return - comparator(lhs, rhs);
    };
  };
  
  /**
   *
   * @param iterators - an array of iterators returning objects in the same sorted order
   * @param comparator - (optional) compares order of iterator output objects, in ascending order.
   * @constructor
   */
  exports.SortedIteratorMerger = function (iterators, comparator) {
    Preconditions.checkType(_.isArray(iterators), 'Expected an array of iterators, but was %s', iterators);
  
    if (Js.isNothing(comparator)) {
      comparator = naturalComparatorDesc;
    } else {
      Preconditions.checkType(_.isFunction(comparator), 'Expected a comparator function, but was %s', comparator);
      comparator = reverseComparator(comparator);
    }
  
    iterators = iterators.clone(); // capture original iterator ordinals
  
    var wrapperComparator = function (lhs, rhs) {
      return comparator(lhs.item, rhs.item);
    };
  
    // initialize the buffer
    var buffer = new PriorityQueue(wrapperComparator);
  
    for (var i = 0; i < iterators.length; i++) {
      var iterator = iterators[i];
      util.checkIsIterator(iterator);
      var item = iterator.next();
  
      if (Js.isSomething(item)) {
        buffer.enq({index: i, item: item});
      }
    }
  
    // pull the next event from the cursors
    this.next = function () {
      if (buffer.size() < 1) {
        return null;
      }
  
      var wrapper = buffer.deq();
  
      if (Js.isNothing(wrapper)) {
        return null;
      }
  
      var sourceIndex = wrapper.index;
      var replacement = iterators[sourceIndex].next();
  
      if (Js.isSomething(replacement)) {
        buffer.enq({index: sourceIndex, item: replacement});
      }
  
      return wrapper.item;
    };
  };
  
  exports.MemoizedIteratorReplay = function (memoized) {
    Preconditions.checkType(memoized instanceof exports.MemoizedIterator);
    var index = 0;
  
    this.next = function () {
      return memoized.at(index++);
    };
  };
  
  /**
   * Record all items returned by an interator, so that another one can replay through
   * them later. The replayer can also iterate past the position of this iterator, in which case
   * the new items will be cached and ready for the subsequent next() call on this iterator.
   *
   * @param iterator
   * @constructor
   */
  exports.MemoizedIterator = function (iterator) {
    util.checkIsIterator(iterator);
  
    var history = [];
  
    var pullNext = function () {
      var item = iterator.next();
      history.push(item);
      return item;
    };
  
    this.at = function (index) {
      Preconditions.check(Js.isIntegerNumber(index), 'Illegal index: %s', index);
      Preconditions.checkRange(index >= 0, 'Index out of bounds: %s', index);
  
      if (index < history.length) {
        return history[index];
      }
  
      if (index === history.length) {
        return pullNext();
      }
  
      throw new Error('Index out of bounds: ' + index);
    };
  
    this.replay = function () {
      return new exports.MemoizedIteratorReplay(this);
    };
  
    var cursor = this.replay();
  
    this.next = cursor.next;
  };
  
  /**
   * Terminate an iterator early.
   *
   * @param iterator
   * @param limit
   * @constructor
   */
  exports.LimitIterator = function (iterator, limit) {
    util.checkIsIterator(iterator);
    Preconditions.checkType(Js.isIntegerNumber(limit), 'Expected number limit, but was %s', limit);
  
    var count = 0;
  
    this.next = function () {
      if (count >= limit) {
        return null;
      }
  
      var item = iterator.next();
  
      if (Js.isNothing(item)) {
        return null;
      }
  
      count++;
  
      return item;
    };
  };
  
  exports.FilterIterator = function (iterator, predicate) {
    util.checkIsIterator(iterator);
    Preconditions.checkType(_.isFunction(predicate), 'Expected a predicate function, but was %s', predicate);
  
    this.next = function () {
      while (true) {
        var item = iterator.next();
  
        if (Js.isNothing(item)) {
          return null;
        }
  
        var filterValue = predicate(item);
  
        switch (filterValue) {
          case true:
            return item;
          case false:
            break; // continue loop
          default:
            throw new Error('Expected predicate to return true (pass through) or false (filter out), but was ' + filterValue);
        }
      }
    };
  };
  
  /**
   * Use a wrapper to wrap custom iterators so that you can call fluent iterator functions on it.
   *
   * @param iterator
   * @constructor
   */
  exports.IteratorWrapper = function (iterator) {
    util.checkIsIterator(iterator);
  
    this.next = function () {
      return iterator.next();
    };
  };
  
  /**
   * This is a superclass for all iterators, with fluent factory methods to layer on any other kind of iterator.
   *
   * @constructor
   */
  exports.Iterator = function () {
  };
  
  exports.Iterator.prototype.toArray = function () {
    var buffer = [];
    var item = this.next();
  
    while (Js.isSomething(item)) {
      buffer.push(item);
      item = this.next();
    }
  
    return buffer;
  };
  
  exports.Iterator.prototype.aggregate = function (reducer, isEqual) {
    return new exports.IteratorAggregator(this, reducer, isEqual);
  };
  
  exports.Iterator.prototype.mergeSortedIterators = function (iterators, comparator) {
    Preconditions.checkType(_.isArray(iterators), 'Expected an array of iterators, but was %s', iterators);
    var allIterators = iterators.clone();
    allIterators.push(this);
    return new exports.SortedIteratorMerger(allIterators, comparator);
  };
  
  exports.Iterator.prototype.memoize = function () {
    return new exports.MemoizedIterator(this);
  };
  
  exports.Iterator.prototype.group = function (isSameGroup) {
    return new group.GroupingIterator(this, isSameGroup);
  };
  
  exports.Iterator.prototype.window = function (windowSize, reducer) {
    return new windowReducer.WindowReducerIterator(this, windowSize, reducer);
  };
  
  exports.Iterator.prototype.transform = function (transformerFunction) {
    return new transformer.TransformerIterator(this, transformerFunction);
  };
  
  exports.Iterator.prototype.limit = function (limit) {
    return new exports.LimitIterator(this, limit);
  };
  
  exports.Iterator.prototype.filter = function (predicate) {
    return new exports.FilterIterator(this, predicate);
  };
  
  // sugar for draining the iterator
  exports.Iterator.prototype.forEach = function (itemCallback) {
    Preconditions.checkType(_.isFunction(itemCallback), 'Expected an item callback function, but was %s', itemCallback);
  
    for (var item = this.next(); Js.isSomething(item); item = this.next()) {
      itemCallback(item);
    }
  };
  
  // extend Iterator abstract class
  Object.merge(exports.IteratorAggregator.prototype, exports.Iterator.prototype, false);
  Object.merge(exports.SortedIteratorMerger.prototype, exports.Iterator.prototype, false);
  Object.merge(exports.ArrayIterator.prototype, exports.Iterator.prototype, false);
  Object.merge(exports.ObjectIterator.prototype, exports.Iterator.prototype, false);
  Object.merge(exports.MemoizedIterator.prototype, exports.Iterator.prototype, false);
  Object.merge(exports.MemoizedIteratorReplay.prototype, exports.Iterator.prototype, false);
  Object.merge(exports.GroupingIterator.prototype, exports.Iterator.prototype, false);
  Object.merge(exports.WindowReducerIterator.prototype, exports.Iterator.prototype, false);
  Object.merge(exports.IteratorWrapper.prototype, exports.Iterator.prototype, false);
  Object.merge(exports.TransformerIterator.prototype, exports.Iterator.prototype, false);
  Object.merge(exports.LimitIterator.prototype, exports.Iterator.prototype, false);
  Object.merge(exports.FilterIterator.prototype, exports.Iterator.prototype, false);
  
  // utility functions
  exports.mergeSortedIterators = function (iterators, comparator) {
    return new exports.SortedIteratorMerger(iterators, comparator);
  };
  
  exports.asIterator = function (iterator) {
    return new exports.IteratorWrapper(iterator);
  };
  },{"./lib/group":3,"./lib/js":4,"./lib/transformer":5,"./lib/util":6,"./lib/window":7,"precondition":8,"priorityqueuejs":10,"sugar":11,"underscore":12}],"FluentIterators":[function(require,module,exports){
  module.exports=require('FR1krT');
  },{}],3:[function(require,module,exports){
  'use strict';
  
  var Js = require('./js');
  var util = require('./util');
  var Preconditions = require('precondition');
  var _ = require('underscore');
  
  /**
   * Group consecutive items pulled out of a source iterator.
   * This iterator returns arrays of consecutive items that belong to the same group, according to the callback function.
   *
   * @param sourceIterator
   * @param isSameGroup - (optional) takes 2 parameters. returns true if they belong to the same group,
   * or false if they don't.
   * By default, we use a strict equality function, if isSameGroup is not provided:
   *  function (lhs, rhs) {
   *    return lhs === rhs;
   *  }
   * @constructor
   */
  exports.GroupingIterator = function (sourceIterator, isSameGroup) {
    util.checkIsIterator(sourceIterator);
  
    if (Js.isNothing(isSameGroup)) {
      isSameGroup = util.strictEquality;
    } else {
      Preconditions.checkType(_.isFunction(isSameGroup));
    }
  
    var group = [];
  
    this.next = function () {
      while (true) {
        var item = sourceIterator.next();
        var fullGroup;
  
        if (Js.isNothing(item)) {
          if (group.length > 0) {
            fullGroup = group;
            group = [];
            return fullGroup;
          } else {
            return null;
          }
        }
  
        if (group.length < 1) {
          group.push(item);
          continue;
        }
  
        if (isSameGroup(group[0], item)) {
          group.push(item);
        } else {
          fullGroup = group;
          group = [item];
          return fullGroup;
        }
      }
    };
  };
  
  },{"./js":4,"./util":6,"precondition":8,"underscore":12}],4:[function(require,module,exports){
  'use strict';
  
  var _ = require('underscore');
  
  var Js = {};
  
  module.exports = Js;
  
  /**
   * shorthand for "is null or undefined"
   * @param x
   */
  Js.isNothing = function (x) {
    return x === undefined || x === null;
  };
  
  /**
   * shorthand for "is not nothing"
   * @param x
   * @returns {boolean}
   */
  Js.isSomething = function (x) {
    return !Js.isNothing(x);
  };
  
  Js.isNumber = function (n) {
    return typeof n === 'number' && !isNaN(n) && isFinite(n);
  };
  
  /**
   * Check that a string or number is an integer.
   * Note that you can't necessarily to math with all integers.
   * String integers and number integers have different + operators (concat vs add).
   * We have many integer ids, so this is useful to check for valid ids.
   *
   * @param n
   * @returns {boolean} true if n is a string or number representing an integer.
   * strings with dots and letters evaluate to false, and objects are false.
   */
  Js.isInteger = function (n) {
    if (n === null) {
      return false;
    }
  
    if (isNaN(n)) {
      return false;
    }
  
    return parseInt(n, 10) === parseFloat(n);
  };
  
  /**
   * Check that a number is an integer. This will reject strings.
   * Note that you can't necessarily do math with all integers.
   * String integers and number integers have different + operators (concat vs add).
   * We have many integer ids, so this is useful to check for valid ids.
   *
   * @param n
   * @returns {boolean} true if n is a string or number representing an integer.
   */
  Js.isIntegerNumber = function (n) {
    if ((typeof n) !== 'number') {
      return false;
    }
  
    return Js.isInteger(n);
  };
  
  /**
   * Check that a string or number is an integer, and it's > 0.
   * Note that you can't necessarily to math with all integers.
   * String integers and number integers have different + operators (concat vs add).
   * We have many integer ids, so this is useful to check for valid ids.
   *
   * @param n
   * @returns {boolean} true if n is a string or number representing an integer.
   * strings with dots and letters evaluate to false, and objects are false.
   */
  Js.isPositiveInteger = function (n) {
    if (!Js.isInteger(n)) {
      return false;
    }
  
    return n > 0;
  };
  
  Js.isEmptyString = function(s) {
    return !_.isString(s) || s.length === 0;
  };
  
  Js.formatString = function () {
    var str = arguments[0];
  
    if (!_.isString(str)) {
      throw 'Expected first argument to be the string format, but was ' + str;
    }
  
    for (var i = 1; i < arguments.length; i++) {
      var arg = arguments[i];
      str = str.replace('%s', arg);
    }
  
    return str;
  };
  
  Js.printException = function (ex) {
    if (!(ex instanceof Error)) {
      return 'Expected an Error, but was ' + ex;
    }
  
    return ex.message + '\n' + ex.stack;
  };
  
  },{"underscore":12}],5:[function(require,module,exports){
  'use strict';
  
  var util = require('./util');
  var Js = require('./js');
  var Preconditions = require('precondition');
  var _ = require('underscore');
  
  exports.TransformerIterator = function (iterator, transformer) {
    util.checkIsIterator(iterator);
    Preconditions.checkType(_.isFunction(transformer), 'Expected transformer function, but was %s', transformer);
  
    this.next = function () {
      var item = iterator.next();
  
      if (Js.isNothing(item)) {
        return null;
      }
  
      return transformer(item);
    };
  };
  
  },{"./js":4,"./util":6,"precondition":8,"underscore":12}],6:[function(require,module,exports){
  'use strict';
  
  var Preconditions = require('precondition');
  var _ = require('underscore');
  
  exports.checkIsIterator = function (iterator) {
    Preconditions.checkType(_.isObject(iterator), 'Illegal iterator: Not an object.');
    Preconditions.checkType(_.isFunction(iterator.next), 'Illegal iterator: Missing next() function.');
  };
  
  exports.strictEquality = function (lhs, rhs) {
    return lhs === rhs;
  };
  
  
  },{"precondition":8,"underscore":12}],7:[function(require,module,exports){
  'use strict';
  
  var util = require('./util');
  var Preconditions = require('precondition');
  var Js = require('./js');
  var _ = require('underscore');
  
  var ArrayReducer = function (sourceIterator, windowSize, reducer) {
    util.checkIsIterator(sourceIterator);
    Preconditions.checkRange(Js.isPositiveInteger(windowSize),
      'Reducer window size out of bounds: %s', windowSize);
    Preconditions.checkType(_.isFunction(reducer));
  
    this.source = sourceIterator;
    this.windowSize = windowSize;
    this.reducer = reducer;
    this.buffer = [];
  };
  
  ArrayReducer.prototype = {
    next: function () {
      var item = this.source.next();
  
      if (Js.isNothing(item)) {
        return null;
      }
  
      this.buffer.push(item);
  
      var reduced = this.buffer.reduce(this.reducer);
  
      if (this.buffer.length >= this.windowSize) {
        this.buffer.shift();
      }
  
      return reduced;
    }
  };
  
  var missingFunctionError = 'Accumulator missing %s function.';
  
  var AccumulatorReducer = function (sourceIterator, windowSize, reducer) {
    util.checkIsIterator(sourceIterator);
    Preconditions.checkRange(Js.isPositiveInteger(windowSize),
      'Reducer window size out of bounds: %s', windowSize);
    Preconditions.checkType(_.isFunction(reducer.add), missingFunctionError, 'add(item)');
    Preconditions.checkType(_.isFunction(reducer.remove), missingFunctionError, 'remove(item)');
    Preconditions.checkType(_.isFunction(reducer.reduce), missingFunctionError, 'reducer()');
  
    this.source = sourceIterator;
    this.windowSize = windowSize;
    this.reducer = reducer;
    this.buffer = [];
  };
  
  AccumulatorReducer.prototype = {
    next: function () {
      var item = this.source.next();
  
      if (Js.isNothing(item)) {
        return null;
      }
  
      this.buffer.push(item);
      this.reducer.add(item);
  
      var reduced = this.reducer.reduce();
  
      if (this.buffer.length >= this.windowSize) {
        this.reducer.remove(this.buffer.shift());
      }
  
      return reduced;
    }
  };
  
  /**
   * Do a sliding-window aggregation on the output of a source iterator,
   * for example: calculating a moving-average. This emits one output for every input.
   *
   * @param sourceIterator
   * @param windowSize - the number of items to include in each run of the reducer.
   * @param reducer - either a function or an object.
   * 1) Function: reducer callback function that you would use in a native Array.reduce() call,
   * as per the mozilla documentation:
   * (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce)
   * This provides O(windowSize * n) time cost, because it runs through the window buffer in each iteration.
   *
   * 2) Object: must have 3 functions: add(item), remove(item), reduce()
   * This alternative gives the caller the option to have a better performance profile, if their
   * data type is amenable to accumulation, and they don't need to run through the window buffer in
   * each iteration, for example a cursor for computing the moving average of a series of numbers.
   *
   * This provides O(n) time cost, as long as the reducer object
   * provides O(1) time cost for add(), remove(), and reduce().
   *
   * @constructor
   */
  exports.WindowReducerIterator = function (sourceIterator, windowSize, reducer) {
    var iterator;
  
    if (_.isFunction(reducer)) {
      iterator = new ArrayReducer(sourceIterator, windowSize, reducer);
    } else if (_.isObject(reducer)) {
      iterator = new AccumulatorReducer(sourceIterator, windowSize, reducer);
    } else {
      throw new TypeError('Expected a reducer function or accumulator object, but was %s', reducer);
    }
  
    this.next = function () {
      return iterator.next();
    };
  };
  
  },{"./js":4,"./util":6,"precondition":8,"underscore":12}],8:[function(require,module,exports){
  module.exports = require('./lib/precondition.js');
  },{"./lib/precondition.js":9}],9:[function(require,module,exports){
  /** Generic check function which throws an error if a given expression is false
  *
  *	The params list is a bit confusing, check the examples to see the available ways of calling this function
  *
  *	@param {Boolean} expression The determinant of whether an exception is thrown
  *	@param {String|Object} [messageOrErrorType] A message or an ErrorType object to throw if expression is false
  *   @param {String|Object} [messageOrMessageArgs] A message, message template, or a message argument
  *	@param {...Object} [messageArgs] Arguments for a provided message template
  *
  *	@returns {Boolean} Returns the expression passed  
  *	@throws {Error}
  *
  *	@example
  *		check(0 < 10); // returns true
  *		check(0 > 10); // throws Error with no message
  *		check(0 > 10, "Something went wrong!"); // throws Error with message: "Something went wrong!"
  *		check(0 > 10, "%s went %s!", "something", "wrong"); // throws Error with message: "Something went wrong!"
  *		check(0 > 10, RangeError, "%s went %s!", "something", "wrong"); // throws RangeError with message: "Something went wrong!"
  *		check(0 > 10, RangeError); // throws RangeError with no message
  */
  exports.check = function(expression, messageOrErrorType){
  	if(expression === false){
  		if(messageOrErrorType && typeof messageOrErrorType !== "string"){ // Check if custom error object passed
  			throw messageOrErrorType(arguments.length > 3 ? templatedMessage(arguments[2], splice.call(arguments,3)) : arguments[2]);	
  		} else {
  			throw new Error(arguments.length > 2 ? templatedMessage(messageOrErrorType, splice.call(arguments,2)) : messageOrErrorType);	
  		}
  	}
  	return expression;
  };
  
  /** Throws a TypeError if a given expression is false
  *
  *	@param {Boolean} expression The determinant of whether an exception is thrown
  *	@param {String} [message] A message or message template for the error (if it gets thrown)
  *	@param {...Object} [messageArgs] Arguments for a provided message template
  *
  *	@returns {Boolean} Returns the expression passed  
  *	@throws {TypeError}
  *
  *	@example
  *		checkType(typeof "Team" === "string"); // returns true
  *		checkType(typeof "Team" === "number"); // throws TypeError with no message
  *		checkType(void 0, "Something went wrong!"); // throws TypeError with message: "Something went wrong!"
  *		checkType(void 0, "%s went %s!", "something", "wrong"); // throws TypeError with message: "Something went wrong!"
  */
  exports.checkType = function(expression, message){
  	if(expression === false){
  		throw new TypeError(arguments.length > 2 ? templatedMessage(message, splice.call(arguments,2)) : message);
  	}
  	return expression;
  };
  
  /** Throws a ReferenceError if a given expression is false
  *
  *	@param {Boolean} expression The determinant of whether an exception is thrown
  *	@param {String} [message] A message or message template for the error (if it gets thrown)
  *	@param {...Object} [messageArgs] Arguments for a provided message template
  *
  *	@returns {Object} Returns the expression passed  
  *	@throws {ReferenceError}
  *
  *	@example
  *		checkDefined("Something"); // returns true
  *		checkDefined(void 0); // throws ReferenceError with no message
  *		checkDefined(void 0, "Something went wrong!"); // throws ReferenceError with message: "Something went wrong!"
  *		checkDefined(void 0, "%s went %s!", "something", "wrong"); // throws ReferenceError with message: "Something went wrong!"
  */
  exports.checkDefined = function(expression, message){
  	if(expression === void 0){
  		throw new ReferenceError(arguments.length > 2 ? templatedMessage(message, splice.call(arguments,2)) : message);
  	}
  
  	return expression;
  };
  
  /** Throws a RangeError if a given expression is false
  *
  *	@param {Boolean} expression The determinant of whether an exception is thrown
  *	@param {String} [message] A message or message template for the error (if it gets thrown)
  *	@param {...Object} [messageArgs] Arguments for a provided message template
  *
  *	@returns {Boolean} Returns the expression passed  
  *	@throws {RangeError}
  *
  *	@example
  *		checkRange(1 > 0); // returns true
  *		checkRange(1 < 2); // throws RangeError with no message
  *		checkRange(1 < 2 && 1 > 2, "Something went wrong!"); // throws RangeError with message: "Something went wrong!"
  *		checkRange(1 < 2 && 1 > 2, "%s went %s!", "something", "wrong"); // throws RangeError with message: "Something went wrong!"
  */
  exports.checkRange = function(expression, message){
  	if(expression === false){
  		throw new RangeError(arguments.length > 2 ? templatedMessage(message, splice.call(arguments,2)) : message);
  	}
  
  	return expression;
  };
  
  var splice = Array.prototype.splice; // Reduce resolution calls
  var templateRegEx = /%s/; // The template placeholder, used to split message templates
  
  /** A basic templating function. 
  	
  	Takes a string with 0 or more '%s' placeholders and an array to populate it with.
  
  	@param {String} messageTemplate A string which may or may not have 0 or more '%s' to denote argument placement
  	@param {Array} [messageArguments] Items to populate the template with
  
  	@example
  		templatedMessage("Hello"); // returns "Hello"
  		templatedMessage("Hello, %s", ["world"]); // returns "Hello, world"
  		templatedMessage("Hello, %s. It's %s degrees outside.", ["world", 72]); // returns "Hello, world. It's 72 degrees outside"
  
  	@returns {String} The resolved message
  */
  var templatedMessage = function(messageTemplate, messageArguments){
  	var result = [],
  		messageArray = messageTemplate.split(templateRegEx),
  		index = 0,
  		length = messageArray.length;
  
  	for(; index < length; index++){
  		result.push(messageArray[index]);
  		result.push(messageArguments[index]);
  	}
  
  	return result.join('');
  };
  
  },{}],10:[function(require,module,exports){
  /**
   * Expose `PriorityQueue`.
   */
  module.exports = PriorityQueue;
  
  /**
   * Initializes a new empty `PriorityQueue` with the given `comparator(a, b)`
   * function, uses `.DEFAULT_COMPARATOR()` when no function is provided.
   *
   * The comparator function must return a positive number when `a > b`, 0 when
   * `a == b` and a negative number when `a < b`.
   *
   * @param {Function}
   * @return {PriorityQueue}
   * @api public
   */
  function PriorityQueue(comparator) {
    this._comparator = comparator || PriorityQueue.DEFAULT_COMPARATOR;
    this._elements = [];
  }
  
  /**
   * Compares `a` and `b`, when `a > b` it returns a positive number, when
   * it returns 0 and when `a < b` it returns a negative number.
   *
   * @param {String|Number} a
   * @param {String|Number} b
   * @return {Number}
   * @api public
   */
  PriorityQueue.DEFAULT_COMPARATOR = function(a, b) {
    if (a instanceof Number && b instanceof Number) {
      return a - b;
    } else {
      a = a.toString();
      b = b.toString();
  
      if (a == b) return 0;
  
      return (a > b) ? 1 : -1;
    }
  };
  
  /**
   * Returns whether the priority queue is empty or not.
   *
   * @return {Boolean}
   * @api public
   */
  PriorityQueue.prototype.isEmpty = function() {
    return this.size() === 0;
  };
  
  /**
   * Peeks at the top element of the priority queue.
   *
   * @return {Object}
   * @throws {Error} when the queue is empty.
   * @api public
   */
  PriorityQueue.prototype.peek = function() {
    if (this.isEmpty()) throw new Error('PriorityQueue is empty');
  
    return this._elements[0];
  };
  
  /**
   * Dequeues the top element of the priority queue.
   *
   * @return {Object}
   * @throws {Error} when the queue is empty.
   * @api public
   */
  PriorityQueue.prototype.deq = function() {
    var first = this.peek();
    var last = this._elements.pop();
    var size = this.size();
  
    if (size === 0) return first;
  
    this._elements[0] = last;
    var current = 0;
  
    while (current < size) {
      var largest = current;
      var left = (2 * current) + 1;
      var right = (2 * current) + 2;
  
      if (left < size && this._compare(left, largest) > 0) {
        largest = left;
      }
  
      if (right < size && this._compare(right, largest) > 0) {
        largest = right;
      }
  
      if (largest === current) break;
  
      this._swap(largest, current);
      current = largest;
    }
  
    return first;
  };
  
  /**
   * Enqueues the `element` at the priority queue and returns its new size.
   *
   * @param {Object} element
   * @return {Number}
   * @api public
   */
  PriorityQueue.prototype.enq = function(element) {
    var size = this._elements.push(element);
    var current = size - 1;
  
    while (current > 0) {
      var parent = Math.floor((current - 1) / 2);
  
      if (this._compare(current, parent) < 0) break;
  
      this._swap(parent, current);
      current = parent;
    }
  
    return size;
  };
  
  /**
   * Returns the size of the priority queue.
   *
   * @return {Number}
   * @api public
   */
  PriorityQueue.prototype.size = function() {
    return this._elements.length;
  };
  
  /**
   *  Iterates over queue elements
   *
   *  @param {Function} fn
   */
  PriorityQueue.prototype.forEach = function(fn) {
    return this._elements.forEach(fn);
  };
  
  /**
   * Compares the values at position `a` and `b` in the priority queue using its
   * comparator function.
   *
   * @param {Number} a
   * @param {Number} b
   * @return {Number}
   * @api private
   */
  PriorityQueue.prototype._compare = function(a, b) {
    return this._comparator(this._elements[a], this._elements[b]);
  };
  
  /**
   * Swaps the values at position `a` and `b` in the priority queue.
   *
   * @param {Number} a
   * @param {Number} b
   * @api private
   */
  PriorityQueue.prototype._swap = function(a, b) {
    var aux = this._elements[a];
    this._elements[a] = this._elements[b];
    this._elements[b] = aux;
  };
  
  },{}],11:[function(require,module,exports){
  (function (global){
  /*
   *  Sugar Library v1.4.1
   *
   *  Freely distributable and licensed under the MIT-style license.
   *  Copyright (c) 2013 Andrew Plummer
   *  http://sugarjs.com/
   *
   * ---------------------------- */
  (function(){
    'use strict';
  
    /***
     * @package Core
     * @description Internal utility and common methods.
     ***/
  
  
    // A few optimizations for Google Closure Compiler will save us a couple kb in the release script.
    var object = Object, array = Array, regexp = RegExp, date = Date, string = String, number = Number, math = Math, Undefined;
  
    // The global context
    var globalContext = typeof global !== 'undefined' ? global : this;
  
    // Internal toString
    var internalToString = object.prototype.toString;
  
    // Internal hasOwnProperty
    var internalHasOwnProperty = object.prototype.hasOwnProperty;
  
    // defineProperty exists in IE8 but will error when trying to define a property on
    // native objects. IE8 does not have defineProperies, however, so this check saves a try/catch block.
    var definePropertySupport = object.defineProperty && object.defineProperties;
  
    // Are regexes type function?
    var regexIsFunction = typeof regexp() === 'function';
  
    // Do strings have no keys?
    var noKeysInStringObjects = !('0' in new string('a'));
  
    // Type check methods need a way to be accessed dynamically.
    var typeChecks = {};
  
    // Classes that can be matched by value
    var matchedByValueReg = /^\[object Date|Array|String|Number|RegExp|Boolean|Arguments\]$/;
  
    // Class initializers and class helpers
    var ClassNames = 'Boolean,Number,String,Array,Date,RegExp,Function'.split(',');
  
    var isBoolean  = buildPrimitiveClassCheck('boolean', ClassNames[0]);
    var isNumber   = buildPrimitiveClassCheck('number',  ClassNames[1]);
    var isString   = buildPrimitiveClassCheck('string',  ClassNames[2]);
  
    var isArray    = buildClassCheck(ClassNames[3]);
    var isDate     = buildClassCheck(ClassNames[4]);
    var isRegExp   = buildClassCheck(ClassNames[5]);
  
  
    // Wanted to enhance performance here by using simply "typeof"
    // but Firefox has two major issues that make this impossible,
    // one fixed, the other not. Despite being typeof "function"
    // the objects below still report in as [object Function], so
    // we need to perform a full class check here.
    //
    // 1. Regexes can be typeof "function" in FF < 3
    //    https://bugzilla.mozilla.org/show_bug.cgi?id=61911 (fixed)
    //
    // 2. HTMLEmbedElement and HTMLObjectElement are be typeof "function"
    //    https://bugzilla.mozilla.org/show_bug.cgi?id=268945 (won't fix)
    //
    var isFunction = buildClassCheck(ClassNames[6]);
  
    function isClass(obj, klass, cached) {
      var k = cached || className(obj);
      return k === '[object '+klass+']';
    }
  
    function buildClassCheck(klass) {
      var fn = (klass === 'Array' && array.isArray) || function(obj, cached) {
        return isClass(obj, klass, cached);
      };
      typeChecks[klass] = fn;
      return fn;
    }
  
    function buildPrimitiveClassCheck(type, klass) {
      var fn = function(obj) {
        if(isObjectType(obj)) {
          return isClass(obj, klass);
        }
        return typeof obj === type;
      }
      typeChecks[klass] = fn;
      return fn;
    }
  
    function className(obj) {
      return internalToString.call(obj);
    }
  
    function initializeClasses() {
      initializeClass(object);
      iterateOverObject(ClassNames, function(i,name) {
        initializeClass(globalContext[name]);
      });
    }
  
    function initializeClass(klass) {
      if(klass['SugarMethods']) return;
      defineProperty(klass, 'SugarMethods', {});
      extend(klass, false, true, {
        'extend': function(methods, override, instance) {
          extend(klass, instance !== false, override, methods);
        },
        'sugarRestore': function() {
          return batchMethodExecute(this, klass, arguments, function(target, name, m) {
            defineProperty(target, name, m.method);
          });
        },
        'sugarRevert': function() {
          return batchMethodExecute(this, klass, arguments, function(target, name, m) {
            if(m['existed']) {
              defineProperty(target, name, m['original']);
            } else {
              delete target[name];
            }
          });
        }
      });
    }
  
    // Class extending methods
  
    function extend(klass, instance, override, methods) {
      var extendee = instance ? klass.prototype : klass;
      initializeClass(klass);
      iterateOverObject(methods, function(name, extendedFn) {
        var nativeFn = extendee[name],
            existed  = hasOwnProperty(extendee, name);
        if(isFunction(override) && nativeFn) {
          extendedFn = wrapNative(nativeFn, extendedFn, override);
        }
        if(override !== false || !nativeFn) {
          defineProperty(extendee, name, extendedFn);
        }
        // If the method is internal to Sugar, then
        // store a reference so it can be restored later.
        klass['SugarMethods'][name] = {
          'method':   extendedFn,
          'existed':  existed,
          'original': nativeFn,
          'instance': instance
        };
      });
    }
  
    function extendSimilar(klass, instance, override, set, fn) {
      var methods = {};
      set = isString(set) ? set.split(',') : set;
      set.forEach(function(name, i) {
        fn(methods, name, i);
      });
      extend(klass, instance, override, methods);
    }
  
    function batchMethodExecute(target, klass, args, fn) {
      var all = args.length === 0, methods = multiArgs(args), changed = false;
      iterateOverObject(klass['SugarMethods'], function(name, m) {
        if(all || methods.indexOf(name) !== -1) {
          changed = true;
          fn(m['instance'] ? target.prototype : target, name, m);
        }
      });
      return changed;
    }
  
    function wrapNative(nativeFn, extendedFn, condition) {
      return function(a) {
        return condition.apply(this, arguments) ?
               extendedFn.apply(this, arguments) :
               nativeFn.apply(this, arguments);
      }
    }
  
    function defineProperty(target, name, method) {
      if(definePropertySupport) {
        object.defineProperty(target, name, {
          'value': method,
          'configurable': true,
          'enumerable': false,
          'writable': true
        });
      } else {
        target[name] = method;
      }
    }
  
  
    // Argument helpers
  
    function multiArgs(args, fn, from) {
      var result = [], i = from || 0, len;
      for(len = args.length; i < len; i++) {
        result.push(args[i]);
        if(fn) fn.call(args, args[i], i);
      }
      return result;
    }
  
    function flattenedArgs(args, fn, from) {
      var arg = args[from || 0];
      if(isArray(arg)) {
        args = arg;
        from = 0;
      }
      return multiArgs(args, fn, from);
    }
  
    function checkCallback(fn) {
      if(!fn || !fn.call) {
        throw new TypeError('Callback is not callable');
      }
    }
  
  
    // General helpers
  
    function isDefined(o) {
      return o !== Undefined;
    }
  
    function isUndefined(o) {
      return o === Undefined;
    }
  
  
    // Object helpers
  
    function hasProperty(obj, prop) {
      return !isPrimitiveType(obj) && prop in obj;
    }
  
    function hasOwnProperty(obj, prop) {
      return !!obj && internalHasOwnProperty.call(obj, prop);
    }
  
    function isObjectType(obj) {
      // 1. Check for null
      // 2. Check for regexes in environments where they are "functions".
      return !!obj && (typeof obj === 'object' || (regexIsFunction && isRegExp(obj)));
    }
  
    function isPrimitiveType(obj) {
      var type = typeof obj;
      return obj == null || type === 'string' || type === 'number' || type === 'boolean';
    }
  
    function isPlainObject(obj, klass) {
      klass = klass || className(obj);
      try {
        // Not own constructor property must be Object
        // This code was borrowed from jQuery.isPlainObject
        if (obj && obj.constructor &&
              !hasOwnProperty(obj, 'constructor') &&
              !hasOwnProperty(obj.constructor.prototype, 'isPrototypeOf')) {
          return false;
        }
      } catch (e) {
        // IE8,9 Will throw exceptions on certain host objects.
        return false;
      }
      // === on the constructor is not safe across iframes
      // 'hasOwnProperty' ensures that the object also inherits
      // from Object, which is false for DOMElements in IE.
      return !!obj && klass === '[object Object]' && 'hasOwnProperty' in obj;
    }
  
    function iterateOverObject(obj, fn) {
      var key;
      for(key in obj) {
        if(!hasOwnProperty(obj, key)) continue;
        if(fn.call(obj, key, obj[key], obj) === false) break;
      }
    }
  
    function simpleRepeat(n, fn) {
      for(var i = 0; i < n; i++) {
        fn(i);
      }
    }
  
    function simpleMerge(target, source) {
      iterateOverObject(source, function(key) {
        target[key] = source[key];
      });
      return target;
    }
  
     // Make primtives types like strings into objects.
     function coercePrimitiveToObject(obj) {
       if(isPrimitiveType(obj)) {
         obj = object(obj);
       }
       if(noKeysInStringObjects && isString(obj)) {
         forceStringCoercion(obj);
       }
       return obj;
     }
  
     // Force strings to have their indexes set in
     // environments that don't do this automatically.
     function forceStringCoercion(obj) {
       var i = 0, chr;
       while(chr = obj.charAt(i)) {
         obj[i++] = chr;
       }
     }
  
    // Hash definition
  
    function Hash(obj) {
      simpleMerge(this, coercePrimitiveToObject(obj));
    };
  
    Hash.prototype.constructor = object;
  
    // Math helpers
  
    var abs   = math.abs;
    var pow   = math.pow;
    var ceil  = math.ceil;
    var floor = math.floor;
    var round = math.round;
    var min   = math.min;
    var max   = math.max;
  
    function withPrecision(val, precision, fn) {
      var multiplier = pow(10, abs(precision || 0));
      fn = fn || round;
      if(precision < 0) multiplier = 1 / multiplier;
      return fn(val * multiplier) / multiplier;
    }
  
    // Full width number helpers
  
    var HalfWidthZeroCode = 0x30;
    var HalfWidthNineCode = 0x39;
    var FullWidthZeroCode = 0xff10;
    var FullWidthNineCode = 0xff19;
  
    var HalfWidthPeriod = '.';
    var FullWidthPeriod = '．';
    var HalfWidthComma  = ',';
  
    // Used here and later in the Date package.
    var FullWidthDigits   = '';
  
    var NumberNormalizeMap = {};
    var NumberNormalizeReg;
  
    function codeIsNumeral(code) {
      return (code >= HalfWidthZeroCode && code <= HalfWidthNineCode) ||
             (code >= FullWidthZeroCode && code <= FullWidthNineCode);
    }
  
    function buildNumberHelpers() {
      var digit, i;
      for(i = 0; i <= 9; i++) {
        digit = chr(i + FullWidthZeroCode);
        FullWidthDigits += digit;
        NumberNormalizeMap[digit] = chr(i + HalfWidthZeroCode);
      }
      NumberNormalizeMap[HalfWidthComma] = '';
      NumberNormalizeMap[FullWidthPeriod] = HalfWidthPeriod;
      // Mapping this to itself to easily be able to easily
      // capture it in stringToNumber to detect decimals later.
      NumberNormalizeMap[HalfWidthPeriod] = HalfWidthPeriod;
      NumberNormalizeReg = regexp('[' + FullWidthDigits + FullWidthPeriod + HalfWidthComma + HalfWidthPeriod + ']', 'g');
    }
  
    // String helpers
  
    function chr(num) {
      return string.fromCharCode(num);
    }
  
    // WhiteSpace/LineTerminator as defined in ES5.1 plus Unicode characters in the Space, Separator category.
    function getTrimmableCharacters() {
      return '\u0009\u000A\u000B\u000C\u000D\u0020\u00A0\u1680\u180E\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u2028\u2029\u3000\uFEFF';
    }
  
    function repeatString(str, num) {
      var result = '', str = str.toString();
      while (num > 0) {
        if (num & 1) {
          result += str;
        }
        if (num >>= 1) {
          str += str;
        }
      }
      return result;
    }
  
    // Returns taking into account full-width characters, commas, and decimals.
    function stringToNumber(str, base) {
      var sanitized, isDecimal;
      sanitized = str.replace(NumberNormalizeReg, function(chr) {
        var replacement = NumberNormalizeMap[chr];
        if(replacement === HalfWidthPeriod) {
          isDecimal = true;
        }
        return replacement;
      });
      return isDecimal ? parseFloat(sanitized) : parseInt(sanitized, base || 10);
    }
  
  
    // Used by Number and Date
  
    function padNumber(num, place, sign, base) {
      var str = abs(num).toString(base || 10);
      str = repeatString('0', place - str.replace(/\.\d+/, '').length) + str;
      if(sign || num < 0) {
        str = (num < 0 ? '-' : '+') + str;
      }
      return str;
    }
  
    function getOrdinalizedSuffix(num) {
      if(num >= 11 && num <= 13) {
        return 'th';
      } else {
        switch(num % 10) {
          case 1:  return 'st';
          case 2:  return 'nd';
          case 3:  return 'rd';
          default: return 'th';
        }
      }
    }
  
  
    // RegExp helpers
  
    function getRegExpFlags(reg, add) {
      var flags = '';
      add = add || '';
      function checkFlag(prop, flag) {
        if(prop || add.indexOf(flag) > -1) {
          flags += flag;
        }
      }
      checkFlag(reg.multiline, 'm');
      checkFlag(reg.ignoreCase, 'i');
      checkFlag(reg.global, 'g');
      checkFlag(reg.sticky, 'y');
      return flags;
    }
  
    function escapeRegExp(str) {
      if(!isString(str)) str = string(str);
      return str.replace(/([\\/\'*+?|()\[\]{}.^$])/g,'\\$1');
    }
  
  
    // Date helpers
  
    function callDateGet(d, method) {
      return d['get' + (d._utc ? 'UTC' : '') + method]();
    }
  
    function callDateSet(d, method, value) {
      return d['set' + (d._utc && method != 'ISOWeek' ? 'UTC' : '') + method](value);
    }
  
    // Used by Array#unique and Object.equal
  
    function stringify(thing, stack) {
      var type = typeof thing,
          thingIsObject,
          thingIsArray,
          klass, value,
          arr, key, i, len;
  
      // Return quickly if string to save cycles
      if(type === 'string') return thing;
  
      klass         = internalToString.call(thing)
      thingIsObject = isPlainObject(thing, klass);
      thingIsArray  = isArray(thing, klass);
  
      if(thing != null && thingIsObject || thingIsArray) {
        // This method for checking for cyclic structures was egregiously stolen from
        // the ingenious method by @kitcambridge from the Underscore script:
        // https://github.com/documentcloud/underscore/issues/240
        if(!stack) stack = [];
        // Allowing a step into the structure before triggering this
        // script to save cycles on standard JSON structures and also to
        // try as hard as possible to catch basic properties that may have
        // been modified.
        if(stack.length > 1) {
          i = stack.length;
          while (i--) {
            if (stack[i] === thing) {
              return 'CYC';
            }
          }
        }
        stack.push(thing);
        value = thing.valueOf() + string(thing.constructor);
        arr = thingIsArray ? thing : object.keys(thing).sort();
        for(i = 0, len = arr.length; i < len; i++) {
          key = thingIsArray ? i : arr[i];
          value += key + stringify(thing[key], stack);
        }
        stack.pop();
      } else if(1 / thing === -Infinity) {
        value = '-0';
      } else {
        value = string(thing && thing.valueOf ? thing.valueOf() : thing);
      }
      return type + klass + value;
    }
  
    function isEqual(a, b) {
      if(a === b) {
        // Return quickly up front when matching by reference,
        // but be careful about 0 !== -0.
        return a !== 0 || 1 / a === 1 / b;
      } else if(objectIsMatchedByValue(a) && objectIsMatchedByValue(b)) {
        return stringify(a) === stringify(b);
      }
      return false;
    }
  
    function objectIsMatchedByValue(obj) {
      // Only known objects are matched by value. This is notably excluding functions, DOM Elements, and instances of
      // user-created classes. The latter can arguably be matched by value, but distinguishing between these and
      // host objects -- which should never be compared by value -- is very tricky so not dealing with it here.
      var klass = className(obj);
      return matchedByValueReg.test(klass) || isPlainObject(obj, klass);
    }
  
  
    // Used by Array#at and String#at
  
    function getEntriesForIndexes(obj, args, isString) {
      var result,
          length    = obj.length,
          argsLen   = args.length,
          overshoot = args[argsLen - 1] !== false,
          multiple  = argsLen > (overshoot ? 1 : 2);
      if(!multiple) {
        return entryAtIndex(obj, length, args[0], overshoot, isString);
      }
      result = [];
      multiArgs(args, function(index) {
        if(isBoolean(index)) return false;
        result.push(entryAtIndex(obj, length, index, overshoot, isString));
      });
      return result;
    }
  
    function entryAtIndex(obj, length, index, overshoot, isString) {
      if(overshoot) {
        index = index % length;
        if(index < 0) index = length + index;
      }
      return isString ? obj.charAt(index) : obj[index];
    }
  
  
    // Object class methods implemented as instance methods
  
    function buildObjectInstanceMethods(set, target) {
      extendSimilar(target, true, false, set, function(methods, name) {
        methods[name + (name === 'equal' ? 's' : '')] = function() {
          return object[name].apply(null, [this].concat(multiArgs(arguments)));
        }
      });
    }
  
    initializeClasses();
    buildNumberHelpers();
  
  
    /***
     * @package ES5
     * @description Shim methods that provide ES5 compatible functionality. This package can be excluded if you do not require legacy browser support (IE8 and below).
     *
     ***/
  
  
    /***
     * Object module
     *
     ***/
  
    extend(object, false, false, {
  
      'keys': function(obj) {
        var keys = [];
        if(!isObjectType(obj) && !isRegExp(obj) && !isFunction(obj)) {
          throw new TypeError('Object required');
        }
        iterateOverObject(obj, function(key, value) {
          keys.push(key);
        });
        return keys;
      }
  
    });
  
  
    /***
     * Array module
     *
     ***/
  
    // ECMA5 methods
  
    function arrayIndexOf(arr, search, fromIndex, increment) {
      var length = arr.length,
          fromRight = increment == -1,
          start = fromRight ? length - 1 : 0,
          index = toIntegerWithDefault(fromIndex, start);
      if(index < 0) {
        index = length + index;
      }
      if((!fromRight && index < 0) || (fromRight && index >= length)) {
        index = start;
      }
      while((fromRight && index >= 0) || (!fromRight && index < length)) {
        if(arr[index] === search) {
          return index;
        }
        index += increment;
      }
      return -1;
    }
  
    function arrayReduce(arr, fn, initialValue, fromRight) {
      var length = arr.length, count = 0, defined = isDefined(initialValue), result, index;
      checkCallback(fn);
      if(length == 0 && !defined) {
        throw new TypeError('Reduce called on empty array with no initial value');
      } else if(defined) {
        result = initialValue;
      } else {
        result = arr[fromRight ? length - 1 : count];
        count++;
      }
      while(count < length) {
        index = fromRight ? length - count - 1 : count;
        if(index in arr) {
          result = fn(result, arr[index], index, arr);
        }
        count++;
      }
      return result;
    }
  
    function toIntegerWithDefault(i, d) {
      if(isNaN(i)) {
        return d;
      } else {
        return parseInt(i >> 0);
      }
    }
  
    function checkFirstArgumentExists(args) {
      if(args.length === 0) {
        throw new TypeError('First argument must be defined');
      }
    }
  
  
  
  
    extend(array, false, false, {
  
      /***
       *
       * @method Array.isArray(<obj>)
       * @returns Boolean
       * @short Returns true if <obj> is an Array.
       * @extra This method is provided for browsers that don't support it internally.
       * @example
       *
       *   Array.isArray(3)        -> false
       *   Array.isArray(true)     -> false
       *   Array.isArray('wasabi') -> false
       *   Array.isArray([1,2,3])  -> true
       *
       ***/
      'isArray': function(obj) {
        return isArray(obj);
      }
  
    });
  
  
    extend(array, true, false, {
  
      /***
       * @method every(<f>, [scope])
       * @returns Boolean
       * @short Returns true if all elements in the array match <f>.
       * @extra [scope] is the %this% object. %all% is provided an alias. In addition to providing this method for browsers that don't support it natively, this method also implements @array_matching.
       * @example
       *
       +   ['a','a','a'].every(function(n) {
       *     return n == 'a';
       *   });
       *   ['a','a','a'].every('a')   -> true
       *   [{a:2},{a:2}].every({a:2}) -> true
       ***/
      'every': function(fn, scope) {
        var length = this.length, index = 0;
        checkFirstArgumentExists(arguments);
        while(index < length) {
          if(index in this && !fn.call(scope, this[index], index, this)) {
            return false;
          }
          index++;
        }
        return true;
      },
  
      /***
       * @method some(<f>, [scope])
       * @returns Boolean
       * @short Returns true if any element in the array matches <f>.
       * @extra [scope] is the %this% object. %any% is provided as an alias. In addition to providing this method for browsers that don't support it natively, this method also implements @array_matching.
       * @example
       *
       +   ['a','b','c'].some(function(n) {
       *     return n == 'a';
       *   });
       +   ['a','b','c'].some(function(n) {
       *     return n == 'd';
       *   });
       *   ['a','b','c'].some('a')   -> true
       *   [{a:2},{b:5}].some({a:2}) -> true
       ***/
      'some': function(fn, scope) {
        var length = this.length, index = 0;
        checkFirstArgumentExists(arguments);
        while(index < length) {
          if(index in this && fn.call(scope, this[index], index, this)) {
            return true;
          }
          index++;
        }
        return false;
      },
  
      /***
       * @method map(<map>, [scope])
       * @returns Array
       * @short Maps the array to another array containing the values that are the result of calling <map> on each element.
       * @extra [scope] is the %this% object. When <map> is a function, it receives three arguments: the current element, the current index, and a reference to the array. In addition to providing this method for browsers that don't support it natively, this enhanced method also directly accepts a string, which is a shortcut for a function that gets that property (or invokes a function) on each element.
       * @example
       *
       *   [1,2,3].map(function(n) {
       *     return n * 3;
       *   });                                  -> [3,6,9]
       *   ['one','two','three'].map(function(n) {
       *     return n.length;
       *   });                                  -> [3,3,5]
       *   ['one','two','three'].map('length')  -> [3,3,5]
       *
       ***/
      'map': function(fn, scope) {
        var scope = arguments[1], length = this.length, index = 0, result = new Array(length);
        checkFirstArgumentExists(arguments);
        while(index < length) {
          if(index in this) {
            result[index] = fn.call(scope, this[index], index, this);
          }
          index++;
        }
        return result;
      },
  
      /***
       * @method filter(<f>, [scope])
       * @returns Array
       * @short Returns any elements in the array that match <f>.
       * @extra [scope] is the %this% object. In addition to providing this method for browsers that don't support it natively, this method also implements @array_matching.
       * @example
       *
       +   [1,2,3].filter(function(n) {
       *     return n > 1;
       *   });
       *   [1,2,2,4].filter(2) -> 2
       *
       ***/
      'filter': function(fn) {
        var scope = arguments[1];
        var length = this.length, index = 0, result = [];
        checkFirstArgumentExists(arguments);
        while(index < length) {
          if(index in this && fn.call(scope, this[index], index, this)) {
            result.push(this[index]);
          }
          index++;
        }
        return result;
      },
  
      /***
       * @method indexOf(<search>, [fromIndex])
       * @returns Number
       * @short Searches the array and returns the first index where <search> occurs, or -1 if the element is not found.
       * @extra [fromIndex] is the index from which to begin the search. This method performs a simple strict equality comparison on <search>. It does not support enhanced functionality such as searching the contents against a regex, callback, or deep comparison of objects. For such functionality, use the %findIndex% method instead.
       * @example
       *
       *   [1,2,3].indexOf(3)           -> 1
       *   [1,2,3].indexOf(7)           -> -1
       *
       ***/
      'indexOf': function(search) {
        var fromIndex = arguments[1];
        if(isString(this)) return this.indexOf(search, fromIndex);
        return arrayIndexOf(this, search, fromIndex, 1);
      },
  
      /***
       * @method lastIndexOf(<search>, [fromIndex])
       * @returns Number
       * @short Searches the array and returns the last index where <search> occurs, or -1 if the element is not found.
       * @extra [fromIndex] is the index from which to begin the search. This method performs a simple strict equality comparison on <search>.
       * @example
       *
       *   [1,2,1].lastIndexOf(1)                 -> 2
       *   [1,2,1].lastIndexOf(7)                 -> -1
       *
       ***/
      'lastIndexOf': function(search) {
        var fromIndex = arguments[1];
        if(isString(this)) return this.lastIndexOf(search, fromIndex);
        return arrayIndexOf(this, search, fromIndex, -1);
      },
  
      /***
       * @method forEach([fn], [scope])
       * @returns Nothing
       * @short Iterates over the array, calling [fn] on each loop.
       * @extra This method is only provided for those browsers that do not support it natively. [scope] becomes the %this% object.
       * @example
       *
       *   ['a','b','c'].forEach(function(a) {
       *     // Called 3 times: 'a','b','c'
       *   });
       *
       ***/
      'forEach': function(fn) {
        var length = this.length, index = 0, scope = arguments[1];
        checkCallback(fn);
        while(index < length) {
          if(index in this) {
            fn.call(scope, this[index], index, this);
          }
          index++;
        }
      },
  
      /***
       * @method reduce(<fn>, [init])
       * @returns Mixed
       * @short Reduces the array to a single result.
       * @extra If [init] is passed as a starting value, that value will be passed as the first argument to the callback. The second argument will be the first element in the array. From that point, the result of the callback will then be used as the first argument of the next iteration. This is often refered to as "accumulation", and [init] is often called an "accumulator". If [init] is not passed, then <fn> will be called n - 1 times, where n is the length of the array. In this case, on the first iteration only, the first argument will be the first element of the array, and the second argument will be the second. After that callbacks work as normal, using the result of the previous callback as the first argument of the next. This method is only provided for those browsers that do not support it natively.
       *
       * @example
       *
       +   [1,2,3,4].reduce(function(a, b) {
       *     return a - b;
       *   });
       +   [1,2,3,4].reduce(function(a, b) {
       *     return a - b;
       *   }, 100);
       *
       ***/
      'reduce': function(fn) {
        return arrayReduce(this, fn, arguments[1]);
      },
  
      /***
       * @method reduceRight([fn], [init])
       * @returns Mixed
       * @short Identical to %Array#reduce%, but operates on the elements in reverse order.
       * @extra This method is only provided for those browsers that do not support it natively.
       *
       *
       *
       *
       * @example
       *
       +   [1,2,3,4].reduceRight(function(a, b) {
       *     return a - b;
       *   });
       *
       ***/
      'reduceRight': function(fn) {
        return arrayReduce(this, fn, arguments[1], true);
      }
  
  
    });
  
  
  
  
    /***
     * String module
     *
     ***/
  
  
    function buildTrim() {
      var support = getTrimmableCharacters().match(/^\s+$/);
      try { string.prototype.trim.call([1]); } catch(e) { support = false; }
      extend(string, true, !support, {
  
        /***
         * @method trim[Side]()
         * @returns String
         * @short Removes leading and/or trailing whitespace from the string.
         * @extra Whitespace is defined as line breaks, tabs, and any character in the "Space, Separator" Unicode category, conforming to the the ES5 spec. The standard %trim% method is only added when not fully supported natively.
         *
         * @set
         *   trim
         *   trimLeft
         *   trimRight
         *
         * @example
         *
         *   '   wasabi   '.trim()      -> 'wasabi'
         *   '   wasabi   '.trimLeft()  -> 'wasabi   '
         *   '   wasabi   '.trimRight() -> '   wasabi'
         *
         ***/
        'trim': function() {
          return this.toString().trimLeft().trimRight();
        },
  
        'trimLeft': function() {
          return this.replace(regexp('^['+getTrimmableCharacters()+']+'), '');
        },
  
        'trimRight': function() {
          return this.replace(regexp('['+getTrimmableCharacters()+']+$'), '');
        }
      });
    }
  
  
  
    /***
     * Function module
     *
     ***/
  
  
    extend(Function, true, false, {
  
       /***
       * @method bind(<scope>, [arg1], ...)
       * @returns Function
       * @short Binds <scope> as the %this% object for the function when it is called. Also allows currying an unlimited number of parameters.
       * @extra "currying" means setting parameters ([arg1], [arg2], etc.) ahead of time so that they are passed when the function is called later. If you pass additional parameters when the function is actually called, they will be added will be added to the end of the curried parameters. This method is provided for browsers that don't support it internally.
       * @example
       *
       +   (function() {
       *     return this;
       *   }).bind('woof')(); -> returns 'woof'; function is bound with 'woof' as the this object.
       *   (function(a) {
       *     return a;
       *   }).bind(1, 2)();   -> returns 2; function is bound with 1 as the this object and 2 curried as the first parameter
       *   (function(a, b) {
       *     return a + b;
       *   }).bind(1, 2)(3);  -> returns 5; function is bound with 1 as the this object, 2 curied as the first parameter and 3 passed as the second when calling the function
       *
       ***/
      'bind': function(scope) {
        var fn = this, args = multiArgs(arguments, null, 1), bound;
        if(!isFunction(this)) {
          throw new TypeError('Function.prototype.bind called on a non-function');
        }
        bound = function() {
          return fn.apply(fn.prototype && this instanceof fn ? this : scope, args.concat(multiArgs(arguments)));
        }
        bound.prototype = this.prototype;
        return bound;
      }
  
    });
  
    /***
     * Date module
     *
     ***/
  
     /***
     * @method toISOString()
     * @returns String
     * @short Formats the string to ISO8601 format.
     * @extra This will always format as UTC time. Provided for browsers that do not support this method.
     * @example
     *
     *   Date.create().toISOString() -> ex. 2011-07-05 12:24:55.528Z
     *
     ***
     * @method toJSON()
     * @returns String
     * @short Returns a JSON representation of the date.
     * @extra This is effectively an alias for %toISOString%. Will always return the date in UTC time. Provided for browsers that do not support this method.
     * @example
     *
     *   Date.create().toJSON() -> ex. 2011-07-05 12:24:55.528Z
     *
     ***/
  
    extend(date, false, false, {
  
       /***
       * @method Date.now()
       * @returns String
       * @short Returns the number of milliseconds since January 1st, 1970 00:00:00 (UTC time).
       * @extra Provided for browsers that do not support this method.
       * @example
       *
       *   Date.now() -> ex. 1311938296231
       *
       ***/
      'now': function() {
        return new date().getTime();
      }
  
    });
  
     function buildISOString() {
      var d = new date(date.UTC(1999, 11, 31)), target = '1999-12-31T00:00:00.000Z';
      var support = d.toISOString && d.toISOString() === target;
      extendSimilar(date, true, !support, 'toISOString,toJSON', function(methods, name) {
        methods[name] = function() {
          return padNumber(this.getUTCFullYear(), 4) + '-' +
                 padNumber(this.getUTCMonth() + 1, 2) + '-' +
                 padNumber(this.getUTCDate(), 2) + 'T' +
                 padNumber(this.getUTCHours(), 2) + ':' +
                 padNumber(this.getUTCMinutes(), 2) + ':' +
                 padNumber(this.getUTCSeconds(), 2) + '.' +
                 padNumber(this.getUTCMilliseconds(), 3) + 'Z';
        }
      });
     }
  
    // Initialize
    buildTrim();
    buildISOString();
  
  
    /***
     * @package Array
     * @dependency core
     * @description Array manipulation and traversal, "fuzzy matching" against elements, alphanumeric sorting and collation, enumerable methods on Object.
     *
     ***/
  
  
    function regexMatcher(reg) {
      reg = regexp(reg);
      return function (el) {
        return reg.test(el);
      }
    }
  
    function dateMatcher(d) {
      var ms = d.getTime();
      return function (el) {
        return !!(el && el.getTime) && el.getTime() === ms;
      }
    }
  
    function functionMatcher(fn) {
      return function (el, i, arr) {
        // Return true up front if match by reference
        return el === fn || fn.call(this, el, i, arr);
      }
    }
  
    function invertedArgsFunctionMatcher(fn) {
      return function (value, key, obj) {
        // Return true up front if match by reference
        return value === fn || fn.call(obj, key, value, obj);
      }
    }
  
    function fuzzyMatcher(obj, isObject) {
      var matchers = {};
      return function (el, i, arr) {
        var key;
        if(!isObjectType(el)) {
          return false;
        }
        for(key in obj) {
          matchers[key] = matchers[key] || getMatcher(obj[key], isObject);
          if(matchers[key].call(arr, el[key], i, arr) === false) {
            return false;
          }
        }
        return true;
      }
    }
  
    function defaultMatcher(f) {
      return function (el) {
        return el === f || isEqual(el, f);
      }
    }
  
    function getMatcher(f, isObject) {
      if(isPrimitiveType(f)) {
        // Do nothing and fall through to the
        // default matcher below.
      } else if(isRegExp(f)) {
        // Match against a regexp
        return regexMatcher(f);
      } else if(isDate(f)) {
        // Match against a date. isEqual below should also
        // catch this but matching directly up front for speed.
        return dateMatcher(f);
      } else if(isFunction(f)) {
        // Match against a filtering function
        if(isObject) {
          return invertedArgsFunctionMatcher(f);
        } else {
          return functionMatcher(f);
        }
      } else if(isPlainObject(f)) {
        // Match against a fuzzy hash or array.
        return fuzzyMatcher(f, isObject);
      }
      // Default is standard isEqual
      return defaultMatcher(f);
    }
  
    function transformArgument(el, map, context, mapArgs) {
      if(!map) {
        return el;
      } else if(map.apply) {
        return map.apply(context, mapArgs || []);
      } else if(isFunction(el[map])) {
        return el[map].call(el);
      } else {
        return el[map];
      }
    }
  
    // Basic array internal methods
  
    function arrayEach(arr, fn, startIndex, loop) {
      var index, i, length = +arr.length;
      if(startIndex < 0) startIndex = arr.length + startIndex;
      i = isNaN(startIndex) ? 0 : startIndex;
      if(loop === true) {
        length += i;
      }
      while(i < length) {
        index = i % arr.length;
        if(!(index in arr)) {
          return iterateOverSparseArray(arr, fn, i, loop);
        } else if(fn.call(arr, arr[index], index, arr) === false) {
          break;
        }
        i++;
      }
    }
  
    function iterateOverSparseArray(arr, fn, fromIndex, loop) {
      var indexes = [], i;
      for(i in arr) {
        if(isArrayIndex(arr, i) && i >= fromIndex) {
          indexes.push(parseInt(i));
        }
      }
      indexes.sort().each(function(index) {
        return fn.call(arr, arr[index], index, arr);
      });
      return arr;
    }
  
    function isArrayIndex(arr, i) {
      return i in arr && toUInt32(i) == i && i != 0xffffffff;
    }
  
    function toUInt32(i) {
      return i >>> 0;
    }
  
    function arrayFind(arr, f, startIndex, loop, returnIndex, context) {
      var result, index, matcher;
      if(arr.length > 0) {
        matcher = getMatcher(f);
        arrayEach(arr, function(el, i) {
          if(matcher.call(context, el, i, arr)) {
            result = el;
            index = i;
            return false;
          }
        }, startIndex, loop);
      }
      return returnIndex ? index : result;
    }
  
    function arrayUnique(arr, map) {
      var result = [], o = {}, transformed;
      arrayEach(arr, function(el, i) {
        transformed = map ? transformArgument(el, map, arr, [el, i, arr]) : el;
        if(!checkForElementInHashAndSet(o, transformed)) {
          result.push(el);
        }
      })
      return result;
    }
  
    function arrayIntersect(arr1, arr2, subtract) {
      var result = [], o = {};
      arr2.each(function(el) {
        checkForElementInHashAndSet(o, el);
      });
      arr1.each(function(el) {
        var stringified = stringify(el),
            isReference = !objectIsMatchedByValue(el);
        // Add the result to the array if:
        // 1. We're subtracting intersections or it doesn't already exist in the result and
        // 2. It exists in the compared array and we're adding, or it doesn't exist and we're removing.
        if(elementExistsInHash(o, stringified, el, isReference) !== subtract) {
          discardElementFromHash(o, stringified, el, isReference);
          result.push(el);
        }
      });
      return result;
    }
  
    function arrayFlatten(arr, level, current) {
      level = level || Infinity;
      current = current || 0;
      var result = [];
      arrayEach(arr, function(el) {
        if(isArray(el) && current < level) {
          result = result.concat(arrayFlatten(el, level, current + 1));
        } else {
          result.push(el);
        }
      });
      return result;
    }
  
    function isArrayLike(obj) {
      return hasProperty(obj, 'length') && !isString(obj) && !isPlainObject(obj);
    }
  
    function isArgumentsObject(obj) {
      // .callee exists on Arguments objects in < IE8
      return hasProperty(obj, 'length') && (className(obj) === '[object Arguments]' || !!obj.callee);
    }
  
    function flatArguments(args) {
      var result = [];
      multiArgs(args, function(arg) {
        result = result.concat(arg);
      });
      return result;
    }
  
    function elementExistsInHash(hash, key, element, isReference) {
      var exists = key in hash;
      if(isReference) {
        if(!hash[key]) {
          hash[key] = [];
        }
        exists = hash[key].indexOf(element) !== -1;
      }
      return exists;
    }
  
    function checkForElementInHashAndSet(hash, element) {
      var stringified = stringify(element),
          isReference = !objectIsMatchedByValue(element),
          exists      = elementExistsInHash(hash, stringified, element, isReference);
      if(isReference) {
        hash[stringified].push(element);
      } else {
        hash[stringified] = element;
      }
      return exists;
    }
  
    function discardElementFromHash(hash, key, element, isReference) {
      var arr, i = 0;
      if(isReference) {
        arr = hash[key];
        while(i < arr.length) {
          if(arr[i] === element) {
            arr.splice(i, 1);
          } else {
            i += 1;
          }
        }
      } else {
        delete hash[key];
      }
    }
  
    // Support methods
  
    function getMinOrMax(obj, map, which, all) {
      var el,
          key,
          edge,
          test,
          result = [],
          max = which === 'max',
          min = which === 'min',
          isArray = array.isArray(obj);
      for(key in obj) {
        if(!obj.hasOwnProperty(key)) continue;
        el   = obj[key];
        test = transformArgument(el, map, obj, isArray ? [el, parseInt(key), obj] : []);
        if(isUndefined(test)) {
          throw new TypeError('Cannot compare with undefined');
        }
        if(test === edge) {
          result.push(el);
        } else if(isUndefined(edge) || (max && test > edge) || (min && test < edge)) {
          result = [el];
          edge = test;
        }
      }
      if(!isArray) result = arrayFlatten(result, 1);
      return all ? result : result[0];
    }
  
  
    // Alphanumeric collation helpers
  
    function collateStrings(a, b) {
      var aValue, bValue, aChar, bChar, aEquiv, bEquiv, index = 0, tiebreaker = 0;
  
      var sortIgnore      = array[AlphanumericSortIgnore];
      var sortIgnoreCase  = array[AlphanumericSortIgnoreCase];
      var sortEquivalents = array[AlphanumericSortEquivalents];
      var sortOrder       = array[AlphanumericSortOrder];
      var naturalSort     = array[AlphanumericSortNatural];
  
      a = getCollationReadyString(a, sortIgnore, sortIgnoreCase);
      b = getCollationReadyString(b, sortIgnore, sortIgnoreCase);
  
      do {
  
        aChar  = getCollationCharacter(a, index, sortEquivalents);
        bChar  = getCollationCharacter(b, index, sortEquivalents);
        aValue = getSortOrderIndex(aChar, sortOrder);
        bValue = getSortOrderIndex(bChar, sortOrder);
  
        if(aValue === -1 || bValue === -1) {
          aValue = a.charCodeAt(index) || null;
          bValue = b.charCodeAt(index) || null;
          if(naturalSort && codeIsNumeral(aValue) && codeIsNumeral(bValue)) {
            aValue = stringToNumber(a.slice(index));
            bValue = stringToNumber(b.slice(index));
          }
        } else {
          aEquiv = aChar !== a.charAt(index);
          bEquiv = bChar !== b.charAt(index);
          if(aEquiv !== bEquiv && tiebreaker === 0) {
            tiebreaker = aEquiv - bEquiv;
          }
        }
        index += 1;
      } while(aValue != null && bValue != null && aValue === bValue);
      if(aValue === bValue) return tiebreaker;
      return aValue - bValue;
    }
  
    function getCollationReadyString(str, sortIgnore, sortIgnoreCase) {
      if(!isString(str)) str = string(str);
      if(sortIgnoreCase) {
        str = str.toLowerCase();
      }
      if(sortIgnore) {
        str = str.replace(sortIgnore, '');
      }
      return str;
    }
  
    function getCollationCharacter(str, index, sortEquivalents) {
      var chr = str.charAt(index);
      return sortEquivalents[chr] || chr;
    }
  
    function getSortOrderIndex(chr, sortOrder) {
      if(!chr) {
        return null;
      } else {
        return sortOrder.indexOf(chr);
      }
    }
  
    var AlphanumericSort            = 'AlphanumericSort';
    var AlphanumericSortOrder       = 'AlphanumericSortOrder';
    var AlphanumericSortIgnore      = 'AlphanumericSortIgnore';
    var AlphanumericSortIgnoreCase  = 'AlphanumericSortIgnoreCase';
    var AlphanumericSortEquivalents = 'AlphanumericSortEquivalents';
    var AlphanumericSortNatural     = 'AlphanumericSortNatural';
  
  
  
    function buildEnhancements() {
      var nativeMap = array.prototype.map;
      var callbackCheck = function() {
        var args = arguments;
        return args.length > 0 && !isFunction(args[0]);
      };
      extendSimilar(array, true, callbackCheck, 'every,all,some,filter,any,none,find,findIndex', function(methods, name) {
        var nativeFn = array.prototype[name]
        methods[name] = function(f) {
          var matcher = getMatcher(f);
          return nativeFn.call(this, function(el, index) {
            return matcher(el, index, this);
          });
        }
      });
      extend(array, true, callbackCheck, {
        'map': function(f) {
          return nativeMap.call(this, function(el, index) {
            return transformArgument(el, f, this, [el, index, this]);
          });
        }
      });
    }
  
    function buildAlphanumericSort() {
      var order = 'AÁÀÂÃĄBCĆČÇDĎÐEÉÈĚÊËĘFGĞHıIÍÌİÎÏJKLŁMNŃŇÑOÓÒÔPQRŘSŚŠŞTŤUÚÙŮÛÜVWXYÝZŹŻŽÞÆŒØÕÅÄÖ';
      var equiv = 'AÁÀÂÃÄ,CÇ,EÉÈÊË,IÍÌİÎÏ,OÓÒÔÕÖ,Sß,UÚÙÛÜ';
      array[AlphanumericSortOrder] = order.split('').map(function(str) {
        return str + str.toLowerCase();
      }).join('');
      var equivalents = {};
      arrayEach(equiv.split(','), function(set) {
        var equivalent = set.charAt(0);
        arrayEach(set.slice(1).split(''), function(chr) {
          equivalents[chr] = equivalent;
          equivalents[chr.toLowerCase()] = equivalent.toLowerCase();
        });
      });
      array[AlphanumericSortNatural] = true;
      array[AlphanumericSortIgnoreCase] = true;
      array[AlphanumericSortEquivalents] = equivalents;
    }
  
    extend(array, false, true, {
  
      /***
       *
       * @method Array.create(<obj1>, <obj2>, ...)
       * @returns Array
       * @short Alternate array constructor.
       * @extra This method will create a single array by calling %concat% on all arguments passed. In addition to ensuring that an unknown variable is in a single, flat array (the standard constructor will create nested arrays, this one will not), it is also a useful shorthand to convert a function's arguments object into a standard array.
       * @example
       *
       *   Array.create('one', true, 3)   -> ['one', true, 3]
       *   Array.create(['one', true, 3]) -> ['one', true, 3]
       +   Array.create(function(n) {
       *     return arguments;
       *   }('howdy', 'doody'));
       *
       ***/
      'create': function() {
        var result = [];
        multiArgs(arguments, function(a) {
          if(isArgumentsObject(a) || isArrayLike(a)) {
            a = array.prototype.slice.call(a, 0);
          }
          result = result.concat(a);
        });
        return result;
      }
  
    });
  
    extend(array, true, false, {
  
      /***
       * @method find(<f>, [context] = undefined)
       * @returns Mixed
       * @short Returns the first element that matches <f>.
       * @extra [context] is the %this% object if passed. When <f> is a function, will use native implementation if it exists. <f> will also match a string, number, array, object, or alternately test against a function or regex. This method implements @array_matching.
       * @example
       *
       +   [{a:1,b:2},{a:1,b:3},{a:1,b:4}].find(function(n) {
       *     return n['a'] == 1;
       *   });                                  -> {a:1,b:3}
       *   ['cuba','japan','canada'].find(/^c/) -> 'cuba'
       *
       ***/
      'find': function(f, context) {
        checkCallback(f);
        return arrayFind(this, f, 0, false, false, context);
      },
  
      /***
       * @method findIndex(<f>, [context] = undefined)
       * @returns Number
       * @short Returns the index of the first element that matches <f> or -1 if not found.
       * @extra [context] is the %this% object if passed. When <f> is a function, will use native implementation if it exists. <f> will also match a string, number, array, object, or alternately test against a function or regex. This method implements @array_matching.
       *
       * @example
       *
       +   [1,2,3,4].findIndex(function(n) {
       *     return n % 2 == 0;
       *   }); -> 1
       +   [1,2,3,4].findIndex(3);               -> 2
       +   ['one','two','three'].findIndex(/t/); -> 1
       *
       ***/
      'findIndex': function(f, context) {
        var index;
        checkCallback(f);
        index = arrayFind(this, f, 0, false, true, context);
        return isUndefined(index) ? -1 : index;
      }
  
    });
  
    extend(array, true, true, {
  
      /***
       * @method findFrom(<f>, [index] = 0, [loop] = false)
       * @returns Array
       * @short Returns any element that matches <f>, beginning from [index].
       * @extra <f> will match a string, number, array, object, or alternately test against a function or regex. Will continue from index = 0 if [loop] is true. This method implements @array_matching.
       * @example
       *
       *   ['cuba','japan','canada'].findFrom(/^c/, 2) -> 'canada'
       *
       ***/
      'findFrom': function(f, index, loop) {
        return arrayFind(this, f, index, loop);
      },
  
      /***
       * @method findIndexFrom(<f>, [index] = 0, [loop] = false)
       * @returns Array
       * @short Returns the index of any element that matches <f>, beginning from [index].
       * @extra <f> will match a string, number, array, object, or alternately test against a function or regex. Will continue from index = 0 if [loop] is true. This method implements @array_matching.
       * @example
       *
       *   ['cuba','japan','canada'].findIndexFrom(/^c/, 2) -> 2
       *
       ***/
      'findIndexFrom': function(f, index, loop) {
        var index = arrayFind(this, f, index, loop, true);
        return isUndefined(index) ? -1 : index;
      },
  
      /***
       * @method findAll(<f>, [index] = 0, [loop] = false)
       * @returns Array
       * @short Returns all elements that match <f>.
       * @extra <f> will match a string, number, array, object, or alternately test against a function or regex. Starts at [index], and will continue once from index = 0 if [loop] is true. This method implements @array_matching.
       * @example
       *
       +   [{a:1,b:2},{a:1,b:3},{a:2,b:4}].findAll(function(n) {
       *     return n['a'] == 1;
       *   });                                        -> [{a:1,b:3},{a:1,b:4}]
       *   ['cuba','japan','canada'].findAll(/^c/)    -> 'cuba','canada'
       *   ['cuba','japan','canada'].findAll(/^c/, 2) -> 'canada'
       *
       ***/
      'findAll': function(f, index, loop) {
        var result = [], matcher;
        if(this.length > 0) {
          matcher = getMatcher(f);
          arrayEach(this, function(el, i, arr) {
            if(matcher(el, i, arr)) {
              result.push(el);
            }
          }, index, loop);
        }
        return result;
      },
  
      /***
       * @method count(<f>)
       * @returns Number
       * @short Counts all elements in the array that match <f>.
       * @extra <f> will match a string, number, array, object, or alternately test against a function or regex. This method implements @array_matching.
       * @example
       *
       *   [1,2,3,1].count(1)       -> 2
       *   ['a','b','c'].count(/b/) -> 1
       +   [{a:1},{b:2}].count(function(n) {
       *     return n['a'] > 1;
       *   });                      -> 0
       *
       ***/
      'count': function(f) {
        if(isUndefined(f)) return this.length;
        return this.findAll(f).length;
      },
  
      /***
       * @method removeAt(<start>, [end])
       * @returns Array
       * @short Removes element at <start>. If [end] is specified, removes the range between <start> and [end]. This method will change the array! If you don't intend the array to be changed use %clone% first.
       * @example
       *
       *   ['a','b','c'].removeAt(0) -> ['b','c']
       *   [1,2,3,4].removeAt(1, 3)  -> [1]
       *
       ***/
      'removeAt': function(start, end) {
        if(isUndefined(start)) return this;
        if(isUndefined(end))   end = start;
        this.splice(start, end - start + 1);
        return this;
      },
  
      /***
       * @method include(<el>, [index])
       * @returns Array
       * @short Adds <el> to the array.
       * @extra This is a non-destructive alias for %add%. It will not change the original array.
       * @example
       *
       *   [1,2,3,4].include(5)       -> [1,2,3,4,5]
       *   [1,2,3,4].include(8, 1)    -> [1,8,2,3,4]
       *   [1,2,3,4].include([5,6,7]) -> [1,2,3,4,5,6,7]
       *
       ***/
      'include': function(el, index) {
        return this.clone().add(el, index);
      },
  
      /***
       * @method exclude([f1], [f2], ...)
       * @returns Array
       * @short Removes any element in the array that matches [f1], [f2], etc.
       * @extra This is a non-destructive alias for %remove%. It will not change the original array. This method implements @array_matching.
       * @example
       *
       *   [1,2,3].exclude(3)         -> [1,2]
       *   ['a','b','c'].exclude(/b/) -> ['a','c']
       +   [{a:1},{b:2}].exclude(function(n) {
       *     return n['a'] == 1;
       *   });                       -> [{b:2}]
       *
       ***/
      'exclude': function() {
        return array.prototype.remove.apply(this.clone(), arguments);
      },
  
      /***
       * @method clone()
       * @returns Array
       * @short Makes a shallow clone of the array.
       * @example
       *
       *   [1,2,3].clone() -> [1,2,3]
       *
       ***/
      'clone': function() {
        return simpleMerge([], this);
      },
  
      /***
       * @method unique([map] = null)
       * @returns Array
       * @short Removes all duplicate elements in the array.
       * @extra [map] may be a function mapping the value to be uniqued on or a string acting as a shortcut. This is most commonly used when you have a key that ensures the object's uniqueness, and don't need to check all fields. This method will also correctly operate on arrays of objects.
       * @example
       *
       *   [1,2,2,3].unique()                 -> [1,2,3]
       *   [{foo:'bar'},{foo:'bar'}].unique() -> [{foo:'bar'}]
       +   [{foo:'bar'},{foo:'bar'}].unique(function(obj){
       *     return obj.foo;
       *   }); -> [{foo:'bar'}]
       *   [{foo:'bar'},{foo:'bar'}].unique('foo') -> [{foo:'bar'}]
       *
       ***/
      'unique': function(map) {
        return arrayUnique(this, map);
      },
  
      /***
       * @method flatten([limit] = Infinity)
       * @returns Array
       * @short Returns a flattened, one-dimensional copy of the array.
       * @extra You can optionally specify a [limit], which will only flatten that depth.
       * @example
       *
       *   [[1], 2, [3]].flatten()      -> [1,2,3]
       *   [['a'],[],'b','c'].flatten() -> ['a','b','c']
       *
       ***/
      'flatten': function(limit) {
        return arrayFlatten(this, limit);
      },
  
      /***
       * @method union([a1], [a2], ...)
       * @returns Array
       * @short Returns an array containing all elements in all arrays with duplicates removed.
       * @extra This method will also correctly operate on arrays of objects.
       * @example
       *
       *   [1,3,5].union([5,7,9])     -> [1,3,5,7,9]
       *   ['a','b'].union(['b','c']) -> ['a','b','c']
       *
       ***/
      'union': function() {
        return arrayUnique(this.concat(flatArguments(arguments)));
      },
  
      /***
       * @method intersect([a1], [a2], ...)
       * @returns Array
       * @short Returns an array containing the elements all arrays have in common.
       * @extra This method will also correctly operate on arrays of objects.
       * @example
       *
       *   [1,3,5].intersect([5,7,9])   -> [5]
       *   ['a','b'].intersect('b','c') -> ['b']
       *
       ***/
      'intersect': function() {
        return arrayIntersect(this, flatArguments(arguments), false);
      },
  
      /***
       * @method subtract([a1], [a2], ...)
       * @returns Array
       * @short Subtracts from the array all elements in [a1], [a2], etc.
       * @extra This method will also correctly operate on arrays of objects.
       * @example
       *
       *   [1,3,5].subtract([5,7,9])   -> [1,3]
       *   [1,3,5].subtract([3],[5])   -> [1]
       *   ['a','b'].subtract('b','c') -> ['a']
       *
       ***/
      'subtract': function(a) {
        return arrayIntersect(this, flatArguments(arguments), true);
      },
  
      /***
       * @method at(<index>, [loop] = true)
       * @returns Mixed
       * @short Gets the element(s) at a given index.
       * @extra When [loop] is true, overshooting the end of the array (or the beginning) will begin counting from the other end. As an alternate syntax, passing multiple indexes will get the elements at those indexes.
       * @example
       *
       *   [1,2,3].at(0)        -> 1
       *   [1,2,3].at(2)        -> 3
       *   [1,2,3].at(4)        -> 2
       *   [1,2,3].at(4, false) -> null
       *   [1,2,3].at(-1)       -> 3
       *   [1,2,3].at(0,1)      -> [1,2]
       *
       ***/
      'at': function() {
        return getEntriesForIndexes(this, arguments);
      },
  
      /***
       * @method first([num] = 1)
       * @returns Mixed
       * @short Returns the first element(s) in the array.
       * @extra When <num> is passed, returns the first <num> elements in the array.
       * @example
       *
       *   [1,2,3].first()        -> 1
       *   [1,2,3].first(2)       -> [1,2]
       *
       ***/
      'first': function(num) {
        if(isUndefined(num)) return this[0];
        if(num < 0) num = 0;
        return this.slice(0, num);
      },
  
      /***
       * @method last([num] = 1)
       * @returns Mixed
       * @short Returns the last element(s) in the array.
       * @extra When <num> is passed, returns the last <num> elements in the array.
       * @example
       *
       *   [1,2,3].last()        -> 3
       *   [1,2,3].last(2)       -> [2,3]
       *
       ***/
      'last': function(num) {
        if(isUndefined(num)) return this[this.length - 1];
        var start = this.length - num < 0 ? 0 : this.length - num;
        return this.slice(start);
      },
  
      /***
       * @method from(<index>)
       * @returns Array
       * @short Returns a slice of the array from <index>.
       * @example
       *
       *   [1,2,3].from(1)  -> [2,3]
       *   [1,2,3].from(2)  -> [3]
       *
       ***/
      'from': function(num) {
        return this.slice(num);
      },
  
      /***
       * @method to(<index>)
       * @returns Array
       * @short Returns a slice of the array up to <index>.
       * @example
       *
       *   [1,2,3].to(1)  -> [1]
       *   [1,2,3].to(2)  -> [1,2]
       *
       ***/
      'to': function(num) {
        if(isUndefined(num)) num = this.length;
        return this.slice(0, num);
      },
  
      /***
       * @method min([map], [all] = false)
       * @returns Mixed
       * @short Returns the element in the array with the lowest value.
       * @extra [map] may be a function mapping the value to be checked or a string acting as a shortcut. If [all] is true, will return all min values in an array.
       * @example
       *
       *   [1,2,3].min()                          -> 1
       *   ['fee','fo','fum'].min('length')       -> 'fo'
       *   ['fee','fo','fum'].min('length', true) -> ['fo']
       +   ['fee','fo','fum'].min(function(n) {
       *     return n.length;
       *   });                              -> ['fo']
       +   [{a:3,a:2}].min(function(n) {
       *     return n['a'];
       *   });                              -> [{a:2}]
       *
       ***/
      'min': function(map, all) {
        return getMinOrMax(this, map, 'min', all);
      },
  
      /***
       * @method max([map], [all] = false)
       * @returns Mixed
       * @short Returns the element in the array with the greatest value.
       * @extra [map] may be a function mapping the value to be checked or a string acting as a shortcut. If [all] is true, will return all max values in an array.
       * @example
       *
       *   [1,2,3].max()                          -> 3
       *   ['fee','fo','fum'].max('length')       -> 'fee'
       *   ['fee','fo','fum'].max('length', true) -> ['fee']
       +   [{a:3,a:2}].max(function(n) {
       *     return n['a'];
       *   });                              -> {a:3}
       *
       ***/
      'max': function(map, all) {
        return getMinOrMax(this, map, 'max', all);
      },
  
      /***
       * @method least([map])
       * @returns Array
       * @short Returns the elements in the array with the least commonly occuring value.
       * @extra [map] may be a function mapping the value to be checked or a string acting as a shortcut.
       * @example
       *
       *   [3,2,2].least()                   -> [3]
       *   ['fe','fo','fum'].least('length') -> ['fum']
       +   [{age:35,name:'ken'},{age:12,name:'bob'},{age:12,name:'ted'}].least(function(n) {
       *     return n.age;
       *   });                               -> [{age:35,name:'ken'}]
       *
       ***/
      'least': function(map, all) {
        return getMinOrMax(this.groupBy.apply(this, [map]), 'length', 'min', all);
      },
  
      /***
       * @method most([map])
       * @returns Array
       * @short Returns the elements in the array with the most commonly occuring value.
       * @extra [map] may be a function mapping the value to be checked or a string acting as a shortcut.
       * @example
       *
       *   [3,2,2].most()                   -> [2]
       *   ['fe','fo','fum'].most('length') -> ['fe','fo']
       +   [{age:35,name:'ken'},{age:12,name:'bob'},{age:12,name:'ted'}].most(function(n) {
       *     return n.age;
       *   });                              -> [{age:12,name:'bob'},{age:12,name:'ted'}]
       *
       ***/
      'most': function(map, all) {
        return getMinOrMax(this.groupBy.apply(this, [map]), 'length', 'max', all);
      },
  
      /***
       * @method sum([map])
       * @returns Number
       * @short Sums all values in the array.
       * @extra [map] may be a function mapping the value to be summed or a string acting as a shortcut.
       * @example
       *
       *   [1,2,2].sum()                           -> 5
       +   [{age:35},{age:12},{age:12}].sum(function(n) {
       *     return n.age;
       *   });                                     -> 59
       *   [{age:35},{age:12},{age:12}].sum('age') -> 59
       *
       ***/
      'sum': function(map) {
        var arr = map ? this.map(map) : this;
        return arr.length > 0 ? arr.reduce(function(a,b) { return a + b; }) : 0;
      },
  
      /***
       * @method average([map])
       * @returns Number
       * @short Gets the mean average for all values in the array.
       * @extra [map] may be a function mapping the value to be averaged or a string acting as a shortcut.
       * @example
       *
       *   [1,2,3].average()                           -> 2
       +   [{age:35},{age:11},{age:11}].average(function(n) {
       *     return n.age;
       *   });                                         -> 19
       *   [{age:35},{age:11},{age:11}].average('age') -> 19
       *
       ***/
      'average': function(map) {
        var arr = map ? this.map(map) : this;
        return arr.length > 0 ? arr.sum() / arr.length : 0;
      },
  
      /***
       * @method inGroups(<num>, [padding])
       * @returns Array
       * @short Groups the array into <num> arrays.
       * @extra [padding] specifies a value with which to pad the last array so that they are all equal length.
       * @example
       *
       *   [1,2,3,4,5,6,7].inGroups(3)         -> [ [1,2,3], [4,5,6], [7] ]
       *   [1,2,3,4,5,6,7].inGroups(3, 'none') -> [ [1,2,3], [4,5,6], [7,'none','none'] ]
       *
       ***/
      'inGroups': function(num, padding) {
        var pad = arguments.length > 1;
        var arr = this;
        var result = [];
        var divisor = ceil(this.length / num);
        simpleRepeat(num, function(i) {
          var index = i * divisor;
          var group = arr.slice(index, index + divisor);
          if(pad && group.length < divisor) {
            simpleRepeat(divisor - group.length, function() {
              group = group.add(padding);
            });
          }
          result.push(group);
        });
        return result;
      },
  
      /***
       * @method inGroupsOf(<num>, [padding] = null)
       * @returns Array
       * @short Groups the array into arrays of <num> elements each.
       * @extra [padding] specifies a value with which to pad the last array so that they are all equal length.
       * @example
       *
       *   [1,2,3,4,5,6,7].inGroupsOf(4)         -> [ [1,2,3,4], [5,6,7] ]
       *   [1,2,3,4,5,6,7].inGroupsOf(4, 'none') -> [ [1,2,3,4], [5,6,7,'none'] ]
       *
       ***/
      'inGroupsOf': function(num, padding) {
        var result = [], len = this.length, arr = this, group;
        if(len === 0 || num === 0) return arr;
        if(isUndefined(num)) num = 1;
        if(isUndefined(padding)) padding = null;
        simpleRepeat(ceil(len / num), function(i) {
          group = arr.slice(num * i, num * i + num);
          while(group.length < num) {
            group.push(padding);
          }
          result.push(group);
        });
        return result;
      },
  
      /***
       * @method isEmpty()
       * @returns Boolean
       * @short Returns true if the array is empty.
       * @extra This is true if the array has a length of zero, or contains only %undefined%, %null%, or %NaN%.
       * @example
       *
       *   [].isEmpty()               -> true
       *   [null,undefined].isEmpty() -> true
       *
       ***/
      'isEmpty': function() {
        return this.compact().length == 0;
      },
  
      /***
       * @method sortBy(<map>, [desc] = false)
       * @returns Array
       * @short Sorts the array by <map>.
       * @extra <map> may be a function, a string acting as a shortcut, or blank (direct comparison of array values). [desc] will sort the array in descending order. When the field being sorted on is a string, the resulting order will be determined by an internal collation algorithm that is optimized for major Western languages, but can be customized. For more information see @array_sorting.
       * @example
       *
       *   ['world','a','new'].sortBy('length')       -> ['a','new','world']
       *   ['world','a','new'].sortBy('length', true) -> ['world','new','a']
       +   [{age:72},{age:13},{age:18}].sortBy(function(n) {
       *     return n.age;
       *   });                                        -> [{age:13},{age:18},{age:72}]
       *
       ***/
      'sortBy': function(map, desc) {
        var arr = this.clone();
        arr.sort(function(a, b) {
          var aProperty, bProperty, comp;
          aProperty = transformArgument(a, map, arr, [a]);
          bProperty = transformArgument(b, map, arr, [b]);
          if(isString(aProperty) && isString(bProperty)) {
            comp = collateStrings(aProperty, bProperty);
          } else if(aProperty < bProperty) {
            comp = -1;
          } else if(aProperty > bProperty) {
            comp = 1;
          } else {
            comp = 0;
          }
          return comp * (desc ? -1 : 1);
        });
        return arr;
      },
  
      /***
       * @method randomize()
       * @returns Array
       * @short Returns a copy of the array with the elements randomized.
       * @extra Uses Fisher-Yates algorithm.
       * @example
       *
       *   [1,2,3,4].randomize()  -> [?,?,?,?]
       *
       ***/
      'randomize': function() {
        var arr = this.concat(), i = arr.length, j, x;
        while(i) {
          j = (math.random() * i) | 0;
          x = arr[--i];
          arr[i] = arr[j];
          arr[j] = x;
        }
        return arr;
      },
  
      /***
       * @method zip([arr1], [arr2], ...)
       * @returns Array
       * @short Merges multiple arrays together.
       * @extra This method "zips up" smaller arrays into one large whose elements are "all elements at index 0", "all elements at index 1", etc. Useful when you have associated data that is split over separated arrays. If the arrays passed have more elements than the original array, they will be discarded. If they have fewer elements, the missing elements will filled with %null%.
       * @example
       *
       *   [1,2,3].zip([4,5,6])                                       -> [[1,2], [3,4], [5,6]]
       *   ['Martin','John'].zip(['Luther','F.'], ['King','Kennedy']) -> [['Martin','Luther','King'], ['John','F.','Kennedy']]
       *
       ***/
      'zip': function() {
        var args = multiArgs(arguments);
        return this.map(function(el, i) {
          return [el].concat(args.map(function(k) {
            return (i in k) ? k[i] : null;
          }));
        });
      },
  
      /***
       * @method sample([num])
       * @returns Mixed
       * @short Returns a random element from the array.
       * @extra If [num] is passed, will return [num] samples from the array.
       * @example
       *
       *   [1,2,3,4,5].sample()  -> // Random element
       *   [1,2,3,4,5].sample(3) -> // Array of 3 random elements
       *
       ***/
      'sample': function(num) {
        var arr = this.randomize();
        return arguments.length > 0 ? arr.slice(0, num) : arr[0];
      },
  
      /***
       * @method each(<fn>, [index] = 0, [loop] = false)
       * @returns Array
       * @short Runs <fn> against each element in the array. Enhanced version of %Array#forEach%.
       * @extra Parameters passed to <fn> are identical to %forEach%, ie. the first parameter is the current element, second parameter is the current index, and third parameter is the array itself. If <fn> returns %false% at any time it will break out of the loop. Once %each% finishes, it will return the array. If [index] is passed, <fn> will begin at that index and work its way to the end. If [loop] is true, it will then start over from the beginning of the array and continue until it reaches [index] - 1.
       * @example
       *
       *   [1,2,3,4].each(function(n) {
       *     // Called 4 times: 1, 2, 3, 4
       *   });
       *   [1,2,3,4].each(function(n) {
       *     // Called 4 times: 3, 4, 1, 2
       *   }, 2, true);
       *
       ***/
      'each': function(fn, index, loop) {
        arrayEach(this, fn, index, loop);
        return this;
      },
  
      /***
       * @method add(<el>, [index])
       * @returns Array
       * @short Adds <el> to the array.
       * @extra If [index] is specified, it will add at [index], otherwise adds to the end of the array. %add% behaves like %concat% in that if <el> is an array it will be joined, not inserted. This method will change the array! Use %include% for a non-destructive alias. Also, %insert% is provided as an alias that reads better when using an index.
       * @example
       *
       *   [1,2,3,4].add(5)       -> [1,2,3,4,5]
       *   [1,2,3,4].add([5,6,7]) -> [1,2,3,4,5,6,7]
       *   [1,2,3,4].insert(8, 1) -> [1,8,2,3,4]
       *
       ***/
      'add': function(el, index) {
        if(!isNumber(number(index)) || isNaN(index)) index = this.length;
        array.prototype.splice.apply(this, [index, 0].concat(el));
        return this;
      },
  
      /***
       * @method remove([f1], [f2], ...)
       * @returns Array
       * @short Removes any element in the array that matches [f1], [f2], etc.
       * @extra Will match a string, number, array, object, or alternately test against a function or regex. This method will change the array! Use %exclude% for a non-destructive alias. This method implements @array_matching.
       * @example
       *
       *   [1,2,3].remove(3)         -> [1,2]
       *   ['a','b','c'].remove(/b/) -> ['a','c']
       +   [{a:1},{b:2}].remove(function(n) {
       *     return n['a'] == 1;
       *   });                       -> [{b:2}]
       *
       ***/
      'remove': function() {
        var arr = this;
        multiArgs(arguments, function(f) {
          var i = 0, matcher = getMatcher(f);
          while(i < arr.length) {
            if(matcher(arr[i], i, arr)) {
              arr.splice(i, 1);
            } else {
              i++;
            }
          }
        });
        return arr;
      },
  
      /***
       * @method compact([all] = false)
       * @returns Array
       * @short Removes all instances of %undefined%, %null%, and %NaN% from the array.
       * @extra If [all] is %true%, all "falsy" elements will be removed. This includes empty strings, 0, and false.
       * @example
       *
       *   [1,null,2,undefined,3].compact() -> [1,2,3]
       *   [1,'',2,false,3].compact()       -> [1,'',2,false,3]
       *   [1,'',2,false,3].compact(true)   -> [1,2,3]
       *
       ***/
      'compact': function(all) {
        var result = [];
        arrayEach(this, function(el, i) {
          if(isArray(el)) {
            result.push(el.compact());
          } else if(all && el) {
            result.push(el);
          } else if(!all && el != null && el.valueOf() === el.valueOf()) {
            result.push(el);
          }
        });
        return result;
      },
  
      /***
       * @method groupBy(<map>, [fn])
       * @returns Object
       * @short Groups the array by <map>.
       * @extra Will return an object with keys equal to the grouped values. <map> may be a mapping function, or a string acting as a shortcut. Optionally calls [fn] for each group.
       * @example
       *
       *   ['fee','fi','fum'].groupBy('length') -> { 2: ['fi'], 3: ['fee','fum'] }
       +   [{age:35,name:'ken'},{age:15,name:'bob'}].groupBy(function(n) {
       *     return n.age;
       *   });                                  -> { 35: [{age:35,name:'ken'}], 15: [{age:15,name:'bob'}] }
       *
       ***/
      'groupBy': function(map, fn) {
        var arr = this, result = {}, key;
        arrayEach(arr, function(el, index) {
          key = transformArgument(el, map, arr, [el, index, arr]);
          if(!result[key]) result[key] = [];
          result[key].push(el);
        });
        if(fn) {
          iterateOverObject(result, fn);
        }
        return result;
      },
  
      /***
       * @method none(<f>)
       * @returns Boolean
       * @short Returns true if none of the elements in the array match <f>.
       * @extra <f> will match a string, number, array, object, or alternately test against a function or regex. This method implements @array_matching.
       * @example
       *
       *   [1,2,3].none(5)         -> true
       *   ['a','b','c'].none(/b/) -> false
       +   [{a:1},{b:2}].none(function(n) {
       *     return n['a'] > 1;
       *   });                     -> true
       *
       ***/
      'none': function() {
        return !this.any.apply(this, arguments);
      }
  
  
    });
  
  
    // Aliases
  
    extend(array, true, true, {
  
      /***
       * @method all()
       * @alias every
       *
       ***/
      'all': array.prototype.every,
  
      /*** @method any()
       * @alias some
       *
       ***/
      'any': array.prototype.some,
  
      /***
       * @method insert()
       * @alias add
       *
       ***/
      'insert': array.prototype.add
  
    });
  
  
    /***
     * Object module
     * Enumerable methods on objects
     *
     ***/
  
     function keysWithObjectCoercion(obj) {
       return object.keys(coercePrimitiveToObject(obj));
     }
  
    /***
     * @method [enumerable](<obj>)
     * @returns Boolean
     * @short Enumerable methods in the Array package are also available to the Object class. They will perform their normal operations for every property in <obj>.
     * @extra In cases where a callback is used, instead of %element, index%, the callback will instead be passed %key, value%. Enumerable methods are also available to extended objects as instance methods.
     *
     * @set
     *   each
     *   map
     *   any
     *   all
     *   none
     *   count
     *   find
     *   findAll
     *   reduce
     *   isEmpty
     *   sum
     *   average
     *   min
     *   max
     *   least
     *   most
     *
     * @example
     *
     *   Object.any({foo:'bar'}, 'bar')            -> true
     *   Object.extended({foo:'bar'}).any('bar')   -> true
     *   Object.isEmpty({})                        -> true
     +   Object.map({ fred: { age: 52 } }, 'age'); -> { fred: 52 }
     *
     ***/
  
    function buildEnumerableMethods(names, mapping) {
      extendSimilar(object, false, true, names, function(methods, name) {
        methods[name] = function(obj, arg1, arg2) {
          var result, coerced = keysWithObjectCoercion(obj), matcher;
          if(!mapping) {
            matcher = getMatcher(arg1, true);
          }
          result = array.prototype[name].call(coerced, function(key) {
            var value = obj[key];
            if(mapping) {
              return transformArgument(value, arg1, obj, [key, value, obj]);
            } else {
              return matcher(value, key, obj);
            }
          }, arg2);
          if(isArray(result)) {
            // The method has returned an array of keys so use this array
            // to build up the resulting object in the form we want it in.
            result = result.reduce(function(o, key, i) {
              o[key] = obj[key];
              return o;
            }, {});
          }
          return result;
        };
      });
      buildObjectInstanceMethods(names, Hash);
    }
  
    function exportSortAlgorithm() {
      array[AlphanumericSort] = collateStrings;
    }
  
    extend(object, false, true, {
  
      'map': function(obj, map) {
        var result = {}, key, value;
        for(key in obj) {
          if(!hasOwnProperty(obj, key)) continue;
          value = obj[key];
          result[key] = transformArgument(value, map, obj, [key, value, obj]);
        }
        return result;
      },
  
      'reduce': function(obj) {
        var values = keysWithObjectCoercion(obj).map(function(key) {
          return obj[key];
        });
        return values.reduce.apply(values, multiArgs(arguments, null, 1));
      },
  
      'each': function(obj, fn) {
        checkCallback(fn);
        iterateOverObject(obj, fn);
        return obj;
      },
  
      /***
       * @method size(<obj>)
       * @returns Number
       * @short Returns the number of properties in <obj>.
       * @extra %size% is available as an instance method on extended objects.
       * @example
       *
       *   Object.size({ foo: 'bar' }) -> 1
       *
       ***/
      'size': function (obj) {
        return keysWithObjectCoercion(obj).length;
      }
  
    });
  
    var EnumerableFindingMethods = 'any,all,none,count,find,findAll,isEmpty'.split(',');
    var EnumerableMappingMethods = 'sum,average,min,max,least,most'.split(',');
    var EnumerableOtherMethods   = 'map,reduce,size'.split(',');
    var EnumerableMethods        = EnumerableFindingMethods.concat(EnumerableMappingMethods).concat(EnumerableOtherMethods);
  
    buildEnhancements();
    buildAlphanumericSort();
    buildEnumerableMethods(EnumerableFindingMethods);
    buildEnumerableMethods(EnumerableMappingMethods, true);
    buildObjectInstanceMethods(EnumerableOtherMethods, Hash);
    exportSortAlgorithm();
  
  
    /***
     * @package Date
     * @dependency core
     * @description Date parsing and formatting, relative formats like "1 minute ago", Number methods like "daysAgo", localization support with default English locale definition.
     *
     ***/
  
    var English;
    var CurrentLocalization;
  
    var TimeFormat = ['ampm','hour','minute','second','ampm','utc','offset_sign','offset_hours','offset_minutes','ampm']
    var DecimalReg = '(?:[,.]\\d+)?';
    var HoursReg   = '\\d{1,2}' + DecimalReg;
    var SixtyReg   = '[0-5]\\d' + DecimalReg;
    var RequiredTime = '({t})?\\s*('+HoursReg+')(?:{h}('+SixtyReg+')?{m}(?::?('+SixtyReg+'){s})?\\s*(?:({t})|(Z)|(?:([+-])(\\d{2,2})(?::?(\\d{2,2}))?)?)?|\\s*({t}))';
  
    var KanjiDigits = '〇一二三四五六七八九十百千万';
    var AsianDigitMap = {};
    var AsianDigitReg;
  
    var DateArgumentUnits;
    var DateUnitsReversed;
    var CoreDateFormats = [];
    var CompiledOutputFormats = {};
  
    var DateFormatTokens = {
  
      'yyyy': function(d) {
        return callDateGet(d, 'FullYear');
      },
  
      'yy': function(d) {
        return callDateGet(d, 'FullYear') % 100;
      },
  
      'ord': function(d) {
        var date = callDateGet(d, 'Date');
        return date + getOrdinalizedSuffix(date);
      },
  
      'tz': function(d) {
        return d.getUTCOffset();
      },
  
      'isotz': function(d) {
        return d.getUTCOffset(true);
      },
  
      'Z': function(d) {
        return d.getUTCOffset();
      },
  
      'ZZ': function(d) {
        return d.getUTCOffset().replace(/(\d{2})$/, ':$1');
      }
  
    };
  
    var DateUnits = [
      {
        name: 'year',
        method: 'FullYear',
        ambiguous: true,
        multiplier: function(d) {
          var adjust = d ? (d.isLeapYear() ? 1 : 0) : 0.25;
          return (365 + adjust) * 24 * 60 * 60 * 1000;
        }
      },
      {
        name: 'month',
        error: 0.919, // Feb 1-28 over 1 month
        method: 'Month',
        ambiguous: true,
        multiplier: function(d, ms) {
          var days = 30.4375, inMonth;
          if(d) {
            inMonth = d.daysInMonth();
            if(ms <= inMonth.days()) {
              days = inMonth;
            }
          }
          return days * 24 * 60 * 60 * 1000;
        }
      },
      {
        name: 'week',
        method: 'ISOWeek',
        multiplier: function() {
          return 7 * 24 * 60 * 60 * 1000;
        }
      },
      {
        name: 'day',
        error: 0.958, // DST traversal over 1 day
        method: 'Date',
        ambiguous: true,
        multiplier: function() {
          return 24 * 60 * 60 * 1000;
        }
      },
      {
        name: 'hour',
        method: 'Hours',
        multiplier: function() {
          return 60 * 60 * 1000;
        }
      },
      {
        name: 'minute',
        method: 'Minutes',
        multiplier: function() {
          return 60 * 1000;
        }
      },
      {
        name: 'second',
        method: 'Seconds',
        multiplier: function() {
          return 1000;
        }
      },
      {
        name: 'millisecond',
        method: 'Milliseconds',
        multiplier: function() {
          return 1;
        }
      }
    ];
  
  
  
  
    // Date Localization
  
    var Localizations = {};
  
    // Localization object
  
    function Localization(l) {
      simpleMerge(this, l);
      this.compiledFormats = CoreDateFormats.concat();
    }
  
    Localization.prototype = {
  
      getMonth: function(n) {
        if(isNumber(n)) {
          return n - 1;
        } else {
          return this['months'].indexOf(n) % 12;
        }
      },
  
      getWeekday: function(n) {
        return this['weekdays'].indexOf(n) % 7;
      },
  
      getNumber: function(n) {
        var i;
        if(isNumber(n)) {
          return n;
        } else if(n && (i = this['numbers'].indexOf(n)) !== -1) {
          return (i + 1) % 10;
        } else {
          return 1;
        }
      },
  
      getNumericDate: function(n) {
        var self = this;
        return n.replace(regexp(this['num'], 'g'), function(d) {
          var num = self.getNumber(d);
          return num || '';
        });
      },
  
      getUnitIndex: function(n) {
        return this['units'].indexOf(n) % 8;
      },
  
      getRelativeFormat: function(adu) {
        return this.convertAdjustedToFormat(adu, adu[2] > 0 ? 'future' : 'past');
      },
  
      getDuration: function(ms) {
        return this.convertAdjustedToFormat(getAdjustedUnit(ms), 'duration');
      },
  
      hasVariant: function(code) {
        code = code || this.code;
        return code === 'en' || code === 'en-US' ? true : this['variant'];
      },
  
      matchAM: function(str) {
        return str === this['ampm'][0];
      },
  
      matchPM: function(str) {
        return str && str === this['ampm'][1];
      },
  
      convertAdjustedToFormat: function(adu, mode) {
        var sign, unit, mult,
            num    = adu[0],
            u      = adu[1],
            ms     = adu[2],
            format = this[mode] || this['relative'];
        if(isFunction(format)) {
          return format.call(this, num, u, ms, mode);
        }
        mult = this['plural'] && num > 1 ? 1 : 0;
        unit = this['units'][mult * 8 + u] || this['units'][u];
        if(this['capitalizeUnit']) unit = simpleCapitalize(unit);
        sign = this['modifiers'].filter(function(m) { return m.name == 'sign' && m.value == (ms > 0 ? 1 : -1); })[0];
        return format.replace(/\{(.*?)\}/g, function(full, match) {
          switch(match) {
            case 'num': return num;
            case 'unit': return unit;
            case 'sign': return sign.src;
          }
        });
      },
  
      getFormats: function() {
        return this.cachedFormat ? [this.cachedFormat].concat(this.compiledFormats) : this.compiledFormats;
      },
  
      addFormat: function(src, allowsTime, match, variant, iso) {
        var to = match || [], loc = this, time, timeMarkers, lastIsNumeral;
  
        src = src.replace(/\s+/g, '[,. ]*');
        src = src.replace(/\{([^,]+?)\}/g, function(all, k) {
          var value, arr, result,
              opt   = k.match(/\?$/),
              nc    = k.match(/^(\d+)\??$/),
              slice = k.match(/(\d)(?:-(\d))?/),
              key   = k.replace(/[^a-z]+$/, '');
          if(nc) {
            value = loc['tokens'][nc[1]];
          } else if(loc[key]) {
            value = loc[key];
          } else if(loc[key + 's']) {
            value = loc[key + 's'];
            if(slice) {
              // Can't use filter here as Prototype hijacks the method and doesn't
              // pass an index, so use a simple loop instead!
              arr = [];
              value.forEach(function(m, i) {
                var mod = i % (loc['units'] ? 8 : value.length);
                if(mod >= slice[1] && mod <= (slice[2] || slice[1])) {
                  arr.push(m);
                }
              });
              value = arr;
            }
            value = arrayToAlternates(value);
          }
          if(nc) {
            result = '(?:' + value + ')';
          } else {
            if(!match) {
              to.push(key);
            }
            result = '(' + value + ')';
          }
          if(opt) {
            result += '?';
          }
          return result;
        });
        if(allowsTime) {
          time = prepareTime(RequiredTime, loc, iso);
          timeMarkers = ['t','[\\s\\u3000]'].concat(loc['timeMarker']);
          lastIsNumeral = src.match(/\\d\{\d,\d\}\)+\??$/);
          addDateInputFormat(loc, '(?:' + time + ')[,\\s\\u3000]+?' + src, TimeFormat.concat(to), variant);
          addDateInputFormat(loc, src + '(?:[,\\s]*(?:' + timeMarkers.join('|') + (lastIsNumeral ? '+' : '*') +')' + time + ')?', to.concat(TimeFormat), variant);
        } else {
          addDateInputFormat(loc, src, to, variant);
        }
      }
  
    };
  
  
    // Localization helpers
  
    function getLocalization(localeCode, fallback) {
      var loc;
      if(!isString(localeCode)) localeCode = '';
      loc = Localizations[localeCode] || Localizations[localeCode.slice(0,2)];
      if(fallback === false && !loc) {
        throw new TypeError('Invalid locale.');
      }
      return loc || CurrentLocalization;
    }
  
    function setLocalization(localeCode, set) {
      var loc, canAbbreviate;
  
      function initializeField(name) {
        var val = loc[name];
        if(isString(val)) {
          loc[name] = val.split(',');
        } else if(!val) {
          loc[name] = [];
        }
      }
  
      function eachAlternate(str, fn) {
        str = str.split('+').map(function(split) {
          return split.replace(/(.+):(.+)$/, function(full, base, suffixes) {
            return suffixes.split('|').map(function(suffix) {
              return base + suffix;
            }).join('|');
          });
        }).join('|');
        return str.split('|').forEach(fn);
      }
  
      function setArray(name, abbreviate, multiple) {
        var arr = [];
        loc[name].forEach(function(full, i) {
          if(abbreviate) {
            full += '+' + full.slice(0,3);
          }
          eachAlternate(full, function(day, j) {
            arr[j * multiple + i] = day.toLowerCase();
          });
        });
        loc[name] = arr;
      }
  
      function getDigit(start, stop, allowNumbers) {
        var str = '\\d{' + start + ',' + stop + '}';
        if(allowNumbers) str += '|(?:' + arrayToAlternates(loc['numbers']) + ')+';
        return str;
      }
  
      function getNum() {
        var arr = ['-?\\d+'].concat(loc['articles']);
        if(loc['numbers']) arr = arr.concat(loc['numbers']);
        return arrayToAlternates(arr);
      }
  
      function setDefault(name, value) {
        loc[name] = loc[name] || value;
      }
  
      function setModifiers() {
        var arr = [];
        loc.modifiersByName = {};
        loc['modifiers'].push({ 'name': 'day', 'src': 'yesterday', 'value': -1 });
        loc['modifiers'].push({ 'name': 'day', 'src': 'today', 'value': 0 });
        loc['modifiers'].push({ 'name': 'day', 'src': 'tomorrow', 'value': 1 });
        loc['modifiers'].forEach(function(modifier) {
          var name = modifier.name;
          eachAlternate(modifier.src, function(t) {
            var locEntry = loc[name];
            loc.modifiersByName[t] = modifier;
            arr.push({ name: name, src: t, value: modifier.value });
            loc[name] = locEntry ? locEntry + '|' + t : t;
          });
        });
        loc['day'] += '|' + arrayToAlternates(loc['weekdays']);
        loc['modifiers'] = arr;
      }
  
      // Initialize the locale
      loc = new Localization(set);
      initializeField('modifiers');
      'months,weekdays,units,numbers,articles,tokens,timeMarker,ampm,timeSuffixes,dateParse,timeParse'.split(',').forEach(initializeField);
  
      canAbbreviate = !loc['monthSuffix'];
  
      setArray('months',   canAbbreviate, 12);
      setArray('weekdays', canAbbreviate, 7);
      setArray('units', false, 8);
      setArray('numbers', false, 10);
  
      setDefault('code', localeCode);
      setDefault('date', getDigit(1,2, loc['digitDate']));
      setDefault('year', "'\\d{2}|" + getDigit(4,4));
      setDefault('num', getNum());
  
      setModifiers();
  
      if(loc['monthSuffix']) {
        loc['month'] = getDigit(1,2);
        loc['months'] = '1,2,3,4,5,6,7,8,9,10,11,12'.split(',').map(function(n) { return n + loc['monthSuffix']; });
      }
      loc['full_month'] = getDigit(1,2) + '|' + arrayToAlternates(loc['months']);
  
      // The order of these formats is very important. Order is reversed so formats that come
      // later will take precedence over formats that come before. This generally means that
      // more specific formats should come later, however, the {year} format should come before
      // {day}, as 2011 needs to be parsed as a year (2011) and not date (20) + hours (11)
  
      // If the locale has time suffixes then add a time only format for that locale
      // that is separate from the core English-based one.
      if(loc['timeSuffixes'].length > 0) {
        loc.addFormat(prepareTime(RequiredTime, loc), false, TimeFormat)
      }
  
      loc.addFormat('{day}', true);
      loc.addFormat('{month}' + (loc['monthSuffix'] || ''));
      loc.addFormat('{year}' + (loc['yearSuffix'] || ''));
  
      loc['timeParse'].forEach(function(src) {
        loc.addFormat(src, true);
      });
  
      loc['dateParse'].forEach(function(src) {
        loc.addFormat(src);
      });
  
      return Localizations[localeCode] = loc;
    }
  
  
    // General helpers
  
    function addDateInputFormat(locale, format, match, variant) {
      locale.compiledFormats.unshift({
        variant: variant,
        locale: locale,
        reg: regexp('^' + format + '$', 'i'),
        to: match
      });
    }
  
    function simpleCapitalize(str) {
      return str.slice(0,1).toUpperCase() + str.slice(1);
    }
  
    function arrayToAlternates(arr) {
      return arr.filter(function(el) {
        return !!el;
      }).join('|');
    }
  
    function getNewDate() {
      var fn = date.SugarNewDate;
      return fn ? fn() : new date;
    }
  
    // Date argument helpers
  
    function collectDateArguments(args, allowDuration) {
      var obj;
      if(isObjectType(args[0])) {
        return args;
      } else if (isNumber(args[0]) && !isNumber(args[1])) {
        return [args[0]];
      } else if (isString(args[0]) && allowDuration) {
        return [getDateParamsFromString(args[0]), args[1]];
      }
      obj = {};
      DateArgumentUnits.forEach(function(u,i) {
        obj[u.name] = args[i];
      });
      return [obj];
    }
  
    function getDateParamsFromString(str, num) {
      var match, params = {};
      match = str.match(/^(\d+)?\s?(\w+?)s?$/i);
      if(match) {
        if(isUndefined(num)) {
          num = parseInt(match[1]) || 1;
        }
        params[match[2].toLowerCase()] = num;
      }
      return params;
    }
  
    // Date iteration helpers
  
    function iterateOverDateUnits(fn, from, to) {
      var i, unit;
      if(isUndefined(to)) to = DateUnitsReversed.length;
      for(i = from || 0; i < to; i++) {
        unit = DateUnitsReversed[i];
        if(fn(unit.name, unit, i) === false) {
          break;
        }
      }
    }
  
    // Date parsing helpers
  
    function getFormatMatch(match, arr) {
      var obj = {}, value, num;
      arr.forEach(function(key, i) {
        value = match[i + 1];
        if(isUndefined(value) || value === '') return;
        if(key === 'year') {
          obj.yearAsString = value.replace(/'/, '');
        }
        num = parseFloat(value.replace(/'/, '').replace(/,/, '.'));
        obj[key] = !isNaN(num) ? num : value.toLowerCase();
      });
      return obj;
    }
  
    function cleanDateInput(str) {
      str = str.trim().replace(/^just (?=now)|\.+$/i, '');
      return convertAsianDigits(str);
    }
  
    function convertAsianDigits(str) {
      return str.replace(AsianDigitReg, function(full, disallowed, match) {
        var sum = 0, place = 1, lastWasHolder, lastHolder;
        if(disallowed) return full;
        match.split('').reverse().forEach(function(letter) {
          var value = AsianDigitMap[letter], holder = value > 9;
          if(holder) {
            if(lastWasHolder) sum += place;
            place *= value / (lastHolder || 1);
            lastHolder = value;
          } else {
            if(lastWasHolder === false) {
              place *= 10;
            }
            sum += place * value;
          }
          lastWasHolder = holder;
        });
        if(lastWasHolder) sum += place;
        return sum;
      });
    }
  
    function getExtendedDate(f, localeCode, prefer, forceUTC) {
      var d, relative, baseLocalization, afterCallbacks, loc, set, unit, unitIndex, weekday, num, tmp;
  
      d = getNewDate();
      afterCallbacks = [];
  
      function afterDateSet(fn) {
        afterCallbacks.push(fn);
      }
  
      function fireCallbacks() {
        afterCallbacks.forEach(function(fn) {
          fn.call();
        });
      }
  
      function setWeekdayOfMonth() {
        var w = d.getWeekday();
        d.setWeekday((7 * (set['num'] - 1)) + (w > weekday ? weekday + 7 : weekday));
      }
  
      function setUnitEdge() {
        var modifier = loc.modifiersByName[set['edge']];
        iterateOverDateUnits(function(name) {
          if(isDefined(set[name])) {
            unit = name;
            return false;
          }
        }, 4);
        if(unit === 'year') set.specificity = 'month';
        else if(unit === 'month' || unit === 'week') set.specificity = 'day';
        d[(modifier.value < 0 ? 'endOf' : 'beginningOf') + simpleCapitalize(unit)]();
        // This value of -2 is arbitrary but it's a nice clean way to hook into this system.
        if(modifier.value === -2) d.reset();
      }
  
      function separateAbsoluteUnits() {
        var params;
        iterateOverDateUnits(function(name, u, i) {
          if(name === 'day') name = 'date';
          if(isDefined(set[name])) {
            // If there is a time unit set that is more specific than
            // the matched unit we have a string like "5:30am in 2 minutes",
            // which is meaningless, so invalidate the date...
            if(i >= unitIndex) {
              invalidateDate(d);
              return false;
            }
            // ...otherwise set the params to set the absolute date
            // as a callback after the relative date has been set.
            params = params || {};
            params[name] = set[name];
            delete set[name];
          }
        });
        if(params) {
          afterDateSet(function() {
            d.set(params, true);
          });
        }
      }
  
      d.utc(forceUTC);
  
      if(isDate(f)) {
        // If the source here is already a date object, then the operation
        // is the same as cloning the date, which preserves the UTC flag.
        d.utc(f.isUTC()).setTime(f.getTime());
      } else if(isNumber(f)) {
        d.setTime(f);
      } else if(isObjectType(f)) {
        d.set(f, true);
        set = f;
      } else if(isString(f)) {
  
        // The act of getting the localization will pre-initialize
        // if it is missing and add the required formats.
        baseLocalization = getLocalization(localeCode);
  
        // Clean the input and convert Kanji based numerals if they exist.
        f = cleanDateInput(f);
  
        if(baseLocalization) {
          iterateOverObject(baseLocalization.getFormats(), function(i, dif) {
            var match = f.match(dif.reg);
            if(match) {
  
              loc = dif.locale;
              set = getFormatMatch(match, dif.to, loc);
              loc.cachedFormat = dif;
  
  
              if(set['utc']) {
                d.utc();
              }
  
              if(set.timestamp) {
                set = set.timestamp;
                return false;
              }
  
              // If there's a variant (crazy Endian American format), swap the month and day.
              if(dif.variant && !isString(set['month']) && (isString(set['date']) || baseLocalization.hasVariant(localeCode))) {
                tmp = set['month'];
                set['month'] = set['date'];
                set['date']  = tmp;
              }
  
              // If the year is 2 digits then get the implied century.
              if(set['year'] && set.yearAsString.length === 2) {
                set['year'] = getYearFromAbbreviation(set['year']);
              }
  
              // Set the month which may be localized.
              if(set['month']) {
                set['month'] = loc.getMonth(set['month']);
                if(set['shift'] && !set['unit']) set['unit'] = loc['units'][7];
              }
  
              // If there is both a weekday and a date, the date takes precedence.
              if(set['weekday'] && set['date']) {
                delete set['weekday'];
              // Otherwise set a localized weekday.
              } else if(set['weekday']) {
                set['weekday'] = loc.getWeekday(set['weekday']);
                if(set['shift'] && !set['unit']) set['unit'] = loc['units'][5];
              }
  
              // Relative day localizations such as "today" and "tomorrow".
              if(set['day'] && (tmp = loc.modifiersByName[set['day']])) {
                set['day'] = tmp.value;
                d.reset();
                relative = true;
              // If the day is a weekday, then set that instead.
              } else if(set['day'] && (weekday = loc.getWeekday(set['day'])) > -1) {
                delete set['day'];
                if(set['num'] && set['month']) {
                  // If we have "the 2nd tuesday of June", set the day to the beginning of the month, then
                  // set the weekday after all other properties have been set. The weekday needs to be set
                  // after the actual set because it requires overriding the "prefer" argument which
                  // could unintentionally send the year into the future, past, etc.
                  afterDateSet(setWeekdayOfMonth);
                  set['day'] = 1;
                } else {
                  set['weekday'] = weekday;
                }
              }
  
              if(set['date'] && !isNumber(set['date'])) {
                set['date'] = loc.getNumericDate(set['date']);
              }
  
              // If the time is 1pm-11pm advance the time by 12 hours.
              if(loc.matchPM(set['ampm']) && set['hour'] < 12) {
                set['hour'] += 12;
              } else if(loc.matchAM(set['ampm']) && set['hour'] === 12) {
                set['hour'] = 0;
              }
  
              // Adjust for timezone offset
              if('offset_hours' in set || 'offset_minutes' in set) {
                d.utc();
                set['offset_minutes'] = set['offset_minutes'] || 0;
                set['offset_minutes'] += set['offset_hours'] * 60;
                if(set['offset_sign'] === '-') {
                  set['offset_minutes'] *= -1;
                }
                set['minute'] -= set['offset_minutes'];
              }
  
              // Date has a unit like "days", "months", etc. are all relative to the current date.
              if(set['unit']) {
                relative  = true;
                num       = loc.getNumber(set['num']);
                unitIndex = loc.getUnitIndex(set['unit']);
                unit      = English['units'][unitIndex];
  
                // Formats like "the 15th of last month" or "6:30pm of next week"
                // contain absolute units in addition to relative ones, so separate
                // them here, remove them from the params, and set up a callback to
                // set them after the relative ones have been set.
                separateAbsoluteUnits();
  
                // Shift and unit, ie "next month", "last week", etc.
                if(set['shift']) {
                  num *= (tmp = loc.modifiersByName[set['shift']]) ? tmp.value : 0;
                }
  
                // Unit and sign, ie "months ago", "weeks from now", etc.
                if(set['sign'] && (tmp = loc.modifiersByName[set['sign']])) {
                  num *= tmp.value;
                }
  
                // Units can be with non-relative dates, set here. ie "the day after monday"
                if(isDefined(set['weekday'])) {
                  d.set({'weekday': set['weekday'] }, true);
                  delete set['weekday'];
                }
  
                // Finally shift the unit.
                set[unit] = (set[unit] || 0) + num;
              }
  
              // If there is an "edge" it needs to be set after the
              // other fields are set. ie "the end of February"
              if(set['edge']) {
                afterDateSet(setUnitEdge);
              }
  
              if(set['year_sign'] === '-') {
                set['year'] *= -1;
              }
  
              iterateOverDateUnits(function(name, unit, i) {
                var value = set[name], fraction = value % 1;
                if(fraction) {
                  set[DateUnitsReversed[i - 1].name] = round(fraction * (name === 'second' ? 1000 : 60));
                  set[name] = floor(value);
                }
              }, 1, 4);
              return false;
            }
          });
        }
        if(!set) {
          // The Date constructor does something tricky like checking the number
          // of arguments so simply passing in undefined won't work.
          if(f !== 'now') {
            d = new date(f);
          }
          if(forceUTC) {
            // Falling back to system date here which cannot be parsed as UTC,
            // so if we're forcing UTC then simply add the offset.
            d.addMinutes(-d.getTimezoneOffset());
          }
        } else if(relative) {
          d.advance(set);
        } else {
          if(d._utc) {
            // UTC times can traverse into other days or even months,
            // so preemtively reset the time here to prevent this.
            d.reset();
          }
          updateDate(d, set, true, false, prefer);
        }
        fireCallbacks();
        // A date created by parsing a string presumes that the format *itself* is UTC, but
        // not that the date, once created, should be manipulated as such. In other words,
        // if you are creating a date object from a server time "2012-11-15T12:00:00Z",
        // in the majority of cases you are using it to create a date that will, after creation,
        // be manipulated as local, so reset the utc flag here.
        d.utc(false);
      }
      return {
        date: d,
        set: set
      }
    }
  
    // If the year is two digits, add the most appropriate century prefix.
    function getYearFromAbbreviation(year) {
      return round(callDateGet(getNewDate(), 'FullYear') / 100) * 100 - round(year / 100) * 100 + year;
    }
  
    function getShortHour(d) {
      var hours = callDateGet(d, 'Hours');
      return hours === 0 ? 12 : hours - (floor(hours / 13) * 12);
    }
  
    // weeksSince won't work here as the result needs to be floored, not rounded.
    function getWeekNumber(date) {
      date = date.clone();
      var dow = callDateGet(date, 'Day') || 7;
      date.addDays(4 - dow).reset();
      return 1 + floor(date.daysSince(date.clone().beginningOfYear()) / 7);
    }
  
    function getAdjustedUnit(ms) {
      var next, ams = abs(ms), value = ams, unitIndex = 0;
      iterateOverDateUnits(function(name, unit, i) {
        next = floor(withPrecision(ams / unit.multiplier(), 1));
        if(next >= 1) {
          value = next;
          unitIndex = i;
        }
      }, 1);
      return [value, unitIndex, ms];
    }
  
    function getRelativeWithMonthFallback(date) {
      var adu = getAdjustedUnit(date.millisecondsFromNow());
      if(allowMonthFallback(date, adu)) {
        // If the adjusted unit is in months, then better to use
        // the "monthsfromNow" which applies a special error margin
        // for edge cases such as Jan-09 - Mar-09 being less than
        // 2 months apart (when using a strict numeric definition).
        // The third "ms" element in the array will handle the sign
        // (past or future), so simply take the absolute value here.
        adu[0] = abs(date.monthsFromNow());
        adu[1] = 6;
      }
      return adu;
    }
  
    function allowMonthFallback(date, adu) {
      // Allow falling back to monthsFromNow if the unit is in months...
      return adu[1] === 6 ||
      // ...or if it's === 4 weeks and there are more days than in the given month
      (adu[1] === 5 && adu[0] === 4 && date.daysFromNow() >= getNewDate().daysInMonth());
    }
  
  
    // Date format token helpers
  
    function createMeridianTokens(slice, caps) {
      var fn = function(d, localeCode) {
        var hours = callDateGet(d, 'Hours');
        return getLocalization(localeCode)['ampm'][floor(hours / 12)] || '';
      }
      createFormatToken('t', fn, 1);
      createFormatToken('tt', fn);
      createFormatToken('T', fn, 1, 1);
      createFormatToken('TT', fn, null, 2);
    }
  
    function createWeekdayTokens(slice, caps) {
      var fn = function(d, localeCode) {
        var dow = callDateGet(d, 'Day');
        return getLocalization(localeCode)['weekdays'][dow];
      }
      createFormatToken('dow', fn, 3);
      createFormatToken('Dow', fn, 3, 1);
      createFormatToken('weekday', fn);
      createFormatToken('Weekday', fn, null, 1);
    }
  
    function createMonthTokens(slice, caps) {
      createMonthToken('mon', 0, 3);
      createMonthToken('month', 0);
  
      // For inflected month forms, namely Russian.
      createMonthToken('month2', 1);
      createMonthToken('month3', 2);
    }
  
    function createMonthToken(token, multiplier, slice) {
      var fn = function(d, localeCode) {
        var month = callDateGet(d, 'Month');
        return getLocalization(localeCode)['months'][month + (multiplier * 12)];
      };
      createFormatToken(token, fn, slice);
      createFormatToken(simpleCapitalize(token), fn, slice, 1);
    }
  
    function createFormatToken(t, fn, slice, caps) {
      DateFormatTokens[t] = function(d, localeCode) {
        var str = fn(d, localeCode);
        if(slice) str = str.slice(0, slice);
        if(caps)  str = str.slice(0, caps).toUpperCase() + str.slice(caps);
        return str;
      }
    }
  
    function createPaddedToken(t, fn, ms) {
      DateFormatTokens[t] = fn;
      DateFormatTokens[t + t] = function (d, localeCode) {
        return padNumber(fn(d, localeCode), 2);
      };
      if(ms) {
        DateFormatTokens[t + t + t] = function (d, localeCode) {
          return padNumber(fn(d, localeCode), 3);
        };
        DateFormatTokens[t + t + t + t] = function (d, localeCode) {
          return padNumber(fn(d, localeCode), 4);
        };
      }
    }
  
  
    // Date formatting helpers
  
    function buildCompiledOutputFormat(format) {
      var match = format.match(/(\{\w+\})|[^{}]+/g);
      CompiledOutputFormats[format] = match.map(function(p) {
        p.replace(/\{(\w+)\}/, function(full, token) {
          p = DateFormatTokens[token] || token;
          return token;
        });
        return p;
      });
    }
  
    function executeCompiledOutputFormat(date, format, localeCode) {
      var compiledFormat, length, i, t, result = '';
      compiledFormat = CompiledOutputFormats[format];
      for(i = 0, length = compiledFormat.length; i < length; i++) {
        t = compiledFormat[i];
        result += isFunction(t) ? t(date, localeCode) : t;
      }
      return result;
    }
  
    function formatDate(date, format, relative, localeCode) {
      var adu;
      if(!date.isValid()) {
        return 'Invalid Date';
      } else if(Date[format]) {
        format = Date[format];
      } else if(isFunction(format)) {
        adu = getRelativeWithMonthFallback(date);
        format = format.apply(date, adu.concat(getLocalization(localeCode)));
      }
      if(!format && relative) {
        adu = adu || getRelativeWithMonthFallback(date);
        // Adjust up if time is in ms, as this doesn't
        // look very good for a standard relative date.
        if(adu[1] === 0) {
          adu[1] = 1;
          adu[0] = 1;
        }
        return getLocalization(localeCode).getRelativeFormat(adu);
      }
      format = format || 'long';
      if(format === 'short' || format === 'long' || format === 'full') {
        format = getLocalization(localeCode)[format];
      }
  
      if(!CompiledOutputFormats[format]) {
        buildCompiledOutputFormat(format);
      }
  
      return executeCompiledOutputFormat(date, format, localeCode);
    }
  
    // Date comparison helpers
  
    function compareDate(d, find, localeCode, buffer, forceUTC) {
      var p, t, min, max, override, capitalized, accuracy = 0, loBuffer = 0, hiBuffer = 0;
      p = getExtendedDate(find, localeCode, null, forceUTC);
      if(buffer > 0) {
        loBuffer = hiBuffer = buffer;
        override = true;
      }
      if(!p.date.isValid()) return false;
      if(p.set && p.set.specificity) {
        DateUnits.forEach(function(u, i) {
          if(u.name === p.set.specificity) {
            accuracy = u.multiplier(p.date, d - p.date) - 1;
          }
        });
        capitalized = simpleCapitalize(p.set.specificity);
        if(p.set['edge'] || p.set['shift']) {
          p.date['beginningOf' + capitalized]();
        }
        if(p.set.specificity === 'month') {
          max = p.date.clone()['endOf' + capitalized]().getTime();
        }
        if(!override && p.set['sign'] && p.set.specificity != 'millisecond') {
          // If the time is relative, there can occasionally be an disparity between the relative date
          // and "now", which it is being compared to, so set an extra buffer to account for this.
          loBuffer = 50;
          hiBuffer = -50;
        }
      }
      t   = d.getTime();
      min = p.date.getTime();
      max = max || (min + accuracy);
      max = compensateForTimezoneTraversal(d, min, max);
      return t >= (min - loBuffer) && t <= (max + hiBuffer);
    }
  
    function compensateForTimezoneTraversal(d, min, max) {
      var dMin, dMax, minOffset, maxOffset;
      dMin = new date(min);
      dMax = new date(max).utc(d.isUTC());
      if(callDateGet(dMax, 'Hours') !== 23) {
        minOffset = dMin.getTimezoneOffset();
        maxOffset = dMax.getTimezoneOffset();
        if(minOffset !== maxOffset) {
          max += (maxOffset - minOffset).minutes();
        }
      }
      return max;
    }
  
    function updateDate(d, params, reset, advance, prefer) {
      var weekday, specificityIndex;
  
      function getParam(key) {
        return isDefined(params[key]) ? params[key] : params[key + 's'];
      }
  
      function paramExists(key) {
        return isDefined(getParam(key));
      }
  
      function uniqueParamExists(key, isDay) {
        return paramExists(key) || (isDay && paramExists('weekday'));
      }
  
      function canDisambiguate() {
        switch(prefer) {
          case -1: return d > getNewDate();
          case  1: return d < getNewDate();
        }
      }
  
      if(isNumber(params) && advance) {
        // If param is a number and we're advancing, the number is presumed to be milliseconds.
        params = { 'milliseconds': params };
      } else if(isNumber(params)) {
        // Otherwise just set the timestamp and return.
        d.setTime(params);
        return d;
      }
  
      // "date" can also be passed for the day
      if(isDefined(params['date'])) {
        params['day'] = params['date'];
      }
  
      // Reset any unit lower than the least specific unit set. Do not do this for weeks
      // or for years. This needs to be performed before the acutal setting of the date
      // because the order needs to be reversed in order to get the lowest specificity,
      // also because higher order units can be overwritten by lower order units, such
      // as setting hour: 3, minute: 345, etc.
      iterateOverDateUnits(function(name, unit, i) {
        var isDay = name === 'day';
        if(uniqueParamExists(name, isDay)) {
          params.specificity = name;
          specificityIndex = +i;
          return false;
        } else if(reset && name !== 'week' && (!isDay || !paramExists('week'))) {
          // Days are relative to months, not weeks, so don't reset if a week exists.
          callDateSet(d, unit.method, (isDay ? 1 : 0));
        }
      });
  
      // Now actually set or advance the date in order, higher units first.
      DateUnits.forEach(function(u, i) {
        var name = u.name, method = u.method, higherUnit = DateUnits[i - 1], value;
        value = getParam(name)
        if(isUndefined(value)) return;
        if(advance) {
          if(name === 'week') {
            value  = (params['day'] || 0) + (value * 7);
            method = 'Date';
          }
          value = (value * advance) + callDateGet(d, method);
        } else if(name === 'month' && paramExists('day')) {
          // When setting the month, there is a chance that we will traverse into a new month.
          // This happens in DST shifts, for example June 1st DST jumping to January 1st
          // (non-DST) will have a shift of -1:00 which will traverse into the previous year.
          // Prevent this by proactively setting the day when we know it will be set again anyway.
          // It can also happen when there are not enough days in the target month. This second
          // situation is identical to checkMonthTraversal below, however when we are advancing
          // we want to reset the date to "the last date in the target month". In the case of
          // DST shifts, however, we want to avoid the "edges" of months as that is where this
          // unintended traversal can happen. This is the reason for the different handling of
          // two similar but slightly different situations.
          //
          // TL;DR This method avoids the edges of a month IF not advancing and the date is going
          // to be set anyway, while checkMonthTraversal resets the date to the last day if advancing.
          //
          callDateSet(d, 'Date', 15);
        }
        callDateSet(d, method, value);
        if(advance && name === 'month') {
          checkMonthTraversal(d, value);
        }
      });
  
  
      // If a weekday is included in the params, set it ahead of time and set the params
      // to reflect the updated date so that resetting works properly.
      if(!advance && !paramExists('day') && paramExists('weekday')) {
        var weekday = getParam('weekday'), isAhead, futurePreferred;
        d.setWeekday(weekday);
      }
  
      // If past or future is preferred, then the process of "disambiguation" will ensure that an
      // ambiguous time/date ("4pm", "thursday", "June", etc.) will be in the past or future.
      if(canDisambiguate()) {
        iterateOverDateUnits(function(name, unit) {
          var ambiguous = unit.ambiguous || (name === 'week' && paramExists('weekday'));
          if(ambiguous && !uniqueParamExists(name, name === 'day')) {
            d[unit.addMethod](prefer);
            return false;
          }
        }, specificityIndex + 1);
      }
      return d;
    }
  
    // The ISO format allows times strung together without a demarcating ":", so make sure
    // that these markers are now optional.
    function prepareTime(format, loc, iso) {
      var timeSuffixMapping = {'h':0,'m':1,'s':2}, add;
      loc = loc || English;
      return format.replace(/{([a-z])}/g, function(full, token) {
        var separators = [],
            isHours = token === 'h',
            tokenIsRequired = isHours && !iso;
        if(token === 't') {
          return loc['ampm'].join('|');
        } else {
          if(isHours) {
            separators.push(':');
          }
          if(add = loc['timeSuffixes'][timeSuffixMapping[token]]) {
            separators.push(add + '\\s*');
          }
          return separators.length === 0 ? '' : '(?:' + separators.join('|') + ')' + (tokenIsRequired ? '' : '?');
        }
      });
    }
  
  
    // If the month is being set, then we don't want to accidentally
    // traverse into a new month just because the target month doesn't have enough
    // days. In other words, "5 months ago" from July 30th is still February, even
    // though there is no February 30th, so it will of necessity be February 28th
    // (or 29th in the case of a leap year).
  
    function checkMonthTraversal(date, targetMonth) {
      if(targetMonth < 0) {
        targetMonth = targetMonth % 12 + 12;
      }
      if(targetMonth % 12 != callDateGet(date, 'Month')) {
        callDateSet(date, 'Date', 0);
      }
    }
  
    function createDate(args, prefer, forceUTC) {
      var f, localeCode;
      if(isNumber(args[1])) {
        // If the second argument is a number, then we have an enumerated constructor type as in "new Date(2003, 2, 12);"
        f = collectDateArguments(args)[0];
      } else {
        f          = args[0];
        localeCode = args[1];
      }
      return getExtendedDate(f, localeCode, prefer, forceUTC).date;
    }
  
    function invalidateDate(d) {
      d.setTime(NaN);
    }
  
    function buildDateUnits() {
      DateUnitsReversed = DateUnits.concat().reverse();
      DateArgumentUnits = DateUnits.concat();
      DateArgumentUnits.splice(2,1);
    }
  
  
    /***
     * @method [units]Since([d], [locale] = currentLocale)
     * @returns Number
     * @short Returns the time since [d] in the appropriate unit.
     * @extra [d] will accept a date object, timestamp, or text format. If not specified, [d] is assumed to be now. [locale] can be passed to specify the locale that the date is in. %[unit]Ago% is provided as an alias to make this more readable when [d] is assumed to be the current date. For more see @date_format.
     *
     * @set
     *   millisecondsSince
     *   secondsSince
     *   minutesSince
     *   hoursSince
     *   daysSince
     *   weeksSince
     *   monthsSince
     *   yearsSince
     *
     * @example
     *
     *   Date.create().millisecondsSince('1 hour ago') -> 3,600,000
     *   Date.create().daysSince('1 week ago')         -> 7
     *   Date.create().yearsSince('15 years ago')      -> 15
     *   Date.create('15 years ago').yearsAgo()        -> 15
     *
     ***
     * @method [units]Ago()
     * @returns Number
     * @short Returns the time ago in the appropriate unit.
     *
     * @set
     *   millisecondsAgo
     *   secondsAgo
     *   minutesAgo
     *   hoursAgo
     *   daysAgo
     *   weeksAgo
     *   monthsAgo
     *   yearsAgo
     *
     * @example
     *
     *   Date.create('last year').millisecondsAgo() -> 3,600,000
     *   Date.create('last year').daysAgo()         -> 7
     *   Date.create('last year').yearsAgo()        -> 15
     *
     ***
     * @method [units]Until([d], [locale] = currentLocale)
     * @returns Number
     * @short Returns the time until [d] in the appropriate unit.
     * @extra [d] will accept a date object, timestamp, or text format. If not specified, [d] is assumed to be now. [locale] can be passed to specify the locale that the date is in. %[unit]FromNow% is provided as an alias to make this more readable when [d] is assumed to be the current date. For more see @date_format.
     *
     * @set
     *   millisecondsUntil
     *   secondsUntil
     *   minutesUntil
     *   hoursUntil
     *   daysUntil
     *   weeksUntil
     *   monthsUntil
     *   yearsUntil
     *
     * @example
     *
     *   Date.create().millisecondsUntil('1 hour from now') -> 3,600,000
     *   Date.create().daysUntil('1 week from now')         -> 7
     *   Date.create().yearsUntil('15 years from now')      -> 15
     *   Date.create('15 years from now').yearsFromNow()    -> 15
     *
     ***
     * @method [units]FromNow()
     * @returns Number
     * @short Returns the time from now in the appropriate unit.
     *
     * @set
     *   millisecondsFromNow
     *   secondsFromNow
     *   minutesFromNow
     *   hoursFromNow
     *   daysFromNow
     *   weeksFromNow
     *   monthsFromNow
     *   yearsFromNow
     *
     * @example
     *
     *   Date.create('next year').millisecondsFromNow() -> 3,600,000
     *   Date.create('next year').daysFromNow()         -> 7
     *   Date.create('next year').yearsFromNow()        -> 15
     *
     ***
     * @method add[Units](<num>, [reset] = false)
     * @returns Date
     * @short Adds <num> of the unit to the date. If [reset] is true, all lower units will be reset.
     * @extra Note that "months" is ambiguous as a unit of time. If the target date falls on a day that does not exist (ie. August 31 -> February 31), the date will be shifted to the last day of the month. Don't use %addMonths% if you need precision.
     *
     * @set
     *   addMilliseconds
     *   addSeconds
     *   addMinutes
     *   addHours
     *   addDays
     *   addWeeks
     *   addMonths
     *   addYears
     *
     * @example
     *
     *   Date.create().addMilliseconds(5) -> current time + 5 milliseconds
     *   Date.create().addDays(5)         -> current time + 5 days
     *   Date.create().addYears(5)        -> current time + 5 years
     *
     ***
     * @method isLast[Unit]()
     * @returns Boolean
     * @short Returns true if the date is last week/month/year.
     *
     * @set
     *   isLastWeek
     *   isLastMonth
     *   isLastYear
     *
     * @example
     *
     *   Date.create('yesterday').isLastWeek()  -> true or false?
     *   Date.create('yesterday').isLastMonth() -> probably not...
     *   Date.create('yesterday').isLastYear()  -> even less likely...
     *
     ***
     * @method isThis[Unit]()
     * @returns Boolean
     * @short Returns true if the date is this week/month/year.
     *
     * @set
     *   isThisWeek
     *   isThisMonth
     *   isThisYear
     *
     * @example
     *
     *   Date.create('tomorrow').isThisWeek()  -> true or false?
     *   Date.create('tomorrow').isThisMonth() -> probably...
     *   Date.create('tomorrow').isThisYear()  -> signs point to yes...
     *
     ***
     * @method isNext[Unit]()
     * @returns Boolean
     * @short Returns true if the date is next week/month/year.
     *
     * @set
     *   isNextWeek
     *   isNextMonth
     *   isNextYear
     *
     * @example
     *
     *   Date.create('tomorrow').isNextWeek()  -> true or false?
     *   Date.create('tomorrow').isNextMonth() -> probably not...
     *   Date.create('tomorrow').isNextYear()  -> even less likely...
     *
     ***
     * @method beginningOf[Unit]()
     * @returns Date
     * @short Sets the date to the beginning of the appropriate unit.
     *
     * @set
     *   beginningOfDay
     *   beginningOfWeek
     *   beginningOfMonth
     *   beginningOfYear
     *
     * @example
     *
     *   Date.create().beginningOfDay()   -> the beginning of today (resets the time)
     *   Date.create().beginningOfWeek()  -> the beginning of the week
     *   Date.create().beginningOfMonth() -> the beginning of the month
     *   Date.create().beginningOfYear()  -> the beginning of the year
     *
     ***
     * @method endOf[Unit]()
     * @returns Date
     * @short Sets the date to the end of the appropriate unit.
     *
     * @set
     *   endOfDay
     *   endOfWeek
     *   endOfMonth
     *   endOfYear
     *
     * @example
     *
     *   Date.create().endOfDay()   -> the end of today (sets the time to 23:59:59.999)
     *   Date.create().endOfWeek()  -> the end of the week
     *   Date.create().endOfMonth() -> the end of the month
     *   Date.create().endOfYear()  -> the end of the year
     *
     ***/
  
    function buildDateMethods() {
      extendSimilar(date, true, true, DateUnits, function(methods, u, i) {
        var name = u.name, caps = simpleCapitalize(name), multiplier = u.multiplier(), since, until;
        u.addMethod = 'add' + caps + 's';
        // "since/until now" only count "past" an integer, i.e. "2 days ago" is
        // anything between 2 - 2.999 days. The default margin of error is 0.999,
        // but "months" have an inherently larger margin, as the number of days
        // in a given month may be significantly less than the number of days in
        // the average month, so for example "30 days" before March 15 may in fact
        // be 1 month ago. Years also have a margin of error due to leap years,
        // but this is roughly 0.999 anyway (365 / 365.25). Other units do not
        // technically need the error margin applied to them but this accounts
        // for discrepancies like (15).hoursAgo() which technically creates the
        // current date first, then creates a date 15 hours before and compares
        // them, the discrepancy between the creation of the 2 dates means that
        // they may actually be 15.0001 hours apart. Milliseconds don't have
        // fractions, so they won't be subject to this error margin.
        function applyErrorMargin(ms) {
          var num      = ms / multiplier,
              fraction = num % 1,
              error    = u.error || 0.999;
          if(fraction && abs(fraction % 1) > error) {
            num = round(num);
          }
          return num < 0 ? ceil(num) : floor(num);
        }
        since = function(f, localeCode) {
          return applyErrorMargin(this.getTime() - date.create(f, localeCode).getTime());
        };
        until = function(f, localeCode) {
          return applyErrorMargin(date.create(f, localeCode).getTime() - this.getTime());
        };
        methods[name+'sAgo']     = until;
        methods[name+'sUntil']   = until;
        methods[name+'sSince']   = since;
        methods[name+'sFromNow'] = since;
        methods[u.addMethod] = function(num, reset) {
          var set = {};
          set[name] = num;
          return this.advance(set, reset);
        };
        buildNumberToDateAlias(u, multiplier);
        if(i < 3) {
          ['Last','This','Next'].forEach(function(shift) {
            methods['is' + shift + caps] = function() {
              return compareDate(this, shift + ' ' + name, 'en');
            };
          });
        }
        if(i < 4) {
          methods['beginningOf' + caps] = function() {
            var set = {};
            switch(name) {
              case 'year':  set['year']    = callDateGet(this, 'FullYear'); break;
              case 'month': set['month']   = callDateGet(this, 'Month');    break;
              case 'day':   set['day']     = callDateGet(this, 'Date');     break;
              case 'week':  set['weekday'] = 0; break;
            }
            return this.set(set, true);
          };
          methods['endOf' + caps] = function() {
            var set = { 'hours': 23, 'minutes': 59, 'seconds': 59, 'milliseconds': 999 };
            switch(name) {
              case 'year':  set['month']   = 11; set['day'] = 31; break;
              case 'month': set['day']     = this.daysInMonth();  break;
              case 'week':  set['weekday'] = 6;                   break;
            }
            return this.set(set, true);
          };
        }
      });
    }
  
    function buildCoreInputFormats() {
      English.addFormat('([+-])?(\\d{4,4})[-.]?{full_month}[-.]?(\\d{1,2})?', true, ['year_sign','year','month','date'], false, true);
      English.addFormat('(\\d{1,2})[-.\\/]{full_month}(?:[-.\\/](\\d{2,4}))?', true, ['date','month','year'], true);
      English.addFormat('{full_month}[-.](\\d{4,4})', false, ['month','year']);
      English.addFormat('\\/Date\\((\\d+(?:[+-]\\d{4,4})?)\\)\\/', false, ['timestamp'])
      English.addFormat(prepareTime(RequiredTime, English), false, TimeFormat)
  
      // When a new locale is initialized it will have the CoreDateFormats initialized by default.
      // From there, adding new formats will push them in front of the previous ones, so the core
      // formats will be the last to be reached. However, the core formats themselves have English
      // months in them, which means that English needs to first be initialized and creates a race
      // condition. I'm getting around this here by adding these generalized formats in the order
      // specific -> general, which will mean they will be added to the English localization in
      // general -> specific order, then chopping them off the front and reversing to get the correct
      // order. Note that there are 7 formats as 2 have times which adds a front and a back format.
      CoreDateFormats = English.compiledFormats.slice(0,7).reverse();
      English.compiledFormats = English.compiledFormats.slice(7).concat(CoreDateFormats);
    }
  
    function buildFormatTokens() {
  
      createPaddedToken('f', function(d) {
        return callDateGet(d, 'Milliseconds');
      }, true);
  
      createPaddedToken('s', function(d) {
        return callDateGet(d, 'Seconds');
      });
  
      createPaddedToken('m', function(d) {
        return callDateGet(d, 'Minutes');
      });
  
      createPaddedToken('h', function(d) {
        return callDateGet(d, 'Hours') % 12 || 12;
      });
  
      createPaddedToken('H', function(d) {
        return callDateGet(d, 'Hours');
      });
  
      createPaddedToken('d', function(d) {
        return callDateGet(d, 'Date');
      });
  
      createPaddedToken('M', function(d) {
        return callDateGet(d, 'Month') + 1;
      });
  
      createMeridianTokens();
      createWeekdayTokens();
      createMonthTokens();
  
      // Aliases
      DateFormatTokens['ms']           = DateFormatTokens['f'];
      DateFormatTokens['milliseconds'] = DateFormatTokens['f'];
      DateFormatTokens['seconds']      = DateFormatTokens['s'];
      DateFormatTokens['minutes']      = DateFormatTokens['m'];
      DateFormatTokens['hours']        = DateFormatTokens['h'];
      DateFormatTokens['24hr']         = DateFormatTokens['H'];
      DateFormatTokens['12hr']         = DateFormatTokens['h'];
      DateFormatTokens['date']         = DateFormatTokens['d'];
      DateFormatTokens['day']          = DateFormatTokens['d'];
      DateFormatTokens['year']         = DateFormatTokens['yyyy'];
  
    }
  
    function buildFormatShortcuts() {
      extendSimilar(date, true, true, 'short,long,full', function(methods, name) {
        methods[name] = function(localeCode) {
          return formatDate(this, name, false, localeCode);
        }
      });
    }
  
    function buildAsianDigits() {
      KanjiDigits.split('').forEach(function(digit, value) {
        var holder;
        if(value > 9) {
          value = pow(10, value - 9);
        }
        AsianDigitMap[digit] = value;
      });
      simpleMerge(AsianDigitMap, NumberNormalizeMap);
      // Kanji numerals may also be included in phrases which are text-based rather
      // than actual numbers such as Chinese weekdays (上周三), and "the day before
      // yesterday" (一昨日) in Japanese, so don't match these.
      AsianDigitReg = regexp('([期週周])?([' + KanjiDigits + FullWidthDigits + ']+)(?!昨)', 'g');
    }
  
     /***
     * @method is[Day]()
     * @returns Boolean
     * @short Returns true if the date falls on that day.
     * @extra Also available: %isYesterday%, %isToday%, %isTomorrow%, %isWeekday%, and %isWeekend%.
     *
     * @set
     *   isToday
     *   isYesterday
     *   isTomorrow
     *   isWeekday
     *   isWeekend
     *   isSunday
     *   isMonday
     *   isTuesday
     *   isWednesday
     *   isThursday
     *   isFriday
     *   isSaturday
     *
     * @example
     *
     *   Date.create('tomorrow').isToday() -> false
     *   Date.create('thursday').isTomorrow() -> ?
     *   Date.create('yesterday').isWednesday() -> ?
     *   Date.create('today').isWeekend() -> ?
     *
     ***
     * @method isFuture()
     * @returns Boolean
     * @short Returns true if the date is in the future.
     * @example
     *
     *   Date.create('next week').isFuture() -> true
     *   Date.create('last week').isFuture() -> false
     *
     ***
     * @method isPast()
     * @returns Boolean
     * @short Returns true if the date is in the past.
     * @example
     *
     *   Date.create('last week').isPast() -> true
     *   Date.create('next week').isPast() -> false
     *
     ***/
    function buildRelativeAliases() {
      var special  = 'today,yesterday,tomorrow,weekday,weekend,future,past'.split(',');
      var weekdays = English['weekdays'].slice(0,7);
      var months   = English['months'].slice(0,12);
      extendSimilar(date, true, true, special.concat(weekdays).concat(months), function(methods, name) {
        methods['is'+ simpleCapitalize(name)] = function(utc) {
         return this.is(name, 0, utc);
        };
      });
    }
  
    function buildUTCAliases() {
      // Don't want to use extend here as it will override
      // the actual "utc" method on the prototype.
      if(date['utc']) return;
      date['utc'] = {
  
          'create': function() {
            return createDate(arguments, 0, true);
          },
  
          'past': function() {
            return createDate(arguments, -1, true);
          },
  
          'future': function() {
            return createDate(arguments, 1, true);
          }
      };
    }
  
    function setDateProperties() {
      extend(date, false , true, {
        'RFC1123': '{Dow}, {dd} {Mon} {yyyy} {HH}:{mm}:{ss} {tz}',
        'RFC1036': '{Weekday}, {dd}-{Mon}-{yy} {HH}:{mm}:{ss} {tz}',
        'ISO8601_DATE': '{yyyy}-{MM}-{dd}',
        'ISO8601_DATETIME': '{yyyy}-{MM}-{dd}T{HH}:{mm}:{ss}.{fff}{isotz}'
      });
    }
  
  
    extend(date, false, true, {
  
       /***
       * @method Date.create(<d>, [locale] = currentLocale)
       * @returns Date
       * @short Alternate Date constructor which understands many different text formats, a timestamp, or another date.
       * @extra If no argument is given, date is assumed to be now. %Date.create% additionally can accept enumerated parameters as with the standard date constructor. [locale] can be passed to specify the locale that the date is in. When unspecified, the current locale (default is English) is assumed. UTC-based dates can be created through the %utc% object. For more see @date_format.
       * @set
       *   Date.utc.create
       *
       * @example
       *
       *   Date.create('July')          -> July of this year
       *   Date.create('1776')          -> 1776
       *   Date.create('today')         -> today
       *   Date.create('wednesday')     -> This wednesday
       *   Date.create('next friday')   -> Next friday
       *   Date.create('July 4, 1776')  -> July 4, 1776
       *   Date.create(-446806800000)   -> November 5, 1955
       *   Date.create(1776, 6, 4)      -> July 4, 1776
       *   Date.create('1776年07月04日', 'ja') -> July 4, 1776
       *   Date.utc.create('July 4, 1776', 'en')  -> July 4, 1776
       *
       ***/
      'create': function() {
        return createDate(arguments);
      },
  
       /***
       * @method Date.past(<d>, [locale] = currentLocale)
       * @returns Date
       * @short Alternate form of %Date.create% with any ambiguity assumed to be the past.
       * @extra For example %"Sunday"% can be either "the Sunday coming up" or "the Sunday last" depending on context. Note that dates explicitly in the future ("next Sunday") will remain in the future. This method simply provides a hint when ambiguity exists. UTC-based dates can be created through the %utc% object. For more, see @date_format.
       * @set
       *   Date.utc.past
       *
       * @example
       *
       *   Date.past('July')          -> July of this year or last depending on the current month
       *   Date.past('Wednesday')     -> This wednesday or last depending on the current weekday
       *
       ***/
      'past': function() {
        return createDate(arguments, -1);
      },
  
       /***
       * @method Date.future(<d>, [locale] = currentLocale)
       * @returns Date
       * @short Alternate form of %Date.create% with any ambiguity assumed to be the future.
       * @extra For example %"Sunday"% can be either "the Sunday coming up" or "the Sunday last" depending on context. Note that dates explicitly in the past ("last Sunday") will remain in the past. This method simply provides a hint when ambiguity exists. UTC-based dates can be created through the %utc% object. For more, see @date_format.
       * @set
       *   Date.utc.future
       *
       * @example
       *
       *   Date.future('July')          -> July of this year or next depending on the current month
       *   Date.future('Wednesday')     -> This wednesday or next depending on the current weekday
       *
       ***/
      'future': function() {
        return createDate(arguments, 1);
      },
  
       /***
       * @method Date.addLocale(<code>, <set>)
       * @returns Locale
       * @short Adds a locale <set> to the locales understood by Sugar.
       * @extra For more see @date_format.
       *
       ***/
      'addLocale': function(localeCode, set) {
        return setLocalization(localeCode, set);
      },
  
       /***
       * @method Date.setLocale(<code>)
       * @returns Locale
       * @short Sets the current locale to be used with dates.
       * @extra Sugar has support for 13 locales that are available through the "Date Locales" package. In addition you can define a new locale with %Date.addLocale%. For more see @date_format.
       *
       ***/
      'setLocale': function(localeCode, set) {
        var loc = getLocalization(localeCode, false);
        CurrentLocalization = loc;
        // The code is allowed to be more specific than the codes which are required:
        // i.e. zh-CN or en-US. Currently this only affects US date variants such as 8/10/2000.
        if(localeCode && localeCode != loc['code']) {
          loc['code'] = localeCode;
        }
        return loc;
      },
  
       /***
       * @method Date.getLocale([code] = current)
       * @returns Locale
       * @short Gets the locale for the given code, or the current locale.
       * @extra The resulting locale object can be manipulated to provide more control over date localizations. For more about locales, see @date_format.
       *
       ***/
      'getLocale': function(localeCode) {
        return !localeCode ? CurrentLocalization : getLocalization(localeCode, false);
      },
  
       /**
       * @method Date.addFormat(<format>, <match>, [code] = null)
       * @returns Nothing
       * @short Manually adds a new date input format.
       * @extra This method allows fine grained control for alternate formats. <format> is a string that can have regex tokens inside. <match> is an array of the tokens that each regex capturing group will map to, for example %year%, %date%, etc. For more, see @date_format.
       *
       **/
      'addFormat': function(format, match, localeCode) {
        addDateInputFormat(getLocalization(localeCode), format, match);
      }
  
    });
  
    extend(date, true, true, {
  
       /***
       * @method set(<set>, [reset] = false)
       * @returns Date
       * @short Sets the date object.
       * @extra This method can accept multiple formats including a single number as a timestamp, an object, or enumerated parameters (as with the Date constructor). If [reset] is %true%, any units more specific than those passed will be reset.
       *
       * @example
       *
       *   new Date().set({ year: 2011, month: 11, day: 31 }) -> December 31, 2011
       *   new Date().set(2011, 11, 31)                       -> December 31, 2011
       *   new Date().set(86400000)                           -> 1 day after Jan 1, 1970
       *   new Date().set({ year: 2004, month: 6 }, true)     -> June 1, 2004, 00:00:00.000
       *
       ***/
      'set': function() {
        var args = collectDateArguments(arguments);
        return updateDate(this, args[0], args[1])
      },
  
       /***
       * @method setWeekday()
       * @returns Nothing
       * @short Sets the weekday of the date.
       * @extra In order to maintain a parallel with %getWeekday% (which itself is an alias for Javascript native %getDay%), Sunday is considered day %0%. This contrasts with ISO-8601 standard (used in %getISOWeek% and %setISOWeek%) which places Sunday at the end of the week (day 7). This effectively means that passing %0% to this method while in the middle of a week will rewind the date, where passing %7% will advance it.
       *
       * @example
       *
       *   d = new Date(); d.setWeekday(1); d; -> Monday of this week
       *   d = new Date(); d.setWeekday(6); d; -> Saturday of this week
       *
       ***/
      'setWeekday': function(dow) {
        if(isUndefined(dow)) return;
        return callDateSet(this, 'Date', callDateGet(this, 'Date') + dow - callDateGet(this, 'Day'));
      },
  
       /***
       * @method setISOWeek()
       * @returns Nothing
       * @short Sets the week (of the year) as defined by the ISO-8601 standard.
       * @extra Note that this standard places Sunday at the end of the week (day 7).
       *
       * @example
       *
       *   d = new Date(); d.setISOWeek(15); d; -> 15th week of the year
       *
       ***/
      'setISOWeek': function(week) {
        var weekday = callDateGet(this, 'Day') || 7;
        if(isUndefined(week)) return;
        this.set({ 'month': 0, 'date': 4 });
        this.set({ 'weekday': 1 });
        if(week > 1) {
          this.addWeeks(week - 1);
        }
        if(weekday !== 1) {
          this.advance({ 'days': weekday - 1 });
        }
        return this.getTime();
      },
  
       /***
       * @method getISOWeek()
       * @returns Number
       * @short Gets the date's week (of the year) as defined by the ISO-8601 standard.
       * @extra Note that this standard places Sunday at the end of the week (day 7). If %utc% is set on the date, the week will be according to UTC time.
       *
       * @example
       *
       *   new Date().getISOWeek()    -> today's week of the year
       *
       ***/
      'getISOWeek': function() {
        return getWeekNumber(this);
      },
  
       /***
       * @method beginningOfISOWeek()
       * @returns Date
       * @short Set the date to the beginning of week as defined by this ISO-8601 standard.
       * @extra Note that this standard places Monday at the start of the week.
       * @example
       *
       *   Date.create().beginningOfISOWeek() -> Monday
       *
       ***/
      'beginningOfISOWeek': function() {
        var day = this.getDay();
        if(day === 0) {
          day = -6;
        } else if(day !== 1) {
          day = 1;
        }
        this.setWeekday(day);
        return this.reset();
      },
  
       /***
       * @method endOfISOWeek()
       * @returns Date
       * @short Set the date to the end of week as defined by this ISO-8601 standard.
       * @extra Note that this standard places Sunday at the end of the week.
       * @example
       *
       *   Date.create().endOfISOWeek() -> Sunday
       *
       ***/
      'endOfISOWeek': function() {
        if(this.getDay() !== 0) {
          this.setWeekday(7);
        }
        return this.endOfDay()
      },
  
       /***
       * @method getUTCOffset([iso])
       * @returns String
       * @short Returns a string representation of the offset from UTC time. If [iso] is true the offset will be in ISO8601 format.
       * @example
       *
       *   new Date().getUTCOffset()     -> "+0900"
       *   new Date().getUTCOffset(true) -> "+09:00"
       *
       ***/
      'getUTCOffset': function(iso) {
        var offset = this._utc ? 0 : this.getTimezoneOffset();
        var colon  = iso === true ? ':' : '';
        if(!offset && iso) return 'Z';
        return padNumber(floor(-offset / 60), 2, true) + colon + padNumber(abs(offset % 60), 2);
      },
  
       /***
       * @method utc([on] = true)
       * @returns Date
       * @short Sets the internal utc flag for the date. When on, UTC-based methods will be called internally.
       * @extra For more see @date_format.
       * @example
       *
       *   new Date().utc(true)
       *   new Date().utc(false)
       *
       ***/
      'utc': function(set) {
        defineProperty(this, '_utc', set === true || arguments.length === 0);
        return this;
      },
  
       /***
       * @method isUTC()
       * @returns Boolean
       * @short Returns true if the date has no timezone offset.
       * @extra This will also return true for utc-based dates (dates that have the %utc% method set true). Note that even if the utc flag is set, %getTimezoneOffset% will always report the same thing as Javascript always reports that based on the environment's locale.
       * @example
       *
       *   new Date().isUTC()           -> true or false?
       *   new Date().utc(true).isUTC() -> true
       *
       ***/
      'isUTC': function() {
        return !!this._utc || this.getTimezoneOffset() === 0;
      },
  
       /***
       * @method advance(<set>, [reset] = false)
       * @returns Date
       * @short Sets the date forward.
       * @extra This method can accept multiple formats including an object, a string in the format %3 days%, a single number as milliseconds, or enumerated parameters (as with the Date constructor). If [reset] is %true%, any units more specific than those passed will be reset. For more see @date_format.
       * @example
       *
       *   new Date().advance({ year: 2 }) -> 2 years in the future
       *   new Date().advance('2 days')    -> 2 days in the future
       *   new Date().advance(0, 2, 3)     -> 2 months 3 days in the future
       *   new Date().advance(86400000)    -> 1 day in the future
       *
       ***/
      'advance': function() {
        var args = collectDateArguments(arguments, true);
        return updateDate(this, args[0], args[1], 1);
      },
  
       /***
       * @method rewind(<set>, [reset] = false)
       * @returns Date
       * @short Sets the date back.
       * @extra This method can accept multiple formats including a single number as a timestamp, an object, or enumerated parameters (as with the Date constructor). If [reset] is %true%, any units more specific than those passed will be reset. For more see @date_format.
       * @example
       *
       *   new Date().rewind({ year: 2 }) -> 2 years in the past
       *   new Date().rewind(0, 2, 3)     -> 2 months 3 days in the past
       *   new Date().rewind(86400000)    -> 1 day in the past
       *
       ***/
      'rewind': function() {
        var args = collectDateArguments(arguments, true);
        return updateDate(this, args[0], args[1], -1);
      },
  
       /***
       * @method isValid()
       * @returns Boolean
       * @short Returns true if the date is valid.
       * @example
       *
       *   new Date().isValid()         -> true
       *   new Date('flexor').isValid() -> false
       *
       ***/
      'isValid': function() {
        return !isNaN(this.getTime());
      },
  
       /***
       * @method isAfter(<d>, [margin] = 0)
       * @returns Boolean
       * @short Returns true if the date is after the <d>.
       * @extra [margin] is to allow extra margin of error (in ms). <d> will accept a date object, timestamp, or text format. If not specified, <d> is assumed to be now. See @date_format for more.
       * @example
       *
       *   new Date().isAfter('tomorrow')  -> false
       *   new Date().isAfter('yesterday') -> true
       *
       ***/
      'isAfter': function(d, margin, utc) {
        return this.getTime() > date.create(d).getTime() - (margin || 0);
      },
  
       /***
       * @method isBefore(<d>, [margin] = 0)
       * @returns Boolean
       * @short Returns true if the date is before <d>.
       * @extra [margin] is to allow extra margin of error (in ms). <d> will accept a date object, timestamp, or text format. If not specified, <d> is assumed to be now. See @date_format for more.
       * @example
       *
       *   new Date().isBefore('tomorrow')  -> true
       *   new Date().isBefore('yesterday') -> false
       *
       ***/
      'isBefore': function(d, margin) {
        return this.getTime() < date.create(d).getTime() + (margin || 0);
      },
  
       /***
       * @method isBetween(<d1>, <d2>, [margin] = 0)
       * @returns Boolean
       * @short Returns true if the date falls between <d1> and <d2>.
       * @extra [margin] is to allow extra margin of error (in ms). <d1> and <d2> will accept a date object, timestamp, or text format. If not specified, they are assumed to be now. See @date_format for more.
       * @example
       *
       *   new Date().isBetween('yesterday', 'tomorrow')    -> true
       *   new Date().isBetween('last year', '2 years ago') -> false
       *
       ***/
      'isBetween': function(d1, d2, margin) {
        var t  = this.getTime();
        var t1 = date.create(d1).getTime();
        var t2 = date.create(d2).getTime();
        var lo = min(t1, t2);
        var hi = max(t1, t2);
        margin = margin || 0;
        return (lo - margin < t) && (hi + margin > t);
      },
  
       /***
       * @method isLeapYear()
       * @returns Boolean
       * @short Returns true if the date is a leap year.
       * @example
       *
       *   Date.create('2000').isLeapYear() -> true
       *
       ***/
      'isLeapYear': function() {
        var year = callDateGet(this, 'FullYear');
        return (year % 4 === 0 && year % 100 !== 0) || (year % 400 === 0);
      },
  
       /***
       * @method daysInMonth()
       * @returns Number
       * @short Returns the number of days in the date's month.
       * @example
       *
       *   Date.create('May').daysInMonth()            -> 31
       *   Date.create('February, 2000').daysInMonth() -> 29
       *
       ***/
      'daysInMonth': function() {
        return 32 - callDateGet(new date(callDateGet(this, 'FullYear'), callDateGet(this, 'Month'), 32), 'Date');
      },
  
       /***
       * @method format(<format>, [locale] = currentLocale)
       * @returns String
       * @short Formats and outputs the date.
       * @extra <format> can be a number of pre-determined formats or a string of tokens. Locale-specific formats are %short%, %long%, and %full% which have their own aliases and can be called with %date.short()%, etc. If <format> is not specified the %long% format is assumed. [locale] specifies a locale code to use (if not specified the current locale is used). See @date_format for more details.
       *
       * @set
       *   short
       *   long
       *   full
       *
       * @example
       *
       *   Date.create().format()                                   -> ex. July 4, 2003
       *   Date.create().format('{Weekday} {d} {Month}, {yyyy}')    -> ex. Monday July 4, 2003
       *   Date.create().format('{hh}:{mm}')                        -> ex. 15:57
       *   Date.create().format('{12hr}:{mm}{tt}')                  -> ex. 3:57pm
       *   Date.create().format(Date.ISO8601_DATETIME)              -> ex. 2011-07-05 12:24:55.528Z
       *   Date.create('last week').format('short', 'ja')                -> ex. 先週
       *   Date.create('yesterday').format(function(value,unit,ms,loc) {
       *     // value = 1, unit = 3, ms = -86400000, loc = [current locale object]
       *   });                                                      -> ex. 1 day ago
       *
       ***/
      'format': function(f, localeCode) {
        return formatDate(this, f, false, localeCode);
      },
  
       /***
       * @method relative([fn], [locale] = currentLocale)
       * @returns String
       * @short Returns a relative date string offset to the current time.
       * @extra [fn] can be passed to provide for more granular control over the resulting string. [fn] is passed 4 arguments: the adjusted value, unit, offset in milliseconds, and a localization object. As an alternate syntax, [locale] can also be passed as the first (and only) parameter. For more, see @date_format.
       * @example
       *
       *   Date.create('90 seconds ago').relative() -> 1 minute ago
       *   Date.create('January').relative()        -> ex. 5 months ago
       *   Date.create('January').relative('ja')    -> 3ヶ月前
       *   Date.create('120 minutes ago').relative(function(val,unit,ms,loc) {
       *     // value = 2, unit = 3, ms = -7200, loc = [current locale object]
       *   });                                      -> ex. 5 months ago
       *
       ***/
      'relative': function(fn, localeCode) {
        if(isString(fn)) {
          localeCode = fn;
          fn = null;
        }
        return formatDate(this, fn, true, localeCode);
      },
  
       /***
       * @method is(<d>, [margin] = 0)
       * @returns Boolean
       * @short Returns true if the date is <d>.
       * @extra <d> will accept a date object, timestamp, or text format. %is% additionally understands more generalized expressions like month/weekday names, 'today', etc, and compares to the precision implied in <d>. [margin] allows an extra margin of error in milliseconds.  For more, see @date_format.
       * @example
       *
       *   Date.create().is('July')               -> true or false?
       *   Date.create().is('1776')               -> false
       *   Date.create().is('today')              -> true
       *   Date.create().is('weekday')            -> true or false?
       *   Date.create().is('July 4, 1776')       -> false
       *   Date.create().is(-6106093200000)       -> false
       *   Date.create().is(new Date(1776, 6, 4)) -> false
       *
       ***/
      'is': function(d, margin, utc) {
        var tmp, comp;
        if(!this.isValid()) return;
        if(isString(d)) {
          d = d.trim().toLowerCase();
          comp = this.clone().utc(utc);
          switch(true) {
            case d === 'future':  return this.getTime() > getNewDate().getTime();
            case d === 'past':    return this.getTime() < getNewDate().getTime();
            case d === 'weekday': return callDateGet(comp, 'Day') > 0 && callDateGet(comp, 'Day') < 6;
            case d === 'weekend': return callDateGet(comp, 'Day') === 0 || callDateGet(comp, 'Day') === 6;
            case (tmp = English['weekdays'].indexOf(d) % 7) > -1: return callDateGet(comp, 'Day') === tmp;
            case (tmp = English['months'].indexOf(d) % 12) > -1:  return callDateGet(comp, 'Month') === tmp;
          }
        }
        return compareDate(this, d, null, margin, utc);
      },
  
       /***
       * @method reset([unit] = 'hours')
       * @returns Date
       * @short Resets the unit passed and all smaller units. Default is "hours", effectively resetting the time.
       * @example
       *
       *   Date.create().reset('day')   -> Beginning of today
       *   Date.create().reset('month') -> 1st of the month
       *
       ***/
      'reset': function(unit) {
        var params = {}, recognized;
        unit = unit || 'hours';
        if(unit === 'date') unit = 'days';
        recognized = DateUnits.some(function(u) {
          return unit === u.name || unit === u.name + 's';
        });
        params[unit] = unit.match(/^days?/) ? 1 : 0;
        return recognized ? this.set(params, true) : this;
      },
  
       /***
       * @method clone()
       * @returns Date
       * @short Clones the date.
       * @example
       *
       *   Date.create().clone() -> Copy of now
       *
       ***/
      'clone': function() {
        var d = new date(this.getTime());
        d.utc(!!this._utc);
        return d;
      }
  
    });
  
  
    // Instance aliases
    extend(date, true, true, {
  
       /***
       * @method iso()
       * @alias toISOString
       *
       ***/
      'iso': function() {
        return this.toISOString();
      },
  
       /***
       * @method getWeekday()
       * @returns Number
       * @short Alias for %getDay%.
       * @set
       *   getUTCWeekday
       *
       * @example
       *
       +   Date.create().getWeekday();    -> (ex.) 3
       +   Date.create().getUTCWeekday();    -> (ex.) 3
       *
       ***/
      'getWeekday':    date.prototype.getDay,
      'getUTCWeekday':    date.prototype.getUTCDay
  
    });
  
  
  
    /***
     * Number module
     *
     ***/
  
    /***
     * @method [unit]()
     * @returns Number
     * @short Takes the number as a corresponding unit of time and converts to milliseconds.
     * @extra Method names can be singular or plural.  Note that as "a month" is ambiguous as a unit of time, %months% will be equivalent to 30.4375 days, the average number in a month. Be careful using %months% if you need exact precision.
     *
     * @set
     *   millisecond
     *   milliseconds
     *   second
     *   seconds
     *   minute
     *   minutes
     *   hour
     *   hours
     *   day
     *   days
     *   week
     *   weeks
     *   month
     *   months
     *   year
     *   years
     *
     * @example
     *
     *   (5).milliseconds() -> 5
     *   (10).hours()       -> 36000000
     *   (1).day()          -> 86400000
     *
     ***
     * @method [unit]Before([d], [locale] = currentLocale)
     * @returns Date
     * @short Returns a date that is <n> units before [d], where <n> is the number.
     * @extra [d] will accept a date object, timestamp, or text format. Note that "months" is ambiguous as a unit of time. If the target date falls on a day that does not exist (ie. August 31 -> February 31), the date will be shifted to the last day of the month. Be careful using %monthsBefore% if you need exact precision. See @date_format for more.
     *
     * @set
     *   millisecondBefore
     *   millisecondsBefore
     *   secondBefore
     *   secondsBefore
     *   minuteBefore
     *   minutesBefore
     *   hourBefore
     *   hoursBefore
     *   dayBefore
     *   daysBefore
     *   weekBefore
     *   weeksBefore
     *   monthBefore
     *   monthsBefore
     *   yearBefore
     *   yearsBefore
     *
     * @example
     *
     *   (5).daysBefore('tuesday')          -> 5 days before tuesday of this week
     *   (1).yearBefore('January 23, 1997') -> January 23, 1996
     *
     ***
     * @method [unit]Ago()
     * @returns Date
     * @short Returns a date that is <n> units ago.
     * @extra Note that "months" is ambiguous as a unit of time. If the target date falls on a day that does not exist (ie. August 31 -> February 31), the date will be shifted to the last day of the month. Be careful using %monthsAgo% if you need exact precision.
     *
     * @set
     *   millisecondAgo
     *   millisecondsAgo
     *   secondAgo
     *   secondsAgo
     *   minuteAgo
     *   minutesAgo
     *   hourAgo
     *   hoursAgo
     *   dayAgo
     *   daysAgo
     *   weekAgo
     *   weeksAgo
     *   monthAgo
     *   monthsAgo
     *   yearAgo
     *   yearsAgo
     *
     * @example
     *
     *   (5).weeksAgo() -> 5 weeks ago
     *   (1).yearAgo()  -> January 23, 1996
     *
     ***
     * @method [unit]After([d], [locale] = currentLocale)
     * @returns Date
     * @short Returns a date <n> units after [d], where <n> is the number.
     * @extra [d] will accept a date object, timestamp, or text format. Note that "months" is ambiguous as a unit of time. If the target date falls on a day that does not exist (ie. August 31 -> February 31), the date will be shifted to the last day of the month. Be careful using %monthsAfter% if you need exact precision. See @date_format for more.
     *
     * @set
     *   millisecondAfter
     *   millisecondsAfter
     *   secondAfter
     *   secondsAfter
     *   minuteAfter
     *   minutesAfter
     *   hourAfter
     *   hoursAfter
     *   dayAfter
     *   daysAfter
     *   weekAfter
     *   weeksAfter
     *   monthAfter
     *   monthsAfter
     *   yearAfter
     *   yearsAfter
     *
     * @example
     *
     *   (5).daysAfter('tuesday')          -> 5 days after tuesday of this week
     *   (1).yearAfter('January 23, 1997') -> January 23, 1998
     *
     ***
     * @method [unit]FromNow()
     * @returns Date
     * @short Returns a date <n> units from now.
     * @extra Note that "months" is ambiguous as a unit of time. If the target date falls on a day that does not exist (ie. August 31 -> February 31), the date will be shifted to the last day of the month. Be careful using %monthsFromNow% if you need exact precision.
     *
     * @set
     *   millisecondFromNow
     *   millisecondsFromNow
     *   secondFromNow
     *   secondsFromNow
     *   minuteFromNow
     *   minutesFromNow
     *   hourFromNow
     *   hoursFromNow
     *   dayFromNow
     *   daysFromNow
     *   weekFromNow
     *   weeksFromNow
     *   monthFromNow
     *   monthsFromNow
     *   yearFromNow
     *   yearsFromNow
     *
     * @example
     *
     *   (5).weeksFromNow() -> 5 weeks ago
     *   (1).yearFromNow()  -> January 23, 1998
     *
     ***/
    function buildNumberToDateAlias(u, multiplier) {
      var name = u.name, methods = {};
      function base() { return round(this * multiplier); }
      function after() { return createDate(arguments)[u.addMethod](this);  }
      function before() { return createDate(arguments)[u.addMethod](-this); }
      methods[name] = base;
      methods[name + 's'] = base;
      methods[name + 'Before'] = before;
      methods[name + 'sBefore'] = before;
      methods[name + 'Ago'] = before;
      methods[name + 'sAgo'] = before;
      methods[name + 'After'] = after;
      methods[name + 'sAfter'] = after;
      methods[name + 'FromNow'] = after;
      methods[name + 'sFromNow'] = after;
      number.extend(methods);
    }
  
    extend(number, true, true, {
  
       /***
       * @method duration([locale] = currentLocale)
       * @returns String
       * @short Takes the number as milliseconds and returns a unit-adjusted localized string.
       * @extra This method is the same as %Date#relative% without the localized equivalent of "from now" or "ago". [locale] can be passed as the first (and only) parameter. Note that this method is only available when the dates package is included.
       * @example
       *
       *   (500).duration() -> '500 milliseconds'
       *   (1200).duration() -> '1 second'
       *   (75).minutes().duration() -> '1 hour'
       *   (75).minutes().duration('es') -> '1 hora'
       *
       ***/
      'duration': function(localeCode) {
        return getLocalization(localeCode).getDuration(this);
      }
  
    });
  
  
    English = CurrentLocalization = date.addLocale('en', {
      'plural':     true,
      'timeMarker': 'at',
      'ampm':       'am,pm',
      'months':     'January,February,March,April,May,June,July,August,September,October,November,December',
      'weekdays':   'Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday',
      'units':      'millisecond:|s,second:|s,minute:|s,hour:|s,day:|s,week:|s,month:|s,year:|s',
      'numbers':    'one,two,three,four,five,six,seven,eight,nine,ten',
      'articles':   'a,an,the',
      'tokens':     'the,st|nd|rd|th,of',
      'short':      '{Month} {d}, {yyyy}',
      'long':       '{Month} {d}, {yyyy} {h}:{mm}{tt}',
      'full':       '{Weekday} {Month} {d}, {yyyy} {h}:{mm}:{ss}{tt}',
      'past':       '{num} {unit} {sign}',
      'future':     '{num} {unit} {sign}',
      'duration':   '{num} {unit}',
      'modifiers': [
        { 'name': 'sign',  'src': 'ago|before', 'value': -1 },
        { 'name': 'sign',  'src': 'from now|after|from|in|later', 'value': 1 },
        { 'name': 'edge',  'src': 'last day', 'value': -2 },
        { 'name': 'edge',  'src': 'end', 'value': -1 },
        { 'name': 'edge',  'src': 'first day|beginning', 'value': 1 },
        { 'name': 'shift', 'src': 'last', 'value': -1 },
        { 'name': 'shift', 'src': 'the|this', 'value': 0 },
        { 'name': 'shift', 'src': 'next', 'value': 1 }
      ],
      'dateParse': [
        '{month} {year}',
        '{shift} {unit=5-7}',
        '{0?} {date}{1}',
        '{0?} {edge} of {shift?} {unit=4-7?}{month?}{year?}'
      ],
      'timeParse': [
        '{num} {unit} {sign}',
        '{sign} {num} {unit}',
        '{0} {num}{1} {day} of {month} {year?}',
        '{weekday?} {month} {date}{1?} {year?}',
        '{date} {month} {year}',
        '{date} {month}',
        '{shift} {weekday}',
        '{shift} week {weekday}',
        '{weekday} {2?} {shift} week',
        '{num} {unit=4-5} {sign} {day}',
        '{0?} {date}{1} of {month}',
        '{0?}{month?} {date?}{1?} of {shift} {unit=6-7}'
      ]
    });
  
    buildDateUnits();
    buildDateMethods();
    buildCoreInputFormats();
    buildFormatTokens();
    buildFormatShortcuts();
    buildAsianDigits();
    buildRelativeAliases();
    buildUTCAliases();
    setDateProperties();
  
  
    /***
     * @package Range
     * @dependency core
     * @description Ranges allow creating spans of numbers, strings, or dates. They can enumerate over specific points within that range, and be manipulated and compared.
     *
     ***/
  
    function Range(start, end) {
      this.start = cloneRangeMember(start);
      this.end   = cloneRangeMember(end);
    };
  
    function getRangeMemberNumericValue(m) {
      return isString(m) ? m.charCodeAt(0) : m;
    }
  
    function getRangeMemberPrimitiveValue(m) {
      if(m == null) return m;
      return isDate(m) ? m.getTime() : m.valueOf();
    }
  
    function cloneRangeMember(m) {
      if(isDate(m)) {
        return new date(m.getTime());
      } else {
        return getRangeMemberPrimitiveValue(m);
      }
    }
  
    function isValidRangeMember(m) {
      var val = getRangeMemberPrimitiveValue(m);
      return !!val || val === 0;
    }
  
    function getDuration(amt) {
      var match, val, unit;
      if(isNumber(amt)) {
        return amt;
      }
      match = amt.toLowerCase().match(/^(\d+)?\s?(\w+?)s?$/i);
      val = parseInt(match[1]) || 1;
      unit = match[2].slice(0,1).toUpperCase() + match[2].slice(1);
      if(unit.match(/hour|minute|second/i)) {
        unit += 's';
      } else if(unit === 'Year') {
        unit = 'FullYear';
      } else if(unit === 'Day') {
        unit = 'Date';
      }
      return [val, unit];
    }
  
    function incrementDate(current, amount) {
      var num, unit, val, d;
      if(isNumber(amount)) {
        return new date(current.getTime() + amount);
      }
      num  = amount[0];
      unit = amount[1];
      val  = callDateGet(current, unit);
      d    = new date(current.getTime());
      callDateSet(d, unit, val + num);
      return d;
    }
  
    function incrementString(current, amount) {
      return string.fromCharCode(current.charCodeAt(0) + amount);
    }
  
    function incrementNumber(current, amount) {
      return current + amount;
    }
  
    /***
     * @method toString()
     * @returns String
     * @short Returns a string representation of the range.
     * @example
     *
     *   Number.range(1, 5).toString()                               -> 1..5
     *   Date.range(new Date(2003, 0), new Date(2005, 0)).toString() -> January 1, 2003..January 1, 2005
     *
     ***/
  
    // Note: 'toString' doesn't appear in a for..in loop in IE even though
    // hasOwnProperty reports true, so extend() can't be used here.
    // Also tried simply setting the prototype = {} up front for all
    // methods but GCC very oddly started dropping properties in the
    // object randomly (maybe because of the global scope?) hence
    // the need for the split logic here.
    Range.prototype.toString = function() {
      return this.isValid() ? this.start + ".." + this.end : 'Invalid Range';
    };
  
    extend(Range, true, true, {
  
      /***
       * @method isValid()
       * @returns Boolean
       * @short Returns true if the range is valid, false otherwise.
       * @example
       *
       *   Date.range(new Date(2003, 0), new Date(2005, 0)).isValid() -> true
       *   Number.range(NaN, NaN).isValid()                           -> false
       *
       ***/
      'isValid': function() {
        return isValidRangeMember(this.start) && isValidRangeMember(this.end) && typeof this.start === typeof this.end;
      },
  
      /***
       * @method span()
       * @returns Number
       * @short Returns the span of the range. If the range is a date range, the value is in milliseconds.
       * @extra The span includes both the start and the end.
       * @example
       *
       *   Number.range(5, 10).span()                              -> 6
       *   Date.range(new Date(2003, 0), new Date(2005, 0)).span() -> 94694400000
       *
       ***/
      'span': function() {
        return this.isValid() ? abs(
          getRangeMemberNumericValue(this.end) - getRangeMemberNumericValue(this.start)
        ) + 1 : NaN;
      },
  
      /***
       * @method contains(<obj>)
       * @returns Boolean
       * @short Returns true if <obj> is contained inside the range. <obj> may be a value or another range.
       * @example
       *
       *   Number.range(5, 10).contains(7)                                              -> true
       *   Date.range(new Date(2003, 0), new Date(2005, 0)).contains(new Date(2004, 0)) -> true
       *
       ***/
      'contains': function(obj) {
        var self = this, arr;
        if(obj == null) return false;
        if(obj.start && obj.end) {
          return obj.start >= this.start && obj.start <= this.end &&
                 obj.end   >= this.start && obj.end   <= this.end;
        } else {
          return obj >= this.start && obj <= this.end;
        }
      },
  
      /***
       * @method every(<amount>, [fn])
       * @returns Array
       * @short Iterates through the range for every <amount>, calling [fn] if it is passed. Returns an array of each increment visited.
       * @extra In the case of date ranges, <amount> can also be a string, in which case it will increment a number of  units. Note that %(2).months()% first resolves to a number, which will be interpreted as milliseconds and is an approximation, so stepping through the actual months by passing %"2 months"% is usually preferable.
       * @example
       *
       *   Number.range(2, 8).every(2)                                       -> [2,4,6,8]
       *   Date.range(new Date(2003, 1), new Date(2003,3)).every("2 months") -> [...]
       *
       ***/
      'every': function(amount, fn) {
        var increment,
            start   = this.start,
            end     = this.end,
            inverse = end < start,
            current = start,
            index   = 0,
            result  = [];
  
        if(isFunction(amount)) {
          fn = amount;
          amount = null;
        }
        amount = amount || 1;
        if(isNumber(start)) {
          increment = incrementNumber;
        } else if(isString(start)) {
          increment = incrementString;
        } else if(isDate(start)) {
          amount    = getDuration(amount);
          increment = incrementDate;
        }
        // Avoiding infinite loops
        if(inverse && amount > 0) {
          amount *= -1;
        }
        while(inverse ? current >= end : current <= end) {
          result.push(current);
          if(fn) {
            fn(current, index);
          }
          current = increment(current, amount);
          index++;
        }
        return result;
      },
  
      /***
       * @method union(<range>)
       * @returns Range
       * @short Returns a new range with the earliest starting point as its start, and the latest ending point as its end. If the two ranges do not intersect this will effectively remove the "gap" between them.
       * @example
       *
       *   Number.range(1, 3).union(Number.range(2, 5)) -> 1..5
       *   Date.range(new Date(2003, 1), new Date(2005, 1)).union(Date.range(new Date(2004, 1), new Date(2006, 1))) -> Jan 1, 2003..Jan 1, 2006
       *
       ***/
      'union': function(range) {
        return new Range(
          this.start < range.start ? this.start : range.start,
          this.end   > range.end   ? this.end   : range.end
        );
      },
  
      /***
       * @method intersect(<range>)
       * @returns Range
       * @short Returns a new range with the latest starting point as its start, and the earliest ending point as its end. If the two ranges do not intersect this will effectively produce an invalid range.
       * @example
       *
       *   Number.range(1, 5).intersect(Number.range(4, 8)) -> 4..5
       *   Date.range(new Date(2003, 1), new Date(2005, 1)).intersect(Date.range(new Date(2004, 1), new Date(2006, 1))) -> Jan 1, 2004..Jan 1, 2005
       *
       ***/
      'intersect': function(range) {
        if(range.start > this.end || range.end < this.start) {
          return new Range(NaN, NaN);
        }
        return new Range(
          this.start > range.start ? this.start : range.start,
          this.end   < range.end   ? this.end   : range.end
        );
      },
  
      /***
       * @method clone()
       * @returns Range
       * @short Clones the range.
       * @extra Members of the range will also be cloned.
       * @example
       *
       *   Number.range(1, 5).clone() -> Returns a copy of the range.
       *
       ***/
      'clone': function(range) {
        return new Range(this.start, this.end);
      },
  
      /***
       * @method clamp(<obj>)
       * @returns Mixed
       * @short Clamps <obj> to be within the range if it falls outside.
       * @example
       *
       *   Number.range(1, 5).clamp(8) -> 5
       *   Date.range(new Date(2010, 0), new Date(2012, 0)).clamp(new Date(2013, 0)) -> 2012-01
       *
       ***/
      'clamp': function(obj) {
        var clamped,
            start = this.start,
            end = this.end,
            min = end < start ? end : start,
            max = start > end ? start : end;
        if(obj < min) {
          clamped = min;
        } else if(obj > max) {
          clamped = max;
        } else {
          clamped = obj;
        }
        return cloneRangeMember(clamped);
      }
  
    });
  
  
    /***
     * Number module
     ***
     * @method Number.range([start], [end])
     * @returns Range
     * @short Creates a new range between [start] and [end]. See @ranges for more.
     * @example
     *
     *   Number.range(5, 10)
     *
     ***
     * String module
     ***
     * @method String.range([start], [end])
     * @returns Range
     * @short Creates a new range between [start] and [end]. See @ranges for more.
     * @example
     *
     *   String.range('a', 'z')
     *
     ***
     * Date module
     ***
     * @method Date.range([start], [end])
     * @returns Range
     * @short Creates a new range between [start] and [end].
     * @extra If either [start] or [end] are null, they will default to the current date. See @ranges for more.
     * @example
     *
     *   Date.range('today', 'tomorrow')
     *
     ***/
    [number, string, date].forEach(function(klass) {
       extend(klass, false, true, {
  
        'range': function(start, end) {
          if(klass.create) {
            start = klass.create(start);
            end   = klass.create(end);
          }
          return new Range(start, end);
        }
  
      });
  
    });
  
    /***
     * Number module
     *
     ***/
  
    extend(number, true, true, {
  
      /***
       * @method upto(<num>, [fn], [step] = 1)
       * @returns Array
       * @short Returns an array containing numbers from the number up to <num>.
       * @extra Optionally calls [fn] callback for each number in that array. [step] allows multiples greater than 1.
       * @example
       *
       *   (2).upto(6) -> [2, 3, 4, 5, 6]
       *   (2).upto(6, function(n) {
       *     // This function is called 5 times receiving n as the value.
       *   });
       *   (2).upto(8, null, 2) -> [2, 4, 6, 8]
       *
       ***/
      'upto': function(num, fn, step) {
        return number.range(this, num).every(step, fn);
      },
  
       /***
       * @method clamp([start] = Infinity, [end] = Infinity)
       * @returns Number
       * @short Constrains the number so that it is between [start] and [end].
       * @extra This will build a range object that has an equivalent %clamp% method.
       * @example
       *
       *   (3).clamp(50, 100)  -> 50
       *   (85).clamp(50, 100) -> 85
       *
       ***/
      'clamp': function(start, end) {
        return new Range(start, end).clamp(this);
      },
  
       /***
       * @method cap([max] = Infinity)
       * @returns Number
       * @short Constrains the number so that it is no greater than [max].
       * @extra This will build a range object that has an equivalent %cap% method.
       * @example
       *
       *   (100).cap(80) -> 80
       *
       ***/
      'cap': function(max) {
        return this.clamp(Undefined, max);
      }
  
    });
  
    extend(number, true, true, {
  
      /***
       * @method downto(<num>, [fn], [step] = 1)
       * @returns Array
       * @short Returns an array containing numbers from the number down to <num>.
       * @extra Optionally calls [fn] callback for each number in that array. [step] allows multiples greater than 1.
       * @example
       *
       *   (8).downto(3) -> [8, 7, 6, 5, 4, 3]
       *   (8).downto(3, function(n) {
       *     // This function is called 6 times receiving n as the value.
       *   });
       *   (8).downto(2, null, 2) -> [8, 6, 4, 2]
       *
       ***/
      'downto': number.prototype.upto
  
    });
  
  
    /***
     * Array module
     *
     ***/
  
    extend(array, false, function(a) { return a instanceof Range; }, {
  
      'create': function(range) {
        return range.every();
      }
  
    });
  
  
    /***
     * @package Function
     * @dependency core
     * @description Lazy, throttled, and memoized functions, delayed functions and handling of timers, argument currying.
     *
     ***/
  
    function setDelay(fn, ms, after, scope, args) {
      // Delay of infinity is never called of course...
      if(ms === Infinity) return;
      if(!fn.timers) fn.timers = [];
      if(!isNumber(ms)) ms = 1;
      // This is a workaround for <= IE8, which apparently has the
      // ability to call timeouts in the queue on the same tick (ms?)
      // even if functionally they have already been cleared.
      fn._canceled = false;
      fn.timers.push(setTimeout(function(){
        if(!fn._canceled) {
          after.apply(scope, args || []);
        }
      }, ms));
    }
  
    extend(Function, true, true, {
  
       /***
       * @method lazy([ms] = 1, [immediate] = false, [limit] = Infinity)
       * @returns Function
       * @short Creates a lazy function that, when called repeatedly, will queue execution and wait [ms] milliseconds to execute.
       * @extra If [immediate] is %true%, first execution will happen immediately, then lock. If [limit] is a fininte number, calls past [limit] will be ignored while execution is locked. Compare this to %throttle%, which will execute only once per [ms] milliseconds. Note that [ms] can also be a fraction. Calling %cancel% on a lazy function will clear the entire queue. For more see @functions.
       * @example
       *
       *   (function() {
       *     // Executes immediately.
       *   }).lazy()();
       *   (3).times(function() {
       *     // Executes 3 times, with each execution 20ms later than the last.
       *   }.lazy(20));
       *   (100).times(function() {
       *     // Executes 50 times, with each execution 20ms later than the last.
       *   }.lazy(20, false, 50));
       *
       ***/
      'lazy': function(ms, immediate, limit) {
        var fn = this, queue = [], locked = false, execute, rounded, perExecution, result;
        ms = ms || 1;
        limit = limit || Infinity;
        rounded = ceil(ms);
        perExecution = round(rounded / ms) || 1;
        execute = function() {
          var queueLength = queue.length, maxPerRound;
          if(queueLength == 0) return;
          // Allow fractions of a millisecond by calling
          // multiple times per actual timeout execution
          maxPerRound = max(queueLength - perExecution, 0);
          while(queueLength > maxPerRound) {
            // Getting uber-meta here...
            result = Function.prototype.apply.apply(fn, queue.shift());
            queueLength--;
          }
          setDelay(lazy, rounded, function() {
            locked = false;
            execute();
          });
        }
        function lazy() {
          // If the execution has locked and it's immediate, then
          // allow 1 less in the queue as 1 call has already taken place.
          if(queue.length < limit - (locked && immediate ? 1 : 0)) {
            queue.push([this, arguments]);
          }
          if(!locked) {
            locked = true;
            if(immediate) {
              execute();
            } else {
              setDelay(lazy, rounded, execute);
            }
          }
          // Return the memoized result
          return result;
        }
        return lazy;
      },
  
       /***
       * @method throttle([ms] = 1)
       * @returns Function
       * @short Creates a "throttled" version of the function that will only be executed once per <ms> milliseconds.
       * @extra This is functionally equivalent to calling %lazy% with a [limit] of %1% and [immediate] as %true%. %throttle% is appropriate when you want to make sure a function is only executed at most once for a given duration. For more see @functions.
       * @example
       *
       *   (3).times(function() {
       *     // called only once. will wait 50ms until it responds again
       *   }.throttle(50));
       *
       ***/
      'throttle': function(ms) {
        return this.lazy(ms, true, 1);
      },
  
       /***
       * @method debounce([ms] = 1)
       * @returns Function
       * @short Creates a "debounced" function that postpones its execution until after <ms> milliseconds have passed.
       * @extra This method is useful to execute a function after things have "settled down". A good example of this is when a user tabs quickly through form fields, execution of a heavy operation should happen after a few milliseconds when they have "settled" on a field. For more see @functions.
       * @example
       *
       *   var fn = (function(arg1) {
       *     // called once 50ms later
       *   }).debounce(50); fn() fn() fn();
       *
       ***/
      'debounce': function(ms) {
        var fn = this;
        function debounced() {
          debounced.cancel();
          setDelay(debounced, ms, fn, this, arguments);
        };
        return debounced;
      },
  
       /***
       * @method delay([ms] = 1, [arg1], ...)
       * @returns Function
       * @short Executes the function after <ms> milliseconds.
       * @extra Returns a reference to itself. %delay% is also a way to execute non-blocking operations that will wait until the CPU is free. Delayed functions can be canceled using the %cancel% method. Can also curry arguments passed in after <ms>.
       * @example
       *
       *   (function(arg1) {
       *     // called 1s later
       *   }).delay(1000, 'arg1');
       *
       ***/
      'delay': function(ms) {
        var fn = this;
        var args = multiArgs(arguments, null, 1);
        setDelay(fn, ms, fn, fn, args);
        return fn;
      },
  
       /***
       * @method every([ms] = 1, [arg1], ...)
       * @returns Function
       * @short Executes the function every <ms> milliseconds.
       * @extra Returns a reference to itself. Repeating functions with %every% can be canceled using the %cancel% method. Can also curry arguments passed in after <ms>.
       * @example
       *
       *   (function(arg1) {
       *     // called every 1s
       *   }).every(1000, 'arg1');
       *
       ***/
      'every': function(ms) {
        var fn = this, args = arguments;
        args = args.length > 1 ? multiArgs(args, null, 1) : [];
        function execute () {
          fn.apply(fn, args);
          setDelay(fn, ms, execute);
        }
        setDelay(fn, ms, execute);
        return fn;
      },
  
       /***
       * @method cancel()
       * @returns Function
       * @short Cancels a delayed function scheduled to be run.
       * @extra %delay%, %lazy%, %throttle%, and %debounce% can all set delays.
       * @example
       *
       *   (function() {
       *     alert('hay'); // Never called
       *   }).delay(500).cancel();
       *
       ***/
      'cancel': function() {
        var timers = this.timers, timer;
        if(isArray(timers)) {
          while(timer = timers.shift()) {
            clearTimeout(timer);
          }
        }
        this._canceled = true;
        return this;
      },
  
       /***
       * @method after([num] = 1)
       * @returns Function
       * @short Creates a function that will execute after [num] calls.
       * @extra %after% is useful for running a final callback after a series of asynchronous operations, when the order in which the operations will complete is unknown.
       * @example
       *
       *   var fn = (function() {
       *     // Will be executed once only
       *   }).after(3); fn(); fn(); fn();
       *
       ***/
      'after': function(num) {
        var fn = this, counter = 0, storedArguments = [];
        if(!isNumber(num)) {
          num = 1;
        } else if(num === 0) {
          fn.call();
          return fn;
        }
        return function() {
          var ret;
          storedArguments.push(multiArgs(arguments));
          counter++;
          if(counter == num) {
            ret = fn.call(this, storedArguments);
            counter = 0;
            storedArguments = [];
            return ret;
          }
        }
      },
  
       /***
       * @method once()
       * @returns Function
       * @short Creates a function that will execute only once and store the result.
       * @extra %once% is useful for creating functions that will cache the result of an expensive operation and use it on subsequent calls. Also it can be useful for creating initialization functions that only need to be run once.
       * @example
       *
       *   var fn = (function() {
       *     // Will be executed once only
       *   }).once(); fn(); fn(); fn();
       *
       ***/
      'once': function() {
        return this.throttle(Infinity, true);
      },
  
       /***
       * @method fill(<arg1>, <arg2>, ...)
       * @returns Function
       * @short Returns a new version of the function which when called will have some of its arguments pre-emptively filled in, also known as "currying".
       * @extra Arguments passed to a "filled" function are generally appended to the curried arguments. However, if %undefined% is passed as any of the arguments to %fill%, it will be replaced, when the "filled" function is executed. This allows currying of arguments even when they occur toward the end of an argument list (the example demonstrates this much more clearly).
       * @example
       *
       *   var delayOneSecond = setTimeout.fill(undefined, 1000);
       *   delayOneSecond(function() {
       *     // Will be executed 1s later
       *   });
       *
       ***/
      'fill': function() {
        var fn = this, curried = multiArgs(arguments);
        return function() {
          var args = multiArgs(arguments);
          curried.forEach(function(arg, index) {
            if(arg != null || index >= args.length) args.splice(index, 0, arg);
          });
          return fn.apply(this, args);
        }
      }
  
  
    });
  
  
    /***
     * @package Number
     * @dependency core
     * @description Number formatting, rounding (with precision), and ranges. Aliases to Math methods.
     *
     ***/
  
  
    function abbreviateNumber(num, roundTo, str, mid, limit, bytes) {
      var fixed        = num.toFixed(20),
          decimalPlace = fixed.search(/\./),
          numeralPlace = fixed.search(/[1-9]/),
          significant  = decimalPlace - numeralPlace,
          unit, i, divisor;
      if(significant > 0) {
        significant -= 1;
      }
      i = max(min(floor(significant / 3), limit === false ? str.length : limit), -mid);
      unit = str.charAt(i + mid - 1);
      if(significant < -9) {
        i = -3;
        roundTo = abs(significant) - 9;
        unit = str.slice(0,1);
      }
      divisor = bytes ? pow(2, 10 * i) : pow(10, i * 3);
      return withPrecision(num / divisor, roundTo || 0).format() + unit.trim();
    }
  
  
    extend(number, false, true, {
  
      /***
       * @method Number.random([n1], [n2])
       * @returns Number
       * @short Returns a random integer between [n1] and [n2].
       * @extra If only 1 number is passed, the other will be 0. If none are passed, the number will be either 0 or 1.
       * @example
       *
       *   Number.random(50, 100) -> ex. 85
       *   Number.random(50)      -> ex. 27
       *   Number.random()        -> ex. 0
       *
       ***/
      'random': function(n1, n2) {
        var minNum, maxNum;
        if(arguments.length == 1) n2 = n1, n1 = 0;
        minNum = min(n1 || 0, isUndefined(n2) ? 1 : n2);
        maxNum = max(n1 || 0, isUndefined(n2) ? 1 : n2) + 1;
        return floor((math.random() * (maxNum - minNum)) + minNum);
      }
  
    });
  
    extend(number, true, true, {
  
      /***
       * @method log(<base> = Math.E)
       * @returns Number
       * @short Returns the logarithm of the number with base <base>, or natural logarithm of the number if <base> is undefined.
       * @example
       *
       *   (64).log(2) -> 6
       *   (9).log(3)  -> 2
       *   (5).log()   -> 1.6094379124341003
       *
       ***/
  
      'log': function(base) {
         return math.log(this) / (base ? math.log(base) : 1);
       },
  
      /***
       * @method abbr([precision] = 0)
       * @returns String
       * @short Returns an abbreviated form of the number.
       * @extra [precision] will round to the given precision.
       * @example
       *
       *   (1000).abbr()    -> "1k"
       *   (1000000).abbr() -> "1m"
       *   (1280).abbr(1)   -> "1.3k"
       *
       ***/
      'abbr': function(precision) {
        return abbreviateNumber(this, precision, 'kmbt', 0, 4);
      },
  
      /***
       * @method metric([precision] = 0, [limit] = 1)
       * @returns String
       * @short Returns the number as a string in metric notation.
       * @extra [precision] will round to the given precision. Both very large numbers and very small numbers are supported. [limit] is the upper limit for the units. The default is %1%, which is "kilo". If [limit] is %false%, the upper limit will be "exa". The lower limit is "nano", and cannot be changed.
       * @example
       *
       *   (1000).metric()            -> "1k"
       *   (1000000).metric()         -> "1,000k"
       *   (1000000).metric(0, false) -> "1M"
       *   (1249).metric(2) + 'g'     -> "1.25kg"
       *   (0.025).metric() + 'm'     -> "25mm"
       *
       ***/
      'metric': function(precision, limit) {
        return abbreviateNumber(this, precision, 'nμm kMGTPE', 4, isUndefined(limit) ? 1 : limit);
      },
  
      /***
       * @method bytes([precision] = 0, [limit] = 4)
       * @returns String
       * @short Returns an abbreviated form of the number, considered to be "Bytes".
       * @extra [precision] will round to the given precision. [limit] is the upper limit for the units. The default is %4%, which is "terabytes" (TB). If [limit] is %false%, the upper limit will be "exa".
       * @example
       *
       *   (1000).bytes()                 -> "1kB"
       *   (1000).bytes(2)                -> "0.98kB"
       *   ((10).pow(20)).bytes()         -> "90,949,470TB"
       *   ((10).pow(20)).bytes(0, false) -> "87EB"
       *
       ***/
      'bytes': function(precision, limit) {
        return abbreviateNumber(this, precision, 'kMGTPE', 0, isUndefined(limit) ? 4 : limit, true) + 'B';
      },
  
      /***
       * @method isInteger()
       * @returns Boolean
       * @short Returns true if the number has no trailing decimal.
       * @example
       *
       *   (420).isInteger() -> true
       *   (4.5).isInteger() -> false
       *
       ***/
      'isInteger': function() {
        return this % 1 == 0;
      },
  
      /***
       * @method isOdd()
       * @returns Boolean
       * @short Returns true if the number is odd.
       * @example
       *
       *   (3).isOdd()  -> true
       *   (18).isOdd() -> false
       *
       ***/
      'isOdd': function() {
        return !isNaN(this) && !this.isMultipleOf(2);
      },
  
      /***
       * @method isEven()
       * @returns Boolean
       * @short Returns true if the number is even.
       * @example
       *
       *   (6).isEven()  -> true
       *   (17).isEven() -> false
       *
       ***/
      'isEven': function() {
        return this.isMultipleOf(2);
      },
  
      /***
       * @method isMultipleOf(<num>)
       * @returns Boolean
       * @short Returns true if the number is a multiple of <num>.
       * @example
       *
       *   (6).isMultipleOf(2)  -> true
       *   (17).isMultipleOf(2) -> false
       *   (32).isMultipleOf(4) -> true
       *   (34).isMultipleOf(4) -> false
       *
       ***/
      'isMultipleOf': function(num) {
        return this % num === 0;
      },
  
  
      /***
       * @method format([place] = 0, [thousands] = ',', [decimal] = '.')
       * @returns String
       * @short Formats the number to a readable string.
       * @extra If [place] is %undefined%, will automatically determine the place. [thousands] is the character used for the thousands separator. [decimal] is the character used for the decimal point.
       * @example
       *
       *   (56782).format()           -> '56,782'
       *   (56782).format(2)          -> '56,782.00'
       *   (4388.43).format(2, ' ')      -> '4 388.43'
       *   (4388.43).format(2, '.', ',') -> '4.388,43'
       *
       ***/
      'format': function(place, thousands, decimal) {
        var i, str, split, integer, fraction, result = '';
        if(isUndefined(thousands)) {
          thousands = ',';
        }
        if(isUndefined(decimal)) {
          decimal = '.';
        }
        str      = (isNumber(place) ? withPrecision(this, place || 0).toFixed(max(place, 0)) : this.toString()).replace(/^-/, '');
        split    = str.split('.');
        integer  = split[0];
        fraction = split[1];
        for(i = integer.length; i > 0; i -= 3) {
          if(i < integer.length) {
            result = thousands + result;
          }
          result = integer.slice(max(0, i - 3), i) + result;
        }
        if(fraction) {
          result += decimal + repeatString('0', (place || 0) - fraction.length) + fraction;
        }
        return (this < 0 ? '-' : '') + result;
      },
  
      /***
       * @method hex([pad] = 1)
       * @returns String
       * @short Converts the number to hexidecimal.
       * @extra [pad] will pad the resulting string to that many places.
       * @example
       *
       *   (255).hex()   -> 'ff';
       *   (255).hex(4)  -> '00ff';
       *   (23654).hex() -> '5c66';
       *
       ***/
      'hex': function(pad) {
        return this.pad(pad || 1, false, 16);
      },
  
      /***
       * @method times(<fn>)
       * @returns Number
       * @short Calls <fn> a number of times equivalent to the number.
       * @example
       *
       *   (8).times(function(i) {
       *     // This function is called 8 times.
       *   });
       *
       ***/
      'times': function(fn) {
        if(fn) {
          for(var i = 0; i < this; i++) {
            fn.call(this, i);
          }
        }
        return this.toNumber();
      },
  
      /***
       * @method chr()
       * @returns String
       * @short Returns a string at the code point of the number.
       * @example
       *
       *   (65).chr() -> "A"
       *   (75).chr() -> "K"
       *
       ***/
      'chr': function() {
        return string.fromCharCode(this);
      },
  
      /***
       * @method pad(<place> = 0, [sign] = false, [base] = 10)
       * @returns String
       * @short Pads a number with "0" to <place>.
       * @extra [sign] allows you to force the sign as well (+05, etc). [base] can change the base for numeral conversion.
       * @example
       *
       *   (5).pad(2)        -> '05'
       *   (-5).pad(4)       -> '-0005'
       *   (82).pad(3, true) -> '+082'
       *
       ***/
      'pad': function(place, sign, base) {
        return padNumber(this, place, sign, base);
      },
  
      /***
       * @method ordinalize()
       * @returns String
       * @short Returns an ordinalized (English) string, i.e. "1st", "2nd", etc.
       * @example
       *
       *   (1).ordinalize() -> '1st';
       *   (2).ordinalize() -> '2nd';
       *   (8).ordinalize() -> '8th';
       *
       ***/
      'ordinalize': function() {
        var suffix, num = abs(this), last = parseInt(num.toString().slice(-2));
        return this + getOrdinalizedSuffix(last);
      },
  
      /***
       * @method toNumber()
       * @returns Number
       * @short Returns a number. This is mostly for compatibility reasons.
       * @example
       *
       *   (420).toNumber() -> 420
       *
       ***/
      'toNumber': function() {
        return parseFloat(this, 10);
      }
  
    });
  
    /***
     * @method round(<precision> = 0)
     * @returns Number
     * @short Shortcut for %Math.round% that also allows a <precision>.
     *
     * @example
     *
     *   (3.241).round()  -> 3
     *   (-3.841).round() -> -4
     *   (3.241).round(2) -> 3.24
     *   (3748).round(-2) -> 3800
     *
     ***
     * @method ceil(<precision> = 0)
     * @returns Number
     * @short Shortcut for %Math.ceil% that also allows a <precision>.
     *
     * @example
     *
     *   (3.241).ceil()  -> 4
     *   (-3.241).ceil() -> -3
     *   (3.241).ceil(2) -> 3.25
     *   (3748).ceil(-2) -> 3800
     *
     ***
     * @method floor(<precision> = 0)
     * @returns Number
     * @short Shortcut for %Math.floor% that also allows a <precision>.
     *
     * @example
     *
     *   (3.241).floor()  -> 3
     *   (-3.841).floor() -> -4
     *   (3.241).floor(2) -> 3.24
     *   (3748).floor(-2) -> 3700
     *
     ***
     * @method [math]()
     * @returns Number
     * @short Math related functions are mapped as shortcuts to numbers and are identical. Note that %Number#log% provides some special defaults.
     *
     * @set
     *   abs
     *   sin
     *   asin
     *   cos
     *   acos
     *   tan
     *   atan
     *   sqrt
     *   exp
     *   pow
     *
     * @example
     *
     *   (3).pow(3) -> 27
     *   (-3).abs() -> 3
     *   (1024).sqrt() -> 32
     *
     ***/
  
    function buildNumber() {
      function createRoundingFunction(fn) {
        return function (precision) {
          return precision ? withPrecision(this, precision, fn) : fn(this);
        }
      }
      extend(number, true, true, {
        'ceil':   createRoundingFunction(ceil),
        'round':  createRoundingFunction(round),
        'floor':  createRoundingFunction(floor)
      });
      extendSimilar(number, true, true, 'abs,pow,sin,asin,cos,acos,tan,atan,exp,pow,sqrt', function(methods, name) {
        methods[name] = function(a, b) {
          return math[name](this, a, b);
        }
      });
    }
  
    buildNumber();
  
  
    /***
     * @package Object
     * @dependency core
     * @description Object manipulation, type checking (isNumber, isString, ...), extended objects with hash-like methods available as instance methods.
     *
     * Much thanks to kangax for his informative aricle about how problems with instanceof and constructor
     * http://perfectionkills.com/instanceof-considered-harmful-or-how-to-write-a-robust-isarray/
     *
     ***/
  
    var ObjectTypeMethods = 'isObject,isNaN'.split(',');
    var ObjectHashMethods = 'keys,values,select,reject,each,merge,clone,equal,watch,tap,has,toQueryString'.split(',');
  
    function setParamsObject(obj, param, value, castBoolean) {
      var reg = /^(.+?)(\[.*\])$/, paramIsArray, match, allKeys, key;
      if(match = param.match(reg)) {
        key = match[1];
        allKeys = match[2].replace(/^\[|\]$/g, '').split('][');
        allKeys.forEach(function(k) {
          paramIsArray = !k || k.match(/^\d+$/);
          if(!key && isArray(obj)) key = obj.length;
          if(!hasOwnProperty(obj, key)) {
            obj[key] = paramIsArray ? [] : {};
          }
          obj = obj[key];
          key = k;
        });
        if(!key && paramIsArray) key = obj.length.toString();
        setParamsObject(obj, key, value, castBoolean);
      } else if(castBoolean && value === 'true') {
        obj[param] = true;
      } else if(castBoolean && value === 'false') {
        obj[param] = false;
      } else {
        obj[param] = value;
      }
    }
  
    function objectToQueryString(base, obj) {
      var tmp;
      // If a custom toString exists bail here and use that instead
      if(isArray(obj) || (isObjectType(obj) && obj.toString === internalToString)) {
        tmp = [];
        iterateOverObject(obj, function(key, value) {
          if(base) {
            key = base + '[' + key + ']';
          }
          tmp.push(objectToQueryString(key, value));
        });
        return tmp.join('&');
      } else {
        if(!base) return '';
        return sanitizeURIComponent(base) + '=' + (isDate(obj) ? obj.getTime() : sanitizeURIComponent(obj));
      }
    }
  
    function sanitizeURIComponent(obj) {
      // undefined, null, and NaN are represented as a blank string,
      // while false and 0 are stringified. "+" is allowed in query string
      return !obj && obj !== false && obj !== 0 ? '' : encodeURIComponent(obj).replace(/%20/g, '+');
    }
  
    function matchInObject(match, key, value) {
      if(isRegExp(match)) {
        return match.test(key);
      } else if(isObjectType(match)) {
        return match[key] === value;
      } else {
        return key === string(match);
      }
    }
  
    function selectFromObject(obj, args, select) {
      var match, result = obj instanceof Hash ? new Hash : {};
      iterateOverObject(obj, function(key, value) {
        match = false;
        flattenedArgs(args, function(arg) {
          if(matchInObject(arg, key, value)) {
            match = true;
          }
        }, 1);
        if(match === select) {
          result[key] = value;
        }
      });
      return result;
    }
  
  
    /***
     * @method Object.is[Type](<obj>)
     * @returns Boolean
     * @short Returns true if <obj> is an object of that type.
     * @extra %isObject% will return false on anything that is not an object literal, including instances of inherited classes. Note also that %isNaN% will ONLY return true if the object IS %NaN%. It does not mean the same as browser native %isNaN%, which returns true for anything that is "not a number".
     *
     * @set
     *   isArray
     *   isObject
     *   isBoolean
     *   isDate
     *   isFunction
     *   isNaN
     *   isNumber
     *   isString
     *   isRegExp
     *
     * @example
     *
     *   Object.isArray([1,2,3])            -> true
     *   Object.isDate(3)                   -> false
     *   Object.isRegExp(/wasabi/)          -> true
     *   Object.isObject({ broken:'wear' }) -> true
     *
     ***/
    function buildTypeMethods() {
      extendSimilar(object, false, true, ClassNames, function(methods, name) {
        var method = 'is' + name;
        ObjectTypeMethods.push(method);
        methods[method] = typeChecks[name];
      });
    }
  
    function buildObjectExtend() {
      extend(object, false, function(){ return arguments.length === 0; }, {
        'extend': function() {
          var methods = ObjectTypeMethods.concat(ObjectHashMethods)
          if(typeof EnumerableMethods !== 'undefined') {
            methods = methods.concat(EnumerableMethods);
          }
          buildObjectInstanceMethods(methods, object);
        }
      });
    }
  
    extend(object, false, true, {
        /***
         * @method watch(<obj>, <prop>, <fn>)
         * @returns Nothing
         * @short Watches a property of <obj> and runs <fn> when it changes.
         * @extra <fn> is passed three arguments: the property <prop>, the old value, and the new value. The return value of [fn] will be set as the new value. This method is useful for things such as validating or cleaning the value when it is set. Warning: this method WILL NOT work in browsers that don't support %Object.defineProperty% (IE 8 and below). This is the only method in Sugar that is not fully compatible with all browsers. %watch% is available as an instance method on extended objects.
         * @example
         *
         *   Object.watch({ foo: 'bar' }, 'foo', function(prop, oldVal, newVal) {
         *     // Will be run when the property 'foo' is set on the object.
         *   });
         *   Object.extended().watch({ foo: 'bar' }, 'foo', function(prop, oldVal, newVal) {
         *     // Will be run when the property 'foo' is set on the object.
         *   });
         *
         ***/
      'watch': function(obj, prop, fn) {
        if(!definePropertySupport) return;
        var value = obj[prop];
        object.defineProperty(obj, prop, {
          'enumerable'  : true,
          'configurable': true,
          'get': function() {
            return value;
          },
          'set': function(to) {
            value = fn.call(obj, prop, value, to);
          }
        });
      }
    });
  
    extend(object, false, function() { return arguments.length > 1; }, {
  
      /***
       * @method keys(<obj>, [fn])
       * @returns Array
       * @short Returns an array containing the keys in <obj>. Optionally calls [fn] for each key.
       * @extra This method is provided for browsers that don't support it natively, and additionally is enhanced to accept the callback [fn]. Returned keys are in no particular order. %keys% is available as an instance method on extended objects.
       * @example
       *
       *   Object.keys({ broken: 'wear' }) -> ['broken']
       *   Object.keys({ broken: 'wear' }, function(key, value) {
       *     // Called once for each key.
       *   });
       *   Object.extended({ broken: 'wear' }).keys() -> ['broken']
       *
       ***/
      'keys': function(obj, fn) {
        var keys = object.keys(obj);
        keys.forEach(function(key) {
          fn.call(obj, key, obj[key]);
        });
        return keys;
      }
  
    });
  
    extend(object, false, true, {
  
      'isObject': function(obj) {
        return isPlainObject(obj);
      },
  
      'isNaN': function(obj) {
        // This is only true of NaN
        return isNumber(obj) && obj.valueOf() !== obj.valueOf();
      },
  
      /***
       * @method equal(<a>, <b>)
       * @returns Boolean
       * @short Returns true if <a> and <b> are equal.
       * @extra %equal% in Sugar is "egal", meaning the values are equal if they are "not observably distinguishable". Note that on extended objects the name is %equals% for readability.
       * @example
       *
       *   Object.equal({a:2}, {a:2}) -> true
       *   Object.equal({a:2}, {a:3}) -> false
       *   Object.extended({a:2}).equals({a:3}) -> false
       *
       ***/
      'equal': function(a, b) {
        return isEqual(a, b);
      },
  
      /***
       * @method Object.extended(<obj> = {})
       * @returns Extended object
       * @short Creates a new object, equivalent to %new Object()% or %{}%, but with extended methods.
       * @extra See extended objects for more.
       * @example
       *
       *   Object.extended()
       *   Object.extended({ happy:true, pappy:false }).keys() -> ['happy','pappy']
       *   Object.extended({ happy:true, pappy:false }).values() -> [true, false]
       *
       ***/
      'extended': function(obj) {
        return new Hash(obj);
      },
  
      /***
       * @method merge(<target>, <source>, [deep] = false, [resolve] = true)
       * @returns Merged object
       * @short Merges all the properties of <source> into <target>.
       * @extra Merges are shallow unless [deep] is %true%. Properties of <source> will win in the case of conflicts, unless [resolve] is %false%. [resolve] can also be a function that resolves the conflict. In this case it will be passed 3 arguments, %key%, %targetVal%, and %sourceVal%, with the context set to <source>. This will allow you to solve conflict any way you want, ie. adding two numbers together, etc. %merge% is available as an instance method on extended objects.
       * @example
       *
       *   Object.merge({a:1},{b:2}) -> { a:1, b:2 }
       *   Object.merge({a:1},{a:2}, false, false) -> { a:1 }
       +   Object.merge({a:1},{a:2}, false, function(key, a, b) {
       *     return a + b;
       *   }); -> { a:3 }
       *   Object.extended({a:1}).merge({b:2}) -> { a:1, b:2 }
       *
       ***/
      'merge': function(target, source, deep, resolve) {
        var key, sourceIsObject, targetIsObject, sourceVal, targetVal, conflict, result;
        // Strings cannot be reliably merged thanks to
        // their properties not being enumerable in < IE8.
        if(target && typeof source !== 'string') {
          for(key in source) {
            if(!hasOwnProperty(source, key) || !target) continue;
            sourceVal      = source[key];
            targetVal      = target[key];
            conflict       = isDefined(targetVal);
            sourceIsObject = isObjectType(sourceVal);
            targetIsObject = isObjectType(targetVal);
            result         = conflict && resolve === false ? targetVal : sourceVal;
  
            if(conflict) {
              if(isFunction(resolve)) {
                // Use the result of the callback as the result.
                result = resolve.call(source, key, targetVal, sourceVal)
              }
            }
  
            // Going deep
            if(deep && (sourceIsObject || targetIsObject)) {
              if(isDate(sourceVal)) {
                result = new date(sourceVal.getTime());
              } else if(isRegExp(sourceVal)) {
                result = new regexp(sourceVal.source, getRegExpFlags(sourceVal));
              } else {
                if(!targetIsObject) target[key] = array.isArray(sourceVal) ? [] : {};
                object.merge(target[key], sourceVal, deep, resolve);
                continue;
              }
            }
            target[key] = result;
          }
        }
        return target;
      },
  
      /***
       * @method values(<obj>, [fn])
       * @returns Array
       * @short Returns an array containing the values in <obj>. Optionally calls [fn] for each value.
       * @extra Returned values are in no particular order. %values% is available as an instance method on extended objects.
       * @example
       *
       *   Object.values({ broken: 'wear' }) -> ['wear']
       *   Object.values({ broken: 'wear' }, function(value) {
       *     // Called once for each value.
       *   });
       *   Object.extended({ broken: 'wear' }).values() -> ['wear']
       *
       ***/
      'values': function(obj, fn) {
        var values = [];
        iterateOverObject(obj, function(k,v) {
          values.push(v);
          if(fn) fn.call(obj,v);
        });
        return values;
      },
  
      /***
       * @method clone(<obj> = {}, [deep] = false)
       * @returns Cloned object
       * @short Creates a clone (copy) of <obj>.
       * @extra Default is a shallow clone, unless [deep] is true. %clone% is available as an instance method on extended objects.
       * @example
       *
       *   Object.clone({foo:'bar'})            -> { foo: 'bar' }
       *   Object.clone()                       -> {}
       *   Object.extended({foo:'bar'}).clone() -> { foo: 'bar' }
       *
       ***/
      'clone': function(obj, deep) {
        var target, klass;
        if(!isObjectType(obj)) {
          return obj;
        }
        klass = className(obj);
        if(isDate(obj, klass) && obj.clone) {
          // Preserve internal UTC flag when applicable.
          return obj.clone();
        } else if(isDate(obj, klass) || isRegExp(obj, klass)) {
          return new obj.constructor(obj);
        } else if(obj instanceof Hash) {
          target = new Hash;
        } else if(isArray(obj, klass)) {
          target = [];
        } else if(isPlainObject(obj, klass)) {
          target = {};
        } else {
          throw new TypeError('Clone must be a basic data type.');
        }
        return object.merge(target, obj, deep);
      },
  
      /***
       * @method Object.fromQueryString(<str>, [booleans] = false)
       * @returns Object
       * @short Converts the query string of a URL into an object.
       * @extra If [booleans] is true, then %"true"% and %"false"% will be cast into booleans. All other values, including numbers will remain their string values.
       * @example
       *
       *   Object.fromQueryString('foo=bar&broken=wear') -> { foo: 'bar', broken: 'wear' }
       *   Object.fromQueryString('foo[]=1&foo[]=2')     -> { foo: ['1','2'] }
       *   Object.fromQueryString('foo=true', true)      -> { foo: true }
       *
       ***/
      'fromQueryString': function(str, castBoolean) {
        var result = object.extended(), split;
        str = str && str.toString ? str.toString() : '';
        str.replace(/^.*?\?/, '').split('&').forEach(function(p) {
          var split = p.split('=');
          if(split.length !== 2) return;
          setParamsObject(result, split[0], decodeURIComponent(split[1]), castBoolean);
        });
        return result;
      },
  
      /***
       * @method Object.toQueryString(<obj>, [namespace] = null)
       * @returns Object
       * @short Converts the object into a query string.
       * @extra Accepts deep nested objects and arrays. If [namespace] is passed, it will be prefixed to all param names.
       * @example
       *
       *   Object.toQueryString({foo:'bar'})          -> 'foo=bar'
       *   Object.toQueryString({foo:['a','b','c']})  -> 'foo[0]=a&foo[1]=b&foo[2]=c'
       *   Object.toQueryString({name:'Bob'}, 'user') -> 'user[name]=Bob'
       *
       ***/
      'toQueryString': function(obj, namespace) {
        return objectToQueryString(namespace, obj);
      },
  
      /***
       * @method tap(<obj>, <fn>)
       * @returns Object
       * @short Runs <fn> and returns <obj>.
       * @extra  A string can also be used as a shortcut to a method. This method is used to run an intermediary function in the middle of method chaining. As a standalone method on the Object class it doesn't have too much use. The power of %tap% comes when using extended objects or modifying the Object prototype with Object.extend().
       * @example
       *
       *   Object.extend();
       *   [2,4,6].map(Math.exp).tap(function(arr) {
       *     arr.pop()
       *   });
       *   [2,4,6].map(Math.exp).tap('pop').map(Math.round); ->  [7,55]
       *
       ***/
      'tap': function(obj, arg) {
        var fn = arg;
        if(!isFunction(arg)) {
          fn = function() {
            if(arg) obj[arg]();
          }
        }
        fn.call(obj, obj);
        return obj;
      },
  
      /***
       * @method has(<obj>, <key>)
       * @returns Boolean
       * @short Checks if <obj> has <key> using hasOwnProperty from Object.prototype.
       * @extra This method is considered safer than %Object#hasOwnProperty% when using objects as hashes. See http://www.devthought.com/2012/01/18/an-object-is-not-a-hash/ for more.
       * @example
       *
       *   Object.has({ foo: 'bar' }, 'foo') -> true
       *   Object.has({ foo: 'bar' }, 'baz') -> false
       *   Object.has({ hasOwnProperty: true }, 'foo') -> false
       *
       ***/
      'has': function (obj, key) {
        return hasOwnProperty(obj, key);
      },
  
      /***
       * @method select(<obj>, <find>, ...)
       * @returns Object
       * @short Builds a new object containing the values specified in <find>.
       * @extra When <find> is a string, that single key will be selected. It can also be a regex, selecting any key that matches, or an object which will match if the key also exists in that object, effectively doing an "intersect" operation on that object. Multiple selections may also be passed as an array or directly as enumerated arguments. %select% is available as an instance method on extended objects.
       * @example
       *
       *   Object.select({a:1,b:2}, 'a')        -> {a:1}
       *   Object.select({a:1,b:2}, /[a-z]/)    -> {a:1,ba:2}
       *   Object.select({a:1,b:2}, {a:1})      -> {a:1}
       *   Object.select({a:1,b:2}, 'a', 'b')   -> {a:1,b:2}
       *   Object.select({a:1,b:2}, ['a', 'b']) -> {a:1,b:2}
       *
       ***/
      'select': function (obj) {
        return selectFromObject(obj, arguments, true);
      },
  
      /***
       * @method reject(<obj>, <find>, ...)
       * @returns Object
       * @short Builds a new object containing all values except those specified in <find>.
       * @extra When <find> is a string, that single key will be rejected. It can also be a regex, rejecting any key that matches, or an object which will match if the key also exists in that object, effectively "subtracting" that object. Multiple selections may also be passed as an array or directly as enumerated arguments. %reject% is available as an instance method on extended objects.
       * @example
       *
       *   Object.reject({a:1,b:2}, 'a')        -> {b:2}
       *   Object.reject({a:1,b:2}, /[a-z]/)    -> {}
       *   Object.reject({a:1,b:2}, {a:1})      -> {b:2}
       *   Object.reject({a:1,b:2}, 'a', 'b')   -> {}
       *   Object.reject({a:1,b:2}, ['a', 'b']) -> {}
       *
       ***/
      'reject': function (obj) {
        return selectFromObject(obj, arguments, false);
      }
  
    });
  
  
    buildTypeMethods();
    buildObjectExtend();
    buildObjectInstanceMethods(ObjectHashMethods, Hash);
  
    /***
     * @package RegExp
     * @dependency core
     * @description Escaping regexes and manipulating their flags.
     *
     * Note here that methods on the RegExp class like .exec and .test will fail in the current version of SpiderMonkey being
     * used by CouchDB when using shorthand regex notation like /foo/. This is the reason for the intermixed use of shorthand
     * and compiled regexes here. If you're using JS in CouchDB, it is safer to ALWAYS compile your regexes from a string.
     *
     ***/
  
    extend(regexp, false, true, {
  
     /***
      * @method RegExp.escape(<str> = '')
      * @returns String
      * @short Escapes all RegExp tokens in a string.
      * @example
      *
      *   RegExp.escape('really?')      -> 'really\?'
      *   RegExp.escape('yes.')         -> 'yes\.'
      *   RegExp.escape('(not really)') -> '\(not really\)'
      *
      ***/
      'escape': function(str) {
        return escapeRegExp(str);
      }
  
    });
  
    extend(regexp, true, true, {
  
     /***
      * @method getFlags()
      * @returns String
      * @short Returns the flags of the regex as a string.
      * @example
      *
      *   /texty/gim.getFlags('testy') -> 'gim'
      *
      ***/
      'getFlags': function() {
        return getRegExpFlags(this);
      },
  
     /***
      * @method setFlags(<flags>)
      * @returns RegExp
      * @short Sets the flags on a regex and retuns a copy.
      * @example
      *
      *   /texty/.setFlags('gim') -> now has global, ignoreCase, and multiline set
      *
      ***/
      'setFlags': function(flags) {
        return regexp(this.source, flags);
      },
  
     /***
      * @method addFlag(<flag>)
      * @returns RegExp
      * @short Adds <flag> to the regex.
      * @example
      *
      *   /texty/.addFlag('g') -> now has global flag set
      *
      ***/
      'addFlag': function(flag) {
        return this.setFlags(getRegExpFlags(this, flag));
      },
  
     /***
      * @method removeFlag(<flag>)
      * @returns RegExp
      * @short Removes <flag> from the regex.
      * @example
      *
      *   /texty/g.removeFlag('g') -> now has global flag removed
      *
      ***/
      'removeFlag': function(flag) {
        return this.setFlags(getRegExpFlags(this).replace(flag, ''));
      }
  
    });
  
  
  
    /***
     * @package String
     * @dependency core
     * @description String manupulation, escaping, encoding, truncation, and:conversion.
     *
     ***/
  
    function getAcronym(word) {
      var inflector = string.Inflector;
      var word = inflector && inflector.acronyms[word];
      if(isString(word)) {
        return word;
      }
    }
  
    function checkRepeatRange(num) {
      num = +num;
      if(num < 0 || num === Infinity) {
        throw new RangeError('Invalid number');
      }
      return num;
    }
  
    function padString(num, padding) {
      return repeatString(isDefined(padding) ? padding : ' ', num);
    }
  
    function truncateString(str, length, from, ellipsis, split) {
      var str1, str2, len1, len2;
      if(str.length <= length) {
        return str.toString();
      }
      ellipsis = isUndefined(ellipsis) ? '...' : ellipsis;
      switch(from) {
        case 'left':
          str2 = split ? truncateOnWord(str, length, true) : str.slice(str.length - length);
          return ellipsis + str2;
        case 'middle':
          len1 = ceil(length / 2);
          len2 = floor(length / 2);
          str1 = split ? truncateOnWord(str, len1) : str.slice(0, len1);
          str2 = split ? truncateOnWord(str, len2, true) : str.slice(str.length - len2);
          return str1 + ellipsis + str2;
        default:
          str1 = split ? truncateOnWord(str, length) : str.slice(0, length);
          return str1 + ellipsis;
      }
    }
  
    function truncateOnWord(str, limit, fromLeft) {
      if(fromLeft) {
        return truncateOnWord(str.reverse(), limit).reverse();
      }
      var reg = regexp('(?=[' + getTrimmableCharacters() + '])');
      var words = str.split(reg);
      var count = 0;
      return words.filter(function(word) {
        count += word.length;
        return count <= limit;
      }).join('');
    }
  
    function numberOrIndex(str, n, from) {
      if(isString(n)) {
        n = str.indexOf(n);
        if(n === -1) {
          n = from ? str.length : 0;
        }
      }
      return n;
    }
  
    var btoa, atob;
  
    function buildBase64(key) {
      if(globalContext.btoa) {
        btoa = globalContext.btoa;
        atob = globalContext.atob;
        return;
      }
      var base64reg = /[^A-Za-z0-9\+\/\=]/g;
      btoa = function(str) {
        var output = '';
        var chr1, chr2, chr3;
        var enc1, enc2, enc3, enc4;
        var i = 0;
        do {
          chr1 = str.charCodeAt(i++);
          chr2 = str.charCodeAt(i++);
          chr3 = str.charCodeAt(i++);
          enc1 = chr1 >> 2;
          enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
          enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
          enc4 = chr3 & 63;
          if (isNaN(chr2)) {
            enc3 = enc4 = 64;
          } else if (isNaN(chr3)) {
            enc4 = 64;
          }
          output = output + key.charAt(enc1) + key.charAt(enc2) + key.charAt(enc3) + key.charAt(enc4);
          chr1 = chr2 = chr3 = '';
          enc1 = enc2 = enc3 = enc4 = '';
        } while (i < str.length);
        return output;
      }
      atob = function(input) {
        var output = '';
        var chr1, chr2, chr3;
        var enc1, enc2, enc3, enc4;
        var i = 0;
        if(input.match(base64reg)) {
          throw new Error('String contains invalid base64 characters');
        }
        input = input.replace(/[^A-Za-z0-9\+\/\=]/g, '');
        do {
          enc1 = key.indexOf(input.charAt(i++));
          enc2 = key.indexOf(input.charAt(i++));
          enc3 = key.indexOf(input.charAt(i++));
          enc4 = key.indexOf(input.charAt(i++));
          chr1 = (enc1 << 2) | (enc2 >> 4);
          chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
          chr3 = ((enc3 & 3) << 6) | enc4;
          output = output + chr(chr1);
          if (enc3 != 64) {
            output = output + chr(chr2);
          }
          if (enc4 != 64) {
            output = output + chr(chr3);
          }
          chr1 = chr2 = chr3 = '';
          enc1 = enc2 = enc3 = enc4 = '';
        } while (i < input.length);
        return output;
      }
    }
  
    extend(string, true, false, {
      /***
       * @method repeat([num] = 0)
       * @returns String
       * @short Returns the string repeated [num] times.
       * @example
       *
       *   'jumpy'.repeat(2) -> 'jumpyjumpy'
       *   'a'.repeat(5)     -> 'aaaaa'
       *   'a'.repeat(0)     -> ''
       *
       ***/
      'repeat': function(num) {
        num = checkRepeatRange(num);
        return repeatString(this, num);
      }
  
    });
  
    extend(string, true, function(reg) { return isRegExp(reg) || arguments.length > 2; }, {
  
      /***
       * @method startsWith(<find>, [pos] = 0, [case] = true)
       * @returns Boolean
       * @short Returns true if the string starts with <find>.
       * @extra <find> may be either a string or regex. Search begins at [pos], which defaults to the entire string. Case sensitive if [case] is true.
       * @example
       *
       *   'hello'.startsWith('hell')           -> true
       *   'hello'.startsWith(/[a-h]/)          -> true
       *   'hello'.startsWith('HELL')           -> false
       *   'hello'.startsWith('ell', 1)         -> true
       *   'hello'.startsWith('HELL', 0, false) -> true
       *
       ***/
      'startsWith': function(reg) {
        var args = arguments, pos = args[1], c = args[2], str = this, source;
        if(pos) str = str.slice(pos);
        if(isUndefined(c)) c = true;
        source = isRegExp(reg) ? reg.source.replace('^', '') : escapeRegExp(reg);
        return regexp('^' + source, c ? '' : 'i').test(str);
      },
  
      /***
       * @method endsWith(<find>, [pos] = length, [case] = true)
       * @returns Boolean
       * @short Returns true if the string ends with <find>.
       * @extra <find> may be either a string or regex. Search ends at [pos], which defaults to the entire string. Case sensitive if [case] is true.
       * @example
       *
       *   'jumpy'.endsWith('py')            -> true
       *   'jumpy'.endsWith(/[q-z]/)         -> true
       *   'jumpy'.endsWith('MPY')           -> false
       *   'jumpy'.endsWith('mp', 4)         -> false
       *   'jumpy'.endsWith('MPY', 5, false) -> true
       *
       ***/
      'endsWith': function(reg) {
        var args = arguments, pos = args[1], c = args[2], str = this, source;
        if(isDefined(pos)) str = str.slice(0, pos);
        if(isUndefined(c)) c = true;
        source = isRegExp(reg) ? reg.source.replace('$', '') : escapeRegExp(reg);
        return regexp(source + '$', c ? '' : 'i').test(str);
      }
  
    });
  
    extend(string, true, true, {
  
       /***
        * @method escapeRegExp()
        * @returns String
        * @short Escapes all RegExp tokens in the string.
        * @example
        *
        *   'really?'.escapeRegExp()       -> 'really\?'
        *   'yes.'.escapeRegExp()         -> 'yes\.'
        *   '(not really)'.escapeRegExp() -> '\(not really\)'
        *
        ***/
      'escapeRegExp': function() {
        return escapeRegExp(this);
      },
  
       /***
        * @method escapeURL([param] = false)
        * @returns String
        * @short Escapes characters in a string to make a valid URL.
        * @extra If [param] is true, it will also escape valid URL characters for use as a URL parameter.
        * @example
        *
        *   'http://foo.com/"bar"'.escapeURL()     -> 'http://foo.com/%22bar%22'
        *   'http://foo.com/"bar"'.escapeURL(true) -> 'http%3A%2F%2Ffoo.com%2F%22bar%22'
        *
        ***/
      'escapeURL': function(param) {
        return param ? encodeURIComponent(this) : encodeURI(this);
      },
  
       /***
        * @method unescapeURL([partial] = false)
        * @returns String
        * @short Restores escaped characters in a URL escaped string.
        * @extra If [partial] is true, it will only unescape non-valid URL characters. [partial] is included here for completeness, but should very rarely be needed.
        * @example
        *
        *   'http%3A%2F%2Ffoo.com%2Fthe%20bar'.unescapeURL()     -> 'http://foo.com/the bar'
        *   'http%3A%2F%2Ffoo.com%2Fthe%20bar'.unescapeURL(true) -> 'http%3A%2F%2Ffoo.com%2Fthe bar'
        *
        ***/
      'unescapeURL': function(param) {
        return param ? decodeURI(this) : decodeURIComponent(this);
      },
  
       /***
        * @method escapeHTML()
        * @returns String
        * @short Converts HTML characters to their entity equivalents.
        * @example
        *
        *   '<p>some text</p>'.escapeHTML() -> '&lt;p&gt;some text&lt;/p&gt;'
        *   'one & two'.escapeHTML()        -> 'one &amp; two'
        *
        ***/
      'escapeHTML': function() {
        return this.replace(/&/g,  '&amp;' )
                   .replace(/</g,  '&lt;'  )
                   .replace(/>/g,  '&gt;'  )
                   .replace(/"/g,  '&quot;')
                   .replace(/'/g,  '&apos;')
                   .replace(/\//g, '&#x2f;');
      },
  
       /***
        * @method unescapeHTML([partial] = false)
        * @returns String
        * @short Restores escaped HTML characters.
        * @example
        *
        *   '&lt;p&gt;some text&lt;/p&gt;'.unescapeHTML() -> '<p>some text</p>'
        *   'one &amp; two'.unescapeHTML()                -> 'one & two'
        *
        ***/
      'unescapeHTML': function() {
        return this.replace(/&lt;/g,   '<')
                   .replace(/&gt;/g,   '>')
                   .replace(/&quot;/g, '"')
                   .replace(/&apos;/g, "'")
                   .replace(/&#x2f;/g, '/')
                   .replace(/&amp;/g,  '&');
      },
  
       /***
        * @method encodeBase64()
        * @returns String
        * @short Encodes the string into base64 encoding.
        * @extra This method wraps the browser native %btoa% when available, and uses a custom implementation when not available. It can also handle Unicode string encodings.
        * @example
        *
        *   'gonna get encoded!'.encodeBase64()  -> 'Z29ubmEgZ2V0IGVuY29kZWQh'
        *   'http://twitter.com/'.encodeBase64() -> 'aHR0cDovL3R3aXR0ZXIuY29tLw=='
        *
        ***/
      'encodeBase64': function() {
        return btoa(unescape(encodeURIComponent(this)));
      },
  
       /***
        * @method decodeBase64()
        * @returns String
        * @short Decodes the string from base64 encoding.
        * @extra This method wraps the browser native %atob% when available, and uses a custom implementation when not available. It can also handle Unicode string encodings.
        * @example
        *
        *   'aHR0cDovL3R3aXR0ZXIuY29tLw=='.decodeBase64() -> 'http://twitter.com/'
        *   'anVzdCBnb3QgZGVjb2RlZA=='.decodeBase64()     -> 'just got decoded!'
        *
        ***/
      'decodeBase64': function() {
        return decodeURIComponent(escape(atob(this)));
      },
  
      /***
       * @method each([search] = single character, [fn])
       * @returns Array
       * @short Runs callback [fn] against each occurence of [search].
       * @extra Returns an array of matches. [search] may be either a string or regex, and defaults to every character in the string.
       * @example
       *
       *   'jumpy'.each() -> ['j','u','m','p','y']
       *   'jumpy'.each(/[r-z]/) -> ['u','y']
       *   'jumpy'.each(/[r-z]/, function(m) {
       *     // Called twice: "u", "y"
       *   });
       *
       ***/
      'each': function(search, fn) {
        var match, i, len;
        if(isFunction(search)) {
          fn = search;
          search = /[\s\S]/g;
        } else if(!search) {
          search = /[\s\S]/g
        } else if(isString(search)) {
          search = regexp(escapeRegExp(search), 'gi');
        } else if(isRegExp(search)) {
          search = regexp(search.source, getRegExpFlags(search, 'g'));
        }
        match = this.match(search) || [];
        if(fn) {
          for(i = 0, len = match.length; i < len; i++) {
            match[i] = fn.call(this, match[i], i, match) || match[i];
          }
        }
        return match;
      },
  
      /***
       * @method shift(<n>)
       * @returns Array
       * @short Shifts each character in the string <n> places in the character map.
       * @example
       *
       *   'a'.shift(1)  -> 'b'
       *   'ク'.shift(1) -> 'グ'
       *
       ***/
      'shift': function(n) {
        var result = '';
        n = n || 0;
        this.codes(function(c) {
          result += chr(c + n);
        });
        return result;
      },
  
      /***
       * @method codes([fn])
       * @returns Array
       * @short Runs callback [fn] against each character code in the string. Returns an array of character codes.
       * @example
       *
       *   'jumpy'.codes() -> [106,117,109,112,121]
       *   'jumpy'.codes(function(c) {
       *     // Called 5 times: 106, 117, 109, 112, 121
       *   });
       *
       ***/
      'codes': function(fn) {
        var codes = [], i, len;
        for(i = 0, len = this.length; i < len; i++) {
          var code = this.charCodeAt(i);
          codes.push(code);
          if(fn) fn.call(this, code, i);
        }
        return codes;
      },
  
      /***
       * @method chars([fn])
       * @returns Array
       * @short Runs callback [fn] against each character in the string. Returns an array of characters.
       * @example
       *
       *   'jumpy'.chars() -> ['j','u','m','p','y']
       *   'jumpy'.chars(function(c) {
       *     // Called 5 times: "j","u","m","p","y"
       *   });
       *
       ***/
      'chars': function(fn) {
        return this.each(fn);
      },
  
      /***
       * @method words([fn])
       * @returns Array
       * @short Runs callback [fn] against each word in the string. Returns an array of words.
       * @extra A "word" here is defined as any sequence of non-whitespace characters.
       * @example
       *
       *   'broken wear'.words() -> ['broken','wear']
       *   'broken wear'.words(function(w) {
       *     // Called twice: "broken", "wear"
       *   });
       *
       ***/
      'words': function(fn) {
        return this.trim().each(/\S+/g, fn);
      },
  
      /***
       * @method lines([fn])
       * @returns Array
       * @short Runs callback [fn] against each line in the string. Returns an array of lines.
       * @example
       *
       *   'broken wear\nand\njumpy jump'.lines() -> ['broken wear','and','jumpy jump']
       *   'broken wear\nand\njumpy jump'.lines(function(l) {
       *     // Called three times: "broken wear", "and", "jumpy jump"
       *   });
       *
       ***/
      'lines': function(fn) {
        return this.trim().each(/^.*$/gm, fn);
      },
  
      /***
       * @method paragraphs([fn])
       * @returns Array
       * @short Runs callback [fn] against each paragraph in the string. Returns an array of paragraphs.
       * @extra A paragraph here is defined as a block of text bounded by two or more line breaks.
       * @example
       *
       *   'Once upon a time.\n\nIn the land of oz...'.paragraphs() -> ['Once upon a time.','In the land of oz...']
       *   'Once upon a time.\n\nIn the land of oz...'.paragraphs(function(p) {
       *     // Called twice: "Once upon a time.", "In teh land of oz..."
       *   });
       *
       ***/
      'paragraphs': function(fn) {
        var paragraphs = this.trim().split(/[\r\n]{2,}/);
        paragraphs = paragraphs.map(function(p) {
          if(fn) var s = fn.call(p);
          return s ? s : p;
        });
        return paragraphs;
      },
  
      /***
       * @method isBlank()
       * @returns Boolean
       * @short Returns true if the string has a length of 0 or contains only whitespace.
       * @example
       *
       *   ''.isBlank()      -> true
       *   '   '.isBlank()   -> true
       *   'noway'.isBlank() -> false
       *
       ***/
      'isBlank': function() {
        return this.trim().length === 0;
      },
  
      /***
       * @method has(<find>)
       * @returns Boolean
       * @short Returns true if the string matches <find>.
       * @extra <find> may be a string or regex.
       * @example
       *
       *   'jumpy'.has('py')     -> true
       *   'broken'.has(/[a-n]/) -> true
       *   'broken'.has(/[s-z]/) -> false
       *
       ***/
      'has': function(find) {
        return this.search(isRegExp(find) ? find : escapeRegExp(find)) !== -1;
      },
  
  
      /***
       * @method add(<str>, [index] = length)
       * @returns String
       * @short Adds <str> at [index]. Negative values are also allowed.
       * @extra %insert% is provided as an alias, and is generally more readable when using an index.
       * @example
       *
       *   'schfifty'.add(' five')      -> schfifty five
       *   'dopamine'.insert('e', 3)       -> dopeamine
       *   'spelling eror'.insert('r', -3) -> spelling error
       *
       ***/
      'add': function(str, index) {
        index = isUndefined(index) ? this.length : index;
        return this.slice(0, index) + str + this.slice(index);
      },
  
      /***
       * @method remove(<f>)
       * @returns String
       * @short Removes any part of the string that matches <f>.
       * @extra <f> can be a string or a regex.
       * @example
       *
       *   'schfifty five'.remove('f')     -> 'schity ive'
       *   'schfifty five'.remove(/[a-f]/g) -> 'shity iv'
       *
       ***/
      'remove': function(f) {
        return this.replace(f, '');
      },
  
      /***
       * @method reverse()
       * @returns String
       * @short Reverses the string.
       * @example
       *
       *   'jumpy'.reverse()        -> 'ypmuj'
       *   'lucky charms'.reverse() -> 'smrahc ykcul'
       *
       ***/
      'reverse': function() {
        return this.split('').reverse().join('');
      },
  
      /***
       * @method compact()
       * @returns String
       * @short Compacts all white space in the string to a single space and trims the ends.
       * @example
       *
       *   'too \n much \n space'.compact() -> 'too much space'
       *   'enough \n '.compact()           -> 'enought'
       *
       ***/
      'compact': function() {
        return this.trim().replace(/([\r\n\s　])+/g, function(match, whitespace){
          return whitespace === '　' ? whitespace : ' ';
        });
      },
  
      /***
       * @method at(<index>, [loop] = true)
       * @returns String or Array
       * @short Gets the character(s) at a given index.
       * @extra When [loop] is true, overshooting the end of the string (or the beginning) will begin counting from the other end. As an alternate syntax, passing multiple indexes will get the characters at those indexes.
       * @example
       *
       *   'jumpy'.at(0)               -> 'j'
       *   'jumpy'.at(2)               -> 'm'
       *   'jumpy'.at(5)               -> 'j'
       *   'jumpy'.at(5, false)        -> ''
       *   'jumpy'.at(-1)              -> 'y'
       *   'lucky charms'.at(2,4,6,8) -> ['u','k','y',c']
       *
       ***/
      'at': function() {
        return getEntriesForIndexes(this, arguments, true);
      },
  
      /***
       * @method from([index] = 0)
       * @returns String
       * @short Returns a section of the string starting from [index].
       * @example
       *
       *   'lucky charms'.from()   -> 'lucky charms'
       *   'lucky charms'.from(7)  -> 'harms'
       *
       ***/
      'from': function(from) {
        return this.slice(numberOrIndex(this, from, true));
      },
  
      /***
       * @method to([index] = end)
       * @returns String
       * @short Returns a section of the string ending at [index].
       * @example
       *
       *   'lucky charms'.to()   -> 'lucky charms'
       *   'lucky charms'.to(7)  -> 'lucky ch'
       *
       ***/
      'to': function(to) {
        if(isUndefined(to)) to = this.length;
        return this.slice(0, numberOrIndex(this, to));
      },
  
      /***
       * @method dasherize()
       * @returns String
       * @short Converts underscores and camel casing to hypens.
       * @example
       *
       *   'a_farewell_to_arms'.dasherize() -> 'a-farewell-to-arms'
       *   'capsLock'.dasherize()           -> 'caps-lock'
       *
       ***/
      'dasherize': function() {
        return this.underscore().replace(/_/g, '-');
      },
  
      /***
       * @method underscore()
       * @returns String
       * @short Converts hyphens and camel casing to underscores.
       * @example
       *
       *   'a-farewell-to-arms'.underscore() -> 'a_farewell_to_arms'
       *   'capsLock'.underscore()           -> 'caps_lock'
       *
       ***/
      'underscore': function() {
        return this
          .replace(/[-\s]+/g, '_')
          .replace(string.Inflector && string.Inflector.acronymRegExp, function(acronym, index) {
            return (index > 0 ? '_' : '') + acronym.toLowerCase();
          })
          .replace(/([A-Z\d]+)([A-Z][a-z])/g,'$1_$2')
          .replace(/([a-z\d])([A-Z])/g,'$1_$2')
          .toLowerCase();
      },
  
      /***
       * @method camelize([first] = true)
       * @returns String
       * @short Converts underscores and hyphens to camel case. If [first] is true the first letter will also be capitalized.
       * @extra If the Inflections package is included acryonyms can also be defined that will be used when camelizing.
       * @example
       *
       *   'caps_lock'.camelize()              -> 'CapsLock'
       *   'moz-border-radius'.camelize()      -> 'MozBorderRadius'
       *   'moz-border-radius'.camelize(false) -> 'mozBorderRadius'
       *
       ***/
      'camelize': function(first) {
        return this.underscore().replace(/(^|_)([^_]+)/g, function(match, pre, word, index) {
          var acronym = getAcronym(word), capitalize = first !== false || index > 0;
          if(acronym) return capitalize ? acronym : acronym.toLowerCase();
          return capitalize ? word.capitalize() : word;
        });
      },
  
      /***
       * @method spacify()
       * @returns String
       * @short Converts camel case, underscores, and hyphens to a properly spaced string.
       * @example
       *
       *   'camelCase'.spacify()                         -> 'camel case'
       *   'an-ugly-string'.spacify()                    -> 'an ugly string'
       *   'oh-no_youDid-not'.spacify().capitalize(true) -> 'something else'
       *
       ***/
      'spacify': function() {
        return this.underscore().replace(/_/g, ' ');
      },
  
      /***
       * @method stripTags([tag1], [tag2], ...)
       * @returns String
       * @short Strips all HTML tags from the string.
       * @extra Tags to strip may be enumerated in the parameters, otherwise will strip all.
       * @example
       *
       *   '<p>just <b>some</b> text</p>'.stripTags()    -> 'just some text'
       *   '<p>just <b>some</b> text</p>'.stripTags('p') -> 'just <b>some</b> text'
       *
       ***/
      'stripTags': function() {
        var str = this, args = arguments.length > 0 ? arguments : [''];
        flattenedArgs(args, function(tag) {
          str = str.replace(regexp('<\/?' + escapeRegExp(tag) + '[^<>]*>', 'gi'), '');
        });
        return str;
      },
  
      /***
       * @method removeTags([tag1], [tag2], ...)
       * @returns String
       * @short Removes all HTML tags and their contents from the string.
       * @extra Tags to remove may be enumerated in the parameters, otherwise will remove all.
       * @example
       *
       *   '<p>just <b>some</b> text</p>'.removeTags()    -> ''
       *   '<p>just <b>some</b> text</p>'.removeTags('b') -> '<p>just text</p>'
       *
       ***/
      'removeTags': function() {
        var str = this, args = arguments.length > 0 ? arguments : ['\\S+'];
        flattenedArgs(args, function(t) {
          var reg = regexp('<(' + t + ')[^<>]*(?:\\/>|>.*?<\\/\\1>)', 'gi');
          str = str.replace(reg, '');
        });
        return str;
      },
  
      /***
       * @method truncate(<length>, [from] = 'right', [ellipsis] = '...')
       * @returns String
       * @short Truncates a string.
       * @extra [from] can be %'right'%, %'left'%, or %'middle'%. If the string is shorter than <length>, [ellipsis] will not be added.
       * @example
       *
       *   'sittin on the dock of the bay'.truncate(18)           -> 'just sittin on the do...'
       *   'sittin on the dock of the bay'.truncate(18, 'left')   -> '...the dock of the bay'
       *   'sittin on the dock of the bay'.truncate(18, 'middle') -> 'just sitt...of the bay'
       *
       ***/
      'truncate': function(length, from, ellipsis) {
        return truncateString(this, length, from, ellipsis);
      },
  
      /***
       * @method truncateOnWord(<length>, [from] = 'right', [ellipsis] = '...')
       * @returns String
       * @short Truncates a string without splitting up words.
       * @extra [from] can be %'right'%, %'left'%, or %'middle'%. If the string is shorter than <length>, [ellipsis] will not be added.
       * @example
       *
       *   'here we go'.truncateOnWord(5)               -> 'here...'
       *   'here we go'.truncateOnWord(5, 'left')       -> '...we go'
       *
       ***/
      'truncateOnWord': function(length, from, ellipsis) {
        return truncateString(this, length, from, ellipsis, true);
      },
  
      /***
       * @method pad[Side](<num> = null, [padding] = ' ')
       * @returns String
       * @short Pads the string out with [padding] to be exactly <num> characters.
       *
       * @set
       *   pad
       *   padLeft
       *   padRight
       *
       * @example
       *
       *   'wasabi'.pad(8)           -> ' wasabi '
       *   'wasabi'.padLeft(8)       -> '  wasabi'
       *   'wasabi'.padRight(8)      -> 'wasabi  '
       *   'wasabi'.padRight(8, '-') -> 'wasabi--'
       *
       ***/
      'pad': function(num, padding) {
        var half, front, back;
        num   = checkRepeatRange(num);
        half  = max(0, num - this.length) / 2;
        front = floor(half);
        back  = ceil(half);
        return padString(front, padding) + this + padString(back, padding);
      },
  
      'padLeft': function(num, padding) {
        num = checkRepeatRange(num);
        return padString(max(0, num - this.length), padding) + this;
      },
  
      'padRight': function(num, padding) {
        num = checkRepeatRange(num);
        return this + padString(max(0, num - this.length), padding);
      },
  
      /***
       * @method first([n] = 1)
       * @returns String
       * @short Returns the first [n] characters of the string.
       * @example
       *
       *   'lucky charms'.first()   -> 'l'
       *   'lucky charms'.first(3)  -> 'luc'
       *
       ***/
      'first': function(num) {
        if(isUndefined(num)) num = 1;
        return this.substr(0, num);
      },
  
      /***
       * @method last([n] = 1)
       * @returns String
       * @short Returns the last [n] characters of the string.
       * @example
       *
       *   'lucky charms'.last()   -> 's'
       *   'lucky charms'.last(3)  -> 'rms'
       *
       ***/
      'last': function(num) {
        if(isUndefined(num)) num = 1;
        var start = this.length - num < 0 ? 0 : this.length - num;
        return this.substr(start);
      },
  
      /***
       * @method toNumber([base] = 10)
       * @returns Number
       * @short Converts the string into a number.
       * @extra Any value with a "." fill be converted to a floating point value, otherwise an integer.
       * @example
       *
       *   '153'.toNumber()    -> 153
       *   '12,000'.toNumber() -> 12000
       *   '10px'.toNumber()   -> 10
       *   'ff'.toNumber(16)   -> 255
       *
       ***/
      'toNumber': function(base) {
        return stringToNumber(this, base);
      },
  
      /***
       * @method capitalize([all] = false)
       * @returns String
       * @short Capitalizes the first character in the string and downcases all other letters.
       * @extra If [all] is true, all words in the string will be capitalized.
       * @example
       *
       *   'hello'.capitalize()           -> 'Hello'
       *   'hello kitty'.capitalize()     -> 'Hello kitty'
       *   'hello kitty'.capitalize(true) -> 'Hello Kitty'
       *
       *
       ***/
      'capitalize': function(all) {
        var lastResponded;
        return this.toLowerCase().replace(all ? /[^']/g : /^\S/, function(lower) {
          var upper = lower.toUpperCase(), result;
          result = lastResponded ? lower : upper;
          lastResponded = upper !== lower;
          return result;
        });
      },
  
      /***
       * @method assign(<obj1>, <obj2>, ...)
       * @returns String
       * @short Assigns variables to tokens in a string, demarcated with `{}`.
       * @extra If an object is passed, it's properties can be assigned using the object's keys (i.e. {name}). If a non-object (string, number, etc.) is passed it can be accessed by the argument number beginning with {1} (as with regex tokens). Multiple objects can be passed and will be merged together (original objects are unaffected).
       * @example
       *
       *   'Welcome, Mr. {name}.'.assign({ name: 'Franklin' })   -> 'Welcome, Mr. Franklin.'
       *   'You are {1} years old today.'.assign(14)             -> 'You are 14 years old today.'
       *   '{n} and {r}'.assign({ n: 'Cheech' }, { r: 'Chong' }) -> 'Cheech and Chong'
       *
       ***/
      'assign': function() {
        var assign = {};
        flattenedArgs(arguments, function(a, i) {
          if(isObjectType(a)) {
            simpleMerge(assign, a);
          } else {
            assign[i + 1] = a;
          }
        });
        return this.replace(/\{([^{]+?)\}/g, function(m, key) {
          return hasOwnProperty(assign, key) ? assign[key] : m;
        });
      }
  
    });
  
  
    // Aliases
  
    extend(string, true, true, {
  
      /***
       * @method insert()
       * @alias add
       *
       ***/
      'insert': string.prototype.add
    });
  
    buildBase64('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=');
  
  
    /***
     *
     * @package Inflections
     * @dependency string
     * @description Pluralization similar to ActiveSupport including uncountable words and acronyms. Humanized and URL-friendly strings.
     *
     ***/
  
    /***
     * String module
     *
     ***/
  
  
    var plurals      = [],
        singulars    = [],
        uncountables = [],
        humans       = [],
        acronyms     = {},
        Downcased,
        Inflector;
  
    function removeFromArray(arr, find) {
      var index = arr.indexOf(find);
      if(index > -1) {
        arr.splice(index, 1);
      }
    }
  
    function removeFromUncountablesAndAddTo(arr, rule, replacement) {
      if(isString(rule)) {
        removeFromArray(uncountables, rule);
      }
      removeFromArray(uncountables, replacement);
      arr.unshift({ rule: rule, replacement: replacement })
    }
  
    function paramMatchesType(param, type) {
      return param == type || param == 'all' || !param;
    }
  
    function isUncountable(word) {
      return uncountables.some(function(uncountable) {
        return new regexp('\\b' + uncountable + '$', 'i').test(word);
      });
    }
  
    function inflect(word, pluralize) {
      word = isString(word) ? word.toString() : '';
      if(word.isBlank() || isUncountable(word)) {
        return word;
      } else {
        return runReplacements(word, pluralize ? plurals : singulars);
      }
    }
  
    function runReplacements(word, table) {
      iterateOverObject(table, function(i, inflection) {
        if(word.match(inflection.rule)) {
          word = word.replace(inflection.rule, inflection.replacement);
          return false;
        }
      });
      return word;
    }
  
    function capitalize(word) {
      return word.replace(/^\W*[a-z]/, function(w){
        return w.toUpperCase();
      });
    }
  
    Inflector = {
  
      /*
       * Specifies a new acronym. An acronym must be specified as it will appear in a camelized string.  An underscore
       * string that contains the acronym will retain the acronym when passed to %camelize%, %humanize%, or %titleize%.
       * A camelized string that contains the acronym will maintain the acronym when titleized or humanized, and will
       * convert the acronym into a non-delimited single lowercase word when passed to String#underscore.
       *
       * Examples:
       *   String.Inflector.acronym('HTML')
       *   'html'.titleize()     -> 'HTML'
       *   'html'.camelize()     -> 'HTML'
       *   'MyHTML'.underscore() -> 'my_html'
       *
       * The acronym, however, must occur as a delimited unit and not be part of another word for conversions to recognize it:
       *
       *   String.Inflector.acronym('HTTP')
       *   'my_http_delimited'.camelize() -> 'MyHTTPDelimited'
       *   'https'.camelize()             -> 'Https', not 'HTTPs'
       *   'HTTPS'.underscore()           -> 'http_s', not 'https'
       *
       *   String.Inflector.acronym('HTTPS')
       *   'https'.camelize()   -> 'HTTPS'
       *   'HTTPS'.underscore() -> 'https'
       *
       * Note: Acronyms that are passed to %pluralize% will no longer be recognized, since the acronym will not occur as
       * a delimited unit in the pluralized result. To work around this, you must specify the pluralized form as an
       * acronym as well:
       *
       *    String.Inflector.acronym('API')
       *    'api'.pluralize().camelize() -> 'Apis'
       *
       *    String.Inflector.acronym('APIs')
       *    'api'.pluralize().camelize() -> 'APIs'
       *
       * %acronym% may be used to specify any word that contains an acronym or otherwise needs to maintain a non-standard
       * capitalization. The only restriction is that the word must begin with a capital letter.
       *
       * Examples:
       *   String.Inflector.acronym('RESTful')
       *   'RESTful'.underscore()           -> 'restful'
       *   'RESTfulController'.underscore() -> 'restful_controller'
       *   'RESTfulController'.titleize()   -> 'RESTful Controller'
       *   'restful'.camelize()             -> 'RESTful'
       *   'restful_controller'.camelize()  -> 'RESTfulController'
       *
       *   String.Inflector.acronym('McDonald')
       *   'McDonald'.underscore() -> 'mcdonald'
       *   'mcdonald'.camelize()   -> 'McDonald'
       */
      'acronym': function(word) {
        acronyms[word.toLowerCase()] = word;
        var all = object.keys(acronyms).map(function(key) {
          return acronyms[key];
        });
        Inflector.acronymRegExp = regexp(all.join('|'), 'g');
      },
  
      /*
       * Specifies a new pluralization rule and its replacement. The rule can either be a string or a regular expression.
       * The replacement should always be a string that may include references to the matched data from the rule.
       */
      'plural': function(rule, replacement) {
        removeFromUncountablesAndAddTo(plurals, rule, replacement);
      },
  
      /*
       * Specifies a new singularization rule and its replacement. The rule can either be a string or a regular expression.
       * The replacement should always be a string that may include references to the matched data from the rule.
       */
      'singular': function(rule, replacement) {
        removeFromUncountablesAndAddTo(singulars, rule, replacement);
      },
  
      /*
       * Specifies a new irregular that applies to both pluralization and singularization at the same time. This can only be used
       * for strings, not regular expressions. You simply pass the irregular in singular and plural form.
       *
       * Examples:
       *   String.Inflector.irregular('octopus', 'octopi')
       *   String.Inflector.irregular('person', 'people')
       */
      'irregular': function(singular, plural) {
        var singularFirst      = singular.first(),
            singularRest       = singular.from(1),
            pluralFirst        = plural.first(),
            pluralRest         = plural.from(1),
            pluralFirstUpper   = pluralFirst.toUpperCase(),
            pluralFirstLower   = pluralFirst.toLowerCase(),
            singularFirstUpper = singularFirst.toUpperCase(),
            singularFirstLower = singularFirst.toLowerCase();
        removeFromArray(uncountables, singular);
        removeFromArray(uncountables, plural);
        if(singularFirstUpper == pluralFirstUpper) {
          Inflector.plural(new regexp('({1}){2}$'.assign(singularFirst, singularRest), 'i'), '$1' + pluralRest);
          Inflector.plural(new regexp('({1}){2}$'.assign(pluralFirst, pluralRest), 'i'), '$1' + pluralRest);
          Inflector.singular(new regexp('({1}){2}$'.assign(pluralFirst, pluralRest), 'i'), '$1' + singularRest);
        } else {
          Inflector.plural(new regexp('{1}{2}$'.assign(singularFirstUpper, singularRest)), pluralFirstUpper + pluralRest);
          Inflector.plural(new regexp('{1}{2}$'.assign(singularFirstLower, singularRest)), pluralFirstLower + pluralRest);
          Inflector.plural(new regexp('{1}{2}$'.assign(pluralFirstUpper, pluralRest)), pluralFirstUpper + pluralRest);
          Inflector.plural(new regexp('{1}{2}$'.assign(pluralFirstLower, pluralRest)), pluralFirstLower + pluralRest);
          Inflector.singular(new regexp('{1}{2}$'.assign(pluralFirstUpper, pluralRest)), singularFirstUpper + singularRest);
          Inflector.singular(new regexp('{1}{2}$'.assign(pluralFirstLower, pluralRest)), singularFirstLower + singularRest);
        }
      },
  
      /*
       * Add uncountable words that shouldn't be attempted inflected.
       *
       * Examples:
       *   String.Inflector.uncountable('money')
       *   String.Inflector.uncountable('money', 'information')
       *   String.Inflector.uncountable(['money', 'information', 'rice'])
       */
      'uncountable': function(first) {
        var add = array.isArray(first) ? first : multiArgs(arguments);
        uncountables = uncountables.concat(add);
      },
  
      /*
       * Specifies a humanized form of a string by a regular expression rule or by a string mapping.
       * When using a regular expression based replacement, the normal humanize formatting is called after the replacement.
       * When a string is used, the human form should be specified as desired (example: 'The name', not 'the_name')
       *
       * Examples:
       *   String.Inflector.human(/_cnt$/i, '_count')
       *   String.Inflector.human('legacy_col_person_name', 'Name')
       */
      'human': function(rule, replacement) {
        humans.unshift({ rule: rule, replacement: replacement })
      },
  
  
      /*
       * Clears the loaded inflections within a given scope (default is 'all').
       * Options are: 'all', 'plurals', 'singulars', 'uncountables', 'humans'.
       *
       * Examples:
       *   String.Inflector.clear('all')
       *   String.Inflector.clear('plurals')
       */
      'clear': function(type) {
        if(paramMatchesType(type, 'singulars'))    singulars    = [];
        if(paramMatchesType(type, 'plurals'))      plurals      = [];
        if(paramMatchesType(type, 'uncountables')) uncountables = [];
        if(paramMatchesType(type, 'humans'))       humans       = [];
        if(paramMatchesType(type, 'acronyms'))     acronyms     = {};
      }
  
    };
  
    Downcased = [
      'and', 'or', 'nor', 'a', 'an', 'the', 'so', 'but', 'to', 'of', 'at',
      'by', 'from', 'into', 'on', 'onto', 'off', 'out', 'in', 'over',
      'with', 'for'
    ];
  
    Inflector.plural(/$/, 's');
    Inflector.plural(/s$/gi, 's');
    Inflector.plural(/(ax|test)is$/gi, '$1es');
    Inflector.plural(/(octop|vir|fung|foc|radi|alumn)(i|us)$/gi, '$1i');
    Inflector.plural(/(census|alias|status)$/gi, '$1es');
    Inflector.plural(/(bu)s$/gi, '$1ses');
    Inflector.plural(/(buffal|tomat)o$/gi, '$1oes');
    Inflector.plural(/([ti])um$/gi, '$1a');
    Inflector.plural(/([ti])a$/gi, '$1a');
    Inflector.plural(/sis$/gi, 'ses');
    Inflector.plural(/f+e?$/gi, 'ves');
    Inflector.plural(/(cuff|roof)$/gi, '$1s');
    Inflector.plural(/([ht]ive)$/gi, '$1s');
    Inflector.plural(/([^aeiouy]o)$/gi, '$1es');
    Inflector.plural(/([^aeiouy]|qu)y$/gi, '$1ies');
    Inflector.plural(/(x|ch|ss|sh)$/gi, '$1es');
    Inflector.plural(/(matr|vert|ind)(?:ix|ex)$/gi, '$1ices');
    Inflector.plural(/([ml])ouse$/gi, '$1ice');
    Inflector.plural(/([ml])ice$/gi, '$1ice');
    Inflector.plural(/^(ox)$/gi, '$1en');
    Inflector.plural(/^(oxen)$/gi, '$1');
    Inflector.plural(/(quiz)$/gi, '$1zes');
    Inflector.plural(/(phot|cant|hom|zer|pian|portic|pr|quart|kimon)o$/gi, '$1os');
    Inflector.plural(/(craft)$/gi, '$1');
    Inflector.plural(/([ft])[eo]{2}(th?)$/gi, '$1ee$2');
  
    Inflector.singular(/s$/gi, '');
    Inflector.singular(/([pst][aiu]s)$/gi, '$1');
    Inflector.singular(/([aeiouy])ss$/gi, '$1ss');
    Inflector.singular(/(n)ews$/gi, '$1ews');
    Inflector.singular(/([ti])a$/gi, '$1um');
    Inflector.singular(/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$/gi, '$1$2sis');
    Inflector.singular(/(^analy)ses$/gi, '$1sis');
    Inflector.singular(/(i)(f|ves)$/i, '$1fe');
    Inflector.singular(/([aeolr]f?)(f|ves)$/i, '$1f');
    Inflector.singular(/([ht]ive)s$/gi, '$1');
    Inflector.singular(/([^aeiouy]|qu)ies$/gi, '$1y');
    Inflector.singular(/(s)eries$/gi, '$1eries');
    Inflector.singular(/(m)ovies$/gi, '$1ovie');
    Inflector.singular(/(x|ch|ss|sh)es$/gi, '$1');
    Inflector.singular(/([ml])(ous|ic)e$/gi, '$1ouse');
    Inflector.singular(/(bus)(es)?$/gi, '$1');
    Inflector.singular(/(o)es$/gi, '$1');
    Inflector.singular(/(shoe)s?$/gi, '$1');
    Inflector.singular(/(cris|ax|test)[ie]s$/gi, '$1is');
    Inflector.singular(/(octop|vir|fung|foc|radi|alumn)(i|us)$/gi, '$1us');
    Inflector.singular(/(census|alias|status)(es)?$/gi, '$1');
    Inflector.singular(/^(ox)(en)?/gi, '$1');
    Inflector.singular(/(vert|ind)(ex|ices)$/gi, '$1ex');
    Inflector.singular(/(matr)(ix|ices)$/gi, '$1ix');
    Inflector.singular(/(quiz)(zes)?$/gi, '$1');
    Inflector.singular(/(database)s?$/gi, '$1');
    Inflector.singular(/ee(th?)$/gi, 'oo$1');
  
    Inflector.irregular('person', 'people');
    Inflector.irregular('man', 'men');
    Inflector.irregular('child', 'children');
    Inflector.irregular('sex', 'sexes');
    Inflector.irregular('move', 'moves');
    Inflector.irregular('save', 'saves');
    Inflector.irregular('cow', 'kine');
    Inflector.irregular('goose', 'geese');
    Inflector.irregular('zombie', 'zombies');
  
    Inflector.uncountable('equipment,information,rice,money,species,series,fish,sheep,jeans'.split(','));
  
  
    extend(string, true, true, {
  
      /***
       * @method pluralize()
       * @returns String
       * @short Returns the plural form of the word in the string.
       * @example
       *
       *   'post'.pluralize()         -> 'posts'
       *   'octopus'.pluralize()      -> 'octopi'
       *   'sheep'.pluralize()        -> 'sheep'
       *   'words'.pluralize()        -> 'words'
       *   'CamelOctopus'.pluralize() -> 'CamelOctopi'
       *
       ***/
      'pluralize': function() {
        return inflect(this, true);
      },
  
      /***
       * @method singularize()
       * @returns String
       * @short The reverse of String#pluralize. Returns the singular form of a word in a string.
       * @example
       *
       *   'posts'.singularize()       -> 'post'
       *   'octopi'.singularize()      -> 'octopus'
       *   'sheep'.singularize()       -> 'sheep'
       *   'word'.singularize()        -> 'word'
       *   'CamelOctopi'.singularize() -> 'CamelOctopus'
       *
       ***/
      'singularize': function() {
        return inflect(this, false);
      },
  
      /***
       * @method humanize()
       * @returns String
       * @short Creates a human readable string.
       * @extra Capitalizes the first word and turns underscores into spaces and strips a trailing '_id', if any. Like String#titleize, this is meant for creating pretty output.
       * @example
       *
       *   'employee_salary'.humanize() -> 'Employee salary'
       *   'author_id'.humanize()       -> 'Author'
       *
       ***/
      'humanize': function() {
        var str = runReplacements(this, humans), acronym;
        str = str.replace(/_id$/g, '');
        str = str.replace(/(_)?([a-z\d]*)/gi, function(match, _, word){
          acronym = hasOwnProperty(acronyms, word) ? acronyms[word] : null;
          return (_ ? ' ' : '') + (acronym || word.toLowerCase());
        });
        return capitalize(str);
      },
  
      /***
       * @method titleize()
       * @returns String
       * @short Creates a title version of the string.
       * @extra Capitalizes all the words and replaces some characters in the string to create a nicer looking title. String#titleize is meant for creating pretty output.
       * @example
       *
       *   'man from the boondocks'.titleize() -> 'Man from the Boondocks'
       *   'x-men: the last stand'.titleize() -> 'X Men: The Last Stand'
       *   'TheManWithoutAPast'.titleize() -> 'The Man Without a Past'
       *   'raiders_of_the_lost_ark'.titleize() -> 'Raiders of the Lost Ark'
       *
       ***/
      'titleize': function() {
        var fullStopPunctuation = /[.:;!]$/, hasPunctuation, lastHadPunctuation, isFirstOrLast;
        return this.spacify().humanize().words(function(word, index, words) {
          hasPunctuation = fullStopPunctuation.test(word);
          isFirstOrLast = index == 0 || index == words.length - 1 || hasPunctuation || lastHadPunctuation;
          lastHadPunctuation = hasPunctuation;
          if(isFirstOrLast || Downcased.indexOf(word) === -1) {
            return capitalize(word);
          } else {
            return word;
          }
        }).join(' ');
      },
  
      /***
       * @method parameterize()
       * @returns String
       * @short Replaces special characters in a string so that it may be used as part of a pretty URL.
       * @example
       *
       *   'hell, no!'.parameterize() -> 'hell-no'
       *
       ***/
      'parameterize': function(separator) {
        var str = this;
        if(separator === undefined) separator = '-';
        if(str.normalize) {
          str = str.normalize();
        }
        str = str.replace(/[^a-z0-9\-_]+/gi, separator)
        if(separator) {
          str = str.replace(new regexp('^{sep}+|{sep}+$|({sep}){sep}+'.assign({ 'sep': escapeRegExp(separator) }), 'g'), '$1');
        }
        return encodeURI(str.toLowerCase());
      }
  
    });
  
    string.Inflector = Inflector;
    string.Inflector.acronyms = acronyms;
  
  
    /***
     *
     * @package Language
     * @dependency string
     * @description Detecting language by character block. Full-width <-> half-width character conversion. Hiragana and Katakana conversions.
     *
     ***/
  
    /***
     * String module
     *
     ***/
  
  
    /***
     * @method has[Script]()
     * @returns Boolean
     * @short Returns true if the string contains any characters in that script.
     *
     * @set
     *   hasArabic
     *   hasCyrillic
     *   hasGreek
     *   hasHangul
     *   hasHan
     *   hasKanji
     *   hasHebrew
     *   hasHiragana
     *   hasKana
     *   hasKatakana
     *   hasLatin
     *   hasThai
     *   hasDevanagari
     *
     * @example
     *
     *   'أتكلم'.hasArabic()          -> true
     *   'визит'.hasCyrillic()        -> true
     *   '잘 먹겠습니다!'.hasHangul() -> true
     *   'ミックスです'.hasKatakana() -> true
     *   "l'année".hasLatin()         -> true
     *
     ***
     * @method is[Script]()
     * @returns Boolean
     * @short Returns true if the string contains only characters in that script. Whitespace is ignored.
     *
     * @set
     *   isArabic
     *   isCyrillic
     *   isGreek
     *   isHangul
     *   isHan
     *   isKanji
     *   isHebrew
     *   isHiragana
     *   isKana
     *   isKatakana
     *   isKatakana
     *   isThai
     *   isDevanagari
     *
     * @example
     *
     *   'أتكلم'.isArabic()          -> true
     *   'визит'.isCyrillic()        -> true
     *   '잘 먹겠습니다!'.isHangul() -> true
     *   'ミックスです'.isKatakana() -> false
     *   "l'année".isLatin()         -> true
     *
     ***/
    var unicodeScripts = [
      { names: ['Arabic'],      source: '\u0600-\u06FF' },
      { names: ['Cyrillic'],    source: '\u0400-\u04FF' },
      { names: ['Devanagari'],  source: '\u0900-\u097F' },
      { names: ['Greek'],       source: '\u0370-\u03FF' },
      { names: ['Hangul'],      source: '\uAC00-\uD7AF\u1100-\u11FF' },
      { names: ['Han','Kanji'], source: '\u4E00-\u9FFF\uF900-\uFAFF' },
      { names: ['Hebrew'],      source: '\u0590-\u05FF' },
      { names: ['Hiragana'],    source: '\u3040-\u309F\u30FB-\u30FC' },
      { names: ['Kana'],        source: '\u3040-\u30FF\uFF61-\uFF9F' },
      { names: ['Katakana'],    source: '\u30A0-\u30FF\uFF61-\uFF9F' },
      { names: ['Latin'],       source: '\u0001-\u007F\u0080-\u00FF\u0100-\u017F\u0180-\u024F' },
      { names: ['Thai'],        source: '\u0E00-\u0E7F' }
    ];
  
    function buildUnicodeScripts() {
      unicodeScripts.forEach(function(s) {
        var is = regexp('^['+s.source+'\\s]+$');
        var has = regexp('['+s.source+']');
        s.names.forEach(function(name) {
          defineProperty(string.prototype, 'is' + name, function() { return is.test(this.trim()); });
          defineProperty(string.prototype, 'has' + name, function() { return has.test(this); });
        });
      });
    }
  
    // Support for converting character widths and katakana to hiragana.
  
    var HALF_WIDTH_TO_FULL_WIDTH_TRAVERSAL = 65248;
  
    var widthConversionRanges = [
      { type: 'a', start: 65,  end: 90  },
      { type: 'a', start: 97,  end: 122 },
      { type: 'n', start: 48,  end: 57  },
      { type: 'p', start: 33,  end: 47  },
      { type: 'p', start: 58,  end: 64  },
      { type: 'p', start: 91,  end: 96  },
      { type: 'p', start: 123, end: 126 }
    ];
  
    var WidthConversionTable;
    var allHankaku   = /[\u0020-\u00A5]|[\uFF61-\uFF9F][ﾞﾟ]?/g;
    var allZenkaku   = /[\u3000-\u301C]|[\u301A-\u30FC]|[\uFF01-\uFF60]|[\uFFE0-\uFFE6]/g;
    var hankakuPunctuation  = '｡､｢｣¥¢£';
    var zenkakuPunctuation  = '。、「」￥￠￡';
    var voicedKatakana      = /[カキクケコサシスセソタチツテトハヒフヘホ]/;
    var semiVoicedKatakana  = /[ハヒフヘホヲ]/;
    var hankakuKatakana     = 'ｱｲｳｴｵｧｨｩｪｫｶｷｸｹｺｻｼｽｾｿﾀﾁﾂｯﾃﾄﾅﾆﾇﾈﾉﾊﾋﾌﾍﾎﾏﾐﾑﾒﾓﾔｬﾕｭﾖｮﾗﾘﾙﾚﾛﾜｦﾝｰ･';
    var zenkakuKatakana     = 'アイウエオァィゥェォカキクケコサシスセソタチツッテトナニヌネノハヒフヘホマミムメモヤャユュヨョラリルレロワヲンー・';
  
    function convertCharacterWidth(str, args, reg, type) {
      if(!WidthConversionTable) {
        buildWidthConversionTables();
      }
      var mode = multiArgs(args).join(''), table = WidthConversionTable[type];
      mode = mode.replace(/all/, '').replace(/(\w)lphabet|umbers?|atakana|paces?|unctuation/g, '$1');
      return str.replace(reg, function(c) {
        if(table[c] && (!mode || mode.has(table[c].type))) {
          return table[c].to;
        } else {
          return c;
        }
      });
    }
  
    function buildWidthConversionTables() {
      var hankaku;
      WidthConversionTable = {
        'zenkaku': {},
        'hankaku': {}
      };
      widthConversionRanges.forEach(function(r) {
        simpleRepeat(r.end - r.start + 1, function(n) {
          n += r.start;
          setWidthConversion(r.type, chr(n), chr(n + HALF_WIDTH_TO_FULL_WIDTH_TRAVERSAL));
        });
      });
      zenkakuKatakana.each(function(c, i) {
        hankaku = hankakuKatakana.charAt(i);
        setWidthConversion('k', hankaku, c);
        if(c.match(voicedKatakana)) {
          setWidthConversion('k', hankaku + 'ﾞ', c.shift(1));
        }
        if(c.match(semiVoicedKatakana)) {
          setWidthConversion('k', hankaku + 'ﾟ', c.shift(2));
        }
      });
      zenkakuPunctuation.each(function(c, i) {
        setWidthConversion('p', hankakuPunctuation.charAt(i), c);
      });
      setWidthConversion('k', 'ｳﾞ', 'ヴ');
      setWidthConversion('k', 'ｦﾞ', 'ヺ');
      setWidthConversion('s', ' ', '　');
    }
  
    function setWidthConversion(type, half, full) {
      WidthConversionTable['zenkaku'][half] = { type: type, to: full };
      WidthConversionTable['hankaku'][full] = { type: type, to: half };
    }
  
  
    extend(string, true, true, {
  
      /***
       * @method hankaku([mode] = 'all')
       * @returns String
       * @short Converts full-width characters (zenkaku) to half-width (hankaku).
       * @extra [mode] accepts any combination of "a" (alphabet), "n" (numbers), "k" (katakana), "s" (spaces), "p" (punctuation), or "all".
       * @example
       *
       *   'タロウ　ＹＡＭＡＤＡです！'.hankaku()                      -> 'ﾀﾛｳ YAMADAです!'
       *   'タロウ　ＹＡＭＡＤＡです！'.hankaku('a')                   -> 'タロウ　YAMADAです！'
       *   'タロウ　ＹＡＭＡＤＡです！'.hankaku('alphabet')            -> 'タロウ　YAMADAです！'
       *   'タロウです！　２５歳です！'.hankaku('katakana', 'numbers') -> 'ﾀﾛｳです！　25歳です！'
       *   'タロウです！　２５歳です！'.hankaku('k', 'n')              -> 'ﾀﾛｳです！　25歳です！'
       *   'タロウです！　２５歳です！'.hankaku('kn')                  -> 'ﾀﾛｳです！　25歳です！'
       *   'タロウです！　２５歳です！'.hankaku('sp')                  -> 'タロウです! ２５歳です!'
       *
       ***/
      'hankaku': function() {
        return convertCharacterWidth(this, arguments, allZenkaku, 'hankaku');
      },
  
      /***
       * @method zenkaku([mode] = 'all')
       * @returns String
       * @short Converts half-width characters (hankaku) to full-width (zenkaku).
       * @extra [mode] accepts any combination of "a" (alphabet), "n" (numbers), "k" (katakana), "s" (spaces), "p" (punctuation), or "all".
       * @example
       *
       *   'ﾀﾛｳ YAMADAです!'.zenkaku()                         -> 'タロウ　ＹＡＭＡＤＡです！'
       *   'ﾀﾛｳ YAMADAです!'.zenkaku('a')                      -> 'ﾀﾛｳ ＹＡＭＡＤＡです!'
       *   'ﾀﾛｳ YAMADAです!'.zenkaku('alphabet')               -> 'ﾀﾛｳ ＹＡＭＡＤＡです!'
       *   'ﾀﾛｳです! 25歳です!'.zenkaku('katakana', 'numbers') -> 'タロウです! ２５歳です!'
       *   'ﾀﾛｳです! 25歳です!'.zenkaku('k', 'n')              -> 'タロウです! ２５歳です!'
       *   'ﾀﾛｳです! 25歳です!'.zenkaku('kn')                  -> 'タロウです! ２５歳です!'
       *   'ﾀﾛｳです! 25歳です!'.zenkaku('sp')                  -> 'ﾀﾛｳです！　25歳です！'
       *
       ***/
      'zenkaku': function() {
        return convertCharacterWidth(this, arguments, allHankaku, 'zenkaku');
      },
  
      /***
       * @method hiragana([all] = true)
       * @returns String
       * @short Converts katakana into hiragana.
       * @extra If [all] is false, only full-width katakana will be converted.
       * @example
       *
       *   'カタカナ'.hiragana()   -> 'かたかな'
       *   'コンニチハ'.hiragana() -> 'こんにちは'
       *   'ｶﾀｶﾅ'.hiragana()       -> 'かたかな'
       *   'ｶﾀｶﾅ'.hiragana(false)  -> 'ｶﾀｶﾅ'
       *
       ***/
      'hiragana': function(all) {
        var str = this;
        if(all !== false) {
          str = str.zenkaku('k');
        }
        return str.replace(/[\u30A1-\u30F6]/g, function(c) {
          return c.shift(-96);
        });
      },
  
      /***
       * @method katakana()
       * @returns String
       * @short Converts hiragana into katakana.
       * @example
       *
       *   'かたかな'.katakana()   -> 'カタカナ'
       *   'こんにちは'.katakana() -> 'コンニチハ'
       *
       ***/
      'katakana': function() {
        return this.replace(/[\u3041-\u3096]/g, function(c) {
          return c.shift(96);
        });
      }
  
  
    });
  
    buildUnicodeScripts();
  
  /*
   *
   * Date.addLocale(<code>) adds this locale to Sugar.
   * To set the locale globally, simply call:
   *
   * Date.setLocale('da');
   *
   * var locale = Date.getLocale(<code>) will return this object, which
   * can be tweaked to change the behavior of parsing/formatting in the locales.
   *
   * locale.addFormat adds a date format (see this file for examples).
   * Special tokens in the date format will be parsed out into regex tokens:
   *
   * {0} is a reference to an entry in locale.tokens. Output: (?:the)?
   * {unit} is a reference to all units. Output: (day|week|month|...)
   * {unit3} is a reference to a specific unit. Output: (hour)
   * {unit3-5} is a reference to a subset of the units array. Output: (hour|day|week)
   * {unit?} "?" makes that token optional. Output: (day|week|month)?
   *
   * {day} Any reference to tokens in the modifiers array will include all with the same name. Output: (yesterday|today|tomorrow)
   *
   * All spaces are optional and will be converted to "\s*"
   *
   * Locale arrays months, weekdays, units, numbers, as well as the "src" field for
   * all entries in the modifiers array follow a special format indicated by a colon:
   *
   * minute:|s  = minute|minutes
   * thicke:n|r = thicken|thicker
   *
   * Additionally in the months, weekdays, units, and numbers array these will be added at indexes that are multiples
   * of the relevant number for retrieval. For example having "sunday:|s" in the units array will result in:
   *
   * units: ['sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sundays']
   *
   * When matched, the index will be found using:
   *
   * units.indexOf(match) % 7;
   *
   * Resulting in the correct index with any number of alternates for that entry.
   *
   */
  
  Date.addLocale('da', {
    'plural': true,
    'months': 'januar,februar,marts,april,maj,juni,juli,august,september,oktober,november,december',
    'weekdays': 'søndag|sondag,mandag,tirsdag,onsdag,torsdag,fredag,lørdag|lordag',
    'units': 'millisekund:|er,sekund:|er,minut:|ter,tim:e|er,dag:|e,ug:e|er|en,måned:|er|en+maaned:|er|en,år:||et+aar:||et',
    'numbers': 'en|et,to,tre,fire,fem,seks,syv,otte,ni,ti',
    'tokens': 'den,for',
    'articles': 'den',
    'short':'d. {d}. {month} {yyyy}',
    'long': 'den {d}. {month} {yyyy} {H}:{mm}',
    'full': '{Weekday} den {d}. {month} {yyyy} {H}:{mm}:{ss}',
    'past': '{num} {unit} {sign}',
    'future': '{sign} {num} {unit}',
    'duration': '{num} {unit}',
    'ampm': 'am,pm',
    'modifiers': [
      { 'name': 'day', 'src': 'forgårs|i forgårs|forgaars|i forgaars', 'value': -2 },
      { 'name': 'day', 'src': 'i går|igår|i gaar|igaar', 'value': -1 },
      { 'name': 'day', 'src': 'i dag|idag', 'value': 0 },
      { 'name': 'day', 'src': 'i morgen|imorgen', 'value': 1 },
      { 'name': 'day', 'src': 'over morgon|overmorgen|i over morgen|i overmorgen|iovermorgen', 'value': 2 },
      { 'name': 'sign', 'src': 'siden', 'value': -1 },
      { 'name': 'sign', 'src': 'om', 'value':  1 },
      { 'name': 'shift', 'src': 'i sidste|sidste', 'value': -1 },
      { 'name': 'shift', 'src': 'denne', 'value': 0 },
      { 'name': 'shift', 'src': 'næste|naeste', 'value': 1 }
    ],
    'dateParse': [
      '{num} {unit} {sign}',
      '{sign} {num} {unit}',
      '{1?} {num} {unit} {sign}',
      '{shift} {unit=5-7}'
    ],
    'timeParse': [
      '{0?} {weekday?} {date?} {month} {year}',
      '{date} {month}',
      '{shift} {weekday}'
    ]
  });
  
  /*
   *
   * Date.addLocale(<code>) adds this locale to Sugar.
   * To set the locale globally, simply call:
   *
   * Date.setLocale('de');
   *
   * var locale = Date.getLocale(<code>) will return this object, which
   * can be tweaked to change the behavior of parsing/formatting in the locales.
   *
   * locale.addFormat adds a date format (see this file for examples).
   * Special tokens in the date format will be parsed out into regex tokens:
   *
   * {0} is a reference to an entry in locale.tokens. Output: (?:the)?
   * {unit} is a reference to all units. Output: (day|week|month|...)
   * {unit3} is a reference to a specific unit. Output: (hour)
   * {unit3-5} is a reference to a subset of the units array. Output: (hour|day|week)
   * {unit?} "?" makes that token optional. Output: (day|week|month)?
   *
   * {day} Any reference to tokens in the modifiers array will include all with the same name. Output: (yesterday|today|tomorrow)
   *
   * All spaces are optional and will be converted to "\s*"
   *
   * Locale arrays months, weekdays, units, numbers, as well as the "src" field for
   * all entries in the modifiers array follow a special format indicated by a colon:
   *
   * minute:|s  = minute|minutes
   * thicke:n|r = thicken|thicker
   *
   * Additionally in the months, weekdays, units, and numbers array these will be added at indexes that are multiples
   * of the relevant number for retrieval. For example having "sunday:|s" in the units array will result in:
   *
   * units: ['sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sundays']
   *
   * When matched, the index will be found using:
   *
   * units.indexOf(match) % 7;
   *
   * Resulting in the correct index with any number of alternates for that entry.
   *
   */
  
  Date.addLocale('de', {
    'plural': true,
     'capitalizeUnit': true,
    'months': 'Januar,Februar,März|Marz,April,Mai,Juni,Juli,August,September,Oktober,November,Dezember',
    'weekdays': 'Sonntag,Montag,Dienstag,Mittwoch,Donnerstag,Freitag,Samstag',
    'units': 'Millisekunde:|n,Sekunde:|n,Minute:|n,Stunde:|n,Tag:|en,Woche:|n,Monat:|en,Jahr:|en',
    'numbers': 'ein:|e|er|en|em,zwei,drei,vier,fuenf,sechs,sieben,acht,neun,zehn',
    'tokens': 'der',
    'short':'{d}. {Month} {yyyy}',
    'long': '{d}. {Month} {yyyy} {H}:{mm}',
    'full': '{Weekday} {d}. {Month} {yyyy} {H}:{mm}:{ss}',
    'past': '{sign} {num} {unit}',
    'future': '{sign} {num} {unit}',
    'duration': '{num} {unit}',
    'timeMarker': 'um',
    'ampm': 'am,pm',
    'modifiers': [
      { 'name': 'day', 'src': 'vorgestern', 'value': -2 },
      { 'name': 'day', 'src': 'gestern', 'value': -1 },
      { 'name': 'day', 'src': 'heute', 'value': 0 },
      { 'name': 'day', 'src': 'morgen', 'value': 1 },
      { 'name': 'day', 'src': 'übermorgen|ubermorgen|uebermorgen', 'value': 2 },
      { 'name': 'sign', 'src': 'vor:|her', 'value': -1 },
      { 'name': 'sign', 'src': 'in', 'value': 1 },
      { 'name': 'shift', 'src': 'letzte:|r|n|s', 'value': -1 },
      { 'name': 'shift', 'src': 'nächste:|r|n|s+nachste:|r|n|s+naechste:|r|n|s+kommende:n|r', 'value': 1 }
    ],
    'dateParse': [
      '{sign} {num} {unit}',
      '{num} {unit} {sign}',
      '{shift} {unit=5-7}'
    ],
    'timeParse': [
      '{weekday?} {date?} {month} {year?}',
      '{shift} {weekday}'
    ]
  });
  
  /*
   *
   * Date.addLocale(<code>) adds this locale to Sugar.
   * To set the locale globally, simply call:
   *
   * Date.setLocale('es');
   *
   * var locale = Date.getLocale(<code>) will return this object, which
   * can be tweaked to change the behavior of parsing/formatting in the locales.
   *
   * locale.addFormat adds a date format (see this file for examples).
   * Special tokens in the date format will be parsed out into regex tokens:
   *
   * {0} is a reference to an entry in locale.tokens. Output: (?:the)?
   * {unit} is a reference to all units. Output: (day|week|month|...)
   * {unit3} is a reference to a specific unit. Output: (hour)
   * {unit3-5} is a reference to a subset of the units array. Output: (hour|day|week)
   * {unit?} "?" makes that token optional. Output: (day|week|month)?
   *
   * {day} Any reference to tokens in the modifiers array will include all with the same name. Output: (yesterday|today|tomorrow)
   *
   * All spaces are optional and will be converted to "\s*"
   *
   * Locale arrays months, weekdays, units, numbers, as well as the "src" field for
   * all entries in the modifiers array follow a special format indicated by a colon:
   *
   * minute:|s  = minute|minutes
   * thicke:n|r = thicken|thicker
   *
   * Additionally in the months, weekdays, units, and numbers array these will be added at indexes that are multiples
   * of the relevant number for retrieval. For example having "sunday:|s" in the units array will result in:
   *
   * units: ['sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sundays']
   *
   * When matched, the index will be found using:
   *
   * units.indexOf(match) % 7;
   *
   * Resulting in the correct index with any number of alternates for that entry.
   *
   */
  
  Date.addLocale('es', {
    'plural': true,
    'months': 'enero,febrero,marzo,abril,mayo,junio,julio,agosto,septiembre,octubre,noviembre,diciembre',
    'weekdays': 'domingo,lunes,martes,miércoles|miercoles,jueves,viernes,sábado|sabado',
    'units': 'milisegundo:|s,segundo:|s,minuto:|s,hora:|s,día|días|dia|dias,semana:|s,mes:|es,año|años|ano|anos',
    'numbers': 'uno,dos,tres,cuatro,cinco,seis,siete,ocho,nueve,diez',
    'tokens': 'el,la,de',
    'short':'{d} {month} {yyyy}',
    'long': '{d} {month} {yyyy} {H}:{mm}',
    'full': '{Weekday} {d} {month} {yyyy} {H}:{mm}:{ss}',
    'past': '{sign} {num} {unit}',
    'future': '{sign} {num} {unit}',
    'duration': '{num} {unit}',
    'timeMarker': 'a las',
    'ampm': 'am,pm',
    'modifiers': [
      { 'name': 'day', 'src': 'anteayer', 'value': -2 },
      { 'name': 'day', 'src': 'ayer', 'value': -1 },
      { 'name': 'day', 'src': 'hoy', 'value': 0 },
      { 'name': 'day', 'src': 'mañana|manana', 'value': 1 },
      { 'name': 'sign', 'src': 'hace', 'value': -1 },
      { 'name': 'sign', 'src': 'dentro de', 'value': 1 },
      { 'name': 'shift', 'src': 'pasad:o|a', 'value': -1 },
      { 'name': 'shift', 'src': 'próximo|próxima|proximo|proxima', 'value': 1 }
    ],
    'dateParse': [
      '{sign} {num} {unit}',
      '{num} {unit} {sign}',
      '{0?}{1?} {unit=5-7} {shift}',
      '{0?}{1?} {shift} {unit=5-7}'
    ],
    'timeParse': [
      '{shift} {weekday}',
      '{weekday} {shift}',
      '{date?} {2?} {month} {2?} {year?}'
    ]
  });
  Date.addLocale('fi', {
      'plural':     true,
      'timeMarker': 'kello',
      'ampm':       ',',
      'months':     'tammikuu,helmikuu,maaliskuu,huhtikuu,toukokuu,kesäkuu,heinäkuu,elokuu,syyskuu,lokakuu,marraskuu,joulukuu',
      'weekdays':   'sunnuntai,maanantai,tiistai,keskiviikko,torstai,perjantai,lauantai',
      'units':      'millisekun:ti|tia|teja|tina|nin,sekun:ti|tia|teja|tina|nin,minuut:ti|tia|teja|tina|in,tun:ti|tia|teja|tina|nin,päiv:ä|ää|iä|änä|än,viik:ko|koa|koja|on|kona,kuukau:si|sia|tta|den|tena,vuo:si|sia|tta|den|tena',
      'numbers':    'yksi|ensimmäinen,kaksi|toinen,kolm:e|as,neljä:s,vii:si|des,kuu:si|des,seitsemä:n|s,kahdeksa:n|s,yhdeksä:n|s,kymmene:n|s',
      'articles':   '',
      'optionals':  '',
      'short':      '{d}. {month}ta {yyyy}',
      'long':       '{d}. {month}ta {yyyy} kello {H}.{mm}',
      'full':       '{Weekday}na {d}. {month}ta {yyyy} kello {H}.{mm}',
      'relative':       function(num, unit, ms, format) {
        var units = this['units'];
        function numberWithUnit(mult) {
          return (num === 1 ? '' : num + ' ') + units[(8 * mult) + unit];
        }
        switch(format) {
          case 'duration':  return numberWithUnit(0);
          case 'past':      return numberWithUnit(num > 1 ? 1 : 0) + ' sitten';
          case 'future':    return numberWithUnit(4) + ' päästä';
        }
      },
      'modifiers': [
          { 'name': 'day',   'src': 'toissa päivänä|toissa päiväistä', 'value': -2 },
          { 'name': 'day',   'src': 'eilen|eilistä', 'value': -1 },
          { 'name': 'day',   'src': 'tänään', 'value': 0 },
          { 'name': 'day',   'src': 'huomenna|huomista', 'value': 1 },
          { 'name': 'day',   'src': 'ylihuomenna|ylihuomista', 'value': 2 },
          { 'name': 'sign',  'src': 'sitten|aiemmin', 'value': -1 },
          { 'name': 'sign',  'src': 'päästä|kuluttua|myöhemmin', 'value': 1 },
          { 'name': 'edge',  'src': 'viimeinen|viimeisenä', 'value': -2 },
          { 'name': 'edge',  'src': 'lopussa', 'value': -1 },
          { 'name': 'edge',  'src': 'ensimmäinen|ensimmäisenä', 'value': 1 },
          { 'name': 'shift', 'src': 'edellinen|edellisenä|edeltävä|edeltävänä|viime|toissa', 'value': -1 },
          { 'name': 'shift', 'src': 'tänä|tämän', 'value': 0 },
          { 'name': 'shift', 'src': 'seuraava|seuraavana|tuleva|tulevana|ensi', 'value': 1 }
      ],
      'dateParse': [
          '{num} {unit} {sign}',
          '{sign} {num} {unit}',
          '{num} {unit=4-5} {sign} {day}',
          '{month} {year}',
          '{shift} {unit=5-7}'
      ],
      'timeParse': [
          '{0} {num}{1} {day} of {month} {year?}',
          '{weekday?} {month} {date}{1} {year?}',
          '{date} {month} {year}',
          '{shift} {weekday}',
          '{shift} week {weekday}',
          '{weekday} {2} {shift} week',
          '{0} {date}{1} of {month}',
          '{0}{month?} {date?}{1} of {shift} {unit=6-7}'
      ]
  });
  /*
   *
   * Date.addLocale(<code>) adds this locale to Sugar.
   * To set the locale globally, simply call:
   *
   * Date.setLocale('fr');
   *
   * var locale = Date.getLocale(<code>) will return this object, which
   * can be tweaked to change the behavior of parsing/formatting in the locales.
   *
   * locale.addFormat adds a date format (see this file for examples).
   * Special tokens in the date format will be parsed out into regex tokens:
   *
   * {0} is a reference to an entry in locale.tokens. Output: (?:the)?
   * {unit} is a reference to all units. Output: (day|week|month|...)
   * {unit3} is a reference to a specific unit. Output: (hour)
   * {unit3-5} is a reference to a subset of the units array. Output: (hour|day|week)
   * {unit?} "?" makes that token optional. Output: (day|week|month)?
   *
   * {day} Any reference to tokens in the modifiers array will include all with the same name. Output: (yesterday|today|tomorrow)
   *
   * All spaces are optional and will be converted to "\s*"
   *
   * Locale arrays months, weekdays, units, numbers, as well as the "src" field for
   * all entries in the modifiers array follow a special format indicated by a colon:
   *
   * minute:|s  = minute|minutes
   * thicke:n|r = thicken|thicker
   *
   * Additionally in the months, weekdays, units, and numbers array these will be added at indexes that are multiples
   * of the relevant number for retrieval. For example having "sunday:|s" in the units array will result in:
   *
   * units: ['sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sundays']
   *
   * When matched, the index will be found using:
   *
   * units.indexOf(match) % 7;
   *
   * Resulting in the correct index with any number of alternates for that entry.
   *
   */
  
  Date.addLocale('fr', {
    'plural': true,
    'months': 'janvier,février|fevrier,mars,avril,mai,juin,juillet,août,septembre,octobre,novembre,décembre|decembre',
    'weekdays': 'dimanche,lundi,mardi,mercredi,jeudi,vendredi,samedi',
    'units': 'milliseconde:|s,seconde:|s,minute:|s,heure:|s,jour:|s,semaine:|s,mois,an:|s|née|nee',
    'numbers': 'un:|e,deux,trois,quatre,cinq,six,sept,huit,neuf,dix',
    'tokens': "l'|la|le",
    'short':'{d} {month} {yyyy}',
    'long': '{d} {month} {yyyy} {H}:{mm}',
    'full': '{Weekday} {d} {month} {yyyy} {H}:{mm}:{ss}',
    'past': '{sign} {num} {unit}',
    'future': '{sign} {num} {unit}',
    'duration': '{num} {unit}',
    'timeMarker': 'à',
    'ampm': 'am,pm',
    'modifiers': [
      { 'name': 'day', 'src': 'hier', 'value': -1 },
      { 'name': 'day', 'src': "aujourd'hui", 'value': 0 },
      { 'name': 'day', 'src': 'demain', 'value': 1 },
      { 'name': 'sign', 'src': 'il y a', 'value': -1 },
      { 'name': 'sign', 'src': "dans|d'ici", 'value': 1 },
      { 'name': 'shift', 'src': 'derni:èr|er|ère|ere', 'value': -1 },
      { 'name': 'shift', 'src': 'prochain:|e', 'value': 1 }
    ],
    'dateParse': [
      '{sign} {num} {unit}',
      '{sign} {num} {unit}',
      '{0?} {unit=5-7} {shift}'
    ],
    'timeParse': [
      '{weekday?} {0?} {date?} {month} {year?}',
      '{0?} {weekday} {shift}'
    ]
  });
  
  /*
   *
   * Date.addLocale(<code>) adds this locale to Sugar.
   * To set the locale globally, simply call:
   *
   * Date.setLocale('it');
   *
   * var locale = Date.getLocale(<code>) will return this object, which
   * can be tweaked to change the behavior of parsing/formatting in the locales.
   *
   * locale.addFormat adds a date format (see this file for examples).
   * Special tokens in the date format will be parsed out into regex tokens:
   *
   * {0} is a reference to an entry in locale.tokens. Output: (?:the)?
   * {unit} is a reference to all units. Output: (day|week|month|...)
   * {unit3} is a reference to a specific unit. Output: (hour)
   * {unit3-5} is a reference to a subset of the units array. Output: (hour|day|week)
   * {unit?} "?" makes that token optional. Output: (day|week|month)?
   *
   * {day} Any reference to tokens in the modifiers array will include all with the same name. Output: (yesterday|today|tomorrow)
   *
   * All spaces are optional and will be converted to "\s*"
   *
   * Locale arrays months, weekdays, units, numbers, as well as the "src" field for
   * all entries in the modifiers array follow a special format indicated by a colon:
   *
   * minute:|s  = minute|minutes
   * thicke:n|r = thicken|thicker
   *
   * Additionally in the months, weekdays, units, and numbers array these will be added at indexes that are multiples
   * of the relevant number for retrieval. For example having "sunday:|s" in the units array will result in:
   *
   * units: ['sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sundays']
   *
   * When matched, the index will be found using:
   *
   * units.indexOf(match) % 7;
   *
   * Resulting in the correct index with any number of alternates for that entry.
   *
   */
  
  Date.addLocale('it', {
    'plural': true,
    'months': 'Gennaio,Febbraio,Marzo,Aprile,Maggio,Giugno,Luglio,Agosto,Settembre,Ottobre,Novembre,Dicembre',
    'weekdays': 'Domenica,Luned:ì|i,Marted:ì|i,Mercoled:ì|i,Gioved:ì|i,Venerd:ì|i,Sabato',
    'units': 'millisecond:o|i,second:o|i,minut:o|i,or:a|e,giorn:o|i,settiman:a|e,mes:e|i,ann:o|i',
    'numbers': "un:|a|o|',due,tre,quattro,cinque,sei,sette,otto,nove,dieci",
    'tokens': "l'|la|il",
    'short':'{d} {Month} {yyyy}',
    'long': '{d} {Month} {yyyy} {H}:{mm}',
    'full': '{Weekday} {d} {Month} {yyyy} {H}:{mm}:{ss}',
    'past': '{num} {unit} {sign}',
    'future': '{num} {unit} {sign}',
    'duration': '{num} {unit}',
    'timeMarker': 'alle',
    'ampm': 'am,pm',
    'modifiers': [
      { 'name': 'day', 'src': 'ieri', 'value': -1 },
      { 'name': 'day', 'src': 'oggi', 'value': 0 },
      { 'name': 'day', 'src': 'domani', 'value': 1 },
      { 'name': 'day', 'src': 'dopodomani', 'value': 2 },
      { 'name': 'sign', 'src': 'fa', 'value': -1 },
      { 'name': 'sign', 'src': 'da adesso', 'value': 1 },
      { 'name': 'shift', 'src': 'scors:o|a', 'value': -1 },
      { 'name': 'shift', 'src': 'prossim:o|a', 'value': 1 }
    ],
    'dateParse': [
      '{num} {unit} {sign}',
      '{0?} {unit=5-7} {shift}',
      '{0?} {shift} {unit=5-7}'
    ],
    'timeParse': [
      '{weekday?} {date?} {month} {year?}',
      '{shift} {weekday}'
    ]
  });
  
  /*
   *
   * Date.addLocale(<code>) adds this locale to Sugar.
   * To set the locale globally, simply call:
   *
   * Date.setLocale('ja');
   *
   * var locale = Date.getLocale(<code>) will return this object, which
   * can be tweaked to change the behavior of parsing/formatting in the locales.
   *
   * locale.addFormat adds a date format (see this file for examples).
   * Special tokens in the date format will be parsed out into regex tokens:
   *
   * {0} is a reference to an entry in locale.tokens. Output: (?:the)?
   * {unit} is a reference to all units. Output: (day|week|month|...)
   * {unit3} is a reference to a specific unit. Output: (hour)
   * {unit3-5} is a reference to a subset of the units array. Output: (hour|day|week)
   * {unit?} "?" makes that token optional. Output: (day|week|month)?
   *
   * {day} Any reference to tokens in the modifiers array will include all with the same name. Output: (yesterday|today|tomorrow)
   *
   * All spaces are optional and will be converted to "\s*"
   *
   * Locale arrays months, weekdays, units, numbers, as well as the "src" field for
   * all entries in the modifiers array follow a special format indicated by a colon:
   *
   * minute:|s  = minute|minutes
   * thicke:n|r = thicken|thicker
   *
   * Additionally in the months, weekdays, units, and numbers array these will be added at indexes that are multiples
   * of the relevant number for retrieval. For example having "sunday:|s" in the units array will result in:
   *
   * units: ['sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sundays']
   *
   * When matched, the index will be found using:
   *
   * units.indexOf(match) % 7;
   *
   * Resulting in the correct index with any number of alternates for that entry.
   *
   */
  
  Date.addLocale('ja', {
    'monthSuffix': '月',
    'weekdays': '日曜日,月曜日,火曜日,水曜日,木曜日,金曜日,土曜日',
    'units': 'ミリ秒,秒,分,時間,日,週間|週,ヶ月|ヵ月|月,年',
    'short': '{yyyy}年{M}月{d}日',
    'long': '{yyyy}年{M}月{d}日 {H}時{mm}分',
    'full': '{yyyy}年{M}月{d}日 {Weekday} {H}時{mm}分{ss}秒',
    'past': '{num}{unit}{sign}',
    'future': '{num}{unit}{sign}',
    'duration': '{num}{unit}',
    'timeSuffixes': '時,分,秒',
    'ampm': '午前,午後',
    'modifiers': [
      { 'name': 'day', 'src': '一昨日', 'value': -2 },
      { 'name': 'day', 'src': '昨日', 'value': -1 },
      { 'name': 'day', 'src': '今日', 'value': 0 },
      { 'name': 'day', 'src': '明日', 'value': 1 },
      { 'name': 'day', 'src': '明後日', 'value': 2 },
      { 'name': 'sign', 'src': '前', 'value': -1 },
      { 'name': 'sign', 'src': '後', 'value':  1 },
      { 'name': 'shift', 'src': '去|先', 'value': -1 },
      { 'name': 'shift', 'src': '来', 'value':  1 }
    ],
    'dateParse': [
      '{num}{unit}{sign}'
    ],
    'timeParse': [
      '{shift}{unit=5-7}{weekday?}',
      '{year}年{month?}月?{date?}日?',
      '{month}月{date?}日?',
      '{date}日'
    ]
  });
  
  /*
   *
   * Date.addLocale(<code>) adds this locale to Sugar.
   * To set the locale globally, simply call:
   *
   * Date.setLocale('ko');
   *
   * var locale = Date.getLocale(<code>) will return this object, which
   * can be tweaked to change the behavior of parsing/formatting in the locales.
   *
   * locale.addFormat adds a date format (see this file for examples).
   * Special tokens in the date format will be parsed out into regex tokens:
   *
   * {0} is a reference to an entry in locale.tokens. Output: (?:the)?
   * {unit} is a reference to all units. Output: (day|week|month|...)
   * {unit3} is a reference to a specific unit. Output: (hour)
   * {unit3-5} is a reference to a subset of the units array. Output: (hour|day|week)
   * {unit?} "?" makes that token optional. Output: (day|week|month)?
   *
   * {day} Any reference to tokens in the modifiers array will include all with the same name. Output: (yesterday|today|tomorrow)
   *
   * All spaces are optional and will be converted to "\s*"
   *
   * Locale arrays months, weekdays, units, numbers, as well as the "src" field for
   * all entries in the modifiers array follow a special format indicated by a colon:
   *
   * minute:|s  = minute|minutes
   * thicke:n|r = thicken|thicker
   *
   * Additionally in the months, weekdays, units, and numbers array these will be added at indexes that are multiples
   * of the relevant number for retrieval. For example having "sunday:|s" in the units array will result in:
   *
   * units: ['sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sundays']
   *
   * When matched, the index will be found using:
   *
   * units.indexOf(match) % 7;
   *
   * Resulting in the correct index with any number of alternates for that entry.
   *
   */
  
  Date.addLocale('ko', {
    'digitDate': true,
    'monthSuffix': '월',
    'weekdays': '일요일,월요일,화요일,수요일,목요일,금요일,토요일',
    'units': '밀리초,초,분,시간,일,주,개월|달,년',
    'numbers': '일|한,이,삼,사,오,육,칠,팔,구,십',
    'short': '{yyyy}년{M}월{d}일',
    'long': '{yyyy}년{M}월{d}일 {H}시{mm}분',
    'full': '{yyyy}년{M}월{d}일 {Weekday} {H}시{mm}분{ss}초',
    'past': '{num}{unit} {sign}',
    'future': '{num}{unit} {sign}',
    'duration': '{num}{unit}',
    'timeSuffixes': '시,분,초',
    'ampm': '오전,오후',
    'modifiers': [
      { 'name': 'day', 'src': '그저께', 'value': -2 },
      { 'name': 'day', 'src': '어제', 'value': -1 },
      { 'name': 'day', 'src': '오늘', 'value': 0 },
      { 'name': 'day', 'src': '내일', 'value': 1 },
      { 'name': 'day', 'src': '모레', 'value': 2 },
      { 'name': 'sign', 'src': '전', 'value': -1 },
      { 'name': 'sign', 'src': '후', 'value':  1 },
      { 'name': 'shift', 'src': '지난|작', 'value': -1 },
      { 'name': 'shift', 'src': '이번', 'value': 0 },
      { 'name': 'shift', 'src': '다음|내', 'value': 1 }
    ],
    'dateParse': [
      '{num}{unit} {sign}',
      '{shift?} {unit=5-7}'
    ],
    'timeParse': [
      '{shift} {unit=5?} {weekday}',
      '{year}년{month?}월?{date?}일?',
      '{month}월{date?}일?',
      '{date}일'
    ]
  });
  
  /*
   *
   * Date.addLocale(<code>) adds this locale to Sugar.
   * To set the locale globally, simply call:
   *
   * Date.setLocale('nl');
   *
   * var locale = Date.getLocale(<code>) will return this object, which
   * can be tweaked to change the behavior of parsing/formatting in the locales.
   *
   * locale.addFormat adds a date format (see this file for examples).
   * Special tokens in the date format will be parsed out into regex tokens:
   *
   * {0} is a reference to an entry in locale.tokens. Output: (?:the)?
   * {unit} is a reference to all units. Output: (day|week|month|...)
   * {unit3} is a reference to a specific unit. Output: (hour)
   * {unit3-5} is a reference to a subset of the units array. Output: (hour|day|week)
   * {unit?} "?" makes that token optional. Output: (day|week|month)?
   *
   * {day} Any reference to tokens in the modifiers array will include all with the same name. Output: (yesterday|today|tomorrow)
   *
   * All spaces are optional and will be converted to "\s*"
   *
   * Locale arrays months, weekdays, units, numbers, as well as the "src" field for
   * all entries in the modifiers array follow a special format indicated by a colon:
   *
   * minute:|s  = minute|minutes
   * thicke:n|r = thicken|thicker
   *
   * Additionally in the months, weekdays, units, and numbers array these will be added at indexes that are multiples
   * of the relevant number for retrieval. For example having "sunday:|s" in the units array will result in:
   *
   * units: ['sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sundays']
   *
   * When matched, the index will be found using:
   *
   * units.indexOf(match) % 7;
   *
   * Resulting in the correct index with any number of alternates for that entry.
   *
   */
  
  Date.addLocale('nl', {
    'plural': true,
    'months': 'januari,februari,maart,april,mei,juni,juli,augustus,september,oktober,november,december',
    'weekdays': 'zondag|zo,maandag|ma,dinsdag|di,woensdag|woe|wo,donderdag|do,vrijdag|vrij|vr,zaterdag|za',
    'units': 'milliseconde:|n,seconde:|n,minu:ut|ten,uur,dag:|en,we:ek|ken,maand:|en,jaar',
    'numbers': 'een,twee,drie,vier,vijf,zes,zeven,acht,negen',
    'tokens': '',
    'short':'{d} {Month} {yyyy}',
    'long': '{d} {Month} {yyyy} {H}:{mm}',
    'full': '{Weekday} {d} {Month} {yyyy} {H}:{mm}:{ss}',
    'past': '{num} {unit} {sign}',
    'future': '{num} {unit} {sign}',
    'duration': '{num} {unit}',
    'timeMarker': "'s|om",
    'modifiers': [
      { 'name': 'day', 'src': 'gisteren', 'value': -1 },
      { 'name': 'day', 'src': 'vandaag', 'value': 0 },
      { 'name': 'day', 'src': 'morgen', 'value': 1 },
      { 'name': 'day', 'src': 'overmorgen', 'value': 2 },
      { 'name': 'sign', 'src': 'geleden', 'value': -1 },
      { 'name': 'sign', 'src': 'vanaf nu', 'value': 1 },
      { 'name': 'shift', 'src': 'laatste|vorige|afgelopen', 'value': -1 },
      { 'name': 'shift', 'src': 'volgend:|e', 'value': 1 }
    ],
    'dateParse': [
      '{num} {unit} {sign}',
      '{0?} {unit=5-7} {shift}',
      '{0?} {shift} {unit=5-7}'
    ],
    'timeParse': [
      '{weekday?} {date?} {month} {year?}',
      '{shift} {weekday}'
    ]
  });
  /*
   *
   * Date.addLocale(<code>) adds this locale to Sugar.
   * To set the locale globally, simply call:
   *
   * Date.setLocale('pl');
   *
   * var locale = Date.getLocale(<code>) will return this object, which
   * can be tweaked to change the behavior of parsing/formatting in the locales.
   *
   * locale.addFormat adds a date format (see this file for examples).
   * Special tokens in the date format will be parsed out into regex tokens:
   *
   * {0} is a reference to an entry in locale.optionals. Output: (?:the)?
   * {unit} is a reference to all units. Output: (day|week|month|...)
   * {unit3} is a reference to a specific unit. Output: (hour)
   * {unit3-5} is a reference to a subset of the units array. Output: (hour|day|week)
   * {unit?} "?" makes that token optional. Output: (day|week|month)?
   *
   * {day} Any reference to tokens in the modifiers array will include all with the same name. Output: (yesterday|today|tomorrow)
   *
   * All spaces are optional and will be converted to "\s*"
   *
   * Locale arrays months, weekdays, units, numbers, as well as the "src" field for
   * all entries in the modifiers array follow a special format indicated by a colon:
   *
   * minute:|s  = minute|minutes
   * thicke:n|r = thicken|thicker
   *
   * Additionally in the months, weekdays, units, and numbers array these will be added at indexes that are multiples
   * of the relevant number for retrieval. For example having "sunday:|s" in the units array will result in:
   *
   * units: ['sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sundays']
   *
   * When matched, the index will be found using:
   *
   * units.indexOf(match) % 7;
   *
   * Resulting in the correct index with any number of alternates for that entry.
   *
   */
  
  Date.addLocale('pl', {
    'plural':    true,
    'months':    'Styczeń|Stycznia,Luty|Lutego,Marzec|Marca,Kwiecień|Kwietnia,Maj|Maja,Czerwiec|Czerwca,Lipiec|Lipca,Sierpień|Sierpnia,Wrzesień|Września,Październik|Października,Listopad|Listopada,Grudzień|Grudnia',
    'weekdays':  'Niedziela|Niedzielę,Poniedziałek,Wtorek,Środ:a|ę,Czwartek,Piątek,Sobota|Sobotę',
    'units':     'milisekund:a|y|,sekund:a|y|,minut:a|y|,godzin:a|y|,dzień|dni,tydzień|tygodnie|tygodni,miesiące|miesiące|miesięcy,rok|lata|lat',
    'numbers':   'jeden|jedną,dwa|dwie,trzy,cztery,pięć,sześć,siedem,osiem,dziewięć,dziesięć',
    'optionals': 'w|we,roku',
    'short':     '{d} {Month} {yyyy}',
    'long':      '{d} {Month} {yyyy} {H}:{mm}',
    'full' :     '{Weekday}, {d} {Month} {yyyy} {H}:{mm}:{ss}',
    'past':      '{num} {unit} {sign}',
    'future':    '{sign} {num} {unit}',
    'duration':  '{num} {unit}',
    'timeMarker':'o',
    'ampm':      'am,pm',
    'modifiers': [
      { 'name': 'day', 'src': 'przedwczoraj', 'value': -2 },
      { 'name': 'day', 'src': 'wczoraj', 'value': -1 },
      { 'name': 'day', 'src': 'dzisiaj|dziś', 'value': 0 },
      { 'name': 'day', 'src': 'jutro', 'value': 1 },
      { 'name': 'day', 'src': 'pojutrze', 'value': 2 },
      { 'name': 'sign', 'src': 'temu|przed', 'value': -1 },
      { 'name': 'sign', 'src': 'za', 'value': 1 },
      { 'name': 'shift', 'src': 'zeszły|zeszła|ostatni|ostatnia', 'value': -1 },
      { 'name': 'shift', 'src': 'następny|następna|następnego|przyszły|przyszła|przyszłego', 'value': 1 }
    ],
    'dateParse': [
      '{num} {unit} {sign}',
      '{sign} {num} {unit}',
      '{month} {year}',
      '{shift} {unit=5-7}',
      '{0} {shift?} {weekday}'
    ],
    'timeParse': [
      '{date} {month} {year?} {1}',
      '{0} {shift?} {weekday}'
    ]
  });
  
  /*
   *
   * Date.addLocale(<code>) adds this locale to Sugar.
   * To set the locale globally, simply call:
   *
   * Date.setLocale('pt');
   *
   * var locale = Date.getLocale(<code>) will return this object, which
   * can be tweaked to change the behavior of parsing/formatting in the locales.
   *
   * locale.addFormat adds a date format (see this file for examples).
   * Special tokens in the date format will be parsed out into regex tokens:
   *
   * {0} is a reference to an entry in locale.tokens. Output: (?:the)?
   * {unit} is a reference to all units. Output: (day|week|month|...)
   * {unit3} is a reference to a specific unit. Output: (hour)
   * {unit3-5} is a reference to a subset of the units array. Output: (hour|day|week)
   * {unit?} "?" makes that token optional. Output: (day|week|month)?
   *
   * {day} Any reference to tokens in the modifiers array will include all with the same name. Output: (yesterday|today|tomorrow)
   *
   * All spaces are optional and will be converted to "\s*"
   *
   * Locale arrays months, weekdays, units, numbers, as well as the "src" field for
   * all entries in the modifiers array follow a special format indicated by a colon:
   *
   * minute:|s  = minute|minutes
   * thicke:n|r = thicken|thicker
   *
   * Additionally in the months, weekdays, units, and numbers array these will be added at indexes that are multiples
   * of the relevant number for retrieval. For example having "sunday:|s" in the units array will result in:
   *
   * units: ['sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sundays']
   *
   * When matched, the index will be found using:
   *
   * units.indexOf(match) % 7;
   *
   * Resulting in the correct index with any number of alternates for that entry.
   *
   */
  
  Date.addLocale('pt', {
    'plural': true,
    'months': 'janeiro,fevereiro,março,abril,maio,junho,julho,agosto,setembro,outubro,novembro,dezembro',
    'weekdays': 'domingo,segunda-feira,terça-feira,quarta-feira,quinta-feira,sexta-feira,sábado|sabado',
    'units': 'milisegundo:|s,segundo:|s,minuto:|s,hora:|s,dia:|s,semana:|s,mês|mêses|mes|meses,ano:|s',
    'numbers': 'um,dois,três|tres,quatro,cinco,seis,sete,oito,nove,dez,uma,duas',
    'tokens': 'a,de',
    'short':'{d} de {month} de {yyyy}',
    'long': '{d} de {month} de {yyyy} {H}:{mm}',
    'full': '{Weekday}, {d} de {month} de {yyyy} {H}:{mm}:{ss}',
    'past': '{num} {unit} {sign}',
    'future': '{sign} {num} {unit}',
    'duration': '{num} {unit}',
    'timeMarker': 'às',
    'ampm': 'am,pm',
    'modifiers': [
      { 'name': 'day', 'src': 'anteontem', 'value': -2 },
      { 'name': 'day', 'src': 'ontem', 'value': -1 },
      { 'name': 'day', 'src': 'hoje', 'value': 0 },
      { 'name': 'day', 'src': 'amanh:ã|a', 'value': 1 },
      { 'name': 'sign', 'src': 'atrás|atras|há|ha', 'value': -1 },
      { 'name': 'sign', 'src': 'daqui a', 'value': 1 },
      { 'name': 'shift', 'src': 'passad:o|a', 'value': -1 },
      { 'name': 'shift', 'src': 'próximo|próxima|proximo|proxima', 'value': 1 }
    ],
    'dateParse': [
      '{num} {unit} {sign}',
      '{sign} {num} {unit}',
      '{0?} {unit=5-7} {shift}',
      '{0?} {shift} {unit=5-7}'
    ],
    'timeParse': [
      '{date?} {1?} {month} {1?} {year?}',
      '{0?} {shift} {weekday}'
    ]
  });
  
  /*
   *
   * Date.addLocale(<code>) adds this locale to Sugar.
   * To set the locale globally, simply call:
   *
   * Date.setLocale('ru');
   *
   * var locale = Date.getLocale(<code>) will return this object, which
   * can be tweaked to change the behavior of parsing/formatting in the locales.
   *
   * locale.addFormat adds a date format (see this file for examples).
   * Special tokens in the date format will be parsed out into regex tokens:
   *
   * {0} is a reference to an entry in locale.tokens. Output: (?:the)?
   * {unit} is a reference to all units. Output: (day|week|month|...)
   * {unit3} is a reference to a specific unit. Output: (hour)
   * {unit3-5} is a reference to a subset of the units array. Output: (hour|day|week)
   * {unit?} "?" makes that token optional. Output: (day|week|month)?
   *
   * {day} Any reference to tokens in the modifiers array will include all with the same name. Output: (yesterday|today|tomorrow)
   *
   * All spaces are optional and will be converted to "\s*"
   *
   * Locale arrays months, weekdays, units, numbers, as well as the "src" field for
   * all entries in the modifiers array follow a special format indicated by a colon:
   *
   * minute:|s  = minute|minutes
   * thicke:n|r = thicken|thicker
   *
   * Additionally in the months, weekdays, units, and numbers array these will be added at indexes that are multiples
   * of the relevant number for retrieval. For example having "sunday:|s" in the units array will result in:
   *
   * units: ['sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sundays']
   *
   * When matched, the index will be found using:
   *
   * units.indexOf(match) % 7;
   *
   * Resulting in the correct index with any number of alternates for that entry.
   *
   */
  
  Date.addLocale('ru', {
    'months': 'Январ:я|ь,Феврал:я|ь,Март:а|,Апрел:я|ь,Ма:я|й,Июн:я|ь,Июл:я|ь,Август:а|,Сентябр:я|ь,Октябр:я|ь,Ноябр:я|ь,Декабр:я|ь',
    'weekdays': 'Воскресенье,Понедельник,Вторник,Среда,Четверг,Пятница,Суббота',
    'units': 'миллисекунд:а|у|ы|,секунд:а|у|ы|,минут:а|у|ы|,час:||а|ов,день|день|дня|дней,недел:я|ю|и|ь|е,месяц:||а|ев|е,год|год|года|лет|году',
    'numbers': 'од:ин|ну,дв:а|е,три,четыре,пять,шесть,семь,восемь,девять,десять',
    'tokens': 'в|на,года',
    'short':'{d} {month} {yyyy} года',
    'long': '{d} {month} {yyyy} года {H}:{mm}',
    'full': '{Weekday} {d} {month} {yyyy} года {H}:{mm}:{ss}',
    'relative': function(num, unit, ms, format) {
      var numberWithUnit, last = num.toString().slice(-1), mult;
      switch(true) {
        case num >= 11 && num <= 15: mult = 3; break;
        case last == 1: mult = 1; break;
        case last >= 2 && last <= 4: mult = 2; break;
        default: mult = 3;
      }
      numberWithUnit = num + ' ' + this['units'][(mult * 8) + unit];
      switch(format) {
        case 'duration':  return numberWithUnit;
        case 'past':      return numberWithUnit + ' назад';
        case 'future':    return 'через ' + numberWithUnit;
      }
    },
    'timeMarker': 'в',
    'ampm': ' утра, вечера',
    'modifiers': [
      { 'name': 'day', 'src': 'позавчера', 'value': -2 },
      { 'name': 'day', 'src': 'вчера', 'value': -1 },
      { 'name': 'day', 'src': 'сегодня', 'value': 0 },
      { 'name': 'day', 'src': 'завтра', 'value': 1 },
      { 'name': 'day', 'src': 'послезавтра', 'value': 2 },
      { 'name': 'sign', 'src': 'назад', 'value': -1 },
      { 'name': 'sign', 'src': 'через', 'value': 1 },
      { 'name': 'shift', 'src': 'прошл:ый|ой|ом', 'value': -1 },
      { 'name': 'shift', 'src': 'следующ:ий|ей|ем', 'value': 1 }
    ],
    'dateParse': [
      '{num} {unit} {sign}',
      '{sign} {num} {unit}',
      '{month} {year}',
      '{0?} {shift} {unit=5-7}'
    ],
    'timeParse': [
      '{date} {month} {year?} {1?}',
      '{0?} {shift} {weekday}'
    ]
  });
  
  /*
   *
   * Date.addLocale(<code>) adds this locale to Sugar.
   * To set the locale globally, simply call:
   *
   * Date.setLocale('sv');
   *
   * var locale = Date.getLocale(<code>) will return this object, which
   * can be tweaked to change the behavior of parsing/formatting in the locales.
   *
   * locale.addFormat adds a date format (see this file for examples).
   * Special tokens in the date format will be parsed out into regex tokens:
   *
   * {0} is a reference to an entry in locale.tokens. Output: (?:the)?
   * {unit} is a reference to all units. Output: (day|week|month|...)
   * {unit3} is a reference to a specific unit. Output: (hour)
   * {unit3-5} is a reference to a subset of the units array. Output: (hour|day|week)
   * {unit?} "?" makes that token optional. Output: (day|week|month)?
   *
   * {day} Any reference to tokens in the modifiers array will include all with the same name. Output: (yesterday|today|tomorrow)
   *
   * All spaces are optional and will be converted to "\s*"
   *
   * Locale arrays months, weekdays, units, numbers, as well as the "src" field for
   * all entries in the modifiers array follow a special format indicated by a colon:
   *
   * minute:|s  = minute|minutes
   * thicke:n|r = thicken|thicker
   *
   * Additionally in the months, weekdays, units, and numbers array these will be added at indexes that are multiples
   * of the relevant number for retrieval. For example having "sunday:|s" in the units array will result in:
   *
   * units: ['sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sundays']
   *
   * When matched, the index will be found using:
   *
   * units.indexOf(match) % 7;
   *
   * Resulting in the correct index with any number of alternates for that entry.
   *
   */
  
  Date.addLocale('sv', {
    'plural': true,
    'months': 'januari,februari,mars,april,maj,juni,juli,augusti,september,oktober,november,december',
    'weekdays': 'söndag|sondag,måndag:|en+mandag:|en,tisdag,onsdag,torsdag,fredag,lördag|lordag',
    'units': 'millisekund:|er,sekund:|er,minut:|er,timm:e|ar,dag:|ar,veck:a|or|an,månad:|er|en+manad:|er|en,år:||et+ar:||et',
    'numbers': 'en|ett,två|tva,tre,fyra,fem,sex,sju,åtta|atta,nio,tio',
    'tokens': 'den,för|for',
    'articles': 'den',
    'short':'den {d} {month} {yyyy}',
    'long': 'den {d} {month} {yyyy} {H}:{mm}',
    'full': '{Weekday} den {d} {month} {yyyy} {H}:{mm}:{ss}',
    'past': '{num} {unit} {sign}',
    'future': '{sign} {num} {unit}',
    'duration': '{num} {unit}',
    'ampm': 'am,pm',
    'modifiers': [
      { 'name': 'day', 'src': 'förrgår|i förrgår|iförrgår|forrgar|i forrgar|iforrgar', 'value': -2 },
      { 'name': 'day', 'src': 'går|i går|igår|gar|i gar|igar', 'value': -1 },
      { 'name': 'day', 'src': 'dag|i dag|idag', 'value': 0 },
      { 'name': 'day', 'src': 'morgon|i morgon|imorgon', 'value': 1 },
      { 'name': 'day', 'src': 'över morgon|övermorgon|i över morgon|i övermorgon|iövermorgon|over morgon|overmorgon|i over morgon|i overmorgon|iovermorgon', 'value': 2 },
      { 'name': 'sign', 'src': 'sedan|sen', 'value': -1 },
      { 'name': 'sign', 'src': 'om', 'value':  1 },
      { 'name': 'shift', 'src': 'i förra|förra|i forra|forra', 'value': -1 },
      { 'name': 'shift', 'src': 'denna', 'value': 0 },
      { 'name': 'shift', 'src': 'nästa|nasta', 'value': 1 }
    ],
    'dateParse': [
      '{num} {unit} {sign}',
      '{sign} {num} {unit}',
      '{1?} {num} {unit} {sign}',
      '{shift} {unit=5-7}'
    ],
    'timeParse': [
      '{0?} {weekday?} {date?} {month} {year}',
      '{date} {month}',
      '{shift} {weekday}'
    ]
  });
  
  /*
   *
   * Date.addLocale(<code>) adds this locale to Sugar.
   * To set the locale globally, simply call:
   *
   * Date.setLocale('zh-CN');
   *
   * var locale = Date.getLocale(<code>) will return this object, which
   * can be tweaked to change the behavior of parsing/formatting in the locales.
   *
   * locale.addFormat adds a date format (see this file for examples).
   * Special tokens in the date format will be parsed out into regex tokens:
   *
   * {0} is a reference to an entry in locale.tokens. Output: (?:the)?
   * {unit} is a reference to all units. Output: (day|week|month|...)
   * {unit3} is a reference to a specific unit. Output: (hour)
   * {unit3-5} is a reference to a subset of the units array. Output: (hour|day|week)
   * {unit?} "?" makes that token optional. Output: (day|week|month)?
   *
   * {day} Any reference to tokens in the modifiers array will include all with the same name. Output: (yesterday|today|tomorrow)
   *
   * All spaces are optional and will be converted to "\s*"
   *
   * Locale arrays months, weekdays, units, numbers, as well as the "src" field for
   * all entries in the modifiers array follow a special format indicated by a colon:
   *
   * minute:|s  = minute|minutes
   * thicke:n|r = thicken|thicker
   *
   * Additionally in the months, weekdays, units, and numbers array these will be added at indexes that are multiples
   * of the relevant number for retrieval. For example having "sunday:|s" in the units array will result in:
   *
   * units: ['sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sundays']
   *
   * When matched, the index will be found using:
   *
   * units.indexOf(match) % 7;
   *
   * Resulting in the correct index with any number of alternates for that entry.
   *
   */
  
  Date.addLocale('zh-CN', {
    'variant': true,
    'monthSuffix': '月',
    'weekdays': '星期日|周日,星期一|周一,星期二|周二,星期三|周三,星期四|周四,星期五|周五,星期六|周六',
    'units': '毫秒,秒钟,分钟,小时,天,个星期|周,个月,年',
    'tokens': '日|号',
    'short':'{yyyy}年{M}月{d}日',
    'long': '{yyyy}年{M}月{d}日 {tt}{h}:{mm}',
    'full': '{yyyy}年{M}月{d}日 {weekday} {tt}{h}:{mm}:{ss}',
    'past': '{num}{unit}{sign}',
    'future': '{num}{unit}{sign}',
    'duration': '{num}{unit}',
    'timeSuffixes': '点|时,分钟?,秒',
    'ampm': '上午,下午',
    'modifiers': [
      { 'name': 'day', 'src': '前天', 'value': -2 },
      { 'name': 'day', 'src': '昨天', 'value': -1 },
      { 'name': 'day', 'src': '今天', 'value': 0 },
      { 'name': 'day', 'src': '明天', 'value': 1 },
      { 'name': 'day', 'src': '后天', 'value': 2 },
      { 'name': 'sign', 'src': '前', 'value': -1 },
      { 'name': 'sign', 'src': '后', 'value':  1 },
      { 'name': 'shift', 'src': '上|去', 'value': -1 },
      { 'name': 'shift', 'src': '这', 'value':  0 },
      { 'name': 'shift', 'src': '下|明', 'value':  1 }
    ],
    'dateParse': [
      '{num}{unit}{sign}',
      '{shift}{unit=5-7}'
    ],
    'timeParse': [
      '{shift}{weekday}',
      '{year}年{month?}月?{date?}{0?}',
      '{month}月{date?}{0?}',
      '{date}[日号]'
    ]
  });
  
  /*
   *
   * Date.addLocale(<code>) adds this locale to Sugar.
   * To set the locale globally, simply call:
   *
   * Date.setLocale('zh-TW');
   *
   * var locale = Date.getLocale(<code>) will return this object, which
   * can be tweaked to change the behavior of parsing/formatting in the locales.
   *
   * locale.addFormat adds a date format (see this file for examples).
   * Special tokens in the date format will be parsed out into regex tokens:
   *
   * {0} is a reference to an entry in locale.tokens. Output: (?:the)?
   * {unit} is a reference to all units. Output: (day|week|month|...)
   * {unit3} is a reference to a specific unit. Output: (hour)
   * {unit3-5} is a reference to a subset of the units array. Output: (hour|day|week)
   * {unit?} "?" makes that token optional. Output: (day|week|month)?
   *
   * {day} Any reference to tokens in the modifiers array will include all with the same name. Output: (yesterday|today|tomorrow)
   *
   * All spaces are optional and will be converted to "\s*"
   *
   * Locale arrays months, weekdays, units, numbers, as well as the "src" field for
   * all entries in the modifiers array follow a special format indicated by a colon:
   *
   * minute:|s  = minute|minutes
   * thicke:n|r = thicken|thicker
   *
   * Additionally in the months, weekdays, units, and numbers array these will be added at indexes that are multiples
   * of the relevant number for retrieval. For example having "sunday:|s" in the units array will result in:
   *
   * units: ['sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sundays']
   *
   * When matched, the index will be found using:
   *
   * units.indexOf(match) % 7;
   *
   * Resulting in the correct index with any number of alternates for that entry.
   *
   */
  
    //'zh-TW': '1;月;年;;星期日|週日,星期一|週一,星期二|週二,星期三|週三,星期四|週四,星期五|週五,星期六|週六;毫秒,秒鐘,分鐘,小時,天,個星期|週,個月,年;;;日|號;;上午,下午;點|時,分鐘?,秒;{num}{unit}{sign},{shift}{unit=5-7};{shift}{weekday},{year}年{month?}月?{date?}{0},{month}月{date?}{0},{date}{0};{yyyy}年{M}月{d}日 {Weekday};{tt}{h}:{mm}:{ss};前天,昨天,今天,明天,後天;,前,,後;,上|去,這,下|明',
  
  Date.addLocale('zh-TW', {
    'monthSuffix': '月',
    'weekdays': '星期日|週日,星期一|週一,星期二|週二,星期三|週三,星期四|週四,星期五|週五,星期六|週六',
    'units': '毫秒,秒鐘,分鐘,小時,天,個星期|週,個月,年',
    'tokens': '日|號',
    'short':'{yyyy}年{M}月{d}日',
    'long': '{yyyy}年{M}月{d}日 {tt}{h}:{mm}',
    'full': '{yyyy}年{M}月{d}日 {Weekday} {tt}{h}:{mm}:{ss}',
    'past': '{num}{unit}{sign}',
    'future': '{num}{unit}{sign}',
    'duration': '{num}{unit}',
    'timeSuffixes': '點|時,分鐘?,秒',
    'ampm': '上午,下午',
    'modifiers': [
      { 'name': 'day', 'src': '前天', 'value': -2 },
      { 'name': 'day', 'src': '昨天', 'value': -1 },
      { 'name': 'day', 'src': '今天', 'value': 0 },
      { 'name': 'day', 'src': '明天', 'value': 1 },
      { 'name': 'day', 'src': '後天', 'value': 2 },
      { 'name': 'sign', 'src': '前', 'value': -1 },
      { 'name': 'sign', 'src': '後', 'value': 1 },
      { 'name': 'shift', 'src': '上|去', 'value': -1 },
      { 'name': 'shift', 'src': '這', 'value':  0 },
      { 'name': 'shift', 'src': '下|明', 'value':  1 }
    ],
    'dateParse': [
      '{num}{unit}{sign}',
      '{shift}{unit=5-7}'
    ],
    'timeParse': [
      '{shift}{weekday}',
      '{year}年{month?}月?{date?}{0?}',
      '{month}月{date?}{0?}',
      '{date}[日號]'
    ]
  });
  
  
  }).call(this);
  
  }).call(this,typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
  },{}],12:[function(require,module,exports){
  //     Underscore.js 1.6.0
  //     http://underscorejs.org
  //     (c) 2009-2014 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
  //     Underscore may be freely distributed under the MIT license.
  
  (function() {
  
    // Baseline setup
    // --------------
  
    // Establish the root object, `window` in the browser, or `exports` on the server.
    var root = this;
  
    // Save the previous value of the `_` variable.
    var previousUnderscore = root._;
  
    // Establish the object that gets returned to break out of a loop iteration.
    var breaker = {};
  
    // Save bytes in the minified (but not gzipped) version:
    var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype;
  
    // Create quick reference variables for speed access to core prototypes.
    var
      push             = ArrayProto.push,
      slice            = ArrayProto.slice,
      concat           = ArrayProto.concat,
      toString         = ObjProto.toString,
      hasOwnProperty   = ObjProto.hasOwnProperty;
  
    // All **ECMAScript 5** native function implementations that we hope to use
    // are declared here.
    var
      nativeForEach      = ArrayProto.forEach,
      nativeMap          = ArrayProto.map,
      nativeReduce       = ArrayProto.reduce,
      nativeReduceRight  = ArrayProto.reduceRight,
      nativeFilter       = ArrayProto.filter,
      nativeEvery        = ArrayProto.every,
      nativeSome         = ArrayProto.some,
      nativeIndexOf      = ArrayProto.indexOf,
      nativeLastIndexOf  = ArrayProto.lastIndexOf,
      nativeIsArray      = Array.isArray,
      nativeKeys         = Object.keys,
      nativeBind         = FuncProto.bind;
  
    // Create a safe reference to the Underscore object for use below.
    var _ = function(obj) {
      if (obj instanceof _) return obj;
      if (!(this instanceof _)) return new _(obj);
      this._wrapped = obj;
    };
  
    // Export the Underscore object for **Node.js**, with
    // backwards-compatibility for the old `require()` API. If we're in
    // the browser, add `_` as a global object via a string identifier,
    // for Closure Compiler "advanced" mode.
    if (typeof exports !== 'undefined') {
      if (typeof module !== 'undefined' && module.exports) {
        exports = module.exports = _;
      }
      exports._ = _;
    } else {
      root._ = _;
    }
  
    // Current version.
    _.VERSION = '1.6.0';
  
    // Collection Functions
    // --------------------
  
    // The cornerstone, an `each` implementation, aka `forEach`.
    // Handles objects with the built-in `forEach`, arrays, and raw objects.
    // Delegates to **ECMAScript 5**'s native `forEach` if available.
    var each = _.each = _.forEach = function(obj, iterator, context) {
      if (obj == null) return obj;
      if (nativeForEach && obj.forEach === nativeForEach) {
        obj.forEach(iterator, context);
      } else if (obj.length === +obj.length) {
        for (var i = 0, length = obj.length; i < length; i++) {
          if (iterator.call(context, obj[i], i, obj) === breaker) return;
        }
      } else {
        var keys = _.keys(obj);
        for (var i = 0, length = keys.length; i < length; i++) {
          if (iterator.call(context, obj[keys[i]], keys[i], obj) === breaker) return;
        }
      }
      return obj;
    };
  
    // Return the results of applying the iterator to each element.
    // Delegates to **ECMAScript 5**'s native `map` if available.
    _.map = _.collect = function(obj, iterator, context) {
      var results = [];
      if (obj == null) return results;
      if (nativeMap && obj.map === nativeMap) return obj.map(iterator, context);
      each(obj, function(value, index, list) {
        results.push(iterator.call(context, value, index, list));
      });
      return results;
    };
  
    var reduceError = 'Reduce of empty array with no initial value';
  
    // **Reduce** builds up a single result from a list of values, aka `inject`,
    // or `foldl`. Delegates to **ECMAScript 5**'s native `reduce` if available.
    _.reduce = _.foldl = _.inject = function(obj, iterator, memo, context) {
      var initial = arguments.length > 2;
      if (obj == null) obj = [];
      if (nativeReduce && obj.reduce === nativeReduce) {
        if (context) iterator = _.bind(iterator, context);
        return initial ? obj.reduce(iterator, memo) : obj.reduce(iterator);
      }
      each(obj, function(value, index, list) {
        if (!initial) {
          memo = value;
          initial = true;
        } else {
          memo = iterator.call(context, memo, value, index, list);
        }
      });
      if (!initial) throw new TypeError(reduceError);
      return memo;
    };
  
    // The right-associative version of reduce, also known as `foldr`.
    // Delegates to **ECMAScript 5**'s native `reduceRight` if available.
    _.reduceRight = _.foldr = function(obj, iterator, memo, context) {
      var initial = arguments.length > 2;
      if (obj == null) obj = [];
      if (nativeReduceRight && obj.reduceRight === nativeReduceRight) {
        if (context) iterator = _.bind(iterator, context);
        return initial ? obj.reduceRight(iterator, memo) : obj.reduceRight(iterator);
      }
      var length = obj.length;
      if (length !== +length) {
        var keys = _.keys(obj);
        length = keys.length;
      }
      each(obj, function(value, index, list) {
        index = keys ? keys[--length] : --length;
        if (!initial) {
          memo = obj[index];
          initial = true;
        } else {
          memo = iterator.call(context, memo, obj[index], index, list);
        }
      });
      if (!initial) throw new TypeError(reduceError);
      return memo;
    };
  
    // Return the first value which passes a truth test. Aliased as `detect`.
    _.find = _.detect = function(obj, predicate, context) {
      var result;
      any(obj, function(value, index, list) {
        if (predicate.call(context, value, index, list)) {
          result = value;
          return true;
        }
      });
      return result;
    };
  
    // Return all the elements that pass a truth test.
    // Delegates to **ECMAScript 5**'s native `filter` if available.
    // Aliased as `select`.
    _.filter = _.select = function(obj, predicate, context) {
      var results = [];
      if (obj == null) return results;
      if (nativeFilter && obj.filter === nativeFilter) return obj.filter(predicate, context);
      each(obj, function(value, index, list) {
        if (predicate.call(context, value, index, list)) results.push(value);
      });
      return results;
    };
  
    // Return all the elements for which a truth test fails.
    _.reject = function(obj, predicate, context) {
      return _.filter(obj, function(value, index, list) {
        return !predicate.call(context, value, index, list);
      }, context);
    };
  
    // Determine whether all of the elements match a truth test.
    // Delegates to **ECMAScript 5**'s native `every` if available.
    // Aliased as `all`.
    _.every = _.all = function(obj, predicate, context) {
      predicate || (predicate = _.identity);
      var result = true;
      if (obj == null) return result;
      if (nativeEvery && obj.every === nativeEvery) return obj.every(predicate, context);
      each(obj, function(value, index, list) {
        if (!(result = result && predicate.call(context, value, index, list))) return breaker;
      });
      return !!result;
    };
  
    // Determine if at least one element in the object matches a truth test.
    // Delegates to **ECMAScript 5**'s native `some` if available.
    // Aliased as `any`.
    var any = _.some = _.any = function(obj, predicate, context) {
      predicate || (predicate = _.identity);
      var result = false;
      if (obj == null) return result;
      if (nativeSome && obj.some === nativeSome) return obj.some(predicate, context);
      each(obj, function(value, index, list) {
        if (result || (result = predicate.call(context, value, index, list))) return breaker;
      });
      return !!result;
    };
  
    // Determine if the array or object contains a given value (using `===`).
    // Aliased as `include`.
    _.contains = _.include = function(obj, target) {
      if (obj == null) return false;
      if (nativeIndexOf && obj.indexOf === nativeIndexOf) return obj.indexOf(target) != -1;
      return any(obj, function(value) {
        return value === target;
      });
    };
  
    // Invoke a method (with arguments) on every item in a collection.
    _.invoke = function(obj, method) {
      var args = slice.call(arguments, 2);
      var isFunc = _.isFunction(method);
      return _.map(obj, function(value) {
        return (isFunc ? method : value[method]).apply(value, args);
      });
    };
  
    // Convenience version of a common use case of `map`: fetching a property.
    _.pluck = function(obj, key) {
      return _.map(obj, _.property(key));
    };
  
    // Convenience version of a common use case of `filter`: selecting only objects
    // containing specific `key:value` pairs.
    _.where = function(obj, attrs) {
      return _.filter(obj, _.matches(attrs));
    };
  
    // Convenience version of a common use case of `find`: getting the first object
    // containing specific `key:value` pairs.
    _.findWhere = function(obj, attrs) {
      return _.find(obj, _.matches(attrs));
    };
  
    // Return the maximum element or (element-based computation).
    // Can't optimize arrays of integers longer than 65,535 elements.
    // See [WebKit Bug 80797](https://bugs.webkit.org/show_bug.cgi?id=80797)
    _.max = function(obj, iterator, context) {
      if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) {
        return Math.max.apply(Math, obj);
      }
      var result = -Infinity, lastComputed = -Infinity;
      each(obj, function(value, index, list) {
        var computed = iterator ? iterator.call(context, value, index, list) : value;
        if (computed > lastComputed) {
          result = value;
          lastComputed = computed;
        }
      });
      return result;
    };
  
    // Return the minimum element (or element-based computation).
    _.min = function(obj, iterator, context) {
      if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) {
        return Math.min.apply(Math, obj);
      }
      var result = Infinity, lastComputed = Infinity;
      each(obj, function(value, index, list) {
        var computed = iterator ? iterator.call(context, value, index, list) : value;
        if (computed < lastComputed) {
          result = value;
          lastComputed = computed;
        }
      });
      return result;
    };
  
    // Shuffle an array, using the modern version of the
    // [Fisher-Yates shuffle](http://en.wikipedia.org/wiki/Fisher–Yates_shuffle).
    _.shuffle = function(obj) {
      var rand;
      var index = 0;
      var shuffled = [];
      each(obj, function(value) {
        rand = _.random(index++);
        shuffled[index - 1] = shuffled[rand];
        shuffled[rand] = value;
      });
      return shuffled;
    };
  
    // Sample **n** random values from a collection.
    // If **n** is not specified, returns a single random element.
    // The internal `guard` argument allows it to work with `map`.
    _.sample = function(obj, n, guard) {
      if (n == null || guard) {
        if (obj.length !== +obj.length) obj = _.values(obj);
        return obj[_.random(obj.length - 1)];
      }
      return _.shuffle(obj).slice(0, Math.max(0, n));
    };
  
    // An internal function to generate lookup iterators.
    var lookupIterator = function(value) {
      if (value == null) return _.identity;
      if (_.isFunction(value)) return value;
      return _.property(value);
    };
  
    // Sort the object's values by a criterion produced by an iterator.
    _.sortBy = function(obj, iterator, context) {
      iterator = lookupIterator(iterator);
      return _.pluck(_.map(obj, function(value, index, list) {
        return {
          value: value,
          index: index,
          criteria: iterator.call(context, value, index, list)
        };
      }).sort(function(left, right) {
        var a = left.criteria;
        var b = right.criteria;
        if (a !== b) {
          if (a > b || a === void 0) return 1;
          if (a < b || b === void 0) return -1;
        }
        return left.index - right.index;
      }), 'value');
    };
  
    // An internal function used for aggregate "group by" operations.
    var group = function(behavior) {
      return function(obj, iterator, context) {
        var result = {};
        iterator = lookupIterator(iterator);
        each(obj, function(value, index) {
          var key = iterator.call(context, value, index, obj);
          behavior(result, key, value);
        });
        return result;
      };
    };
  
    // Groups the object's values by a criterion. Pass either a string attribute
    // to group by, or a function that returns the criterion.
    _.groupBy = group(function(result, key, value) {
      _.has(result, key) ? result[key].push(value) : result[key] = [value];
    });
  
    // Indexes the object's values by a criterion, similar to `groupBy`, but for
    // when you know that your index values will be unique.
    _.indexBy = group(function(result, key, value) {
      result[key] = value;
    });
  
    // Counts instances of an object that group by a certain criterion. Pass
    // either a string attribute to count by, or a function that returns the
    // criterion.
    _.countBy = group(function(result, key) {
      _.has(result, key) ? result[key]++ : result[key] = 1;
    });
  
    // Use a comparator function to figure out the smallest index at which
    // an object should be inserted so as to maintain order. Uses binary search.
    _.sortedIndex = function(array, obj, iterator, context) {
      iterator = lookupIterator(iterator);
      var value = iterator.call(context, obj);
      var low = 0, high = array.length;
      while (low < high) {
        var mid = (low + high) >>> 1;
        iterator.call(context, array[mid]) < value ? low = mid + 1 : high = mid;
      }
      return low;
    };
  
    // Safely create a real, live array from anything iterable.
    _.toArray = function(obj) {
      if (!obj) return [];
      if (_.isArray(obj)) return slice.call(obj);
      if (obj.length === +obj.length) return _.map(obj, _.identity);
      return _.values(obj);
    };
  
    // Return the number of elements in an object.
    _.size = function(obj) {
      if (obj == null) return 0;
      return (obj.length === +obj.length) ? obj.length : _.keys(obj).length;
    };
  
    // Array Functions
    // ---------------
  
    // Get the first element of an array. Passing **n** will return the first N
    // values in the array. Aliased as `head` and `take`. The **guard** check
    // allows it to work with `_.map`.
    _.first = _.head = _.take = function(array, n, guard) {
      if (array == null) return void 0;
      if ((n == null) || guard) return array[0];
      if (n < 0) return [];
      return slice.call(array, 0, n);
    };
  
    // Returns everything but the last entry of the array. Especially useful on
    // the arguments object. Passing **n** will return all the values in
    // the array, excluding the last N. The **guard** check allows it to work with
    // `_.map`.
    _.initial = function(array, n, guard) {
      return slice.call(array, 0, array.length - ((n == null) || guard ? 1 : n));
    };
  
    // Get the last element of an array. Passing **n** will return the last N
    // values in the array. The **guard** check allows it to work with `_.map`.
    _.last = function(array, n, guard) {
      if (array == null) return void 0;
      if ((n == null) || guard) return array[array.length - 1];
      return slice.call(array, Math.max(array.length - n, 0));
    };
  
    // Returns everything but the first entry of the array. Aliased as `tail` and `drop`.
    // Especially useful on the arguments object. Passing an **n** will return
    // the rest N values in the array. The **guard**
    // check allows it to work with `_.map`.
    _.rest = _.tail = _.drop = function(array, n, guard) {
      return slice.call(array, (n == null) || guard ? 1 : n);
    };
  
    // Trim out all falsy values from an array.
    _.compact = function(array) {
      return _.filter(array, _.identity);
    };
  
    // Internal implementation of a recursive `flatten` function.
    var flatten = function(input, shallow, output) {
      if (shallow && _.every(input, _.isArray)) {
        return concat.apply(output, input);
      }
      each(input, function(value) {
        if (_.isArray(value) || _.isArguments(value)) {
          shallow ? push.apply(output, value) : flatten(value, shallow, output);
        } else {
          output.push(value);
        }
      });
      return output;
    };
  
    // Flatten out an array, either recursively (by default), or just one level.
    _.flatten = function(array, shallow) {
      return flatten(array, shallow, []);
    };
  
    // Return a version of the array that does not contain the specified value(s).
    _.without = function(array) {
      return _.difference(array, slice.call(arguments, 1));
    };
  
    // Split an array into two arrays: one whose elements all satisfy the given
    // predicate, and one whose elements all do not satisfy the predicate.
    _.partition = function(array, predicate) {
      var pass = [], fail = [];
      each(array, function(elem) {
        (predicate(elem) ? pass : fail).push(elem);
      });
      return [pass, fail];
    };
  
    // Produce a duplicate-free version of the array. If the array has already
    // been sorted, you have the option of using a faster algorithm.
    // Aliased as `unique`.
    _.uniq = _.unique = function(array, isSorted, iterator, context) {
      if (_.isFunction(isSorted)) {
        context = iterator;
        iterator = isSorted;
        isSorted = false;
      }
      var initial = iterator ? _.map(array, iterator, context) : array;
      var results = [];
      var seen = [];
      each(initial, function(value, index) {
        if (isSorted ? (!index || seen[seen.length - 1] !== value) : !_.contains(seen, value)) {
          seen.push(value);
          results.push(array[index]);
        }
      });
      return results;
    };
  
    // Produce an array that contains the union: each distinct element from all of
    // the passed-in arrays.
    _.union = function() {
      return _.uniq(_.flatten(arguments, true));
    };
  
    // Produce an array that contains every item shared between all the
    // passed-in arrays.
    _.intersection = function(array) {
      var rest = slice.call(arguments, 1);
      return _.filter(_.uniq(array), function(item) {
        return _.every(rest, function(other) {
          return _.contains(other, item);
        });
      });
    };
  
    // Take the difference between one array and a number of other arrays.
    // Only the elements present in just the first array will remain.
    _.difference = function(array) {
      var rest = concat.apply(ArrayProto, slice.call(arguments, 1));
      return _.filter(array, function(value){ return !_.contains(rest, value); });
    };
  
    // Zip together multiple lists into a single array -- elements that share
    // an index go together.
    _.zip = function() {
      var length = _.max(_.pluck(arguments, 'length').concat(0));
      var results = new Array(length);
      for (var i = 0; i < length; i++) {
        results[i] = _.pluck(arguments, '' + i);
      }
      return results;
    };
  
    // Converts lists into objects. Pass either a single array of `[key, value]`
    // pairs, or two parallel arrays of the same length -- one of keys, and one of
    // the corresponding values.
    _.object = function(list, values) {
      if (list == null) return {};
      var result = {};
      for (var i = 0, length = list.length; i < length; i++) {
        if (values) {
          result[list[i]] = values[i];
        } else {
          result[list[i][0]] = list[i][1];
        }
      }
      return result;
    };
  
    // If the browser doesn't supply us with indexOf (I'm looking at you, **MSIE**),
    // we need this function. Return the position of the first occurrence of an
    // item in an array, or -1 if the item is not included in the array.
    // Delegates to **ECMAScript 5**'s native `indexOf` if available.
    // If the array is large and already in sort order, pass `true`
    // for **isSorted** to use binary search.
    _.indexOf = function(array, item, isSorted) {
      if (array == null) return -1;
      var i = 0, length = array.length;
      if (isSorted) {
        if (typeof isSorted == 'number') {
          i = (isSorted < 0 ? Math.max(0, length + isSorted) : isSorted);
        } else {
          i = _.sortedIndex(array, item);
          return array[i] === item ? i : -1;
        }
      }
      if (nativeIndexOf && array.indexOf === nativeIndexOf) return array.indexOf(item, isSorted);
      for (; i < length; i++) if (array[i] === item) return i;
      return -1;
    };
  
    // Delegates to **ECMAScript 5**'s native `lastIndexOf` if available.
    _.lastIndexOf = function(array, item, from) {
      if (array == null) return -1;
      var hasIndex = from != null;
      if (nativeLastIndexOf && array.lastIndexOf === nativeLastIndexOf) {
        return hasIndex ? array.lastIndexOf(item, from) : array.lastIndexOf(item);
      }
      var i = (hasIndex ? from : array.length);
      while (i--) if (array[i] === item) return i;
      return -1;
    };
  
    // Generate an integer Array containing an arithmetic progression. A port of
    // the native Python `range()` function. See
    // [the Python documentation](http://docs.python.org/library/functions.html#range).
    _.range = function(start, stop, step) {
      if (arguments.length <= 1) {
        stop = start || 0;
        start = 0;
      }
      step = arguments[2] || 1;
  
      var length = Math.max(Math.ceil((stop - start) / step), 0);
      var idx = 0;
      var range = new Array(length);
  
      while(idx < length) {
        range[idx++] = start;
        start += step;
      }
  
      return range;
    };
  
    // Function (ahem) Functions
    // ------------------
  
    // Reusable constructor function for prototype setting.
    var ctor = function(){};
  
    // Create a function bound to a given object (assigning `this`, and arguments,
    // optionally). Delegates to **ECMAScript 5**'s native `Function.bind` if
    // available.
    _.bind = function(func, context) {
      var args, bound;
      if (nativeBind && func.bind === nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));
      if (!_.isFunction(func)) throw new TypeError;
      args = slice.call(arguments, 2);
      return bound = function() {
        if (!(this instanceof bound)) return func.apply(context, args.concat(slice.call(arguments)));
        ctor.prototype = func.prototype;
        var self = new ctor;
        ctor.prototype = null;
        var result = func.apply(self, args.concat(slice.call(arguments)));
        if (Object(result) === result) return result;
        return self;
      };
    };
  
    // Partially apply a function by creating a version that has had some of its
    // arguments pre-filled, without changing its dynamic `this` context. _ acts
    // as a placeholder, allowing any combination of arguments to be pre-filled.
    _.partial = function(func) {
      var boundArgs = slice.call(arguments, 1);
      return function() {
        var position = 0;
        var args = boundArgs.slice();
        for (var i = 0, length = args.length; i < length; i++) {
          if (args[i] === _) args[i] = arguments[position++];
        }
        while (position < arguments.length) args.push(arguments[position++]);
        return func.apply(this, args);
      };
    };
  
    // Bind a number of an object's methods to that object. Remaining arguments
    // are the method names to be bound. Useful for ensuring that all callbacks
    // defined on an object belong to it.
    _.bindAll = function(obj) {
      var funcs = slice.call(arguments, 1);
      if (funcs.length === 0) throw new Error('bindAll must be passed function names');
      each(funcs, function(f) { obj[f] = _.bind(obj[f], obj); });
      return obj;
    };
  
    // Memoize an expensive function by storing its results.
    _.memoize = function(func, hasher) {
      var memo = {};
      hasher || (hasher = _.identity);
      return function() {
        var key = hasher.apply(this, arguments);
        return _.has(memo, key) ? memo[key] : (memo[key] = func.apply(this, arguments));
      };
    };
  
    // Delays a function for the given number of milliseconds, and then calls
    // it with the arguments supplied.
    _.delay = function(func, wait) {
      var args = slice.call(arguments, 2);
      return setTimeout(function(){ return func.apply(null, args); }, wait);
    };
  
    // Defers a function, scheduling it to run after the current call stack has
    // cleared.
    _.defer = function(func) {
      return _.delay.apply(_, [func, 1].concat(slice.call(arguments, 1)));
    };
  
    // Returns a function, that, when invoked, will only be triggered at most once
    // during a given window of time. Normally, the throttled function will run
    // as much as it can, without ever going more than once per `wait` duration;
    // but if you'd like to disable the execution on the leading edge, pass
    // `{leading: false}`. To disable execution on the trailing edge, ditto.
    _.throttle = function(func, wait, options) {
      var context, args, result;
      var timeout = null;
      var previous = 0;
      options || (options = {});
      var later = function() {
        previous = options.leading === false ? 0 : _.now();
        timeout = null;
        result = func.apply(context, args);
        context = args = null;
      };
      return function() {
        var now = _.now();
        if (!previous && options.leading === false) previous = now;
        var remaining = wait - (now - previous);
        context = this;
        args = arguments;
        if (remaining <= 0) {
          clearTimeout(timeout);
          timeout = null;
          previous = now;
          result = func.apply(context, args);
          context = args = null;
        } else if (!timeout && options.trailing !== false) {
          timeout = setTimeout(later, remaining);
        }
        return result;
      };
    };
  
    // Returns a function, that, as long as it continues to be invoked, will not
    // be triggered. The function will be called after it stops being called for
    // N milliseconds. If `immediate` is passed, trigger the function on the
    // leading edge, instead of the trailing.
    _.debounce = function(func, wait, immediate) {
      var timeout, args, context, timestamp, result;
  
      var later = function() {
        var last = _.now() - timestamp;
        if (last < wait) {
          timeout = setTimeout(later, wait - last);
        } else {
          timeout = null;
          if (!immediate) {
            result = func.apply(context, args);
            context = args = null;
          }
        }
      };
  
      return function() {
        context = this;
        args = arguments;
        timestamp = _.now();
        var callNow = immediate && !timeout;
        if (!timeout) {
          timeout = setTimeout(later, wait);
        }
        if (callNow) {
          result = func.apply(context, args);
          context = args = null;
        }
  
        return result;
      };
    };
  
    // Returns a function that will be executed at most one time, no matter how
    // often you call it. Useful for lazy initialization.
    _.once = function(func) {
      var ran = false, memo;
      return function() {
        if (ran) return memo;
        ran = true;
        memo = func.apply(this, arguments);
        func = null;
        return memo;
      };
    };
  
    // Returns the first function passed as an argument to the second,
    // allowing you to adjust arguments, run code before and after, and
    // conditionally execute the original function.
    _.wrap = function(func, wrapper) {
      return _.partial(wrapper, func);
    };
  
    // Returns a function that is the composition of a list of functions, each
    // consuming the return value of the function that follows.
    _.compose = function() {
      var funcs = arguments;
      return function() {
        var args = arguments;
        for (var i = funcs.length - 1; i >= 0; i--) {
          args = [funcs[i].apply(this, args)];
        }
        return args[0];
      };
    };
  
    // Returns a function that will only be executed after being called N times.
    _.after = function(times, func) {
      return function() {
        if (--times < 1) {
          return func.apply(this, arguments);
        }
      };
    };
  
    // Object Functions
    // ----------------
  
    // Retrieve the names of an object's properties.
    // Delegates to **ECMAScript 5**'s native `Object.keys`
    _.keys = function(obj) {
      if (!_.isObject(obj)) return [];
      if (nativeKeys) return nativeKeys(obj);
      var keys = [];
      for (var key in obj) if (_.has(obj, key)) keys.push(key);
      return keys;
    };
  
    // Retrieve the values of an object's properties.
    _.values = function(obj) {
      var keys = _.keys(obj);
      var length = keys.length;
      var values = new Array(length);
      for (var i = 0; i < length; i++) {
        values[i] = obj[keys[i]];
      }
      return values;
    };
  
    // Convert an object into a list of `[key, value]` pairs.
    _.pairs = function(obj) {
      var keys = _.keys(obj);
      var length = keys.length;
      var pairs = new Array(length);
      for (var i = 0; i < length; i++) {
        pairs[i] = [keys[i], obj[keys[i]]];
      }
      return pairs;
    };
  
    // Invert the keys and values of an object. The values must be serializable.
    _.invert = function(obj) {
      var result = {};
      var keys = _.keys(obj);
      for (var i = 0, length = keys.length; i < length; i++) {
        result[obj[keys[i]]] = keys[i];
      }
      return result;
    };
  
    // Return a sorted list of the function names available on the object.
    // Aliased as `methods`
    _.functions = _.methods = function(obj) {
      var names = [];
      for (var key in obj) {
        if (_.isFunction(obj[key])) names.push(key);
      }
      return names.sort();
    };
  
    // Extend a given object with all the properties in passed-in object(s).
    _.extend = function(obj) {
      each(slice.call(arguments, 1), function(source) {
        if (source) {
          for (var prop in source) {
            obj[prop] = source[prop];
          }
        }
      });
      return obj;
    };
  
    // Return a copy of the object only containing the whitelisted properties.
    _.pick = function(obj) {
      var copy = {};
      var keys = concat.apply(ArrayProto, slice.call(arguments, 1));
      each(keys, function(key) {
        if (key in obj) copy[key] = obj[key];
      });
      return copy;
    };
  
     // Return a copy of the object without the blacklisted properties.
    _.omit = function(obj) {
      var copy = {};
      var keys = concat.apply(ArrayProto, slice.call(arguments, 1));
      for (var key in obj) {
        if (!_.contains(keys, key)) copy[key] = obj[key];
      }
      return copy;
    };
  
    // Fill in a given object with default properties.
    _.defaults = function(obj) {
      each(slice.call(arguments, 1), function(source) {
        if (source) {
          for (var prop in source) {
            if (obj[prop] === void 0) obj[prop] = source[prop];
          }
        }
      });
      return obj;
    };
  
    // Create a (shallow-cloned) duplicate of an object.
    _.clone = function(obj) {
      if (!_.isObject(obj)) return obj;
      return _.isArray(obj) ? obj.slice() : _.extend({}, obj);
    };
  
    // Invokes interceptor with the obj, and then returns obj.
    // The primary purpose of this method is to "tap into" a method chain, in
    // order to perform operations on intermediate results within the chain.
    _.tap = function(obj, interceptor) {
      interceptor(obj);
      return obj;
    };
  
    // Internal recursive comparison function for `isEqual`.
    var eq = function(a, b, aStack, bStack) {
      // Identical objects are equal. `0 === -0`, but they aren't identical.
      // See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal).
      if (a === b) return a !== 0 || 1 / a == 1 / b;
      // A strict comparison is necessary because `null == undefined`.
      if (a == null || b == null) return a === b;
      // Unwrap any wrapped objects.
      if (a instanceof _) a = a._wrapped;
      if (b instanceof _) b = b._wrapped;
      // Compare `[[Class]]` names.
      var className = toString.call(a);
      if (className != toString.call(b)) return false;
      switch (className) {
        // Strings, numbers, dates, and booleans are compared by value.
        case '[object String]':
          // Primitives and their corresponding object wrappers are equivalent; thus, `"5"` is
          // equivalent to `new String("5")`.
          return a == String(b);
        case '[object Number]':
          // `NaN`s are equivalent, but non-reflexive. An `egal` comparison is performed for
          // other numeric values.
          return a != +a ? b != +b : (a == 0 ? 1 / a == 1 / b : a == +b);
        case '[object Date]':
        case '[object Boolean]':
          // Coerce dates and booleans to numeric primitive values. Dates are compared by their
          // millisecond representations. Note that invalid dates with millisecond representations
          // of `NaN` are not equivalent.
          return +a == +b;
        // RegExps are compared by their source patterns and flags.
        case '[object RegExp]':
          return a.source == b.source &&
                 a.global == b.global &&
                 a.multiline == b.multiline &&
                 a.ignoreCase == b.ignoreCase;
      }
      if (typeof a != 'object' || typeof b != 'object') return false;
      // Assume equality for cyclic structures. The algorithm for detecting cyclic
      // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.
      var length = aStack.length;
      while (length--) {
        // Linear search. Performance is inversely proportional to the number of
        // unique nested structures.
        if (aStack[length] == a) return bStack[length] == b;
      }
      // Objects with different constructors are not equivalent, but `Object`s
      // from different frames are.
      var aCtor = a.constructor, bCtor = b.constructor;
      if (aCtor !== bCtor && !(_.isFunction(aCtor) && (aCtor instanceof aCtor) &&
                               _.isFunction(bCtor) && (bCtor instanceof bCtor))
                          && ('constructor' in a && 'constructor' in b)) {
        return false;
      }
      // Add the first object to the stack of traversed objects.
      aStack.push(a);
      bStack.push(b);
      var size = 0, result = true;
      // Recursively compare objects and arrays.
      if (className == '[object Array]') {
        // Compare array lengths to determine if a deep comparison is necessary.
        size = a.length;
        result = size == b.length;
        if (result) {
          // Deep compare the contents, ignoring non-numeric properties.
          while (size--) {
            if (!(result = eq(a[size], b[size], aStack, bStack))) break;
          }
        }
      } else {
        // Deep compare objects.
        for (var key in a) {
          if (_.has(a, key)) {
            // Count the expected number of properties.
            size++;
            // Deep compare each member.
            if (!(result = _.has(b, key) && eq(a[key], b[key], aStack, bStack))) break;
          }
        }
        // Ensure that both objects contain the same number of properties.
        if (result) {
          for (key in b) {
            if (_.has(b, key) && !(size--)) break;
          }
          result = !size;
        }
      }
      // Remove the first object from the stack of traversed objects.
      aStack.pop();
      bStack.pop();
      return result;
    };
  
    // Perform a deep comparison to check if two objects are equal.
    _.isEqual = function(a, b) {
      return eq(a, b, [], []);
    };
  
    // Is a given array, string, or object empty?
    // An "empty" object has no enumerable own-properties.
    _.isEmpty = function(obj) {
      if (obj == null) return true;
      if (_.isArray(obj) || _.isString(obj)) return obj.length === 0;
      for (var key in obj) if (_.has(obj, key)) return false;
      return true;
    };
  
    // Is a given value a DOM element?
    _.isElement = function(obj) {
      return !!(obj && obj.nodeType === 1);
    };
  
    // Is a given value an array?
    // Delegates to ECMA5's native Array.isArray
    _.isArray = nativeIsArray || function(obj) {
      return toString.call(obj) == '[object Array]';
    };
  
    // Is a given variable an object?
    _.isObject = function(obj) {
      return obj === Object(obj);
    };
  
    // Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp.
    each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp'], function(name) {
      _['is' + name] = function(obj) {
        return toString.call(obj) == '[object ' + name + ']';
      };
    });
  
    // Define a fallback version of the method in browsers (ahem, IE), where
    // there isn't any inspectable "Arguments" type.
    if (!_.isArguments(arguments)) {
      _.isArguments = function(obj) {
        return !!(obj && _.has(obj, 'callee'));
      };
    }
  
    // Optimize `isFunction` if appropriate.
    if (typeof (/./) !== 'function') {
      _.isFunction = function(obj) {
        return typeof obj === 'function';
      };
    }
  
    // Is a given object a finite number?
    _.isFinite = function(obj) {
      return isFinite(obj) && !isNaN(parseFloat(obj));
    };
  
    // Is the given value `NaN`? (NaN is the only number which does not equal itself).
    _.isNaN = function(obj) {
      return _.isNumber(obj) && obj != +obj;
    };
  
    // Is a given value a boolean?
    _.isBoolean = function(obj) {
      return obj === true || obj === false || toString.call(obj) == '[object Boolean]';
    };
  
    // Is a given value equal to null?
    _.isNull = function(obj) {
      return obj === null;
    };
  
    // Is a given variable undefined?
    _.isUndefined = function(obj) {
      return obj === void 0;
    };
  
    // Shortcut function for checking if an object has a given property directly
    // on itself (in other words, not on a prototype).
    _.has = function(obj, key) {
      return hasOwnProperty.call(obj, key);
    };
  
    // Utility Functions
    // -----------------
  
    // Run Underscore.js in *noConflict* mode, returning the `_` variable to its
    // previous owner. Returns a reference to the Underscore object.
    _.noConflict = function() {
      root._ = previousUnderscore;
      return this;
    };
  
    // Keep the identity function around for default iterators.
    _.identity = function(value) {
      return value;
    };
  
    _.constant = function(value) {
      return function () {
        return value;
      };
    };
  
    _.property = function(key) {
      return function(obj) {
        return obj[key];
      };
    };
  
    // Returns a predicate for checking whether an object has a given set of `key:value` pairs.
    _.matches = function(attrs) {
      return function(obj) {
        if (obj === attrs) return true; //avoid comparing an object to itself.
        for (var key in attrs) {
          if (attrs[key] !== obj[key])
            return false;
        }
        return true;
      }
    };
  
    // Run a function **n** times.
    _.times = function(n, iterator, context) {
      var accum = Array(Math.max(0, n));
      for (var i = 0; i < n; i++) accum[i] = iterator.call(context, i);
      return accum;
    };
  
    // Return a random integer between min and max (inclusive).
    _.random = function(min, max) {
      if (max == null) {
        max = min;
        min = 0;
      }
      return min + Math.floor(Math.random() * (max - min + 1));
    };
  
    // A (possibly faster) way to get the current timestamp as an integer.
    _.now = Date.now || function() { return new Date().getTime(); };
  
    // List of HTML entities for escaping.
    var entityMap = {
      escape: {
        '&': '&amp;',
        '<': '&lt;',
        '>': '&gt;',
        '"': '&quot;',
        "'": '&#x27;'
      }
    };
    entityMap.unescape = _.invert(entityMap.escape);
  
    // Regexes containing the keys and values listed immediately above.
    var entityRegexes = {
      escape:   new RegExp('[' + _.keys(entityMap.escape).join('') + ']', 'g'),
      unescape: new RegExp('(' + _.keys(entityMap.unescape).join('|') + ')', 'g')
    };
  
    // Functions for escaping and unescaping strings to/from HTML interpolation.
    _.each(['escape', 'unescape'], function(method) {
      _[method] = function(string) {
        if (string == null) return '';
        return ('' + string).replace(entityRegexes[method], function(match) {
          return entityMap[method][match];
        });
      };
    });
  
    // If the value of the named `property` is a function then invoke it with the
    // `object` as context; otherwise, return it.
    _.result = function(object, property) {
      if (object == null) return void 0;
      var value = object[property];
      return _.isFunction(value) ? value.call(object) : value;
    };
  
    // Add your own custom functions to the Underscore object.
    _.mixin = function(obj) {
      each(_.functions(obj), function(name) {
        var func = _[name] = obj[name];
        _.prototype[name] = function() {
          var args = [this._wrapped];
          push.apply(args, arguments);
          return result.call(this, func.apply(_, args));
        };
      });
    };
  
    // Generate a unique integer id (unique within the entire client session).
    // Useful for temporary DOM ids.
    var idCounter = 0;
    _.uniqueId = function(prefix) {
      var id = ++idCounter + '';
      return prefix ? prefix + id : id;
    };
  
    // By default, Underscore uses ERB-style template delimiters, change the
    // following template settings to use alternative delimiters.
    _.templateSettings = {
      evaluate    : /<%([\s\S]+?)%>/g,
      interpolate : /<%=([\s\S]+?)%>/g,
      escape      : /<%-([\s\S]+?)%>/g
    };
  
    // When customizing `templateSettings`, if you don't want to define an
    // interpolation, evaluation or escaping regex, we need one that is
    // guaranteed not to match.
    var noMatch = /(.)^/;
  
    // Certain characters need to be escaped so that they can be put into a
    // string literal.
    var escapes = {
      "'":      "'",
      '\\':     '\\',
      '\r':     'r',
      '\n':     'n',
      '\t':     't',
      '\u2028': 'u2028',
      '\u2029': 'u2029'
    };
  
    var escaper = /\\|'|\r|\n|\t|\u2028|\u2029/g;
  
    // JavaScript micro-templating, similar to John Resig's implementation.
    // Underscore templating handles arbitrary delimiters, preserves whitespace,
    // and correctly escapes quotes within interpolated code.
    _.template = function(text, data, settings) {
      var render;
      settings = _.defaults({}, settings, _.templateSettings);
  
      // Combine delimiters into one regular expression via alternation.
      var matcher = new RegExp([
        (settings.escape || noMatch).source,
        (settings.interpolate || noMatch).source,
        (settings.evaluate || noMatch).source
      ].join('|') + '|$', 'g');
  
      // Compile the template source, escaping string literals appropriately.
      var index = 0;
      var source = "__p+='";
      text.replace(matcher, function(match, escape, interpolate, evaluate, offset) {
        source += text.slice(index, offset)
          .replace(escaper, function(match) { return '\\' + escapes[match]; });
  
        if (escape) {
          source += "'+\n((__t=(" + escape + "))==null?'':_.escape(__t))+\n'";
        }
        if (interpolate) {
          source += "'+\n((__t=(" + interpolate + "))==null?'':__t)+\n'";
        }
        if (evaluate) {
          source += "';\n" + evaluate + "\n__p+='";
        }
        index = offset + match.length;
        return match;
      });
      source += "';\n";
  
      // If a variable is not specified, place data values in local scope.
      if (!settings.variable) source = 'with(obj||{}){\n' + source + '}\n';
  
      source = "var __t,__p='',__j=Array.prototype.join," +
        "print=function(){__p+=__j.call(arguments,'');};\n" +
        source + "return __p;\n";
  
      try {
        render = new Function(settings.variable || 'obj', '_', source);
      } catch (e) {
        e.source = source;
        throw e;
      }
  
      if (data) return render(data, _);
      var template = function(data) {
        return render.call(this, data, _);
      };
  
      // Provide the compiled function source as a convenience for precompilation.
      template.source = 'function(' + (settings.variable || 'obj') + '){\n' + source + '}';
  
      return template;
    };
  
    // Add a "chain" function, which will delegate to the wrapper.
    _.chain = function(obj) {
      return _(obj).chain();
    };
  
    // OOP
    // ---------------
    // If Underscore is called as a function, it returns a wrapped object that
    // can be used OO-style. This wrapper holds altered versions of all the
    // underscore functions. Wrapped objects may be chained.
  
    // Helper function to continue chaining intermediate results.
    var result = function(obj) {
      return this._chain ? _(obj).chain() : obj;
    };
  
    // Add all of the Underscore functions to the wrapper object.
    _.mixin(_);
  
    // Add all mutator Array functions to the wrapper.
    each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {
      var method = ArrayProto[name];
      _.prototype[name] = function() {
        var obj = this._wrapped;
        method.apply(obj, arguments);
        if ((name == 'shift' || name == 'splice') && obj.length === 0) delete obj[0];
        return result.call(this, obj);
      };
    });
  
    // Add all accessor Array functions to the wrapper.
    each(['concat', 'join', 'slice'], function(name) {
      var method = ArrayProto[name];
      _.prototype[name] = function() {
        return result.call(this, method.apply(this._wrapped, arguments));
      };
    });
  
    _.extend(_.prototype, {
  
      // Start chaining a wrapped Underscore object.
      chain: function() {
        this._chain = true;
        return this;
      },
  
      // Extracts the result from a wrapped and chained object.
      value: function() {
        return this._wrapped;
      }
  
    });
  
    // AMD registration happens at the end for compatibility with AMD loaders
    // that may not enforce next-turn semantics on modules. Even though general
    // practice for AMD registration is to be anonymous, underscore registers
    // as a named module because, like jQuery, it is a base library that is
    // popular enough to be bundled in a third party lib, but not be part of
    // an AMD load request. Those cases could generate an error when an
    // anonymous define() is called outside of a loader request.
    if (typeof define === 'function' && define.amd) {
      define('underscore', [], function() {
        return _;
      });
    }
  }).call(this);
  
  },{}]},{},["FR1krT"])