Skip to:
Content

BuddyPress.org

Ticket #5757: 5757.01.patch

File 5757.01.patch, 164.1 KB (added by r-a-y, 4 years ago)
  • src/bp-activity/bp-activity-filters.php

     
    204204        $activity_allowedtags['img']['class']  = array();
    205205        $activity_allowedtags['img']['id']     = array();
    206206        $activity_allowedtags['img']['title']  = array();
    207         $activity_allowedtags['span']          = array();
    208         $activity_allowedtags['span']['class'] = array();
     207
     208        $activity_allowedtags['span']                   = array();
     209        $activity_allowedtags['span']['class']          = array();
     210        $activity_allowedtags['span']['data-livestamp'] = array();
    209211
    210212
    211213        /**
  • src/bp-activity/bp-activity-template.php

     
    15641564        // Get the time since this activity was recorded.
    15651565        $date_recorded  = bp_core_time_since( $activities_template->activity->date_recorded );
    15661566
     1567        // Set up 'time-since' <span>.
     1568        $time_since = sprintf(
     1569                '<span class="time-since" data-livestamp="%1$s">%2$s</span>',
     1570                bp_core_get_iso8601_date( $activities_template->activity->date_recorded ),
     1571                $date_recorded
     1572        );
     1573
    15671574        /**
    15681575         * Filters the activity item time since markup.
    15691576         *
     
    15721579         * @param array $value Array containing the time since markup and the current activity component.
    15731580         */
    15741581        $time_since = apply_filters_ref_array( 'bp_activity_time_since', array(
    1575                 '<span class="time-since">' . $date_recorded . '</span>',
     1582                $time_since,
    15761583                &$activities_template->activity
    15771584        ) );
    15781585
  • src/bp-core/bp-core-cssjs.php

     
    4747                // 2.4
    4848                'bp-cover-image' => array( 'file' => "{$url}cover-image{$min}.js", 'dependencies' => array(), 'footer' => true ),
    4949
     50                // 2.6
     51                'bp-moment'    => array( 'file' => "{$url}moment{$min}.js", 'dependencies' => array(), 'footer' => true ),
     52                'bp-livestamp' => array( 'file' => "{$url}livestamp{$min}.js", 'dependencies' => array( 'jquery', 'bp-moment' ), 'footer' => true ),
    5053        ) );
    5154
    5255        $version = bp_get_version();
     
    462465        }
    463466}
    464467add_action( 'bp_enqueue_scripts', 'bp_add_cover_image_inline_css', 11 );
     468
     469/**
     470 * Enqueues livestamp.js on BuddyPress pages.
     471 *
     472 * @since 2.6.0
     473 */
     474function bp_core_add_livestamp() {
     475        if ( false === is_buddypress() ) {
     476                return;
     477        }
     478
     479        bp_core_enqueue_livestamp();
     480}
     481add_action( 'bp_enqueue_scripts', 'bp_core_add_livestamp' );
     482
     483/**
     484 * Enqueue and localize livestamp.js script.
     485 *
     486 * @since 2.6.0
     487 */
     488function bp_core_enqueue_livestamp() {
     489        // If bp-moment isn't enqueued, do it now.
     490        if ( true === wp_script_is( 'bp-livestamp' ) ) {
     491                return;
     492        }
     493
     494        wp_enqueue_script( 'bp-livestamp' );
     495
     496        // We're only localizing the relative time strings for moment.js since that's
     497        // all we need for now.
     498        wp_localize_script( 'bp-livestamp', 'BP_Moment_i18n', array(
     499                'future' => __( 'in %s',         'buddypress' ),
     500                'past'   => __( '%s ago',        'buddypress' ),
     501                's'      => __( 'a few seconds', 'buddypress' ),
     502                'm'      => __( 'a minute',      'buddypress' ),
     503                'mm'     => __( '%d minutes',    'buddypress' ),
     504                'h'      => __( 'an hour',       'buddypress' ),
     505                'hh'     => __( '%d hours',      'buddypress' ),
     506                'd'      => __( 'a day',         'buddypress' ),
     507                'dd'     => __( '%d days',       'buddypress' ),
     508                'M'      => __( 'a month',       'buddypress' ),
     509                'MM'     => __( '%d months',     'buddypress' ),
     510                'y'      => __( 'a year',        'buddypress' ),
     511                'yy'     => __( '%d years',      'buddypress' ),
     512        ) );
     513
     514        $inline_js = <<<EOD
     515jq(function() {
     516        moment.locale( 'bp', {
     517                relativeTime : BP_Moment_i18n
     518        });
     519});
     520EOD;
     521
     522        wp_add_inline_script ( 'bp-livestamp', $inline_js );
     523}
     524 No newline at end of file
  • src/bp-core/bp-core-functions.php

     
    12711271        return apply_filters( 'bp_core_time_since', $output, $older_date, $newer_date );
    12721272}
    12731273
     1274/**
     1275 * Output an ISO-8601 date from a date string.
     1276 *
     1277 * @since 2.6.0
     1278 *
     1279 * @param string String of date to convert. Timezone should be UTC before using this.
     1280 * @return string
     1281 */
     1282 function bp_core_iso8601_date( $timestamp = '' ) {
     1283        echo bp_core_get_iso8601_date( $timestamp );
     1284}
     1285        /**
     1286         * Return an ISO-8601 date from a date string.
     1287         *
     1288         * @since 2.6.0
     1289         *
     1290         * @param string String of date to convert. Timezone should be UTC before using this.
     1291         * @return string
     1292         */
     1293         function bp_core_get_iso8601_date( $timestamp = '' ) {
     1294                if ( empty( $timestamp ) ) {
     1295                        return '';
     1296                }
     1297
     1298                $date = new DateTime( $timestamp, new DateTimeZone( 'UTC' ) );
     1299                return $date->format( DateTime::ISO8601 );
     1300        }
     1301
    12741302/** Messages ******************************************************************/
    12751303
    12761304/**
  • new file src/bp-core/js/livestamp.js

    new file mode 100644
    - +  
     1// Livestamp.js / v1.1.2 / (c) 2012 Matt Bradley / MIT License
     2(function($, moment) {
     3  var updateInterval = 1e3,
     4      paused = false,
     5      $livestamps = $([]),
     6
     7  init = function() {
     8    livestampGlobal.resume();
     9  },
     10
     11  prep = function($el, timestamp) {
     12    var oldData = $el.data('livestampdata');
     13    if (typeof timestamp == 'number')
     14      timestamp *= 1e3;
     15
     16    $el.removeAttr('data-livestamp')
     17      .removeData('livestamp');
     18
     19    timestamp = moment(timestamp);
     20    if (moment.isMoment(timestamp) && !isNaN(+timestamp)) {
     21      var newData = $.extend({ }, { 'original': $el.contents() }, oldData);
     22      newData.moment = moment(timestamp);
     23
     24      $el.data('livestampdata', newData).empty();
     25      $livestamps.push($el[0]);
     26    }
     27  },
     28
     29  run = function() {
     30    if (paused) return;
     31    livestampGlobal.update();
     32    setTimeout(run, updateInterval);
     33  },
     34
     35  livestampGlobal = {
     36    update: function() {
     37      $('[data-livestamp]').each(function() {
     38        var $this = $(this);
     39        prep($this, $this.data('livestamp'));
     40      });
     41
     42      var toRemove = [];
     43      $livestamps.each(function() {
     44        var $this = $(this),
     45            data = $this.data('livestampdata');
     46
     47        if (data === undefined)
     48          toRemove.push(this);
     49        else if (moment.isMoment(data.moment)) {
     50          var from = $this.html(),
     51              to = data.moment.fromNow();
     52
     53          if (from != to) {
     54            var e = $.Event('change.livestamp');
     55            $this.trigger(e, [from, to]);
     56            if (!e.isDefaultPrevented())
     57              $this.html(to);
     58          }
     59        }
     60      });
     61
     62      $livestamps = $livestamps.not(toRemove);
     63    },
     64
     65    pause: function() {
     66      paused = true;
     67    },
     68
     69    resume: function() {
     70      paused = false;
     71      run();
     72    },
     73
     74    interval: function(interval) {
     75      if (interval === undefined)
     76        return updateInterval;
     77      updateInterval = interval;
     78    }
     79  },
     80
     81  livestampLocal = {
     82    add: function($el, timestamp) {
     83      if (typeof timestamp == 'number')
     84        timestamp *= 1e3;
     85      timestamp = moment(timestamp);
     86
     87      if (moment.isMoment(timestamp) && !isNaN(+timestamp)) {
     88        $el.each(function() {
     89          prep($(this), timestamp);
     90        });
     91        livestampGlobal.update();
     92      }
     93
     94      return $el;
     95    },
     96
     97    destroy: function($el) {
     98      $livestamps = $livestamps.not($el);
     99      $el.each(function() {
     100        var $this = $(this),
     101            data = $this.data('livestampdata');
     102
     103        if (data === undefined)
     104          return $el;
     105
     106        $this
     107          .html(data.original ? data.original : '')
     108          .removeData('livestampdata');
     109      });
     110
     111      return $el;
     112    },
     113
     114    isLivestamp: function($el) {
     115      return $el.data('livestampdata') !== undefined;
     116    }
     117  };
     118
     119  $.livestamp = livestampGlobal;
     120  $(init);
     121  $.fn.livestamp = function(method, options) {
     122    if (!livestampLocal[method]) {
     123      options = method;
     124      method = 'add';
     125    }
     126
     127    return livestampLocal[method](this, options);
     128  };
     129})(jQuery, moment);
  • new file src/bp-core/js/moment.js

    new file mode 100644
    - +  
     1//! moment.js
     2//! version : 2.13.0
     3//! authors : Tim Wood, Iskren Chernev, Moment.js contributors
     4//! license : MIT
     5//! momentjs.com
     6
     7;(function (global, factory) {
     8    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
     9    typeof define === 'function' && define.amd ? define(factory) :
     10    global.moment = factory()
     11}(this, function () { 'use strict';
     12
     13    var hookCallback;
     14
     15    function utils_hooks__hooks () {
     16        return hookCallback.apply(null, arguments);
     17    }
     18
     19    // This is done to register the method called with moment()
     20    // without creating circular dependencies.
     21    function setHookCallback (callback) {
     22        hookCallback = callback;
     23    }
     24
     25    function isArray(input) {
     26        return input instanceof Array || Object.prototype.toString.call(input) === '[object Array]';
     27    }
     28
     29    function isDate(input) {
     30        return input instanceof Date || Object.prototype.toString.call(input) === '[object Date]';
     31    }
     32
     33    function map(arr, fn) {
     34        var res = [], i;
     35        for (i = 0; i < arr.length; ++i) {
     36            res.push(fn(arr[i], i));
     37        }
     38        return res;
     39    }
     40
     41    function hasOwnProp(a, b) {
     42        return Object.prototype.hasOwnProperty.call(a, b);
     43    }
     44
     45    function extend(a, b) {
     46        for (var i in b) {
     47            if (hasOwnProp(b, i)) {
     48                a[i] = b[i];
     49            }
     50        }
     51
     52        if (hasOwnProp(b, 'toString')) {
     53            a.toString = b.toString;
     54        }
     55
     56        if (hasOwnProp(b, 'valueOf')) {
     57            a.valueOf = b.valueOf;
     58        }
     59
     60        return a;
     61    }
     62
     63    function create_utc__createUTC (input, format, locale, strict) {
     64        return createLocalOrUTC(input, format, locale, strict, true).utc();
     65    }
     66
     67    function defaultParsingFlags() {
     68        // We need to deep clone this object.
     69        return {
     70            empty           : false,
     71            unusedTokens    : [],
     72            unusedInput     : [],
     73            overflow        : -2,
     74            charsLeftOver   : 0,
     75            nullInput       : false,
     76            invalidMonth    : null,
     77            invalidFormat   : false,
     78            userInvalidated : false,
     79            iso             : false,
     80            parsedDateParts : [],
     81            meridiem        : null
     82        };
     83    }
     84
     85    function getParsingFlags(m) {
     86        if (m._pf == null) {
     87            m._pf = defaultParsingFlags();
     88        }
     89        return m._pf;
     90    }
     91
     92    var some;
     93    if (Array.prototype.some) {
     94        some = Array.prototype.some;
     95    } else {
     96        some = function (fun) {
     97            var t = Object(this);
     98            var len = t.length >>> 0;
     99
     100            for (var i = 0; i < len; i++) {
     101                if (i in t && fun.call(this, t[i], i, t)) {
     102                    return true;
     103                }
     104            }
     105
     106            return false;
     107        };
     108    }
     109
     110    function valid__isValid(m) {
     111        if (m._isValid == null) {
     112            var flags = getParsingFlags(m);
     113            var parsedParts = some.call(flags.parsedDateParts, function (i) {
     114                return i != null;
     115            });
     116            m._isValid = !isNaN(m._d.getTime()) &&
     117                flags.overflow < 0 &&
     118                !flags.empty &&
     119                !flags.invalidMonth &&
     120                !flags.invalidWeekday &&
     121                !flags.nullInput &&
     122                !flags.invalidFormat &&
     123                !flags.userInvalidated &&
     124                (!flags.meridiem || (flags.meridiem && parsedParts));
     125
     126            if (m._strict) {
     127                m._isValid = m._isValid &&
     128                    flags.charsLeftOver === 0 &&
     129                    flags.unusedTokens.length === 0 &&
     130                    flags.bigHour === undefined;
     131            }
     132        }
     133        return m._isValid;
     134    }
     135
     136    function valid__createInvalid (flags) {
     137        var m = create_utc__createUTC(NaN);
     138        if (flags != null) {
     139            extend(getParsingFlags(m), flags);
     140        }
     141        else {
     142            getParsingFlags(m).userInvalidated = true;
     143        }
     144
     145        return m;
     146    }
     147
     148    function isUndefined(input) {
     149        return input === void 0;
     150    }
     151
     152    // Plugins that add properties should also add the key here (null value),
     153    // so we can properly clone ourselves.
     154    var momentProperties = utils_hooks__hooks.momentProperties = [];
     155
     156    function copyConfig(to, from) {
     157        var i, prop, val;
     158
     159        if (!isUndefined(from._isAMomentObject)) {
     160            to._isAMomentObject = from._isAMomentObject;
     161        }
     162        if (!isUndefined(from._i)) {
     163            to._i = from._i;
     164        }
     165        if (!isUndefined(from._f)) {
     166            to._f = from._f;
     167        }
     168        if (!isUndefined(from._l)) {
     169            to._l = from._l;
     170        }
     171        if (!isUndefined(from._strict)) {
     172            to._strict = from._strict;
     173        }
     174        if (!isUndefined(from._tzm)) {
     175            to._tzm = from._tzm;
     176        }
     177        if (!isUndefined(from._isUTC)) {
     178            to._isUTC = from._isUTC;
     179        }
     180        if (!isUndefined(from._offset)) {
     181            to._offset = from._offset;
     182        }
     183        if (!isUndefined(from._pf)) {
     184            to._pf = getParsingFlags(from);
     185        }
     186        if (!isUndefined(from._locale)) {
     187            to._locale = from._locale;
     188        }
     189
     190        if (momentProperties.length > 0) {
     191            for (i in momentProperties) {
     192                prop = momentProperties[i];
     193                val = from[prop];
     194                if (!isUndefined(val)) {
     195                    to[prop] = val;
     196                }
     197            }
     198        }
     199
     200        return to;
     201    }
     202
     203    var updateInProgress = false;
     204
     205    // Moment prototype object
     206    function Moment(config) {
     207        copyConfig(this, config);
     208        this._d = new Date(config._d != null ? config._d.getTime() : NaN);
     209        // Prevent infinite loop in case updateOffset creates new moment
     210        // objects.
     211        if (updateInProgress === false) {
     212            updateInProgress = true;
     213            utils_hooks__hooks.updateOffset(this);
     214            updateInProgress = false;
     215        }
     216    }
     217
     218    function isMoment (obj) {
     219        return obj instanceof Moment || (obj != null && obj._isAMomentObject != null);
     220    }
     221
     222    function absFloor (number) {
     223        if (number < 0) {
     224            return Math.ceil(number);
     225        } else {
     226            return Math.floor(number);
     227        }
     228    }
     229
     230    function toInt(argumentForCoercion) {
     231        var coercedNumber = +argumentForCoercion,
     232            value = 0;
     233
     234        if (coercedNumber !== 0 && isFinite(coercedNumber)) {
     235            value = absFloor(coercedNumber);
     236        }
     237
     238        return value;
     239    }
     240
     241    // compare two arrays, return the number of differences
     242    function compareArrays(array1, array2, dontConvert) {
     243        var len = Math.min(array1.length, array2.length),
     244            lengthDiff = Math.abs(array1.length - array2.length),
     245            diffs = 0,
     246            i;
     247        for (i = 0; i < len; i++) {
     248            if ((dontConvert && array1[i] !== array2[i]) ||
     249                (!dontConvert && toInt(array1[i]) !== toInt(array2[i]))) {
     250                diffs++;
     251            }
     252        }
     253        return diffs + lengthDiff;
     254    }
     255
     256    function warn(msg) {
     257        if (utils_hooks__hooks.suppressDeprecationWarnings === false &&
     258                (typeof console !==  'undefined') && console.warn) {
     259            console.warn('Deprecation warning: ' + msg);
     260        }
     261    }
     262
     263    function deprecate(msg, fn) {
     264        var firstTime = true;
     265
     266        return extend(function () {
     267            if (utils_hooks__hooks.deprecationHandler != null) {
     268                utils_hooks__hooks.deprecationHandler(null, msg);
     269            }
     270            if (firstTime) {
     271                warn(msg + '\nArguments: ' + Array.prototype.slice.call(arguments).join(', ') + '\n' + (new Error()).stack);
     272                firstTime = false;
     273            }
     274            return fn.apply(this, arguments);
     275        }, fn);
     276    }
     277
     278    var deprecations = {};
     279
     280    function deprecateSimple(name, msg) {
     281        if (utils_hooks__hooks.deprecationHandler != null) {
     282            utils_hooks__hooks.deprecationHandler(name, msg);
     283        }
     284        if (!deprecations[name]) {
     285            warn(msg);
     286            deprecations[name] = true;
     287        }
     288    }
     289
     290    utils_hooks__hooks.suppressDeprecationWarnings = false;
     291    utils_hooks__hooks.deprecationHandler = null;
     292
     293    function isFunction(input) {
     294        return input instanceof Function || Object.prototype.toString.call(input) === '[object Function]';
     295    }
     296
     297    function isObject(input) {
     298        return Object.prototype.toString.call(input) === '[object Object]';
     299    }
     300
     301    function locale_set__set (config) {
     302        var prop, i;
     303        for (i in config) {
     304            prop = config[i];
     305            if (isFunction(prop)) {
     306                this[i] = prop;
     307            } else {
     308                this['_' + i] = prop;
     309            }
     310        }
     311        this._config = config;
     312        // Lenient ordinal parsing accepts just a number in addition to
     313        // number + (possibly) stuff coming from _ordinalParseLenient.
     314        this._ordinalParseLenient = new RegExp(this._ordinalParse.source + '|' + (/\d{1,2}/).source);
     315    }
     316
     317    function mergeConfigs(parentConfig, childConfig) {
     318        var res = extend({}, parentConfig), prop;
     319        for (prop in childConfig) {
     320            if (hasOwnProp(childConfig, prop)) {
     321                if (isObject(parentConfig[prop]) && isObject(childConfig[prop])) {
     322                    res[prop] = {};
     323                    extend(res[prop], parentConfig[prop]);
     324                    extend(res[prop], childConfig[prop]);
     325                } else if (childConfig[prop] != null) {
     326                    res[prop] = childConfig[prop];
     327                } else {
     328                    delete res[prop];
     329                }
     330            }
     331        }
     332        return res;
     333    }
     334
     335    function Locale(config) {
     336        if (config != null) {
     337            this.set(config);
     338        }
     339    }
     340
     341    var keys;
     342
     343    if (Object.keys) {
     344        keys = Object.keys;
     345    } else {
     346        keys = function (obj) {
     347            var i, res = [];
     348            for (i in obj) {
     349                if (hasOwnProp(obj, i)) {
     350                    res.push(i);
     351                }
     352            }
     353            return res;
     354        };
     355    }
     356
     357    // internal storage for locale config files
     358    var locales = {};
     359    var globalLocale;
     360
     361    function normalizeLocale(key) {
     362        return key ? key.toLowerCase().replace('_', '-') : key;
     363    }
     364
     365    // pick the locale from the array
     366    // try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each
     367    // substring from most specific to least, but move to the next array item if it's a more specific variant than the current root
     368    function chooseLocale(names) {
     369        var i = 0, j, next, locale, split;
     370
     371        while (i < names.length) {
     372            split = normalizeLocale(names[i]).split('-');
     373            j = split.length;
     374            next = normalizeLocale(names[i + 1]);
     375            next = next ? next.split('-') : null;
     376            while (j > 0) {
     377                locale = loadLocale(split.slice(0, j).join('-'));
     378                if (locale) {
     379                    return locale;
     380                }
     381                if (next && next.length >= j && compareArrays(split, next, true) >= j - 1) {
     382                    //the next array item is better than a shallower substring of this one
     383                    break;
     384                }
     385                j--;
     386            }
     387            i++;
     388        }
     389        return null;
     390    }
     391
     392    function loadLocale(name) {
     393        var oldLocale = null;
     394        // TODO: Find a better way to register and load all the locales in Node
     395        if (!locales[name] && (typeof module !== 'undefined') &&
     396                module && module.exports) {
     397            try {
     398                oldLocale = globalLocale._abbr;
     399                require('./locale/' + name);
     400                // because defineLocale currently also sets the global locale, we
     401                // want to undo that for lazy loaded locales
     402                locale_locales__getSetGlobalLocale(oldLocale);
     403            } catch (e) { }
     404        }
     405        return locales[name];
     406    }
     407
     408    // This function will load locale and then set the global locale.  If
     409    // no arguments are passed in, it will simply return the current global
     410    // locale key.
     411    function locale_locales__getSetGlobalLocale (key, values) {
     412        var data;
     413        if (key) {
     414            if (isUndefined(values)) {
     415                data = locale_locales__getLocale(key);
     416            }
     417            else {
     418                data = defineLocale(key, values);
     419            }
     420
     421            if (data) {
     422                // moment.duration._locale = moment._locale = data;
     423                globalLocale = data;
     424            }
     425        }
     426
     427        return globalLocale._abbr;
     428    }
     429
     430    function defineLocale (name, config) {
     431        if (config !== null) {
     432            config.abbr = name;
     433            if (locales[name] != null) {
     434                deprecateSimple('defineLocaleOverride',
     435                        'use moment.updateLocale(localeName, config) to change ' +
     436                        'an existing locale. moment.defineLocale(localeName, ' +
     437                        'config) should only be used for creating a new locale');
     438                config = mergeConfigs(locales[name]._config, config);
     439            } else if (config.parentLocale != null) {
     440                if (locales[config.parentLocale] != null) {
     441                    config = mergeConfigs(locales[config.parentLocale]._config, config);
     442                } else {
     443                    // treat as if there is no base config
     444                    deprecateSimple('parentLocaleUndefined',
     445                            'specified parentLocale is not defined yet');
     446                }
     447            }
     448            locales[name] = new Locale(config);
     449
     450            // backwards compat for now: also set the locale
     451            locale_locales__getSetGlobalLocale(name);
     452
     453            return locales[name];
     454        } else {
     455            // useful for testing
     456            delete locales[name];
     457            return null;
     458        }
     459    }
     460
     461    function updateLocale(name, config) {
     462        if (config != null) {
     463            var locale;
     464            if (locales[name] != null) {
     465                config = mergeConfigs(locales[name]._config, config);
     466            }
     467            locale = new Locale(config);
     468            locale.parentLocale = locales[name];
     469            locales[name] = locale;
     470
     471            // backwards compat for now: also set the locale
     472            locale_locales__getSetGlobalLocale(name);
     473        } else {
     474            // pass null for config to unupdate, useful for tests
     475            if (locales[name] != null) {
     476                if (locales[name].parentLocale != null) {
     477                    locales[name] = locales[name].parentLocale;
     478                } else if (locales[name] != null) {
     479                    delete locales[name];
     480                }
     481            }
     482        }
     483        return locales[name];
     484    }
     485
     486    // returns locale data
     487    function locale_locales__getLocale (key) {
     488        var locale;
     489
     490        if (key && key._locale && key._locale._abbr) {
     491            key = key._locale._abbr;
     492        }
     493
     494        if (!key) {
     495            return globalLocale;
     496        }
     497
     498        if (!isArray(key)) {
     499            //short-circuit everything else
     500            locale = loadLocale(key);
     501            if (locale) {
     502                return locale;
     503            }
     504            key = [key];
     505        }
     506
     507        return chooseLocale(key);
     508    }
     509
     510    function locale_locales__listLocales() {
     511        return keys(locales);
     512    }
     513
     514    var aliases = {};
     515
     516    function addUnitAlias (unit, shorthand) {
     517        var lowerCase = unit.toLowerCase();
     518        aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit;
     519    }
     520
     521    function normalizeUnits(units) {
     522        return typeof units === 'string' ? aliases[units] || aliases[units.toLowerCase()] : undefined;
     523    }
     524
     525    function normalizeObjectUnits(inputObject) {
     526        var normalizedInput = {},
     527            normalizedProp,
     528            prop;
     529
     530        for (prop in inputObject) {
     531            if (hasOwnProp(inputObject, prop)) {
     532                normalizedProp = normalizeUnits(prop);
     533                if (normalizedProp) {
     534                    normalizedInput[normalizedProp] = inputObject[prop];
     535                }
     536            }
     537        }
     538
     539        return normalizedInput;
     540    }
     541
     542    function makeGetSet (unit, keepTime) {
     543        return function (value) {
     544            if (value != null) {
     545                get_set__set(this, unit, value);
     546                utils_hooks__hooks.updateOffset(this, keepTime);
     547                return this;
     548            } else {
     549                return get_set__get(this, unit);
     550            }
     551        };
     552    }
     553
     554    function get_set__get (mom, unit) {
     555        return mom.isValid() ?
     556            mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]() : NaN;
     557    }
     558
     559    function get_set__set (mom, unit, value) {
     560        if (mom.isValid()) {
     561            mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value);
     562        }
     563    }
     564
     565    // MOMENTS
     566
     567    function getSet (units, value) {
     568        var unit;
     569        if (typeof units === 'object') {
     570            for (unit in units) {
     571                this.set(unit, units[unit]);
     572            }
     573        } else {
     574            units = normalizeUnits(units);
     575            if (isFunction(this[units])) {
     576                return this[units](value);
     577            }
     578        }
     579        return this;
     580    }
     581
     582    function zeroFill(number, targetLength, forceSign) {
     583        var absNumber = '' + Math.abs(number),
     584            zerosToFill = targetLength - absNumber.length,
     585            sign = number >= 0;
     586        return (sign ? (forceSign ? '+' : '') : '-') +
     587            Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) + absNumber;
     588    }
     589
     590    var formattingTokens = /(\[[^\[]*\])|(\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|YYYYYY|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g;
     591
     592    var localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g;
     593
     594    var formatFunctions = {};
     595
     596    var formatTokenFunctions = {};
     597
     598    // token:    'M'
     599    // padded:   ['MM', 2]
     600    // ordinal:  'Mo'
     601    // callback: function () { this.month() + 1 }
     602    function addFormatToken (token, padded, ordinal, callback) {
     603        var func = callback;
     604        if (typeof callback === 'string') {
     605            func = function () {
     606                return this[callback]();
     607            };
     608        }
     609        if (token) {
     610            formatTokenFunctions[token] = func;
     611        }
     612        if (padded) {
     613            formatTokenFunctions[padded[0]] = function () {
     614                return zeroFill(func.apply(this, arguments), padded[1], padded[2]);
     615            };
     616        }
     617        if (ordinal) {
     618            formatTokenFunctions[ordinal] = function () {
     619                return this.localeData().ordinal(func.apply(this, arguments), token);
     620            };
     621        }
     622    }
     623
     624    function removeFormattingTokens(input) {
     625        if (input.match(/\[[\s\S]/)) {
     626            return input.replace(/^\[|\]$/g, '');
     627        }
     628        return input.replace(/\\/g, '');
     629    }
     630
     631    function makeFormatFunction(format) {
     632        var array = format.match(formattingTokens), i, length;
     633
     634        for (i = 0, length = array.length; i < length; i++) {
     635            if (formatTokenFunctions[array[i]]) {
     636                array[i] = formatTokenFunctions[array[i]];
     637            } else {
     638                array[i] = removeFormattingTokens(array[i]);
     639            }
     640        }
     641
     642        return function (mom) {
     643            var output = '', i;
     644            for (i = 0; i < length; i++) {
     645                output += array[i] instanceof Function ? array[i].call(mom, format) : array[i];
     646            }
     647            return output;
     648        };
     649    }
     650
     651    // format date using native date object
     652    function formatMoment(m, format) {
     653        if (!m.isValid()) {
     654            return m.localeData().invalidDate();
     655        }
     656
     657        format = expandFormat(format, m.localeData());
     658        formatFunctions[format] = formatFunctions[format] || makeFormatFunction(format);
     659
     660        return formatFunctions[format](m);
     661    }
     662
     663    function expandFormat(format, locale) {
     664        var i = 5;
     665
     666        function replaceLongDateFormatTokens(input) {
     667            return locale.longDateFormat(input) || input;
     668        }
     669
     670        localFormattingTokens.lastIndex = 0;
     671        while (i >= 0 && localFormattingTokens.test(format)) {
     672            format = format.replace(localFormattingTokens, replaceLongDateFormatTokens);
     673            localFormattingTokens.lastIndex = 0;
     674            i -= 1;
     675        }
     676
     677        return format;
     678    }
     679
     680    var match1         = /\d/;            //       0 - 9
     681    var match2         = /\d\d/;          //      00 - 99
     682    var match3         = /\d{3}/;         //     000 - 999
     683    var match4         = /\d{4}/;         //    0000 - 9999
     684    var match6         = /[+-]?\d{6}/;    // -999999 - 999999
     685    var match1to2      = /\d\d?/;         //       0 - 99
     686    var match3to4      = /\d\d\d\d?/;     //     999 - 9999
     687    var match5to6      = /\d\d\d\d\d\d?/; //   99999 - 999999
     688    var match1to3      = /\d{1,3}/;       //       0 - 999
     689    var match1to4      = /\d{1,4}/;       //       0 - 9999
     690    var match1to6      = /[+-]?\d{1,6}/;  // -999999 - 999999
     691
     692    var matchUnsigned  = /\d+/;           //       0 - inf
     693    var matchSigned    = /[+-]?\d+/;      //    -inf - inf
     694
     695    var matchOffset    = /Z|[+-]\d\d:?\d\d/gi; // +00:00 -00:00 +0000 -0000 or Z
     696    var matchShortOffset = /Z|[+-]\d\d(?::?\d\d)?/gi; // +00 -00 +00:00 -00:00 +0000 -0000 or Z
     697
     698    var matchTimestamp = /[+-]?\d+(\.\d{1,3})?/; // 123456789 123456789.123
     699
     700    // any word (or two) characters or numbers including two/three word month in arabic.
     701    // includes scottish gaelic two word and hyphenated months
     702    var matchWord = /[0-9]*['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+|[\u0600-\u06FF\/]+(\s*?[\u0600-\u06FF]+){1,2}/i;
     703
     704
     705    var regexes = {};
     706
     707    function addRegexToken (token, regex, strictRegex) {
     708        regexes[token] = isFunction(regex) ? regex : function (isStrict, localeData) {
     709            return (isStrict && strictRegex) ? strictRegex : regex;
     710        };
     711    }
     712
     713    function getParseRegexForToken (token, config) {
     714        if (!hasOwnProp(regexes, token)) {
     715            return new RegExp(unescapeFormat(token));
     716        }
     717
     718        return regexes[token](config._strict, config._locale);
     719    }
     720
     721    // Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript
     722    function unescapeFormat(s) {
     723        return regexEscape(s.replace('\\', '').replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, function (matched, p1, p2, p3, p4) {
     724            return p1 || p2 || p3 || p4;
     725        }));
     726    }
     727
     728    function regexEscape(s) {
     729        return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
     730    }
     731
     732    var tokens = {};
     733
     734    function addParseToken (token, callback) {
     735        var i, func = callback;
     736        if (typeof token === 'string') {
     737            token = [token];
     738        }
     739        if (typeof callback === 'number') {
     740            func = function (input, array) {
     741                array[callback] = toInt(input);
     742            };
     743        }
     744        for (i = 0; i < token.length; i++) {
     745            tokens[token[i]] = func;
     746        }
     747    }
     748
     749    function addWeekParseToken (token, callback) {
     750        addParseToken(token, function (input, array, config, token) {
     751            config._w = config._w || {};
     752            callback(input, config._w, config, token);
     753        });
     754    }
     755
     756    function addTimeToArrayFromToken(token, input, config) {
     757        if (input != null && hasOwnProp(tokens, token)) {
     758            tokens[token](input, config._a, config, token);
     759        }
     760    }
     761
     762    var YEAR = 0;
     763    var MONTH = 1;
     764    var DATE = 2;
     765    var HOUR = 3;
     766    var MINUTE = 4;
     767    var SECOND = 5;
     768    var MILLISECOND = 6;
     769    var WEEK = 7;
     770    var WEEKDAY = 8;
     771
     772    var indexOf;
     773
     774    if (Array.prototype.indexOf) {
     775        indexOf = Array.prototype.indexOf;
     776    } else {
     777        indexOf = function (o) {
     778            // I know
     779            var i;
     780            for (i = 0; i < this.length; ++i) {
     781                if (this[i] === o) {
     782                    return i;
     783                }
     784            }
     785            return -1;
     786        };
     787    }
     788
     789    function daysInMonth(year, month) {
     790        return new Date(Date.UTC(year, month + 1, 0)).getUTCDate();
     791    }
     792
     793    // FORMATTING
     794
     795    addFormatToken('M', ['MM', 2], 'Mo', function () {
     796        return this.month() + 1;
     797    });
     798
     799    addFormatToken('MMM', 0, 0, function (format) {
     800        return this.localeData().monthsShort(this, format);
     801    });
     802
     803    addFormatToken('MMMM', 0, 0, function (format) {
     804        return this.localeData().months(this, format);
     805    });
     806
     807    // ALIASES
     808
     809    addUnitAlias('month', 'M');
     810
     811    // PARSING
     812
     813    addRegexToken('M',    match1to2);
     814    addRegexToken('MM',   match1to2, match2);
     815    addRegexToken('MMM',  function (isStrict, locale) {
     816        return locale.monthsShortRegex(isStrict);
     817    });
     818    addRegexToken('MMMM', function (isStrict, locale) {
     819        return locale.monthsRegex(isStrict);
     820    });
     821
     822    addParseToken(['M', 'MM'], function (input, array) {
     823        array[MONTH] = toInt(input) - 1;
     824    });
     825
     826    addParseToken(['MMM', 'MMMM'], function (input, array, config, token) {
     827        var month = config._locale.monthsParse(input, token, config._strict);
     828        // if we didn't find a month name, mark the date as invalid.
     829        if (month != null) {
     830            array[MONTH] = month;
     831        } else {
     832            getParsingFlags(config).invalidMonth = input;
     833        }
     834    });
     835
     836    // LOCALES
     837
     838    var MONTHS_IN_FORMAT = /D[oD]?(\[[^\[\]]*\]|\s+)+MMMM?/;
     839    var defaultLocaleMonths = 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_');
     840    function localeMonths (m, format) {
     841        return isArray(this._months) ? this._months[m.month()] :
     842            this._months[MONTHS_IN_FORMAT.test(format) ? 'format' : 'standalone'][m.month()];
     843    }
     844
     845    var defaultLocaleMonthsShort = 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_');
     846    function localeMonthsShort (m, format) {
     847        return isArray(this._monthsShort) ? this._monthsShort[m.month()] :
     848            this._monthsShort[MONTHS_IN_FORMAT.test(format) ? 'format' : 'standalone'][m.month()];
     849    }
     850
     851    function units_month__handleStrictParse(monthName, format, strict) {
     852        var i, ii, mom, llc = monthName.toLocaleLowerCase();
     853        if (!this._monthsParse) {
     854            // this is not used
     855            this._monthsParse = [];
     856            this._longMonthsParse = [];
     857            this._shortMonthsParse = [];
     858            for (i = 0; i < 12; ++i) {
     859                mom = create_utc__createUTC([2000, i]);
     860                this._shortMonthsParse[i] = this.monthsShort(mom, '').toLocaleLowerCase();
     861                this._longMonthsParse[i] = this.months(mom, '').toLocaleLowerCase();
     862            }
     863        }
     864
     865        if (strict) {
     866            if (format === 'MMM') {
     867                ii = indexOf.call(this._shortMonthsParse, llc);
     868                return ii !== -1 ? ii : null;
     869            } else {
     870                ii = indexOf.call(this._longMonthsParse, llc);
     871                return ii !== -1 ? ii : null;
     872            }
     873        } else {
     874            if (format === 'MMM') {
     875                ii = indexOf.call(this._shortMonthsParse, llc);
     876                if (ii !== -1) {
     877                    return ii;
     878                }
     879                ii = indexOf.call(this._longMonthsParse, llc);
     880                return ii !== -1 ? ii : null;
     881            } else {
     882                ii = indexOf.call(this._longMonthsParse, llc);
     883                if (ii !== -1) {
     884                    return ii;
     885                }
     886                ii = indexOf.call(this._shortMonthsParse, llc);
     887                return ii !== -1 ? ii : null;
     888            }
     889        }
     890    }
     891
     892    function localeMonthsParse (monthName, format, strict) {
     893        var i, mom, regex;
     894
     895        if (this._monthsParseExact) {
     896            return units_month__handleStrictParse.call(this, monthName, format, strict);
     897        }
     898
     899        if (!this._monthsParse) {
     900            this._monthsParse = [];
     901            this._longMonthsParse = [];
     902            this._shortMonthsParse = [];
     903        }
     904
     905        // TODO: add sorting
     906        // Sorting makes sure if one month (or abbr) is a prefix of another
     907        // see sorting in computeMonthsParse
     908        for (i = 0; i < 12; i++) {
     909            // make the regex if we don't have it already
     910            mom = create_utc__createUTC([2000, i]);
     911            if (strict && !this._longMonthsParse[i]) {
     912                this._longMonthsParse[i] = new RegExp('^' + this.months(mom, '').replace('.', '') + '$', 'i');
     913                this._shortMonthsParse[i] = new RegExp('^' + this.monthsShort(mom, '').replace('.', '') + '$', 'i');
     914            }
     915            if (!strict && !this._monthsParse[i]) {
     916                regex = '^' + this.months(mom, '') + '|^' + this.monthsShort(mom, '');
     917                this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i');
     918            }
     919            // test the regex
     920            if (strict && format === 'MMMM' && this._longMonthsParse[i].test(monthName)) {
     921                return i;
     922            } else if (strict && format === 'MMM' && this._shortMonthsParse[i].test(monthName)) {
     923                return i;
     924            } else if (!strict && this._monthsParse[i].test(monthName)) {
     925                return i;
     926            }
     927        }
     928    }
     929
     930    // MOMENTS
     931
     932    function setMonth (mom, value) {
     933        var dayOfMonth;
     934
     935        if (!mom.isValid()) {
     936            // No op
     937            return mom;
     938        }
     939
     940        if (typeof value === 'string') {
     941            if (/^\d+$/.test(value)) {
     942                value = toInt(value);
     943            } else {
     944                value = mom.localeData().monthsParse(value);
     945                // TODO: Another silent failure?
     946                if (typeof value !== 'number') {
     947                    return mom;
     948                }
     949            }
     950        }
     951
     952        dayOfMonth = Math.min(mom.date(), daysInMonth(mom.year(), value));
     953        mom._d['set' + (mom._isUTC ? 'UTC' : '') + 'Month'](value, dayOfMonth);
     954        return mom;
     955    }
     956
     957    function getSetMonth (value) {
     958        if (value != null) {
     959            setMonth(this, value);
     960            utils_hooks__hooks.updateOffset(this, true);
     961            return this;
     962        } else {
     963            return get_set__get(this, 'Month');
     964        }
     965    }
     966
     967    function getDaysInMonth () {
     968        return daysInMonth(this.year(), this.month());
     969    }
     970
     971    var defaultMonthsShortRegex = matchWord;
     972    function monthsShortRegex (isStrict) {
     973        if (this._monthsParseExact) {
     974            if (!hasOwnProp(this, '_monthsRegex')) {
     975                computeMonthsParse.call(this);
     976            }
     977            if (isStrict) {
     978                return this._monthsShortStrictRegex;
     979            } else {
     980                return this._monthsShortRegex;
     981            }
     982        } else {
     983            return this._monthsShortStrictRegex && isStrict ?
     984                this._monthsShortStrictRegex : this._monthsShortRegex;
     985        }
     986    }
     987
     988    var defaultMonthsRegex = matchWord;
     989    function monthsRegex (isStrict) {
     990        if (this._monthsParseExact) {
     991            if (!hasOwnProp(this, '_monthsRegex')) {
     992                computeMonthsParse.call(this);
     993            }
     994            if (isStrict) {
     995                return this._monthsStrictRegex;
     996            } else {
     997                return this._monthsRegex;
     998            }
     999        } else {
     1000            return this._monthsStrictRegex && isStrict ?
     1001                this._monthsStrictRegex : this._monthsRegex;
     1002        }
     1003    }
     1004
     1005    function computeMonthsParse () {
     1006        function cmpLenRev(a, b) {
     1007            return b.length - a.length;
     1008        }
     1009
     1010        var shortPieces = [], longPieces = [], mixedPieces = [],
     1011            i, mom;
     1012        for (i = 0; i < 12; i++) {
     1013            // make the regex if we don't have it already
     1014            mom = create_utc__createUTC([2000, i]);
     1015            shortPieces.push(this.monthsShort(mom, ''));
     1016            longPieces.push(this.months(mom, ''));
     1017            mixedPieces.push(this.months(mom, ''));
     1018            mixedPieces.push(this.monthsShort(mom, ''));
     1019        }
     1020        // Sorting makes sure if one month (or abbr) is a prefix of another it
     1021        // will match the longer piece.
     1022        shortPieces.sort(cmpLenRev);
     1023        longPieces.sort(cmpLenRev);
     1024        mixedPieces.sort(cmpLenRev);
     1025        for (i = 0; i < 12; i++) {
     1026            shortPieces[i] = regexEscape(shortPieces[i]);
     1027            longPieces[i] = regexEscape(longPieces[i]);
     1028            mixedPieces[i] = regexEscape(mixedPieces[i]);
     1029        }
     1030
     1031        this._monthsRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
     1032        this._monthsShortRegex = this._monthsRegex;
     1033        this._monthsStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i');
     1034        this._monthsShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i');
     1035    }
     1036
     1037    function checkOverflow (m) {
     1038        var overflow;
     1039        var a = m._a;
     1040
     1041        if (a && getParsingFlags(m).overflow === -2) {
     1042            overflow =
     1043                a[MONTH]       < 0 || a[MONTH]       > 11  ? MONTH :
     1044                a[DATE]        < 1 || a[DATE]        > daysInMonth(a[YEAR], a[MONTH]) ? DATE :
     1045                a[HOUR]        < 0 || a[HOUR]        > 24 || (a[HOUR] === 24 && (a[MINUTE] !== 0 || a[SECOND] !== 0 || a[MILLISECOND] !== 0)) ? HOUR :
     1046                a[MINUTE]      < 0 || a[MINUTE]      > 59  ? MINUTE :
     1047                a[SECOND]      < 0 || a[SECOND]      > 59  ? SECOND :
     1048                a[MILLISECOND] < 0 || a[MILLISECOND] > 999 ? MILLISECOND :
     1049                -1;
     1050
     1051            if (getParsingFlags(m)._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) {
     1052                overflow = DATE;
     1053            }
     1054            if (getParsingFlags(m)._overflowWeeks && overflow === -1) {
     1055                overflow = WEEK;
     1056            }
     1057            if (getParsingFlags(m)._overflowWeekday && overflow === -1) {
     1058                overflow = WEEKDAY;
     1059            }
     1060
     1061            getParsingFlags(m).overflow = overflow;
     1062        }
     1063
     1064        return m;
     1065    }
     1066
     1067    // iso 8601 regex
     1068    // 0000-00-00 0000-W00 or 0000-W00-0 + T + 00 or 00:00 or 00:00:00 or 00:00:00.000 + +00:00 or +0000 or +00)
     1069    var extendedIsoRegex = /^\s*((?:[+-]\d{6}|\d{4})-(?:\d\d-\d\d|W\d\d-\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?::\d\d(?::\d\d(?:[.,]\d+)?)?)?)([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?/;
     1070    var basicIsoRegex = /^\s*((?:[+-]\d{6}|\d{4})(?:\d\d\d\d|W\d\d\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?:\d\d(?:\d\d(?:[.,]\d+)?)?)?)([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?/;
     1071
     1072    var tzRegex = /Z|[+-]\d\d(?::?\d\d)?/;
     1073
     1074    var isoDates = [
     1075        ['YYYYYY-MM-DD', /[+-]\d{6}-\d\d-\d\d/],
     1076        ['YYYY-MM-DD', /\d{4}-\d\d-\d\d/],
     1077        ['GGGG-[W]WW-E', /\d{4}-W\d\d-\d/],
     1078        ['GGGG-[W]WW', /\d{4}-W\d\d/, false],
     1079        ['YYYY-DDD', /\d{4}-\d{3}/],
     1080        ['YYYY-MM', /\d{4}-\d\d/, false],
     1081        ['YYYYYYMMDD', /[+-]\d{10}/],
     1082        ['YYYYMMDD', /\d{8}/],
     1083        // YYYYMM is NOT allowed by the standard
     1084        ['GGGG[W]WWE', /\d{4}W\d{3}/],
     1085        ['GGGG[W]WW', /\d{4}W\d{2}/, false],
     1086        ['YYYYDDD', /\d{7}/]
     1087    ];
     1088
     1089    // iso time formats and regexes
     1090    var isoTimes = [
     1091        ['HH:mm:ss.SSSS', /\d\d:\d\d:\d\d\.\d+/],
     1092        ['HH:mm:ss,SSSS', /\d\d:\d\d:\d\d,\d+/],
     1093        ['HH:mm:ss', /\d\d:\d\d:\d\d/],
     1094        ['HH:mm', /\d\d:\d\d/],
     1095        ['HHmmss.SSSS', /\d\d\d\d\d\d\.\d+/],
     1096        ['HHmmss,SSSS', /\d\d\d\d\d\d,\d+/],
     1097        ['HHmmss', /\d\d\d\d\d\d/],
     1098        ['HHmm', /\d\d\d\d/],
     1099        ['HH', /\d\d/]
     1100    ];
     1101
     1102    var aspNetJsonRegex = /^\/?Date\((\-?\d+)/i;
     1103
     1104    // date from iso format
     1105    function configFromISO(config) {
     1106        var i, l,
     1107            string = config._i,
     1108            match = extendedIsoRegex.exec(string) || basicIsoRegex.exec(string),
     1109            allowTime, dateFormat, timeFormat, tzFormat;
     1110
     1111        if (match) {
     1112            getParsingFlags(config).iso = true;
     1113
     1114            for (i = 0, l = isoDates.length; i < l; i++) {
     1115                if (isoDates[i][1].exec(match[1])) {
     1116                    dateFormat = isoDates[i][0];
     1117                    allowTime = isoDates[i][2] !== false;
     1118                    break;
     1119                }
     1120            }
     1121            if (dateFormat == null) {
     1122                config._isValid = false;
     1123                return;
     1124            }
     1125            if (match[3]) {
     1126                for (i = 0, l = isoTimes.length; i < l; i++) {
     1127                    if (isoTimes[i][1].exec(match[3])) {
     1128                        // match[2] should be 'T' or space
     1129                        timeFormat = (match[2] || ' ') + isoTimes[i][0];
     1130                        break;
     1131                    }
     1132                }
     1133                if (timeFormat == null) {
     1134                    config._isValid = false;
     1135                    return;
     1136                }
     1137            }
     1138            if (!allowTime && timeFormat != null) {
     1139                config._isValid = false;
     1140                return;
     1141            }
     1142            if (match[4]) {
     1143                if (tzRegex.exec(match[4])) {
     1144                    tzFormat = 'Z';
     1145                } else {
     1146                    config._isValid = false;
     1147                    return;
     1148                }
     1149            }
     1150            config._f = dateFormat + (timeFormat || '') + (tzFormat || '');
     1151            configFromStringAndFormat(config);
     1152        } else {
     1153            config._isValid = false;
     1154        }
     1155    }
     1156
     1157    // date from iso format or fallback
     1158    function configFromString(config) {
     1159        var matched = aspNetJsonRegex.exec(config._i);
     1160
     1161        if (matched !== null) {
     1162            config._d = new Date(+matched[1]);
     1163            return;
     1164        }
     1165
     1166        configFromISO(config);
     1167        if (config._isValid === false) {
     1168            delete config._isValid;
     1169            utils_hooks__hooks.createFromInputFallback(config);
     1170        }
     1171    }
     1172
     1173    utils_hooks__hooks.createFromInputFallback = deprecate(
     1174        'moment construction falls back to js Date. This is ' +
     1175        'discouraged and will be removed in upcoming major ' +
     1176        'release. Please refer to ' +
     1177        'https://github.com/moment/moment/issues/1407 for more info.',
     1178        function (config) {
     1179            config._d = new Date(config._i + (config._useUTC ? ' UTC' : ''));
     1180        }
     1181    );
     1182
     1183    function createDate (y, m, d, h, M, s, ms) {
     1184        //can't just apply() to create a date:
     1185        //http://stackoverflow.com/questions/181348/instantiating-a-javascript-object-by-calling-prototype-constructor-apply
     1186        var date = new Date(y, m, d, h, M, s, ms);
     1187
     1188        //the date constructor remaps years 0-99 to 1900-1999
     1189        if (y < 100 && y >= 0 && isFinite(date.getFullYear())) {
     1190            date.setFullYear(y);
     1191        }
     1192        return date;
     1193    }
     1194
     1195    function createUTCDate (y) {
     1196        var date = new Date(Date.UTC.apply(null, arguments));
     1197
     1198        //the Date.UTC function remaps years 0-99 to 1900-1999
     1199        if (y < 100 && y >= 0 && isFinite(date.getUTCFullYear())) {
     1200            date.setUTCFullYear(y);
     1201        }
     1202        return date;
     1203    }
     1204
     1205    // FORMATTING
     1206
     1207    addFormatToken('Y', 0, 0, function () {
     1208        var y = this.year();
     1209        return y <= 9999 ? '' + y : '+' + y;
     1210    });
     1211
     1212    addFormatToken(0, ['YY', 2], 0, function () {
     1213        return this.year() % 100;
     1214    });
     1215
     1216    addFormatToken(0, ['YYYY',   4],       0, 'year');
     1217    addFormatToken(0, ['YYYYY',  5],       0, 'year');
     1218    addFormatToken(0, ['YYYYYY', 6, true], 0, 'year');
     1219
     1220    // ALIASES
     1221
     1222    addUnitAlias('year', 'y');
     1223
     1224    // PARSING
     1225
     1226    addRegexToken('Y',      matchSigned);
     1227    addRegexToken('YY',     match1to2, match2);
     1228    addRegexToken('YYYY',   match1to4, match4);
     1229    addRegexToken('YYYYY',  match1to6, match6);
     1230    addRegexToken('YYYYYY', match1to6, match6);
     1231
     1232    addParseToken(['YYYYY', 'YYYYYY'], YEAR);
     1233    addParseToken('YYYY', function (input, array) {
     1234        array[YEAR] = input.length === 2 ? utils_hooks__hooks.parseTwoDigitYear(input) : toInt(input);
     1235    });
     1236    addParseToken('YY', function (input, array) {
     1237        array[YEAR] = utils_hooks__hooks.parseTwoDigitYear(input);
     1238    });
     1239    addParseToken('Y', function (input, array) {
     1240        array[YEAR] = parseInt(input, 10);
     1241    });
     1242
     1243    // HELPERS
     1244
     1245    function daysInYear(year) {
     1246        return isLeapYear(year) ? 366 : 365;
     1247    }
     1248
     1249    function isLeapYear(year) {
     1250        return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
     1251    }
     1252
     1253    // HOOKS
     1254
     1255    utils_hooks__hooks.parseTwoDigitYear = function (input) {
     1256        return toInt(input) + (toInt(input) > 68 ? 1900 : 2000);
     1257    };
     1258
     1259    // MOMENTS
     1260
     1261    var getSetYear = makeGetSet('FullYear', true);
     1262
     1263    function getIsLeapYear () {
     1264        return isLeapYear(this.year());
     1265    }
     1266
     1267    // start-of-first-week - start-of-year
     1268    function firstWeekOffset(year, dow, doy) {
     1269        var // first-week day -- which january is always in the first week (4 for iso, 1 for other)
     1270            fwd = 7 + dow - doy,
     1271            // first-week day local weekday -- which local weekday is fwd
     1272            fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7;
     1273
     1274        return -fwdlw + fwd - 1;
     1275    }
     1276
     1277    //http://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday
     1278    function dayOfYearFromWeeks(year, week, weekday, dow, doy) {
     1279        var localWeekday = (7 + weekday - dow) % 7,
     1280            weekOffset = firstWeekOffset(year, dow, doy),
     1281            dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset,
     1282            resYear, resDayOfYear;
     1283
     1284        if (dayOfYear <= 0) {
     1285            resYear = year - 1;
     1286            resDayOfYear = daysInYear(resYear) + dayOfYear;
     1287        } else if (dayOfYear > daysInYear(year)) {
     1288            resYear = year + 1;
     1289            resDayOfYear = dayOfYear - daysInYear(year);
     1290        } else {
     1291            resYear = year;
     1292            resDayOfYear = dayOfYear;
     1293        }
     1294
     1295        return {
     1296            year: resYear,
     1297            dayOfYear: resDayOfYear
     1298        };
     1299    }
     1300
     1301    function weekOfYear(mom, dow, doy) {
     1302        var weekOffset = firstWeekOffset(mom.year(), dow, doy),
     1303            week = Math.floor((mom.dayOfYear() - weekOffset - 1) / 7) + 1,
     1304            resWeek, resYear;
     1305
     1306        if (week < 1) {
     1307            resYear = mom.year() - 1;
     1308            resWeek = week + weeksInYear(resYear, dow, doy);
     1309        } else if (week > weeksInYear(mom.year(), dow, doy)) {
     1310            resWeek = week - weeksInYear(mom.year(), dow, doy);
     1311            resYear = mom.year() + 1;
     1312        } else {
     1313            resYear = mom.year();
     1314            resWeek = week;
     1315        }
     1316
     1317        return {
     1318            week: resWeek,
     1319            year: resYear
     1320        };
     1321    }
     1322
     1323    function weeksInYear(year, dow, doy) {
     1324        var weekOffset = firstWeekOffset(year, dow, doy),
     1325            weekOffsetNext = firstWeekOffset(year + 1, dow, doy);
     1326        return (daysInYear(year) - weekOffset + weekOffsetNext) / 7;
     1327    }
     1328
     1329    // Pick the first defined of two or three arguments.
     1330    function defaults(a, b, c) {
     1331        if (a != null) {
     1332            return a;
     1333        }
     1334        if (b != null) {
     1335            return b;
     1336        }
     1337        return c;
     1338    }
     1339
     1340    function currentDateArray(config) {
     1341        // hooks is actually the exported moment object
     1342        var nowValue = new Date(utils_hooks__hooks.now());
     1343        if (config._useUTC) {
     1344            return [nowValue.getUTCFullYear(), nowValue.getUTCMonth(), nowValue.getUTCDate()];
     1345        }
     1346        return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()];
     1347    }
     1348
     1349    // convert an array to a date.
     1350    // the array should mirror the parameters below
     1351    // note: all values past the year are optional and will default to the lowest possible value.
     1352    // [year, month, day , hour, minute, second, millisecond]
     1353    function configFromArray (config) {
     1354        var i, date, input = [], currentDate, yearToUse;
     1355
     1356        if (config._d) {
     1357            return;
     1358        }
     1359
     1360        currentDate = currentDateArray(config);
     1361
     1362        //compute day of the year from weeks and weekdays
     1363        if (config._w && config._a[DATE] == null && config._a[MONTH] == null) {
     1364            dayOfYearFromWeekInfo(config);
     1365        }
     1366
     1367        //if the day of the year is set, figure out what it is
     1368        if (config._dayOfYear) {
     1369            yearToUse = defaults(config._a[YEAR], currentDate[YEAR]);
     1370
     1371            if (config._dayOfYear > daysInYear(yearToUse)) {
     1372                getParsingFlags(config)._overflowDayOfYear = true;
     1373            }
     1374
     1375            date = createUTCDate(yearToUse, 0, config._dayOfYear);
     1376            config._a[MONTH] = date.getUTCMonth();
     1377            config._a[DATE] = date.getUTCDate();
     1378        }
     1379
     1380        // Default to current date.
     1381        // * if no year, month, day of month are given, default to today
     1382        // * if day of month is given, default month and year
     1383        // * if month is given, default only year
     1384        // * if year is given, don't default anything
     1385        for (i = 0; i < 3 && config._a[i] == null; ++i) {
     1386            config._a[i] = input[i] = currentDate[i];
     1387        }
     1388
     1389        // Zero out whatever was not defaulted, including time
     1390        for (; i < 7; i++) {
     1391            config._a[i] = input[i] = (config._a[i] == null) ? (i === 2 ? 1 : 0) : config._a[i];
     1392        }
     1393
     1394        // Check for 24:00:00.000
     1395        if (config._a[HOUR] === 24 &&
     1396                config._a[MINUTE] === 0 &&
     1397                config._a[SECOND] === 0 &&
     1398                config._a[MILLISECOND] === 0) {
     1399            config._nextDay = true;
     1400            config._a[HOUR] = 0;
     1401        }
     1402
     1403        config._d = (config._useUTC ? createUTCDate : createDate).apply(null, input);
     1404        // Apply timezone offset from input. The actual utcOffset can be changed
     1405        // with parseZone.
     1406        if (config._tzm != null) {
     1407            config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
     1408        }
     1409
     1410        if (config._nextDay) {
     1411            config._a[HOUR] = 24;
     1412        }
     1413    }
     1414
     1415    function dayOfYearFromWeekInfo(config) {
     1416        var w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow;
     1417
     1418        w = config._w;
     1419        if (w.GG != null || w.W != null || w.E != null) {
     1420            dow = 1;
     1421            doy = 4;
     1422
     1423            // TODO: We need to take the current isoWeekYear, but that depends on
     1424            // how we interpret now (local, utc, fixed offset). So create
     1425            // a now version of current config (take local/utc/offset flags, and
     1426            // create now).
     1427            weekYear = defaults(w.GG, config._a[YEAR], weekOfYear(local__createLocal(), 1, 4).year);
     1428            week = defaults(w.W, 1);
     1429            weekday = defaults(w.E, 1);
     1430            if (weekday < 1 || weekday > 7) {
     1431                weekdayOverflow = true;
     1432            }
     1433        } else {
     1434            dow = config._locale._week.dow;
     1435            doy = config._locale._week.doy;
     1436
     1437            weekYear = defaults(w.gg, config._a[YEAR], weekOfYear(local__createLocal(), dow, doy).year);
     1438            week = defaults(w.w, 1);
     1439
     1440            if (w.d != null) {
     1441                // weekday -- low day numbers are considered next week
     1442                weekday = w.d;
     1443                if (weekday < 0 || weekday > 6) {
     1444                    weekdayOverflow = true;
     1445                }
     1446            } else if (w.e != null) {
     1447                // local weekday -- counting starts from begining of week
     1448                weekday = w.e + dow;
     1449                if (w.e < 0 || w.e > 6) {
     1450                    weekdayOverflow = true;
     1451                }
     1452            } else {
     1453                // default to begining of week
     1454                weekday = dow;
     1455            }
     1456        }
     1457        if (week < 1 || week > weeksInYear(weekYear, dow, doy)) {
     1458            getParsingFlags(config)._overflowWeeks = true;
     1459        } else if (weekdayOverflow != null) {
     1460            getParsingFlags(config)._overflowWeekday = true;
     1461        } else {
     1462            temp = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy);
     1463            config._a[YEAR] = temp.year;
     1464            config._dayOfYear = temp.dayOfYear;
     1465        }
     1466    }
     1467
     1468    // constant that refers to the ISO standard
     1469    utils_hooks__hooks.ISO_8601 = function () {};
     1470
     1471    // date from string and format string
     1472    function configFromStringAndFormat(config) {
     1473        // TODO: Move this to another part of the creation flow to prevent circular deps
     1474        if (config._f === utils_hooks__hooks.ISO_8601) {
     1475            configFromISO(config);
     1476            return;
     1477        }
     1478
     1479        config._a = [];
     1480        getParsingFlags(config).empty = true;
     1481
     1482        // This array is used to make a Date, either with `new Date` or `Date.UTC`
     1483        var string = '' + config._i,
     1484            i, parsedInput, tokens, token, skipped,
     1485            stringLength = string.length,
     1486            totalParsedInputLength = 0;
     1487
     1488        tokens = expandFormat(config._f, config._locale).match(formattingTokens) || [];
     1489
     1490        for (i = 0; i < tokens.length; i++) {
     1491            token = tokens[i];
     1492            parsedInput = (string.match(getParseRegexForToken(token, config)) || [])[0];
     1493            // console.log('token', token, 'parsedInput', parsedInput,
     1494            //         'regex', getParseRegexForToken(token, config));
     1495            if (parsedInput) {
     1496                skipped = string.substr(0, string.indexOf(parsedInput));
     1497                if (skipped.length > 0) {
     1498                    getParsingFlags(config).unusedInput.push(skipped);
     1499                }
     1500                string = string.slice(string.indexOf(parsedInput) + parsedInput.length);
     1501                totalParsedInputLength += parsedInput.length;
     1502            }
     1503            // don't parse if it's not a known token
     1504            if (formatTokenFunctions[token]) {
     1505                if (parsedInput) {
     1506                    getParsingFlags(config).empty = false;
     1507                }
     1508                else {
     1509                    getParsingFlags(config).unusedTokens.push(token);
     1510                }
     1511                addTimeToArrayFromToken(token, parsedInput, config);
     1512            }
     1513            else if (config._strict && !parsedInput) {
     1514                getParsingFlags(config).unusedTokens.push(token);
     1515            }
     1516        }
     1517
     1518        // add remaining unparsed input length to the string
     1519        getParsingFlags(config).charsLeftOver = stringLength - totalParsedInputLength;
     1520        if (string.length > 0) {
     1521            getParsingFlags(config).unusedInput.push(string);
     1522        }
     1523
     1524        // clear _12h flag if hour is <= 12
     1525        if (getParsingFlags(config).bigHour === true &&
     1526                config._a[HOUR] <= 12 &&
     1527                config._a[HOUR] > 0) {
     1528            getParsingFlags(config).bigHour = undefined;
     1529        }
     1530
     1531        getParsingFlags(config).parsedDateParts = config._a.slice(0);
     1532        getParsingFlags(config).meridiem = config._meridiem;
     1533        // handle meridiem
     1534        config._a[HOUR] = meridiemFixWrap(config._locale, config._a[HOUR], config._meridiem);
     1535
     1536        configFromArray(config);
     1537        checkOverflow(config);
     1538    }
     1539
     1540
     1541    function meridiemFixWrap (locale, hour, meridiem) {
     1542        var isPm;
     1543
     1544        if (meridiem == null) {
     1545            // nothing to do
     1546            return hour;
     1547        }
     1548        if (locale.meridiemHour != null) {
     1549            return locale.meridiemHour(hour, meridiem);
     1550        } else if (locale.isPM != null) {
     1551            // Fallback
     1552            isPm = locale.isPM(meridiem);
     1553            if (isPm && hour < 12) {
     1554                hour += 12;
     1555            }
     1556            if (!isPm && hour === 12) {
     1557                hour = 0;
     1558            }
     1559            return hour;
     1560        } else {
     1561            // this is not supposed to happen
     1562            return hour;
     1563        }
     1564    }
     1565
     1566    // date from string and array of format strings
     1567    function configFromStringAndArray(config) {
     1568        var tempConfig,
     1569            bestMoment,
     1570
     1571            scoreToBeat,
     1572            i,
     1573            currentScore;
     1574
     1575        if (config._f.length === 0) {
     1576            getParsingFlags(config).invalidFormat = true;
     1577            config._d = new Date(NaN);
     1578            return;
     1579        }
     1580
     1581        for (i = 0; i < config._f.length; i++) {
     1582            currentScore = 0;
     1583            tempConfig = copyConfig({}, config);
     1584            if (config._useUTC != null) {
     1585                tempConfig._useUTC = config._useUTC;
     1586            }
     1587            tempConfig._f = config._f[i];
     1588            configFromStringAndFormat(tempConfig);
     1589
     1590            if (!valid__isValid(tempConfig)) {
     1591                continue;
     1592            }
     1593
     1594            // if there is any input that was not parsed add a penalty for that format
     1595            currentScore += getParsingFlags(tempConfig).charsLeftOver;
     1596
     1597            //or tokens
     1598            currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10;
     1599
     1600            getParsingFlags(tempConfig).score = currentScore;
     1601
     1602            if (scoreToBeat == null || currentScore < scoreToBeat) {
     1603                scoreToBeat = currentScore;
     1604                bestMoment = tempConfig;
     1605            }
     1606        }
     1607
     1608        extend(config, bestMoment || tempConfig);
     1609    }
     1610
     1611    function configFromObject(config) {
     1612        if (config._d) {
     1613            return;
     1614        }
     1615
     1616        var i = normalizeObjectUnits(config._i);
     1617        config._a = map([i.year, i.month, i.day || i.date, i.hour, i.minute, i.second, i.millisecond], function (obj) {
     1618            return obj && parseInt(obj, 10);
     1619        });
     1620
     1621        configFromArray(config);
     1622    }
     1623
     1624    function createFromConfig (config) {
     1625        var res = new Moment(checkOverflow(prepareConfig(config)));
     1626        if (res._nextDay) {
     1627            // Adding is smart enough around DST
     1628            res.add(1, 'd');
     1629            res._nextDay = undefined;
     1630        }
     1631
     1632        return res;
     1633    }
     1634
     1635    function prepareConfig (config) {
     1636        var input = config._i,
     1637            format = config._f;
     1638
     1639        config._locale = config._locale || locale_locales__getLocale(config._l);
     1640
     1641        if (input === null || (format === undefined && input === '')) {
     1642            return valid__createInvalid({nullInput: true});
     1643        }
     1644
     1645        if (typeof input === 'string') {
     1646            config._i = input = config._locale.preparse(input);
     1647        }
     1648
     1649        if (isMoment(input)) {
     1650            return new Moment(checkOverflow(input));
     1651        } else if (isArray(format)) {
     1652            configFromStringAndArray(config);
     1653        } else if (format) {
     1654            configFromStringAndFormat(config);
     1655        } else if (isDate(input)) {
     1656            config._d = input;
     1657        } else {
     1658            configFromInput(config);
     1659        }
     1660
     1661        if (!valid__isValid(config)) {
     1662            config._d = null;
     1663        }
     1664
     1665        return config;
     1666    }
     1667
     1668    function configFromInput(config) {
     1669        var input = config._i;
     1670        if (input === undefined) {
     1671            config._d = new Date(utils_hooks__hooks.now());
     1672        } else if (isDate(input)) {
     1673            config._d = new Date(input.valueOf());
     1674        } else if (typeof input === 'string') {
     1675            configFromString(config);
     1676        } else if (isArray(input)) {
     1677            config._a = map(input.slice(0), function (obj) {
     1678                return parseInt(obj, 10);
     1679            });
     1680            configFromArray(config);
     1681        } else if (typeof(input) === 'object') {
     1682            configFromObject(config);
     1683        } else if (typeof(input) === 'number') {
     1684            // from milliseconds
     1685            config._d = new Date(input);
     1686        } else {
     1687            utils_hooks__hooks.createFromInputFallback(config);
     1688        }
     1689    }
     1690
     1691    function createLocalOrUTC (input, format, locale, strict, isUTC) {
     1692        var c = {};
     1693
     1694        if (typeof(locale) === 'boolean') {
     1695            strict = locale;
     1696            locale = undefined;
     1697        }
     1698        // object construction must be done this way.
     1699        // https://github.com/moment/moment/issues/1423
     1700        c._isAMomentObject = true;
     1701        c._useUTC = c._isUTC = isUTC;
     1702        c._l = locale;
     1703        c._i = input;
     1704        c._f = format;
     1705        c._strict = strict;
     1706
     1707        return createFromConfig(c);
     1708    }
     1709
     1710    function local__createLocal (input, format, locale, strict) {
     1711        return createLocalOrUTC(input, format, locale, strict, false);
     1712    }
     1713
     1714    var prototypeMin = deprecate(
     1715         'moment().min is deprecated, use moment.max instead. https://github.com/moment/moment/issues/1548',
     1716         function () {
     1717             var other = local__createLocal.apply(null, arguments);
     1718             if (this.isValid() && other.isValid()) {
     1719                 return other < this ? this : other;
     1720             } else {
     1721                 return valid__createInvalid();
     1722             }
     1723         }
     1724     );
     1725
     1726    var prototypeMax = deprecate(
     1727        'moment().max is deprecated, use moment.min instead. https://github.com/moment/moment/issues/1548',
     1728        function () {
     1729            var other = local__createLocal.apply(null, arguments);
     1730            if (this.isValid() && other.isValid()) {
     1731                return other > this ? this : other;
     1732            } else {
     1733                return valid__createInvalid();
     1734            }
     1735        }
     1736    );
     1737
     1738    // Pick a moment m from moments so that m[fn](other) is true for all
     1739    // other. This relies on the function fn to be transitive.
     1740    //
     1741    // moments should either be an array of moment objects or an array, whose
     1742    // first element is an array of moment objects.
     1743    function pickBy(fn, moments) {
     1744        var res, i;
     1745        if (moments.length === 1 && isArray(moments[0])) {
     1746            moments = moments[0];
     1747        }
     1748        if (!moments.length) {
     1749            return local__createLocal();
     1750        }
     1751        res = moments[0];
     1752        for (i = 1; i < moments.length; ++i) {
     1753            if (!moments[i].isValid() || moments[i][fn](res)) {
     1754                res = moments[i];
     1755            }
     1756        }
     1757        return res;
     1758    }
     1759
     1760    // TODO: Use [].sort instead?
     1761    function min () {
     1762        var args = [].slice.call(arguments, 0);
     1763
     1764        return pickBy('isBefore', args);
     1765    }
     1766
     1767    function max () {
     1768        var args = [].slice.call(arguments, 0);
     1769
     1770        return pickBy('isAfter', args);
     1771    }
     1772
     1773    var now = function () {
     1774        return Date.now ? Date.now() : +(new Date());
     1775    };
     1776
     1777    function Duration (duration) {
     1778        var normalizedInput = normalizeObjectUnits(duration),
     1779            years = normalizedInput.year || 0,
     1780            quarters = normalizedInput.quarter || 0,
     1781            months = normalizedInput.month || 0,
     1782            weeks = normalizedInput.week || 0,
     1783            days = normalizedInput.day || 0,
     1784            hours = normalizedInput.hour || 0,
     1785            minutes = normalizedInput.minute || 0,
     1786            seconds = normalizedInput.second || 0,
     1787            milliseconds = normalizedInput.millisecond || 0;
     1788
     1789        // representation for dateAddRemove
     1790        this._milliseconds = +milliseconds +
     1791            seconds * 1e3 + // 1000
     1792            minutes * 6e4 + // 1000 * 60
     1793            hours * 1000 * 60 * 60; //using 1000 * 60 * 60 instead of 36e5 to avoid floating point rounding errors https://github.com/moment/moment/issues/2978
     1794        // Because of dateAddRemove treats 24 hours as different from a
     1795        // day when working around DST, we need to store them separately
     1796        this._days = +days +
     1797            weeks * 7;
     1798        // It is impossible translate months into days without knowing
     1799        // which months you are are talking about, so we have to store
     1800        // it separately.
     1801        this._months = +months +
     1802            quarters * 3 +
     1803            years * 12;
     1804
     1805        this._data = {};
     1806
     1807        this._locale = locale_locales__getLocale();
     1808
     1809        this._bubble();
     1810    }
     1811
     1812    function isDuration (obj) {
     1813        return obj instanceof Duration;
     1814    }
     1815
     1816    // FORMATTING
     1817
     1818    function offset (token, separator) {
     1819        addFormatToken(token, 0, 0, function () {
     1820            var offset = this.utcOffset();
     1821            var sign = '+';
     1822            if (offset < 0) {
     1823                offset = -offset;
     1824                sign = '-';
     1825            }
     1826            return sign + zeroFill(~~(offset / 60), 2) + separator + zeroFill(~~(offset) % 60, 2);
     1827        });
     1828    }
     1829
     1830    offset('Z', ':');
     1831    offset('ZZ', '');
     1832
     1833    // PARSING
     1834
     1835    addRegexToken('Z',  matchShortOffset);
     1836    addRegexToken('ZZ', matchShortOffset);
     1837    addParseToken(['Z', 'ZZ'], function (input, array, config) {
     1838        config._useUTC = true;
     1839        config._tzm = offsetFromString(matchShortOffset, input);
     1840    });
     1841
     1842    // HELPERS
     1843
     1844    // timezone chunker
     1845    // '+10:00' > ['10',  '00']
     1846    // '-1530'  > ['-15', '30']
     1847    var chunkOffset = /([\+\-]|\d\d)/gi;
     1848
     1849    function offsetFromString(matcher, string) {
     1850        var matches = ((string || '').match(matcher) || []);
     1851        var chunk   = matches[matches.length - 1] || [];
     1852        var parts   = (chunk + '').match(chunkOffset) || ['-', 0, 0];
     1853        var minutes = +(parts[1] * 60) + toInt(parts[2]);
     1854
     1855        return parts[0] === '+' ? minutes : -minutes;
     1856    }
     1857
     1858    // Return a moment from input, that is local/utc/zone equivalent to model.
     1859    function cloneWithOffset(input, model) {
     1860        var res, diff;
     1861        if (model._isUTC) {
     1862            res = model.clone();
     1863            diff = (isMoment(input) || isDate(input) ? input.valueOf() : local__createLocal(input).valueOf()) - res.valueOf();
     1864            // Use low-level api, because this fn is low-level api.
     1865            res._d.setTime(res._d.valueOf() + diff);
     1866            utils_hooks__hooks.updateOffset(res, false);
     1867            return res;
     1868        } else {
     1869            return local__createLocal(input).local();
     1870        }
     1871    }
     1872
     1873    function getDateOffset (m) {
     1874        // On Firefox.24 Date#getTimezoneOffset returns a floating point.
     1875        // https://github.com/moment/moment/pull/1871
     1876        return -Math.round(m._d.getTimezoneOffset() / 15) * 15;
     1877    }
     1878
     1879    // HOOKS
     1880
     1881    // This function will be called whenever a moment is mutated.
     1882    // It is intended to keep the offset in sync with the timezone.
     1883    utils_hooks__hooks.updateOffset = function () {};
     1884
     1885    // MOMENTS
     1886
     1887    // keepLocalTime = true means only change the timezone, without
     1888    // affecting the local hour. So 5:31:26 +0300 --[utcOffset(2, true)]-->
     1889    // 5:31:26 +0200 It is possible that 5:31:26 doesn't exist with offset
     1890    // +0200, so we adjust the time as needed, to be valid.
     1891    //
     1892    // Keeping the time actually adds/subtracts (one hour)
     1893    // from the actual represented time. That is why we call updateOffset
     1894    // a second time. In case it wants us to change the offset again
     1895    // _changeInProgress == true case, then we have to adjust, because
     1896    // there is no such time in the given timezone.
     1897    function getSetOffset (input, keepLocalTime) {
     1898        var offset = this._offset || 0,
     1899            localAdjust;
     1900        if (!this.isValid()) {
     1901            return input != null ? this : NaN;
     1902        }
     1903        if (input != null) {
     1904            if (typeof input === 'string') {
     1905                input = offsetFromString(matchShortOffset, input);
     1906            } else if (Math.abs(input) < 16) {
     1907                input = input * 60;
     1908            }
     1909            if (!this._isUTC && keepLocalTime) {
     1910                localAdjust = getDateOffset(this);
     1911            }
     1912            this._offset = input;
     1913            this._isUTC = true;
     1914            if (localAdjust != null) {
     1915                this.add(localAdjust, 'm');
     1916            }
     1917            if (offset !== input) {
     1918                if (!keepLocalTime || this._changeInProgress) {
     1919                    add_subtract__addSubtract(this, create__createDuration(input - offset, 'm'), 1, false);
     1920                } else if (!this._changeInProgress) {
     1921                    this._changeInProgress = true;
     1922                    utils_hooks__hooks.updateOffset(this, true);
     1923                    this._changeInProgress = null;
     1924                }
     1925            }
     1926            return this;
     1927        } else {
     1928            return this._isUTC ? offset : getDateOffset(this);
     1929        }
     1930    }
     1931
     1932    function getSetZone (input, keepLocalTime) {
     1933        if (input != null) {
     1934            if (typeof input !== 'string') {
     1935                input = -input;
     1936            }
     1937
     1938            this.utcOffset(input, keepLocalTime);
     1939
     1940            return this;
     1941        } else {
     1942            return -this.utcOffset();
     1943        }
     1944    }
     1945
     1946    function setOffsetToUTC (keepLocalTime) {
     1947        return this.utcOffset(0, keepLocalTime);
     1948    }
     1949
     1950    function setOffsetToLocal (keepLocalTime) {
     1951        if (this._isUTC) {
     1952            this.utcOffset(0, keepLocalTime);
     1953            this._isUTC = false;
     1954
     1955            if (keepLocalTime) {
     1956                this.subtract(getDateOffset(this), 'm');
     1957            }
     1958        }
     1959        return this;
     1960    }
     1961
     1962    function setOffsetToParsedOffset () {
     1963        if (this._tzm) {
     1964            this.utcOffset(this._tzm);
     1965        } else if (typeof this._i === 'string') {
     1966            this.utcOffset(offsetFromString(matchOffset, this._i));
     1967        }
     1968        return this;
     1969    }
     1970
     1971    function hasAlignedHourOffset (input) {
     1972        if (!this.isValid()) {
     1973            return false;
     1974        }
     1975        input = input ? local__createLocal(input).utcOffset() : 0;
     1976
     1977        return (this.utcOffset() - input) % 60 === 0;
     1978    }
     1979
     1980    function isDaylightSavingTime () {
     1981        return (
     1982            this.utcOffset() > this.clone().month(0).utcOffset() ||
     1983            this.utcOffset() > this.clone().month(5).utcOffset()
     1984        );
     1985    }
     1986
     1987    function isDaylightSavingTimeShifted () {
     1988        if (!isUndefined(this._isDSTShifted)) {
     1989            return this._isDSTShifted;
     1990        }
     1991
     1992        var c = {};
     1993
     1994        copyConfig(c, this);
     1995        c = prepareConfig(c);
     1996
     1997        if (c._a) {
     1998            var other = c._isUTC ? create_utc__createUTC(c._a) : local__createLocal(c._a);
     1999            this._isDSTShifted = this.isValid() &&
     2000                compareArrays(c._a, other.toArray()) > 0;
     2001        } else {
     2002            this._isDSTShifted = false;
     2003        }
     2004
     2005        return this._isDSTShifted;
     2006    }
     2007
     2008    function isLocal () {
     2009        return this.isValid() ? !this._isUTC : false;
     2010    }
     2011
     2012    function isUtcOffset () {
     2013        return this.isValid() ? this._isUTC : false;
     2014    }
     2015
     2016    function isUtc () {
     2017        return this.isValid() ? this._isUTC && this._offset === 0 : false;
     2018    }
     2019
     2020    // ASP.NET json date format regex
     2021    var aspNetRegex = /^(\-)?(?:(\d*)[. ])?(\d+)\:(\d+)(?:\:(\d+)\.?(\d{3})?\d*)?$/;
     2022
     2023    // from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html
     2024    // somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere
     2025    // and further modified to allow for strings containing both week and day
     2026    var isoRegex = /^(-)?P(?:(-?[0-9,.]*)Y)?(?:(-?[0-9,.]*)M)?(?:(-?[0-9,.]*)W)?(?:(-?[0-9,.]*)D)?(?:T(?:(-?[0-9,.]*)H)?(?:(-?[0-9,.]*)M)?(?:(-?[0-9,.]*)S)?)?$/;
     2027
     2028    function create__createDuration (input, key) {
     2029        var duration = input,
     2030            // matching against regexp is expensive, do it on demand
     2031            match = null,
     2032            sign,
     2033            ret,
     2034            diffRes;
     2035
     2036        if (isDuration(input)) {
     2037            duration = {
     2038                ms : input._milliseconds,
     2039                d  : input._days,
     2040                M  : input._months
     2041            };
     2042        } else if (typeof input === 'number') {
     2043            duration = {};
     2044            if (key) {
     2045                duration[key] = input;
     2046            } else {
     2047                duration.milliseconds = input;
     2048            }
     2049        } else if (!!(match = aspNetRegex.exec(input))) {
     2050            sign = (match[1] === '-') ? -1 : 1;
     2051            duration = {
     2052                y  : 0,
     2053                d  : toInt(match[DATE])        * sign,
     2054                h  : toInt(match[HOUR])        * sign,
     2055                m  : toInt(match[MINUTE])      * sign,
     2056                s  : toInt(match[SECOND])      * sign,
     2057                ms : toInt(match[MILLISECOND]) * sign
     2058            };
     2059        } else if (!!(match = isoRegex.exec(input))) {
     2060            sign = (match[1] === '-') ? -1 : 1;
     2061            duration = {
     2062                y : parseIso(match[2], sign),
     2063                M : parseIso(match[3], sign),
     2064                w : parseIso(match[4], sign),
     2065                d : parseIso(match[5], sign),
     2066                h : parseIso(match[6], sign),
     2067                m : parseIso(match[7], sign),
     2068                s : parseIso(match[8], sign)
     2069            };
     2070        } else if (duration == null) {// checks for null or undefined
     2071            duration = {};
     2072        } else if (typeof duration === 'object' && ('from' in duration || 'to' in duration)) {
     2073            diffRes = momentsDifference(local__createLocal(duration.from), local__createLocal(duration.to));
     2074
     2075            duration = {};
     2076            duration.ms = diffRes.milliseconds;
     2077            duration.M = diffRes.months;
     2078        }
     2079
     2080        ret = new Duration(duration);
     2081
     2082        if (isDuration(input) && hasOwnProp(input, '_locale')) {
     2083            ret._locale = input._locale;
     2084        }
     2085
     2086        return ret;
     2087    }
     2088
     2089    create__createDuration.fn = Duration.prototype;
     2090
     2091    function parseIso (inp, sign) {
     2092        // We'd normally use ~~inp for this, but unfortunately it also
     2093        // converts floats to ints.
     2094        // inp may be undefined, so careful calling replace on it.
     2095        var res = inp && parseFloat(inp.replace(',', '.'));
     2096        // apply sign while we're at it
     2097        return (isNaN(res) ? 0 : res) * sign;
     2098    }
     2099
     2100    function positiveMomentsDifference(base, other) {
     2101        var res = {milliseconds: 0, months: 0};
     2102
     2103        res.months = other.month() - base.month() +
     2104            (other.year() - base.year()) * 12;
     2105        if (base.clone().add(res.months, 'M').isAfter(other)) {
     2106            --res.months;
     2107        }
     2108
     2109        res.milliseconds = +other - +(base.clone().add(res.months, 'M'));
     2110
     2111        return res;
     2112    }
     2113
     2114    function momentsDifference(base, other) {
     2115        var res;
     2116        if (!(base.isValid() && other.isValid())) {
     2117            return {milliseconds: 0, months: 0};
     2118        }
     2119
     2120        other = cloneWithOffset(other, base);
     2121        if (base.isBefore(other)) {
     2122            res = positiveMomentsDifference(base, other);
     2123        } else {
     2124            res = positiveMomentsDifference(other, base);
     2125            res.milliseconds = -res.milliseconds;
     2126            res.months = -res.months;
     2127        }
     2128
     2129        return res;
     2130    }
     2131
     2132    function absRound (number) {
     2133        if (number < 0) {
     2134            return Math.round(-1 * number) * -1;
     2135        } else {
     2136            return Math.round(number);
     2137        }
     2138    }
     2139
     2140    // TODO: remove 'name' arg after deprecation is removed
     2141    function createAdder(direction, name) {
     2142        return function (val, period) {
     2143            var dur, tmp;
     2144            //invert the arguments, but complain about it
     2145            if (period !== null && !isNaN(+period)) {
     2146                deprecateSimple(name, 'moment().' + name  + '(period, number) is deprecated. Please use moment().' + name + '(number, period).');
     2147                tmp = val; val = period; period = tmp;
     2148            }
     2149
     2150            val = typeof val === 'string' ? +val : val;
     2151            dur = create__createDuration(val, period);
     2152            add_subtract__addSubtract(this, dur, direction);
     2153            return this;
     2154        };
     2155    }
     2156
     2157    function add_subtract__addSubtract (mom, duration, isAdding, updateOffset) {
     2158        var milliseconds = duration._milliseconds,
     2159            days = absRound(duration._days),
     2160            months = absRound(duration._months);
     2161
     2162        if (!mom.isValid()) {
     2163            // No op
     2164            return;
     2165        }
     2166
     2167        updateOffset = updateOffset == null ? true : updateOffset;
     2168
     2169        if (milliseconds) {
     2170            mom._d.setTime(mom._d.valueOf() + milliseconds * isAdding);
     2171        }
     2172        if (days) {
     2173            get_set__set(mom, 'Date', get_set__get(mom, 'Date') + days * isAdding);
     2174        }
     2175        if (months) {
     2176            setMonth(mom, get_set__get(mom, 'Month') + months * isAdding);
     2177        }
     2178        if (updateOffset) {
     2179            utils_hooks__hooks.updateOffset(mom, days || months);
     2180        }
     2181    }
     2182
     2183    var add_subtract__add      = createAdder(1, 'add');
     2184    var add_subtract__subtract = createAdder(-1, 'subtract');
     2185
     2186    function moment_calendar__calendar (time, formats) {
     2187        // We want to compare the start of today, vs this.
     2188        // Getting start-of-today depends on whether we're local/utc/offset or not.
     2189        var now = time || local__createLocal(),
     2190            sod = cloneWithOffset(now, this).startOf('day'),
     2191            diff = this.diff(sod, 'days', true),
     2192            format = diff < -6 ? 'sameElse' :
     2193                diff < -1 ? 'lastWeek' :
     2194                diff < 0 ? 'lastDay' :
     2195                diff < 1 ? 'sameDay' :
     2196                diff < 2 ? 'nextDay' :
     2197                diff < 7 ? 'nextWeek' : 'sameElse';
     2198
     2199        var output = formats && (isFunction(formats[format]) ? formats[format]() : formats[format]);
     2200
     2201        return this.format(output || this.localeData().calendar(format, this, local__createLocal(now)));
     2202    }
     2203
     2204    function clone () {
     2205        return new Moment(this);
     2206    }
     2207
     2208    function isAfter (input, units) {
     2209        var localInput = isMoment(input) ? input : local__createLocal(input);
     2210        if (!(this.isValid() && localInput.isValid())) {
     2211            return false;
     2212        }
     2213        units = normalizeUnits(!isUndefined(units) ? units : 'millisecond');
     2214        if (units === 'millisecond') {
     2215            return this.valueOf() > localInput.valueOf();
     2216        } else {
     2217            return localInput.valueOf() < this.clone().startOf(units).valueOf();
     2218        }
     2219    }
     2220
     2221    function isBefore (input, units) {
     2222        var localInput = isMoment(input) ? input : local__createLocal(input);
     2223        if (!(this.isValid() && localInput.isValid())) {
     2224            return false;
     2225        }
     2226        units = normalizeUnits(!isUndefined(units) ? units : 'millisecond');
     2227        if (units === 'millisecond') {
     2228            return this.valueOf() < localInput.valueOf();
     2229        } else {
     2230            return this.clone().endOf(units).valueOf() < localInput.valueOf();
     2231        }
     2232    }
     2233
     2234    function isBetween (from, to, units, inclusivity) {
     2235        inclusivity = inclusivity || '()';
     2236        return (inclusivity[0] === '(' ? this.isAfter(from, units) : !this.isBefore(from, units)) &&
     2237            (inclusivity[1] === ')' ? this.isBefore(to, units) : !this.isAfter(to, units));
     2238    }
     2239
     2240    function isSame (input, units) {
     2241        var localInput = isMoment(input) ? input : local__createLocal(input),
     2242            inputMs;
     2243        if (!(this.isValid() && localInput.isValid())) {
     2244            return false;
     2245        }
     2246        units = normalizeUnits(units || 'millisecond');
     2247        if (units === 'millisecond') {
     2248            return this.valueOf() === localInput.valueOf();
     2249        } else {
     2250            inputMs = localInput.valueOf();
     2251            return this.clone().startOf(units).valueOf() <= inputMs && inputMs <= this.clone().endOf(units).valueOf();
     2252        }
     2253    }
     2254
     2255    function isSameOrAfter (input, units) {
     2256        return this.isSame(input, units) || this.isAfter(input,units);
     2257    }
     2258
     2259    function isSameOrBefore (input, units) {
     2260        return this.isSame(input, units) || this.isBefore(input,units);
     2261    }
     2262
     2263    function diff (input, units, asFloat) {
     2264        var that,
     2265            zoneDelta,
     2266            delta, output;
     2267
     2268        if (!this.isValid()) {
     2269            return NaN;
     2270        }
     2271
     2272        that = cloneWithOffset(input, this);
     2273
     2274        if (!that.isValid()) {
     2275            return NaN;
     2276        }
     2277
     2278        zoneDelta = (that.utcOffset() - this.utcOffset()) * 6e4;
     2279
     2280        units = normalizeUnits(units);
     2281
     2282        if (units === 'year' || units === 'month' || units === 'quarter') {
     2283            output = monthDiff(this, that);
     2284            if (units === 'quarter') {
     2285                output = output / 3;
     2286            } else if (units === 'year') {
     2287                output = output / 12;
     2288            }
     2289        } else {
     2290            delta = this - that;
     2291            output = units === 'second' ? delta / 1e3 : // 1000
     2292                units === 'minute' ? delta / 6e4 : // 1000 * 60
     2293                units === 'hour' ? delta / 36e5 : // 1000 * 60 * 60
     2294                units === 'day' ? (delta - zoneDelta) / 864e5 : // 1000 * 60 * 60 * 24, negate dst
     2295                units === 'week' ? (delta - zoneDelta) / 6048e5 : // 1000 * 60 * 60 * 24 * 7, negate dst
     2296                delta;
     2297        }
     2298        return asFloat ? output : absFloor(output);
     2299    }
     2300
     2301    function monthDiff (a, b) {
     2302        // difference in months
     2303        var wholeMonthDiff = ((b.year() - a.year()) * 12) + (b.month() - a.month()),
     2304            // b is in (anchor - 1 month, anchor + 1 month)
     2305            anchor = a.clone().add(wholeMonthDiff, 'months'),
     2306            anchor2, adjust;
     2307
     2308        if (b - anchor < 0) {
     2309            anchor2 = a.clone().add(wholeMonthDiff - 1, 'months');
     2310            // linear across the month
     2311            adjust = (b - anchor) / (anchor - anchor2);
     2312        } else {
     2313            anchor2 = a.clone().add(wholeMonthDiff + 1, 'months');
     2314            // linear across the month
     2315            adjust = (b - anchor) / (anchor2 - anchor);
     2316        }
     2317
     2318        //check for negative zero, return zero if negative zero
     2319        return -(wholeMonthDiff + adjust) || 0;
     2320    }
     2321
     2322    utils_hooks__hooks.defaultFormat = 'YYYY-MM-DDTHH:mm:ssZ';
     2323    utils_hooks__hooks.defaultFormatUtc = 'YYYY-MM-DDTHH:mm:ss[Z]';
     2324
     2325    function toString () {
     2326        return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ');
     2327    }
     2328
     2329    function moment_format__toISOString () {
     2330        var m = this.clone().utc();
     2331        if (0 < m.year() && m.year() <= 9999) {
     2332            if (isFunction(Date.prototype.toISOString)) {
     2333                // native implementation is ~50x faster, use it when we can
     2334                return this.toDate().toISOString();
     2335            } else {
     2336                return formatMoment(m, 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]');
     2337            }
     2338        } else {
     2339            return formatMoment(m, 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]');
     2340        }
     2341    }
     2342
     2343    function format (inputString) {
     2344        if (!inputString) {
     2345            inputString = this.isUtc() ? utils_hooks__hooks.defaultFormatUtc : utils_hooks__hooks.defaultFormat;
     2346        }
     2347        var output = formatMoment(this, inputString);
     2348        return this.localeData().postformat(output);
     2349    }
     2350
     2351    function from (time, withoutSuffix) {
     2352        if (this.isValid() &&
     2353                ((isMoment(time) && time.isValid()) ||
     2354                 local__createLocal(time).isValid())) {
     2355            return create__createDuration({to: this, from: time}).locale(this.locale()).humanize(!withoutSuffix);
     2356        } else {
     2357            return this.localeData().invalidDate();
     2358        }
     2359    }
     2360
     2361    function fromNow (withoutSuffix) {
     2362        return this.from(local__createLocal(), withoutSuffix);
     2363    }
     2364
     2365    function to (time, withoutSuffix) {
     2366        if (this.isValid() &&
     2367                ((isMoment(time) && time.isValid()) ||
     2368                 local__createLocal(time).isValid())) {
     2369            return create__createDuration({from: this, to: time}).locale(this.locale()).humanize(!withoutSuffix);
     2370        } else {
     2371            return this.localeData().invalidDate();
     2372        }
     2373    }
     2374
     2375    function toNow (withoutSuffix) {
     2376        return this.to(local__createLocal(), withoutSuffix);
     2377    }
     2378
     2379    // If passed a locale key, it will set the locale for this
     2380    // instance.  Otherwise, it will return the locale configuration
     2381    // variables for this instance.
     2382    function locale (key) {
     2383        var newLocaleData;
     2384
     2385        if (key === undefined) {
     2386            return this._locale._abbr;
     2387        } else {
     2388            newLocaleData = locale_locales__getLocale(key);
     2389            if (newLocaleData != null) {
     2390                this._locale = newLocaleData;
     2391            }
     2392            return this;
     2393        }
     2394    }
     2395
     2396    var lang = deprecate(
     2397        'moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.',
     2398        function (key) {
     2399            if (key === undefined) {
     2400                return this.localeData();
     2401            } else {
     2402                return this.locale(key);
     2403            }
     2404        }
     2405    );
     2406
     2407    function localeData () {
     2408        return this._locale;
     2409    }
     2410
     2411    function startOf (units) {
     2412        units = normalizeUnits(units);
     2413        // the following switch intentionally omits break keywords
     2414        // to utilize falling through the cases.
     2415        switch (units) {
     2416        case 'year':
     2417            this.month(0);
     2418            /* falls through */
     2419        case 'quarter':
     2420        case 'month':
     2421            this.date(1);
     2422            /* falls through */
     2423        case 'week':
     2424        case 'isoWeek':
     2425        case 'day':
     2426        case 'date':
     2427            this.hours(0);
     2428            /* falls through */
     2429        case 'hour':
     2430            this.minutes(0);
     2431            /* falls through */
     2432        case 'minute':
     2433            this.seconds(0);
     2434            /* falls through */
     2435        case 'second':
     2436            this.milliseconds(0);
     2437        }
     2438
     2439        // weeks are a special case
     2440        if (units === 'week') {
     2441            this.weekday(0);
     2442        }
     2443        if (units === 'isoWeek') {
     2444            this.isoWeekday(1);
     2445        }
     2446
     2447        // quarters are also special
     2448        if (units === 'quarter') {
     2449            this.month(Math.floor(this.month() / 3) * 3);
     2450        }
     2451
     2452        return this;
     2453    }
     2454
     2455    function endOf (units) {
     2456        units = normalizeUnits(units);
     2457        if (units === undefined || units === 'millisecond') {
     2458            return this;
     2459        }
     2460
     2461        // 'date' is an alias for 'day', so it should be considered as such.
     2462        if (units === 'date') {
     2463            units = 'day';
     2464        }
     2465
     2466        return this.startOf(units).add(1, (units === 'isoWeek' ? 'week' : units)).subtract(1, 'ms');
     2467    }
     2468
     2469    function to_type__valueOf () {
     2470        return this._d.valueOf() - ((this._offset || 0) * 60000);
     2471    }
     2472
     2473    function unix () {
     2474        return Math.floor(this.valueOf() / 1000);
     2475    }
     2476
     2477    function toDate () {
     2478        return this._offset ? new Date(this.valueOf()) : this._d;
     2479    }
     2480
     2481    function toArray () {
     2482        var m = this;
     2483        return [m.year(), m.month(), m.date(), m.hour(), m.minute(), m.second(), m.millisecond()];
     2484    }
     2485
     2486    function toObject () {
     2487        var m = this;
     2488        return {
     2489            years: m.year(),
     2490            months: m.month(),
     2491            date: m.date(),
     2492            hours: m.hours(),
     2493            minutes: m.minutes(),
     2494            seconds: m.seconds(),
     2495            milliseconds: m.milliseconds()
     2496        };
     2497    }
     2498
     2499    function toJSON () {
     2500        // new Date(NaN).toJSON() === null
     2501        return this.isValid() ? this.toISOString() : null;
     2502    }
     2503
     2504    function moment_valid__isValid () {
     2505        return valid__isValid(this);
     2506    }
     2507
     2508    function parsingFlags () {
     2509        return extend({}, getParsingFlags(this));
     2510    }
     2511
     2512    function invalidAt () {
     2513        return getParsingFlags(this).overflow;
     2514    }
     2515
     2516    function creationData() {
     2517        return {
     2518            input: this._i,
     2519            format: this._f,
     2520            locale: this._locale,
     2521            isUTC: this._isUTC,
     2522            strict: this._strict
     2523        };
     2524    }
     2525
     2526    // FORMATTING
     2527
     2528    addFormatToken(0, ['gg', 2], 0, function () {
     2529        return this.weekYear() % 100;
     2530    });
     2531
     2532    addFormatToken(0, ['GG', 2], 0, function () {
     2533        return this.isoWeekYear() % 100;
     2534    });
     2535
     2536    function addWeekYearFormatToken (token, getter) {
     2537        addFormatToken(0, [token, token.length], 0, getter);
     2538    }
     2539
     2540    addWeekYearFormatToken('gggg',     'weekYear');
     2541    addWeekYearFormatToken('ggggg',    'weekYear');
     2542    addWeekYearFormatToken('GGGG',  'isoWeekYear');
     2543    addWeekYearFormatToken('GGGGG', 'isoWeekYear');
     2544
     2545    // ALIASES
     2546
     2547    addUnitAlias('weekYear', 'gg');
     2548    addUnitAlias('isoWeekYear', 'GG');
     2549
     2550    // PARSING
     2551
     2552    addRegexToken('G',      matchSigned);
     2553    addRegexToken('g',      matchSigned);
     2554    addRegexToken('GG',     match1to2, match2);
     2555    addRegexToken('gg',     match1to2, match2);
     2556    addRegexToken('GGGG',   match1to4, match4);
     2557    addRegexToken('gggg',   match1to4, match4);
     2558    addRegexToken('GGGGG',  match1to6, match6);
     2559    addRegexToken('ggggg',  match1to6, match6);
     2560
     2561    addWeekParseToken(['gggg', 'ggggg', 'GGGG', 'GGGGG'], function (input, week, config, token) {
     2562        week[token.substr(0, 2)] = toInt(input);
     2563    });
     2564
     2565    addWeekParseToken(['gg', 'GG'], function (input, week, config, token) {
     2566        week[token] = utils_hooks__hooks.parseTwoDigitYear(input);
     2567    });
     2568
     2569    // MOMENTS
     2570
     2571    function getSetWeekYear (input) {
     2572        return getSetWeekYearHelper.call(this,
     2573                input,
     2574                this.week(),
     2575                this.weekday(),
     2576                this.localeData()._week.dow,
     2577                this.localeData()._week.doy);
     2578    }
     2579
     2580    function getSetISOWeekYear (input) {
     2581        return getSetWeekYearHelper.call(this,
     2582                input, this.isoWeek(), this.isoWeekday(), 1, 4);
     2583    }
     2584
     2585    function getISOWeeksInYear () {
     2586        return weeksInYear(this.year(), 1, 4);
     2587    }
     2588
     2589    function getWeeksInYear () {
     2590        var weekInfo = this.localeData()._week;
     2591        return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy);
     2592    }
     2593
     2594    function getSetWeekYearHelper(input, week, weekday, dow, doy) {
     2595        var weeksTarget;
     2596        if (input == null) {
     2597            return weekOfYear(this, dow, doy).year;
     2598        } else {
     2599            weeksTarget = weeksInYear(input, dow, doy);
     2600            if (week > weeksTarget) {
     2601                week = weeksTarget;
     2602            }
     2603            return setWeekAll.call(this, input, week, weekday, dow, doy);
     2604        }
     2605    }
     2606
     2607    function setWeekAll(weekYear, week, weekday, dow, doy) {
     2608        var dayOfYearData = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy),
     2609            date = createUTCDate(dayOfYearData.year, 0, dayOfYearData.dayOfYear);
     2610
     2611        this.year(date.getUTCFullYear());
     2612        this.month(date.getUTCMonth());
     2613        this.date(date.getUTCDate());
     2614        return this;
     2615    }
     2616
     2617    // FORMATTING
     2618
     2619    addFormatToken('Q', 0, 'Qo', 'quarter');
     2620
     2621    // ALIASES
     2622
     2623    addUnitAlias('quarter', 'Q');
     2624
     2625    // PARSING
     2626
     2627    addRegexToken('Q', match1);
     2628    addParseToken('Q', function (input, array) {
     2629        array[MONTH] = (toInt(input) - 1) * 3;
     2630    });
     2631
     2632    // MOMENTS
     2633
     2634    function getSetQuarter (input) {
     2635        return input == null ? Math.ceil((this.month() + 1) / 3) : this.month((input - 1) * 3 + this.month() % 3);
     2636    }
     2637
     2638    // FORMATTING
     2639
     2640    addFormatToken('w', ['ww', 2], 'wo', 'week');
     2641    addFormatToken('W', ['WW', 2], 'Wo', 'isoWeek');
     2642
     2643    // ALIASES
     2644
     2645    addUnitAlias('week', 'w');
     2646    addUnitAlias('isoWeek', 'W');
     2647
     2648    // PARSING
     2649
     2650    addRegexToken('w',  match1to2);
     2651    addRegexToken('ww', match1to2, match2);
     2652    addRegexToken('W',  match1to2);
     2653    addRegexToken('WW', match1to2, match2);
     2654
     2655    addWeekParseToken(['w', 'ww', 'W', 'WW'], function (input, week, config, token) {
     2656        week[token.substr(0, 1)] = toInt(input);
     2657    });
     2658
     2659    // HELPERS
     2660
     2661    // LOCALES
     2662
     2663    function localeWeek (mom) {
     2664        return weekOfYear(mom, this._week.dow, this._week.doy).week;
     2665    }
     2666
     2667    var defaultLocaleWeek = {
     2668        dow : 0, // Sunday is the first day of the week.
     2669        doy : 6  // The week that contains Jan 1st is the first week of the year.
     2670    };
     2671
     2672    function localeFirstDayOfWeek () {
     2673        return this._week.dow;
     2674    }
     2675
     2676    function localeFirstDayOfYear () {
     2677        return this._week.doy;
     2678    }
     2679
     2680    // MOMENTS
     2681
     2682    function getSetWeek (input) {
     2683        var week = this.localeData().week(this);
     2684        return input == null ? week : this.add((input - week) * 7, 'd');
     2685    }
     2686
     2687    function getSetISOWeek (input) {
     2688        var week = weekOfYear(this, 1, 4).week;
     2689        return input == null ? week : this.add((input - week) * 7, 'd');
     2690    }
     2691
     2692    // FORMATTING
     2693
     2694    addFormatToken('D', ['DD', 2], 'Do', 'date');
     2695
     2696    // ALIASES
     2697
     2698    addUnitAlias('date', 'D');
     2699
     2700    // PARSING
     2701
     2702    addRegexToken('D',  match1to2);
     2703    addRegexToken('DD', match1to2, match2);
     2704    addRegexToken('Do', function (isStrict, locale) {
     2705        return isStrict ? locale._ordinalParse : locale._ordinalParseLenient;
     2706    });
     2707
     2708    addParseToken(['D', 'DD'], DATE);
     2709    addParseToken('Do', function (input, array) {
     2710        array[DATE] = toInt(input.match(match1to2)[0], 10);
     2711    });
     2712
     2713    // MOMENTS
     2714
     2715    var getSetDayOfMonth = makeGetSet('Date', true);
     2716
     2717    // FORMATTING
     2718
     2719    addFormatToken('d', 0, 'do', 'day');
     2720
     2721    addFormatToken('dd', 0, 0, function (format) {
     2722        return this.localeData().weekdaysMin(this, format);
     2723    });
     2724
     2725    addFormatToken('ddd', 0, 0, function (format) {
     2726        return this.localeData().weekdaysShort(this, format);
     2727    });
     2728
     2729    addFormatToken('dddd', 0, 0, function (format) {
     2730        return this.localeData().weekdays(this, format);
     2731    });
     2732
     2733    addFormatToken('e', 0, 0, 'weekday');
     2734    addFormatToken('E', 0, 0, 'isoWeekday');
     2735
     2736    // ALIASES
     2737
     2738    addUnitAlias('day', 'd');
     2739    addUnitAlias('weekday', 'e');
     2740    addUnitAlias('isoWeekday', 'E');
     2741
     2742    // PARSING
     2743
     2744    addRegexToken('d',    match1to2);
     2745    addRegexToken('e',    match1to2);
     2746    addRegexToken('E',    match1to2);
     2747    addRegexToken('dd',   function (isStrict, locale) {
     2748        return locale.weekdaysMinRegex(isStrict);
     2749    });
     2750    addRegexToken('ddd',   function (isStrict, locale) {
     2751        return locale.weekdaysShortRegex(isStrict);
     2752    });
     2753    addRegexToken('dddd',   function (isStrict, locale) {
     2754        return locale.weekdaysRegex(isStrict);
     2755    });
     2756
     2757    addWeekParseToken(['dd', 'ddd', 'dddd'], function (input, week, config, token) {
     2758        var weekday = config._locale.weekdaysParse(input, token, config._strict);
     2759        // if we didn't get a weekday name, mark the date as invalid
     2760        if (weekday != null) {
     2761            week.d = weekday;
     2762        } else {
     2763            getParsingFlags(config).invalidWeekday = input;
     2764        }
     2765    });
     2766
     2767    addWeekParseToken(['d', 'e', 'E'], function (input, week, config, token) {
     2768        week[token] = toInt(input);
     2769    });
     2770
     2771    // HELPERS
     2772
     2773    function parseWeekday(input, locale) {
     2774        if (typeof input !== 'string') {
     2775            return input;
     2776        }
     2777
     2778        if (!isNaN(input)) {
     2779            return parseInt(input, 10);
     2780        }
     2781
     2782        input = locale.weekdaysParse(input);
     2783        if (typeof input === 'number') {
     2784            return input;
     2785        }
     2786
     2787        return null;
     2788    }
     2789
     2790    // LOCALES
     2791
     2792    var defaultLocaleWeekdays = 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_');
     2793    function localeWeekdays (m, format) {
     2794        return isArray(this._weekdays) ? this._weekdays[m.day()] :
     2795            this._weekdays[this._weekdays.isFormat.test(format) ? 'format' : 'standalone'][m.day()];
     2796    }
     2797
     2798    var defaultLocaleWeekdaysShort = 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_');
     2799    function localeWeekdaysShort (m) {
     2800        return this._weekdaysShort[m.day()];
     2801    }
     2802
     2803    var defaultLocaleWeekdaysMin = 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_');
     2804    function localeWeekdaysMin (m) {
     2805        return this._weekdaysMin[m.day()];
     2806    }
     2807
     2808    function day_of_week__handleStrictParse(weekdayName, format, strict) {
     2809        var i, ii, mom, llc = weekdayName.toLocaleLowerCase();
     2810        if (!this._weekdaysParse) {
     2811            this._weekdaysParse = [];
     2812            this._shortWeekdaysParse = [];
     2813            this._minWeekdaysParse = [];
     2814
     2815            for (i = 0; i < 7; ++i) {
     2816                mom = create_utc__createUTC([2000, 1]).day(i);
     2817                this._minWeekdaysParse[i] = this.weekdaysMin(mom, '').toLocaleLowerCase();
     2818                this._shortWeekdaysParse[i] = this.weekdaysShort(mom, '').toLocaleLowerCase();
     2819                this._weekdaysParse[i] = this.weekdays(mom, '').toLocaleLowerCase();
     2820            }
     2821        }
     2822
     2823        if (strict) {
     2824            if (format === 'dddd') {
     2825                ii = indexOf.call(this._weekdaysParse, llc);
     2826                return ii !== -1 ? ii : null;
     2827            } else if (format === 'ddd') {
     2828                ii = indexOf.call(this._shortWeekdaysParse, llc);
     2829                return ii !== -1 ? ii : null;
     2830            } else {
     2831                ii = indexOf.call(this._minWeekdaysParse, llc);
     2832                return ii !== -1 ? ii : null;
     2833            }
     2834        } else {
     2835            if (format === 'dddd') {
     2836                ii = indexOf.call(this._weekdaysParse, llc);
     2837                if (ii !== -1) {
     2838                    return ii;
     2839                }
     2840                ii = indexOf.call(this._shortWeekdaysParse, llc);
     2841                if (ii !== -1) {
     2842                    return ii;
     2843                }
     2844                ii = indexOf.call(this._minWeekdaysParse, llc);
     2845                return ii !== -1 ? ii : null;
     2846            } else if (format === 'ddd') {
     2847                ii = indexOf.call(this._shortWeekdaysParse, llc);
     2848                if (ii !== -1) {
     2849                    return ii;
     2850                }
     2851                ii = indexOf.call(this._weekdaysParse, llc);
     2852                if (ii !== -1) {
     2853                    return ii;
     2854                }
     2855                ii = indexOf.call(this._minWeekdaysParse, llc);
     2856                return ii !== -1 ? ii : null;
     2857            } else {
     2858                ii = indexOf.call(this._minWeekdaysParse, llc);
     2859                if (ii !== -1) {
     2860                    return ii;
     2861                }
     2862                ii = indexOf.call(this._weekdaysParse, llc);
     2863                if (ii !== -1) {
     2864                    return ii;
     2865                }
     2866                ii = indexOf.call(this._shortWeekdaysParse, llc);
     2867                return ii !== -1 ? ii : null;
     2868            }
     2869        }
     2870    }
     2871
     2872    function localeWeekdaysParse (weekdayName, format, strict) {
     2873        var i, mom, regex;
     2874
     2875        if (this._weekdaysParseExact) {
     2876            return day_of_week__handleStrictParse.call(this, weekdayName, format, strict);
     2877        }
     2878
     2879        if (!this._weekdaysParse) {
     2880            this._weekdaysParse = [];
     2881            this._minWeekdaysParse = [];
     2882            this._shortWeekdaysParse = [];
     2883            this._fullWeekdaysParse = [];
     2884        }
     2885
     2886        for (i = 0; i < 7; i++) {
     2887            // make the regex if we don't have it already
     2888
     2889            mom = create_utc__createUTC([2000, 1]).day(i);
     2890            if (strict && !this._fullWeekdaysParse[i]) {
     2891                this._fullWeekdaysParse[i] = new RegExp('^' + this.weekdays(mom, '').replace('.', '\.?') + '$', 'i');
     2892                this._shortWeekdaysParse[i] = new RegExp('^' + this.weekdaysShort(mom, '').replace('.', '\.?') + '$', 'i');
     2893                this._minWeekdaysParse[i] = new RegExp('^' + this.weekdaysMin(mom, '').replace('.', '\.?') + '$', 'i');
     2894            }
     2895            if (!this._weekdaysParse[i]) {
     2896                regex = '^' + this.weekdays(mom, '') + '|^' + this.weekdaysShort(mom, '') + '|^' + this.weekdaysMin(mom, '');
     2897                this._weekdaysParse[i] = new RegExp(regex.replace('.', ''), 'i');
     2898            }
     2899            // test the regex
     2900            if (strict && format === 'dddd' && this._fullWeekdaysParse[i].test(weekdayName)) {
     2901                return i;
     2902            } else if (strict && format === 'ddd' && this._shortWeekdaysParse[i].test(weekdayName)) {
     2903                return i;
     2904            } else if (strict && format === 'dd' && this._minWeekdaysParse[i].test(weekdayName)) {
     2905                return i;
     2906            } else if (!strict && this._weekdaysParse[i].test(weekdayName)) {
     2907                return i;
     2908            }
     2909        }
     2910    }
     2911
     2912    // MOMENTS
     2913
     2914    function getSetDayOfWeek (input) {
     2915        if (!this.isValid()) {
     2916            return input != null ? this : NaN;
     2917        }
     2918        var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay();
     2919        if (input != null) {
     2920            input = parseWeekday(input, this.localeData());
     2921            return this.add(input - day, 'd');
     2922        } else {
     2923            return day;
     2924        }
     2925    }
     2926
     2927    function getSetLocaleDayOfWeek (input) {
     2928        if (!this.isValid()) {
     2929            return input != null ? this : NaN;
     2930        }
     2931        var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7;
     2932        return input == null ? weekday : this.add(input - weekday, 'd');
     2933    }
     2934
     2935    function getSetISODayOfWeek (input) {
     2936        if (!this.isValid()) {
     2937            return input != null ? this : NaN;
     2938        }
     2939        // behaves the same as moment#day except
     2940        // as a getter, returns 7 instead of 0 (1-7 range instead of 0-6)
     2941        // as a setter, sunday should belong to the previous week.
     2942        return input == null ? this.day() || 7 : this.day(this.day() % 7 ? input : input - 7);
     2943    }
     2944
     2945    var defaultWeekdaysRegex = matchWord;
     2946    function weekdaysRegex (isStrict) {
     2947        if (this._weekdaysParseExact) {
     2948            if (!hasOwnProp(this, '_weekdaysRegex')) {
     2949                computeWeekdaysParse.call(this);
     2950            }
     2951            if (isStrict) {
     2952                return this._weekdaysStrictRegex;
     2953            } else {
     2954                return this._weekdaysRegex;
     2955            }
     2956        } else {
     2957            return this._weekdaysStrictRegex && isStrict ?
     2958                this._weekdaysStrictRegex : this._weekdaysRegex;
     2959        }
     2960    }
     2961
     2962    var defaultWeekdaysShortRegex = matchWord;
     2963    function weekdaysShortRegex (isStrict) {
     2964        if (this._weekdaysParseExact) {
     2965            if (!hasOwnProp(this, '_weekdaysRegex')) {
     2966                computeWeekdaysParse.call(this);
     2967            }
     2968            if (isStrict) {
     2969                return this._weekdaysShortStrictRegex;
     2970            } else {
     2971                return this._weekdaysShortRegex;
     2972            }
     2973        } else {
     2974            return this._weekdaysShortStrictRegex && isStrict ?
     2975                this._weekdaysShortStrictRegex : this._weekdaysShortRegex;
     2976        }
     2977    }
     2978
     2979    var defaultWeekdaysMinRegex = matchWord;
     2980    function weekdaysMinRegex (isStrict) {
     2981        if (this._weekdaysParseExact) {
     2982            if (!hasOwnProp(this, '_weekdaysRegex')) {
     2983                computeWeekdaysParse.call(this);
     2984            }
     2985            if (isStrict) {
     2986                return this._weekdaysMinStrictRegex;
     2987            } else {
     2988                return this._weekdaysMinRegex;
     2989            }
     2990        } else {
     2991            return this._weekdaysMinStrictRegex && isStrict ?
     2992                this._weekdaysMinStrictRegex : this._weekdaysMinRegex;
     2993        }
     2994    }
     2995
     2996
     2997    function computeWeekdaysParse () {
     2998        function cmpLenRev(a, b) {
     2999            return b.length - a.length;
     3000        }
     3001
     3002        var minPieces = [], shortPieces = [], longPieces = [], mixedPieces = [],
     3003            i, mom, minp, shortp, longp;
     3004        for (i = 0; i < 7; i++) {
     3005            // make the regex if we don't have it already
     3006            mom = create_utc__createUTC([2000, 1]).day(i);
     3007            minp = this.weekdaysMin(mom, '');
     3008            shortp = this.weekdaysShort(mom, '');
     3009            longp = this.weekdays(mom, '');
     3010            minPieces.push(minp);
     3011            shortPieces.push(shortp);
     3012            longPieces.push(longp);
     3013            mixedPieces.push(minp);
     3014            mixedPieces.push(shortp);
     3015            mixedPieces.push(longp);
     3016        }
     3017        // Sorting makes sure if one weekday (or abbr) is a prefix of another it
     3018        // will match the longer piece.
     3019        minPieces.sort(cmpLenRev);
     3020        shortPieces.sort(cmpLenRev);
     3021        longPieces.sort(cmpLenRev);
     3022        mixedPieces.sort(cmpLenRev);
     3023        for (i = 0; i < 7; i++) {
     3024            shortPieces[i] = regexEscape(shortPieces[i]);
     3025            longPieces[i] = regexEscape(longPieces[i]);
     3026            mixedPieces[i] = regexEscape(mixedPieces[i]);
     3027        }
     3028
     3029        this._weekdaysRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
     3030        this._weekdaysShortRegex = this._weekdaysRegex;
     3031        this._weekdaysMinRegex = this._weekdaysRegex;
     3032
     3033        this._weekdaysStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i');
     3034        this._weekdaysShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i');
     3035        this._weekdaysMinStrictRegex = new RegExp('^(' + minPieces.join('|') + ')', 'i');
     3036    }
     3037
     3038    // FORMATTING
     3039
     3040    addFormatToken('DDD', ['DDDD', 3], 'DDDo', 'dayOfYear');
     3041
     3042    // ALIASES
     3043
     3044    addUnitAlias('dayOfYear', 'DDD');
     3045
     3046    // PARSING
     3047
     3048    addRegexToken('DDD',  match1to3);
     3049    addRegexToken('DDDD', match3);
     3050    addParseToken(['DDD', 'DDDD'], function (input, array, config) {
     3051        config._dayOfYear = toInt(input);
     3052    });
     3053
     3054    // HELPERS
     3055
     3056    // MOMENTS
     3057
     3058    function getSetDayOfYear (input) {
     3059        var dayOfYear = Math.round((this.clone().startOf('day') - this.clone().startOf('year')) / 864e5) + 1;
     3060        return input == null ? dayOfYear : this.add((input - dayOfYear), 'd');
     3061    }
     3062
     3063    // FORMATTING
     3064
     3065    function hFormat() {
     3066        return this.hours() % 12 || 12;
     3067    }
     3068
     3069    function kFormat() {
     3070        return this.hours() || 24;
     3071    }
     3072
     3073    addFormatToken('H', ['HH', 2], 0, 'hour');
     3074    addFormatToken('h', ['hh', 2], 0, hFormat);
     3075    addFormatToken('k', ['kk', 2], 0, kFormat);
     3076
     3077    addFormatToken('hmm', 0, 0, function () {
     3078        return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2);
     3079    });
     3080
     3081    addFormatToken('hmmss', 0, 0, function () {
     3082        return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2) +
     3083            zeroFill(this.seconds(), 2);
     3084    });
     3085
     3086    addFormatToken('Hmm', 0, 0, function () {
     3087        return '' + this.hours() + zeroFill(this.minutes(), 2);
     3088    });
     3089
     3090    addFormatToken('Hmmss', 0, 0, function () {
     3091        return '' + this.hours() + zeroFill(this.minutes(), 2) +
     3092            zeroFill(this.seconds(), 2);
     3093    });
     3094
     3095    function meridiem (token, lowercase) {
     3096        addFormatToken(token, 0, 0, function () {
     3097            return this.localeData().meridiem(this.hours(), this.minutes(), lowercase);
     3098        });
     3099    }
     3100
     3101    meridiem('a', true);
     3102    meridiem('A', false);
     3103
     3104    // ALIASES
     3105
     3106    addUnitAlias('hour', 'h');
     3107
     3108    // PARSING
     3109
     3110    function matchMeridiem (isStrict, locale) {
     3111        return locale._meridiemParse;
     3112    }
     3113
     3114    addRegexToken('a',  matchMeridiem);
     3115    addRegexToken('A',  matchMeridiem);
     3116    addRegexToken('H',  match1to2);
     3117    addRegexToken('h',  match1to2);
     3118    addRegexToken('HH', match1to2, match2);
     3119    addRegexToken('hh', match1to2, match2);
     3120
     3121    addRegexToken('hmm', match3to4);
     3122    addRegexToken('hmmss', match5to6);
     3123    addRegexToken('Hmm', match3to4);
     3124    addRegexToken('Hmmss', match5to6);
     3125
     3126    addParseToken(['H', 'HH'], HOUR);
     3127    addParseToken(['a', 'A'], function (input, array, config) {
     3128        config._isPm = config._locale.isPM(input);
     3129        config._meridiem = input;
     3130    });
     3131    addParseToken(['h', 'hh'], function (input, array, config) {
     3132        array[HOUR] = toInt(input);
     3133        getParsingFlags(config).bigHour = true;
     3134    });
     3135    addParseToken('hmm', function (input, array, config) {
     3136        var pos = input.length - 2;
     3137        array[HOUR] = toInt(input.substr(0, pos));
     3138        array[MINUTE] = toInt(input.substr(pos));
     3139        getParsingFlags(config).bigHour = true;
     3140    });
     3141    addParseToken('hmmss', function (input, array, config) {
     3142        var pos1 = input.length - 4;
     3143        var pos2 = input.length - 2;
     3144        array[HOUR] = toInt(input.substr(0, pos1));
     3145        array[MINUTE] = toInt(input.substr(pos1, 2));
     3146        array[SECOND] = toInt(input.substr(pos2));
     3147        getParsingFlags(config).bigHour = true;
     3148    });
     3149    addParseToken('Hmm', function (input, array, config) {
     3150        var pos = input.length - 2;
     3151        array[HOUR] = toInt(input.substr(0, pos));
     3152        array[MINUTE] = toInt(input.substr(pos));
     3153    });
     3154    addParseToken('Hmmss', function (input, array, config) {
     3155        var pos1 = input.length - 4;
     3156        var pos2 = input.length - 2;
     3157        array[HOUR] = toInt(input.substr(0, pos1));
     3158        array[MINUTE] = toInt(input.substr(pos1, 2));
     3159        array[SECOND] = toInt(input.substr(pos2));
     3160    });
     3161
     3162    // LOCALES
     3163
     3164    function localeIsPM (input) {
     3165        // IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays
     3166        // Using charAt should be more compatible.
     3167        return ((input + '').toLowerCase().charAt(0) === 'p');
     3168    }
     3169
     3170    var defaultLocaleMeridiemParse = /[ap]\.?m?\.?/i;
     3171    function localeMeridiem (hours, minutes, isLower) {
     3172        if (hours > 11) {
     3173            return isLower ? 'pm' : 'PM';
     3174        } else {
     3175            return isLower ? 'am' : 'AM';
     3176        }
     3177    }
     3178
     3179
     3180    // MOMENTS
     3181
     3182    // Setting the hour should keep the time, because the user explicitly
     3183    // specified which hour he wants. So trying to maintain the same hour (in
     3184    // a new timezone) makes sense. Adding/subtracting hours does not follow
     3185    // this rule.
     3186    var getSetHour = makeGetSet('Hours', true);
     3187
     3188    // FORMATTING
     3189
     3190    addFormatToken('m', ['mm', 2], 0, 'minute');
     3191
     3192    // ALIASES
     3193
     3194    addUnitAlias('minute', 'm');
     3195
     3196    // PARSING
     3197
     3198    addRegexToken('m',  match1to2);
     3199    addRegexToken('mm', match1to2, match2);
     3200    addParseToken(['m', 'mm'], MINUTE);
     3201
     3202    // MOMENTS
     3203
     3204    var getSetMinute = makeGetSet('Minutes', false);
     3205
     3206    // FORMATTING
     3207
     3208    addFormatToken('s', ['ss', 2], 0, 'second');
     3209
     3210    // ALIASES
     3211
     3212    addUnitAlias('second', 's');
     3213
     3214    // PARSING
     3215
     3216    addRegexToken('s',  match1to2);
     3217    addRegexToken('ss', match1to2, match2);
     3218    addParseToken(['s', 'ss'], SECOND);
     3219
     3220    // MOMENTS
     3221
     3222    var getSetSecond = makeGetSet('Seconds', false);
     3223
     3224    // FORMATTING
     3225
     3226    addFormatToken('S', 0, 0, function () {
     3227        return ~~(this.millisecond() / 100);
     3228    });
     3229
     3230    addFormatToken(0, ['SS', 2], 0, function () {
     3231        return ~~(this.millisecond() / 10);
     3232    });
     3233
     3234    addFormatToken(0, ['SSS', 3], 0, 'millisecond');
     3235    addFormatToken(0, ['SSSS', 4], 0, function () {
     3236        return this.millisecond() * 10;
     3237    });
     3238    addFormatToken(0, ['SSSSS', 5], 0, function () {
     3239        return this.millisecond() * 100;
     3240    });
     3241    addFormatToken(0, ['SSSSSS', 6], 0, function () {
     3242        return this.millisecond() * 1000;
     3243    });
     3244    addFormatToken(0, ['SSSSSSS', 7], 0, function () {
     3245        return this.millisecond() * 10000;
     3246    });
     3247    addFormatToken(0, ['SSSSSSSS', 8], 0, function () {
     3248        return this.millisecond() * 100000;
     3249    });
     3250    addFormatToken(0, ['SSSSSSSSS', 9], 0, function () {
     3251        return this.millisecond() * 1000000;
     3252    });
     3253
     3254
     3255    // ALIASES
     3256
     3257    addUnitAlias('millisecond', 'ms');
     3258
     3259    // PARSING
     3260
     3261    addRegexToken('S',    match1to3, match1);
     3262    addRegexToken('SS',   match1to3, match2);
     3263    addRegexToken('SSS',  match1to3, match3);
     3264
     3265    var token;
     3266    for (token = 'SSSS'; token.length <= 9; token += 'S') {
     3267        addRegexToken(token, matchUnsigned);
     3268    }
     3269
     3270    function parseMs(input, array) {
     3271        array[MILLISECOND] = toInt(('0.' + input) * 1000);
     3272    }
     3273
     3274    for (token = 'S'; token.length <= 9; token += 'S') {
     3275        addParseToken(token, parseMs);
     3276    }
     3277    // MOMENTS
     3278
     3279    var getSetMillisecond = makeGetSet('Milliseconds', false);
     3280
     3281    // FORMATTING
     3282
     3283    addFormatToken('z',  0, 0, 'zoneAbbr');
     3284    addFormatToken('zz', 0, 0, 'zoneName');
     3285
     3286    // MOMENTS
     3287
     3288    function getZoneAbbr () {
     3289        return this._isUTC ? 'UTC' : '';
     3290    }
     3291
     3292    function getZoneName () {
     3293        return this._isUTC ? 'Coordinated Universal Time' : '';
     3294    }
     3295
     3296    var momentPrototype__proto = Moment.prototype;
     3297
     3298    momentPrototype__proto.add               = add_subtract__add;
     3299    momentPrototype__proto.calendar          = moment_calendar__calendar;
     3300    momentPrototype__proto.clone             = clone;
     3301    momentPrototype__proto.diff              = diff;
     3302    momentPrototype__proto.endOf             = endOf;
     3303    momentPrototype__proto.format            = format;
     3304    momentPrototype__proto.from              = from;
     3305    momentPrototype__proto.fromNow           = fromNow;
     3306    momentPrototype__proto.to                = to;
     3307    momentPrototype__proto.toNow             = toNow;
     3308    momentPrototype__proto.get               = getSet;
     3309    momentPrototype__proto.invalidAt         = invalidAt;
     3310    momentPrototype__proto.isAfter           = isAfter;
     3311    momentPrototype__proto.isBefore          = isBefore;
     3312    momentPrototype__proto.isBetween         = isBetween;
     3313    momentPrototype__proto.isSame            = isSame;
     3314    momentPrototype__proto.isSameOrAfter     = isSameOrAfter;
     3315    momentPrototype__proto.isSameOrBefore    = isSameOrBefore;
     3316    momentPrototype__proto.isValid           = moment_valid__isValid;
     3317    momentPrototype__proto.lang              = lang;
     3318    momentPrototype__proto.locale            = locale;
     3319    momentPrototype__proto.localeData        = localeData;
     3320    momentPrototype__proto.max               = prototypeMax;
     3321    momentPrototype__proto.min               = prototypeMin;
     3322    momentPrototype__proto.parsingFlags      = parsingFlags;
     3323    momentPrototype__proto.set               = getSet;
     3324    momentPrototype__proto.startOf           = startOf;
     3325    momentPrototype__proto.subtract          = add_subtract__subtract;
     3326    momentPrototype__proto.toArray           = toArray;
     3327    momentPrototype__proto.toObject          = toObject;
     3328    momentPrototype__proto.toDate            = toDate;
     3329    momentPrototype__proto.toISOString       = moment_format__toISOString;
     3330    momentPrototype__proto.toJSON            = toJSON;
     3331    momentPrototype__proto.toString          = toString;
     3332    momentPrototype__proto.unix              = unix;
     3333    momentPrototype__proto.valueOf           = to_type__valueOf;
     3334    momentPrototype__proto.creationData      = creationData;
     3335
     3336    // Year
     3337    momentPrototype__proto.year       = getSetYear;
     3338    momentPrototype__proto.isLeapYear = getIsLeapYear;
     3339
     3340    // Week Year
     3341    momentPrototype__proto.weekYear    = getSetWeekYear;
     3342    momentPrototype__proto.isoWeekYear = getSetISOWeekYear;
     3343
     3344    // Quarter
     3345    momentPrototype__proto.quarter = momentPrototype__proto.quarters = getSetQuarter;
     3346
     3347    // Month
     3348    momentPrototype__proto.month       = getSetMonth;
     3349    momentPrototype__proto.daysInMonth = getDaysInMonth;
     3350
     3351    // Week
     3352    momentPrototype__proto.week           = momentPrototype__proto.weeks        = getSetWeek;
     3353    momentPrototype__proto.isoWeek        = momentPrototype__proto.isoWeeks     = getSetISOWeek;
     3354    momentPrototype__proto.weeksInYear    = getWeeksInYear;
     3355    momentPrototype__proto.isoWeeksInYear = getISOWeeksInYear;
     3356
     3357    // Day
     3358    momentPrototype__proto.date       = getSetDayOfMonth;
     3359    momentPrototype__proto.day        = momentPrototype__proto.days             = getSetDayOfWeek;
     3360    momentPrototype__proto.weekday    = getSetLocaleDayOfWeek;
     3361    momentPrototype__proto.isoWeekday = getSetISODayOfWeek;
     3362    momentPrototype__proto.dayOfYear  = getSetDayOfYear;
     3363
     3364    // Hour
     3365    momentPrototype__proto.hour = momentPrototype__proto.hours = getSetHour;
     3366
     3367    // Minute
     3368    momentPrototype__proto.minute = momentPrototype__proto.minutes = getSetMinute;
     3369
     3370    // Second
     3371    momentPrototype__proto.second = momentPrototype__proto.seconds = getSetSecond;
     3372
     3373    // Millisecond
     3374    momentPrototype__proto.millisecond = momentPrototype__proto.milliseconds = getSetMillisecond;
     3375
     3376    // Offset
     3377    momentPrototype__proto.utcOffset            = getSetOffset;
     3378    momentPrototype__proto.utc                  = setOffsetToUTC;
     3379    momentPrototype__proto.local                = setOffsetToLocal;
     3380    momentPrototype__proto.parseZone            = setOffsetToParsedOffset;
     3381    momentPrototype__proto.hasAlignedHourOffset = hasAlignedHourOffset;
     3382    momentPrototype__proto.isDST                = isDaylightSavingTime;
     3383    momentPrototype__proto.isDSTShifted         = isDaylightSavingTimeShifted;
     3384    momentPrototype__proto.isLocal              = isLocal;
     3385    momentPrototype__proto.isUtcOffset          = isUtcOffset;
     3386    momentPrototype__proto.isUtc                = isUtc;
     3387    momentPrototype__proto.isUTC                = isUtc;
     3388
     3389    // Timezone
     3390    momentPrototype__proto.zoneAbbr = getZoneAbbr;
     3391    momentPrototype__proto.zoneName = getZoneName;
     3392
     3393    // Deprecations
     3394    momentPrototype__proto.dates  = deprecate('dates accessor is deprecated. Use date instead.', getSetDayOfMonth);
     3395    momentPrototype__proto.months = deprecate('months accessor is deprecated. Use month instead', getSetMonth);
     3396    momentPrototype__proto.years  = deprecate('years accessor is deprecated. Use year instead', getSetYear);
     3397    momentPrototype__proto.zone   = deprecate('moment().zone is deprecated, use moment().utcOffset instead. https://github.com/moment/moment/issues/1779', getSetZone);
     3398
     3399    var momentPrototype = momentPrototype__proto;
     3400
     3401    function moment__createUnix (input) {
     3402        return local__createLocal(input * 1000);
     3403    }
     3404
     3405    function moment__createInZone () {
     3406        return local__createLocal.apply(null, arguments).parseZone();
     3407    }
     3408
     3409    var defaultCalendar = {
     3410        sameDay : '[Today at] LT',
     3411        nextDay : '[Tomorrow at] LT',
     3412        nextWeek : 'dddd [at] LT',
     3413        lastDay : '[Yesterday at] LT',
     3414        lastWeek : '[Last] dddd [at] LT',
     3415        sameElse : 'L'
     3416    };
     3417
     3418    function locale_calendar__calendar (key, mom, now) {
     3419        var output = this._calendar[key];
     3420        return isFunction(output) ? output.call(mom, now) : output;
     3421    }
     3422
     3423    var defaultLongDateFormat = {
     3424        LTS  : 'h:mm:ss A',
     3425        LT   : 'h:mm A',
     3426        L    : 'MM/DD/YYYY',
     3427        LL   : 'MMMM D, YYYY',
     3428        LLL  : 'MMMM D, YYYY h:mm A',
     3429        LLLL : 'dddd, MMMM D, YYYY h:mm A'
     3430    };
     3431
     3432    function longDateFormat (key) {
     3433        var format = this._longDateFormat[key],
     3434            formatUpper = this._longDateFormat[key.toUpperCase()];
     3435
     3436        if (format || !formatUpper) {
     3437            return format;
     3438        }
     3439
     3440        this._longDateFormat[key] = formatUpper.replace(/MMMM|MM|DD|dddd/g, function (val) {
     3441            return val.slice(1);
     3442        });
     3443
     3444        return this._longDateFormat[key];
     3445    }
     3446
     3447    var defaultInvalidDate = 'Invalid date';
     3448
     3449    function invalidDate () {
     3450        return this._invalidDate;
     3451    }
     3452
     3453    var defaultOrdinal = '%d';
     3454    var defaultOrdinalParse = /\d{1,2}/;
     3455
     3456    function ordinal (number) {
     3457        return this._ordinal.replace('%d', number);
     3458    }
     3459
     3460    function preParsePostFormat (string) {
     3461        return string;
     3462    }
     3463
     3464    var defaultRelativeTime = {
     3465        future : 'in %s',
     3466        past   : '%s ago',
     3467        s  : 'a few seconds',
     3468        m  : 'a minute',
     3469        mm : '%d minutes',
     3470        h  : 'an hour',
     3471        hh : '%d hours',
     3472        d  : 'a day',
     3473        dd : '%d days',
     3474        M  : 'a month',
     3475        MM : '%d months',
     3476        y  : 'a year',
     3477        yy : '%d years'
     3478    };
     3479
     3480    function relative__relativeTime (number, withoutSuffix, string, isFuture) {
     3481        var output = this._relativeTime[string];
     3482        return (isFunction(output)) ?
     3483            output(number, withoutSuffix, string, isFuture) :
     3484            output.replace(/%d/i, number);
     3485    }
     3486
     3487    function pastFuture (diff, output) {
     3488        var format = this._relativeTime[diff > 0 ? 'future' : 'past'];
     3489        return isFunction(format) ? format(output) : format.replace(/%s/i, output);
     3490    }
     3491
     3492    var prototype__proto = Locale.prototype;
     3493
     3494    prototype__proto._calendar       = defaultCalendar;
     3495    prototype__proto.calendar        = locale_calendar__calendar;
     3496    prototype__proto._longDateFormat = defaultLongDateFormat;
     3497    prototype__proto.longDateFormat  = longDateFormat;
     3498    prototype__proto._invalidDate    = defaultInvalidDate;
     3499    prototype__proto.invalidDate     = invalidDate;
     3500    prototype__proto._ordinal        = defaultOrdinal;
     3501    prototype__proto.ordinal         = ordinal;
     3502    prototype__proto._ordinalParse   = defaultOrdinalParse;
     3503    prototype__proto.preparse        = preParsePostFormat;
     3504    prototype__proto.postformat      = preParsePostFormat;
     3505    prototype__proto._relativeTime   = defaultRelativeTime;
     3506    prototype__proto.relativeTime    = relative__relativeTime;
     3507    prototype__proto.pastFuture      = pastFuture;
     3508    prototype__proto.set             = locale_set__set;
     3509
     3510    // Month
     3511    prototype__proto.months            =        localeMonths;
     3512    prototype__proto._months           = defaultLocaleMonths;
     3513    prototype__proto.monthsShort       =        localeMonthsShort;
     3514    prototype__proto._monthsShort      = defaultLocaleMonthsShort;
     3515    prototype__proto.monthsParse       =        localeMonthsParse;
     3516    prototype__proto._monthsRegex      = defaultMonthsRegex;
     3517    prototype__proto.monthsRegex       = monthsRegex;
     3518    prototype__proto._monthsShortRegex = defaultMonthsShortRegex;
     3519    prototype__proto.monthsShortRegex  = monthsShortRegex;
     3520
     3521    // Week
     3522    prototype__proto.week = localeWeek;
     3523    prototype__proto._week = defaultLocaleWeek;
     3524    prototype__proto.firstDayOfYear = localeFirstDayOfYear;
     3525    prototype__proto.firstDayOfWeek = localeFirstDayOfWeek;
     3526
     3527    // Day of Week
     3528    prototype__proto.weekdays       =        localeWeekdays;
     3529    prototype__proto._weekdays      = defaultLocaleWeekdays;
     3530    prototype__proto.weekdaysMin    =        localeWeekdaysMin;
     3531    prototype__proto._weekdaysMin   = defaultLocaleWeekdaysMin;
     3532    prototype__proto.weekdaysShort  =        localeWeekdaysShort;
     3533    prototype__proto._weekdaysShort = defaultLocaleWeekdaysShort;
     3534    prototype__proto.weekdaysParse  =        localeWeekdaysParse;
     3535
     3536    prototype__proto._weekdaysRegex      = defaultWeekdaysRegex;
     3537    prototype__proto.weekdaysRegex       =        weekdaysRegex;
     3538    prototype__proto._weekdaysShortRegex = defaultWeekdaysShortRegex;
     3539    prototype__proto.weekdaysShortRegex  =        weekdaysShortRegex;
     3540    prototype__proto._weekdaysMinRegex   = defaultWeekdaysMinRegex;
     3541    prototype__proto.weekdaysMinRegex    =        weekdaysMinRegex;
     3542
     3543    // Hours
     3544    prototype__proto.isPM = localeIsPM;
     3545    prototype__proto._meridiemParse = defaultLocaleMeridiemParse;
     3546    prototype__proto.meridiem = localeMeridiem;
     3547
     3548    function lists__get (format, index, field, setter) {
     3549        var locale = locale_locales__getLocale();
     3550        var utc = create_utc__createUTC().set(setter, index);
     3551        return locale[field](utc, format);
     3552    }
     3553
     3554    function listMonthsImpl (format, index, field) {
     3555        if (typeof format === 'number') {
     3556            index = format;
     3557            format = undefined;
     3558        }
     3559
     3560        format = format || '';
     3561
     3562        if (index != null) {
     3563            return lists__get(format, index, field, 'month');
     3564        }
     3565
     3566        var i;
     3567        var out = [];
     3568        for (i = 0; i < 12; i++) {
     3569            out[i] = lists__get(format, i, field, 'month');
     3570        }
     3571        return out;
     3572    }
     3573
     3574    // ()
     3575    // (5)
     3576    // (fmt, 5)
     3577    // (fmt)
     3578    // (true)
     3579    // (true, 5)
     3580    // (true, fmt, 5)
     3581    // (true, fmt)
     3582    function listWeekdaysImpl (localeSorted, format, index, field) {
     3583        if (typeof localeSorted === 'boolean') {
     3584            if (typeof format === 'number') {
     3585                index = format;
     3586                format = undefined;
     3587            }
     3588
     3589            format = format || '';
     3590        } else {
     3591            format = localeSorted;
     3592            index = format;
     3593            localeSorted = false;
     3594
     3595            if (typeof format === 'number') {
     3596                index = format;
     3597                format = undefined;
     3598            }
     3599
     3600            format = format || '';
     3601        }
     3602
     3603        var locale = locale_locales__getLocale(),
     3604            shift = localeSorted ? locale._week.dow : 0;
     3605
     3606        if (index != null) {
     3607            return lists__get(format, (index + shift) % 7, field, 'day');
     3608        }
     3609
     3610        var i;
     3611        var out = [];
     3612        for (i = 0; i < 7; i++) {
     3613            out[i] = lists__get(format, (i + shift) % 7, field, 'day');
     3614        }
     3615        return out;
     3616    }
     3617
     3618    function lists__listMonths (format, index) {
     3619        return listMonthsImpl(format, index, 'months');
     3620    }
     3621
     3622    function lists__listMonthsShort (format, index) {
     3623        return listMonthsImpl(format, index, 'monthsShort');
     3624    }
     3625
     3626    function lists__listWeekdays (localeSorted, format, index) {
     3627        return listWeekdaysImpl(localeSorted, format, index, 'weekdays');
     3628    }
     3629
     3630    function lists__listWeekdaysShort (localeSorted, format, index) {
     3631        return listWeekdaysImpl(localeSorted, format, index, 'weekdaysShort');
     3632    }
     3633
     3634    function lists__listWeekdaysMin (localeSorted, format, index) {
     3635        return listWeekdaysImpl(localeSorted, format, index, 'weekdaysMin');
     3636    }
     3637
     3638    locale_locales__getSetGlobalLocale('en', {
     3639        ordinalParse: /\d{1,2}(th|st|nd|rd)/,
     3640        ordinal : function (number) {
     3641            var b = number % 10,
     3642                output = (toInt(number % 100 / 10) === 1) ? 'th' :
     3643                (b === 1) ? 'st' :
     3644                (b === 2) ? 'nd' :
     3645                (b === 3) ? 'rd' : 'th';
     3646            return number + output;
     3647        }
     3648    });
     3649
     3650    // Side effect imports
     3651    utils_hooks__hooks.lang = deprecate('moment.lang is deprecated. Use moment.locale instead.', locale_locales__getSetGlobalLocale);
     3652    utils_hooks__hooks.langData = deprecate('moment.langData is deprecated. Use moment.localeData instead.', locale_locales__getLocale);
     3653
     3654    var mathAbs = Math.abs;
     3655
     3656    function duration_abs__abs () {
     3657        var data           = this._data;
     3658
     3659        this._milliseconds = mathAbs(this._milliseconds);
     3660        this._days         = mathAbs(this._days);
     3661        this._months       = mathAbs(this._months);
     3662
     3663        data.milliseconds  = mathAbs(data.milliseconds);
     3664        data.seconds       = mathAbs(data.seconds);
     3665        data.minutes       = mathAbs(data.minutes);
     3666        data.hours         = mathAbs(data.hours);
     3667        data.months        = mathAbs(data.months);
     3668        data.years         = mathAbs(data.years);
     3669
     3670        return this;
     3671    }
     3672
     3673    function duration_add_subtract__addSubtract (duration, input, value, direction) {
     3674        var other = create__createDuration(input, value);
     3675
     3676        duration._milliseconds += direction * other._milliseconds;
     3677        duration._days         += direction * other._days;
     3678        duration._months       += direction * other._months;
     3679
     3680        return duration._bubble();
     3681    }
     3682
     3683    // supports only 2.0-style add(1, 's') or add(duration)
     3684    function duration_add_subtract__add (input, value) {
     3685        return duration_add_subtract__addSubtract(this, input, value, 1);
     3686    }
     3687
     3688    // supports only 2.0-style subtract(1, 's') or subtract(duration)
     3689    function duration_add_subtract__subtract (input, value) {
     3690        return duration_add_subtract__addSubtract(this, input, value, -1);
     3691    }
     3692
     3693    function absCeil (number) {
     3694        if (number < 0) {
     3695            return Math.floor(number);
     3696        } else {
     3697            return Math.ceil(number);
     3698        }
     3699    }
     3700
     3701    function bubble () {
     3702        var milliseconds = this._milliseconds;
     3703        var days         = this._days;
     3704        var months       = this._months;
     3705        var data         = this._data;
     3706        var seconds, minutes, hours, years, monthsFromDays;
     3707
     3708        // if we have a mix of positive and negative values, bubble down first
     3709        // check: https://github.com/moment/moment/issues/2166
     3710        if (!((milliseconds >= 0 && days >= 0 && months >= 0) ||
     3711                (milliseconds <= 0 && days <= 0 && months <= 0))) {
     3712            milliseconds += absCeil(monthsToDays(months) + days) * 864e5;
     3713            days = 0;
     3714            months = 0;
     3715        }
     3716
     3717        // The following code bubbles up values, see the tests for
     3718        // examples of what that means.
     3719        data.milliseconds = milliseconds % 1000;
     3720
     3721        seconds           = absFloor(milliseconds / 1000);
     3722        data.seconds      = seconds % 60;
     3723
     3724        minutes           = absFloor(seconds / 60);
     3725        data.minutes      = minutes % 60;
     3726
     3727        hours             = absFloor(minutes / 60);
     3728        data.hours        = hours % 24;
     3729
     3730        days += absFloor(hours / 24);
     3731
     3732        // convert days to months
     3733        monthsFromDays = absFloor(daysToMonths(days));
     3734        months += monthsFromDays;
     3735        days -= absCeil(monthsToDays(monthsFromDays));
     3736
     3737        // 12 months -> 1 year
     3738        years = absFloor(months / 12);
     3739        months %= 12;
     3740
     3741        data.days   = days;
     3742        data.months = months;
     3743        data.years  = years;
     3744
     3745        return this;
     3746    }
     3747
     3748    function daysToMonths (days) {
     3749        // 400 years have 146097 days (taking into account leap year rules)
     3750        // 400 years have 12 months === 4800
     3751        return days * 4800 / 146097;
     3752    }
     3753
     3754    function monthsToDays (months) {
     3755        // the reverse of daysToMonths
     3756        return months * 146097 / 4800;
     3757    }
     3758
     3759    function as (units) {
     3760        var days;
     3761        var months;
     3762        var milliseconds = this._milliseconds;
     3763
     3764        units = normalizeUnits(units);
     3765
     3766        if (units === 'month' || units === 'year') {
     3767            days   = this._days   + milliseconds / 864e5;
     3768            months = this._months + daysToMonths(days);
     3769            return units === 'month' ? months : months / 12;
     3770        } else {
     3771            // handle milliseconds separately because of floating point math errors (issue #1867)
     3772            days = this._days + Math.round(monthsToDays(this._months));
     3773            switch (units) {
     3774                case 'week'   : return days / 7     + milliseconds / 6048e5;
     3775                case 'day'    : return days         + milliseconds / 864e5;
     3776                case 'hour'   : return days * 24    + milliseconds / 36e5;
     3777                case 'minute' : return days * 1440  + milliseconds / 6e4;
     3778                case 'second' : return days * 86400 + milliseconds / 1000;
     3779                // Math.floor prevents floating point math errors here
     3780                case 'millisecond': return Math.floor(days * 864e5) + milliseconds;
     3781                default: throw new Error('Unknown unit ' + units);
     3782            }
     3783        }
     3784    }
     3785
     3786    // TODO: Use this.as('ms')?
     3787    function duration_as__valueOf () {
     3788        return (
     3789            this._milliseconds +
     3790            this._days * 864e5 +
     3791            (this._months % 12) * 2592e6 +
     3792            toInt(this._months / 12) * 31536e6
     3793        );
     3794    }
     3795
     3796    function makeAs (alias) {
     3797        return function () {
     3798            return this.as(alias);
     3799        };
     3800    }
     3801
     3802    var asMilliseconds = makeAs('ms');
     3803    var asSeconds      = makeAs('s');
     3804    var asMinutes      = makeAs('m');
     3805    var asHours        = makeAs('h');
     3806    var asDays         = makeAs('d');
     3807    var asWeeks        = makeAs('w');
     3808    var asMonths       = makeAs('M');
     3809    var asYears        = makeAs('y');
     3810
     3811    function duration_get__get (units) {
     3812        units = normalizeUnits(units);
     3813        return this[units + 's']();
     3814    }
     3815
     3816    function makeGetter(name) {
     3817        return function () {
     3818            return this._data[name];
     3819        };
     3820    }
     3821
     3822    var milliseconds = makeGetter('milliseconds');
     3823    var seconds      = makeGetter('seconds');
     3824    var minutes      = makeGetter('minutes');
     3825    var hours        = makeGetter('hours');
     3826    var days         = makeGetter('days');
     3827    var months       = makeGetter('months');
     3828    var years        = makeGetter('years');
     3829
     3830    function weeks () {
     3831        return absFloor(this.days() / 7);
     3832    }
     3833
     3834    var round = Math.round;
     3835    var thresholds = {
     3836        s: 45,  // seconds to minute
     3837        m: 45,  // minutes to hour
     3838        h: 22,  // hours to day
     3839        d: 26,  // days to month
     3840        M: 11   // months to year
     3841    };
     3842
     3843    // helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize
     3844    function substituteTimeAgo(string, number, withoutSuffix, isFuture, locale) {
     3845        return locale.relativeTime(number || 1, !!withoutSuffix, string, isFuture);
     3846    }
     3847
     3848    function duration_humanize__relativeTime (posNegDuration, withoutSuffix, locale) {
     3849        var duration = create__createDuration(posNegDuration).abs();
     3850        var seconds  = round(duration.as('s'));
     3851        var minutes  = round(duration.as('m'));
     3852        var hours    = round(duration.as('h'));
     3853        var days     = round(duration.as('d'));
     3854        var months   = round(duration.as('M'));
     3855        var years    = round(duration.as('y'));
     3856
     3857        var a = seconds < thresholds.s && ['s', seconds]  ||
     3858                minutes <= 1           && ['m']           ||
     3859                minutes < thresholds.m && ['mm', minutes] ||
     3860                hours   <= 1           && ['h']           ||
     3861                hours   < thresholds.h && ['hh', hours]   ||
     3862                days    <= 1           && ['d']           ||
     3863                days    < thresholds.d && ['dd', days]    ||
     3864                months  <= 1           && ['M']           ||
     3865                months  < thresholds.M && ['MM', months]  ||
     3866                years   <= 1           && ['y']           || ['yy', years];
     3867
     3868        a[2] = withoutSuffix;
     3869        a[3] = +posNegDuration > 0;
     3870        a[4] = locale;
     3871        return substituteTimeAgo.apply(null, a);
     3872    }
     3873
     3874    // This function allows you to set a threshold for relative time strings
     3875    function duration_humanize__getSetRelativeTimeThreshold (threshold, limit) {
     3876        if (thresholds[threshold] === undefined) {
     3877            return false;
     3878        }
     3879        if (limit === undefined) {
     3880            return thresholds[threshold];
     3881        }
     3882        thresholds[threshold] = limit;
     3883        return true;
     3884    }
     3885
     3886    function humanize (withSuffix) {
     3887        var locale = this.localeData();
     3888        var output = duration_humanize__relativeTime(this, !withSuffix, locale);
     3889
     3890        if (withSuffix) {
     3891            output = locale.pastFuture(+this, output);
     3892        }
     3893
     3894        return locale.postformat(output);
     3895    }
     3896
     3897    var iso_string__abs = Math.abs;
     3898
     3899    function iso_string__toISOString() {
     3900        // for ISO strings we do not use the normal bubbling rules:
     3901        //  * milliseconds bubble up until they become hours
     3902        //  * days do not bubble at all
     3903        //  * months bubble up until they become years
     3904        // This is because there is no context-free conversion between hours and days
     3905        // (think of clock changes)
     3906        // and also not between days and months (28-31 days per month)
     3907        var seconds = iso_string__abs(this._milliseconds) / 1000;
     3908        var days         = iso_string__abs(this._days);
     3909        var months       = iso_string__abs(this._months);
     3910        var minutes, hours, years;
     3911
     3912        // 3600 seconds -> 60 minutes -> 1 hour
     3913        minutes           = absFloor(seconds / 60);
     3914        hours             = absFloor(minutes / 60);
     3915        seconds %= 60;
     3916        minutes %= 60;
     3917
     3918        // 12 months -> 1 year
     3919        years  = absFloor(months / 12);
     3920        months %= 12;
     3921
     3922
     3923        // inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js
     3924        var Y = years;
     3925        var M = months;
     3926        var D = days;
     3927        var h = hours;
     3928        var m = minutes;
     3929        var s = seconds;
     3930        var total = this.asSeconds();
     3931
     3932        if (!total) {
     3933            // this is the same as C#'s (Noda) and python (isodate)...
     3934            // but not other JS (goog.date)
     3935            return 'P0D';
     3936        }
     3937
     3938        return (total < 0 ? '-' : '') +
     3939            'P' +
     3940            (Y ? Y + 'Y' : '') +
     3941            (M ? M + 'M' : '') +
     3942            (D ? D + 'D' : '') +
     3943            ((h || m || s) ? 'T' : '') +
     3944            (h ? h + 'H' : '') +
     3945            (m ? m + 'M' : '') +
     3946            (s ? s + 'S' : '');
     3947    }
     3948
     3949    var duration_prototype__proto = Duration.prototype;
     3950
     3951    duration_prototype__proto.abs            = duration_abs__abs;
     3952    duration_prototype__proto.add            = duration_add_subtract__add;
     3953    duration_prototype__proto.subtract       = duration_add_subtract__subtract;
     3954    duration_prototype__proto.as             = as;
     3955    duration_prototype__proto.asMilliseconds = asMilliseconds;
     3956    duration_prototype__proto.asSeconds      = asSeconds;
     3957    duration_prototype__proto.asMinutes      = asMinutes;
     3958    duration_prototype__proto.asHours        = asHours;
     3959    duration_prototype__proto.asDays         = asDays;
     3960    duration_prototype__proto.asWeeks        = asWeeks;
     3961    duration_prototype__proto.asMonths       = asMonths;
     3962    duration_prototype__proto.asYears        = asYears;
     3963    duration_prototype__proto.valueOf        = duration_as__valueOf;
     3964    duration_prototype__proto._bubble        = bubble;
     3965    duration_prototype__proto.get            = duration_get__get;
     3966    duration_prototype__proto.milliseconds   = milliseconds;
     3967    duration_prototype__proto.seconds        = seconds;
     3968    duration_prototype__proto.minutes        = minutes;
     3969    duration_prototype__proto.hours          = hours;
     3970    duration_prototype__proto.days           = days;
     3971    duration_prototype__proto.weeks          = weeks;
     3972    duration_prototype__proto.months         = months;
     3973    duration_prototype__proto.years          = years;
     3974    duration_prototype__proto.humanize       = humanize;
     3975    duration_prototype__proto.toISOString    = iso_string__toISOString;
     3976    duration_prototype__proto.toString       = iso_string__toISOString;
     3977    duration_prototype__proto.toJSON         = iso_string__toISOString;
     3978    duration_prototype__proto.locale         = locale;
     3979    duration_prototype__proto.localeData     = localeData;
     3980
     3981    // Deprecations
     3982    duration_prototype__proto.toIsoString = deprecate('toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)', iso_string__toISOString);
     3983    duration_prototype__proto.lang = lang;
     3984
     3985    // Side effect imports
     3986
     3987    // FORMATTING
     3988
     3989    addFormatToken('X', 0, 0, 'unix');
     3990    addFormatToken('x', 0, 0, 'valueOf');
     3991
     3992    // PARSING
     3993
     3994    addRegexToken('x', matchSigned);
     3995    addRegexToken('X', matchTimestamp);
     3996    addParseToken('X', function (input, array, config) {
     3997        config._d = new Date(parseFloat(input, 10) * 1000);
     3998    });
     3999    addParseToken('x', function (input, array, config) {
     4000        config._d = new Date(toInt(input));
     4001    });
     4002
     4003    // Side effect imports
     4004
     4005
     4006    utils_hooks__hooks.version = '2.13.0';
     4007
     4008    setHookCallback(local__createLocal);
     4009
     4010    utils_hooks__hooks.fn                    = momentPrototype;
     4011    utils_hooks__hooks.min                   = min;
     4012    utils_hooks__hooks.max                   = max;
     4013    utils_hooks__hooks.now                   = now;
     4014    utils_hooks__hooks.utc                   = create_utc__createUTC;
     4015    utils_hooks__hooks.unix                  = moment__createUnix;
     4016    utils_hooks__hooks.months                = lists__listMonths;
     4017    utils_hooks__hooks.isDate                = isDate;
     4018    utils_hooks__hooks.locale                = locale_locales__getSetGlobalLocale;
     4019    utils_hooks__hooks.invalid               = valid__createInvalid;
     4020    utils_hooks__hooks.duration              = create__createDuration;
     4021    utils_hooks__hooks.isMoment              = isMoment;
     4022    utils_hooks__hooks.weekdays              = lists__listWeekdays;
     4023    utils_hooks__hooks.parseZone             = moment__createInZone;
     4024    utils_hooks__hooks.localeData            = locale_locales__getLocale;
     4025    utils_hooks__hooks.isDuration            = isDuration;
     4026    utils_hooks__hooks.monthsShort           = lists__listMonthsShort;
     4027    utils_hooks__hooks.weekdaysMin           = lists__listWeekdaysMin;
     4028    utils_hooks__hooks.defineLocale          = defineLocale;
     4029    utils_hooks__hooks.updateLocale          = updateLocale;
     4030    utils_hooks__hooks.locales               = locale_locales__listLocales;
     4031    utils_hooks__hooks.weekdaysShort         = lists__listWeekdaysShort;
     4032    utils_hooks__hooks.normalizeUnits        = normalizeUnits;
     4033    utils_hooks__hooks.relativeTimeThreshold = duration_humanize__getSetRelativeTimeThreshold;
     4034    utils_hooks__hooks.prototype             = momentPrototype;
     4035
     4036    var _moment = utils_hooks__hooks;
     4037
     4038    return _moment;
     4039
     4040}));
     4041 No newline at end of file
  • src/bp-friends/bp-friends-widgets.php

     
    7878                                <div class="item">
    7979                                        <div class="item-title fn"><a href="<?php bp_member_permalink(); ?>" title="<?php bp_member_name(); ?>"><?php bp_member_name(); ?></a></div>
    8080                                        <?php if ( 'active' == $type ) : ?>
    81                                                 <div class="item-meta"><span class="activity"><?php bp_member_last_active(); ?></span></div>
     81                                                <div class="item-meta"><span class="activity" data-livestamp="<?php bp_core_iso8601_date( bp_get_member_last_active( array( 'relative' => false ) ) ); ?>"><?php bp_member_last_active(); ?></span></div>
    8282                                        <?php elseif ( 'newest' == $type ) : ?>
    83                                                 <div class="item-meta"><span class="activity"><?php bp_member_registered(); ?></span></div>
     83                                                <div class="item-meta"><span class="activity" data-livestamp="<?php bp_core_iso8601_date( bp_get_member_registered( array( 'relative' => false ) ) ); ?>"><?php bp_member_registered(); ?></span></div>
    8484                                        <?php elseif ( bp_is_active( 'friends' ) ) : ?>
    8585                                                <div class="item-meta"><span class="activity"><?php bp_member_total_friend_count(); ?></span></div>
    8686                                        <?php endif; ?>
  • src/bp-friends/classes/class-bp-core-friends-widget.php

     
    106106                                                <div class="item">
    107107                                                        <div class="item-title fn"><a href="<?php bp_member_permalink(); ?>" title="<?php bp_member_name(); ?>"><?php bp_member_name(); ?></a></div>
    108108                                                        <div class="item-meta">
    109                                                                 <span class="activity">
    110                                                                 <?php
    111                                                                         if ( 'newest' == $instance['friend_default'] )
    112                                                                                 bp_member_registered();
    113                                                                         if ( 'active' == $instance['friend_default'] )
    114                                                                                 bp_member_last_active();
    115                                                                         if ( 'popular' == $instance['friend_default'] )
    116                                                                                 bp_member_total_friend_count();
    117                                                                 ?>
    118                                                                 </span>
     109                                                                <?php if ( 'newest' == $instance['friend_default'] ) : ?>
     110                                                                        <span class="activity" data-livestamp="<?php bp_core_iso8601_date( bp_get_member_registered( array( 'relative' => false ) ) ); ?>"><?php bp_member_registered(); ?></span>
     111                                                                <?php elseif ( 'active' == $instance['friend_default'] ) : ?>
     112                                                                        <span class="activity" data-livestamp="<?php bp_core_iso8601_date( bp_get_member_last_activity( array( 'relative' => false ) ) ); ?>"><?php bp_member_last_active(); ?></span>
     113                                                                <?php else : ?>
     114                                                                        <span class="activity"><?php bp_member_total_friend_count(); ?></span>
     115                                                                <?php endif; ?>
    119116                                                        </div>
    120117                                                </div>
    121118                                        </li>
  • src/bp-groups/bp-groups-template.php

     
    684684 * Output the 'last active' string for the current group in the loop.
    685685 *
    686686 * @since 1.0.0
     687 * @sicne 2.6.0 Added $args as a parameter.
    687688 *
    688  * @param object|bool $group Optional. Group object.
    689  *                           Default: current group in loop.
     689 * @param object|bool  $group Optional. Group object. Default: current group in loop.
     690 * @param array|string $args {@see bp_get_group_last_active()}.
    690691 */
    691 function bp_group_last_active( $group = false ) {
    692         echo bp_get_group_last_active( $group );
     692function bp_group_last_active( $group = false, $args = array() ) {
     693        echo bp_get_group_last_active( $group, $args );
    693694}
    694695        /**
    695696         * Return the 'last active' string for the current group in the loop.
    696697         *
    697698         * @since 1.0.0
     699         * @since 2.6.0 Added $args as a parameter.
    698700         *
    699          * @param object|bool $group Optional. Group object.
    700          *                           Default: current group in loop.
     701         * @param object|bool  $group Optional. Group object. Default: current group in loop.
     702         * @param array|string $args {
     703         *     Array of optional parameters.
     704         *     @type bool $relative If true, returns relative active date. eg. active 5 months ago.
     705         *                          If false, returns active date value from database. Default: true.
     706         * }
    701707         * @return string
    702708         */
    703         function bp_get_group_last_active( $group = false ) {
     709        function bp_get_group_last_active( $group = false, $args = array() ) {
    704710                global $groups_template;
    705711
    706712                if ( empty( $group ) ) {
    707713                        $group =& $groups_template->group;
    708714                }
    709715
    710                 $last_active = $group->last_activity;
     716                $r = wp_parse_args( $args, array(
     717                        'relative' => true
     718                ) );
    711719
    712                 if ( !$last_active ) {
     720                $last_active = $group->last_activity;
     721                if ( ! $last_active ) {
    713722                        $last_active = groups_get_groupmeta( $group->id, 'last_activity' );
    714723                }
    715724
     725                // We do not want relative time, so return now.
     726                // @todo Should the 'bp_get_group_last_active' filter be applied here?
     727                if ( false === $r['relative'] ) {
     728                        return esc_attr( $last_active );
     729                }
     730
    716731                if ( empty( $last_active ) ) {
    717732                        return __( 'not yet active', 'buddypress' );
    718733                } else {
     
    10521067 * Output the created date of the current group in the loop.
    10531068 *
    10541069 * @since 1.0.0
     1070 * @since 2.6.0 Added $args as a parameter.
    10551071 *
    1056  * @param object|bool $group Optional. Group object.
    1057  *                           Default: current group in loop.
     1072 * @param object|bool  $group Optional. Group object. Default: current group in loop.
     1073 * @param array|string $args  {@see bp_get_group_date_created()}.
    10581074 */
    1059 function bp_group_date_created( $group = false ) {
    1060         echo bp_get_group_date_created( $group );
     1075function bp_group_date_created( $group = false, $args = array() ) {
     1076        echo bp_get_group_date_created( $group, $args );
    10611077}
    10621078        /**
    10631079         * Return the created date of the current group in the loop.
    10641080         *
    10651081         * @since 1.0.0
     1082         * @since 2.6.0 Added $args as a parameter.
    10661083         *
    1067          * @param object|bool $group Optional. Group object.
    1068          *                           Default: current group in loop.
     1084         * @param object|bool  $group Optional. Group object. Default: current group in loop.
     1085         * @param array|string $args {
     1086         *     Array of optional parameters.
     1087         *     @type bool $relative If true, returns relative created date. eg. active 5 months ago.
     1088         *                          If false, returns created date value from database. Default: true.
     1089         * }
    10691090         * @return string
    10701091         */
    1071         function bp_get_group_date_created( $group = false ) {
     1092        function bp_get_group_date_created( $group = false, $args = array() ) {
    10721093                global $groups_template;
    10731094
     1095                $r = wp_parse_args( $args, array(
     1096                        'relative' => true
     1097                ) );
     1098
    10741099                if ( empty( $group ) ) {
    10751100                        $group =& $groups_template->group;
    10761101                }
    10771102
     1103                // We do not want relative time, so return now.
     1104                // @todo Should the 'bp_get_group_date_created' filter be applied here?
     1105                if ( false === $r['relative'] ) {
     1106                        return esc_attr( $group->date_created );
     1107                }
     1108
    10781109                /**
    10791110                 * Filters the created date of the current group in the loop.
    10801111                 *
     
    39734004}
    39744005
    39754006/**
     4007 * Output the joined date for the current member in the group member loop.
     4008 *
    39764009 * @since 1.0.0
     4010 * @since 2.6.0 Added $args as a parameter.
     4011 *
     4012 * @param array|string $args {@see bp_get_group_member_joined_since()}
     4013 * @return string
    39774014 */
    39784015function bp_group_member_joined_since() {
    39794016        echo bp_get_group_member_joined_since();
    39804017}
    3981 
    39824018        /**
     4019         * Return the joined date for the current member in the group member loop.
     4020         *
    39834021         * @since 1.0.0
     4022         * @since 2.6.0 Added $args as a parameter.
    39844023         *
    3985          * @return mixed|void
     4024         * @param array|string $args {
     4025         *     Array of optional parameters.
     4026         *     @type bool $relative If true, returns relative joined date. eg. joined 5 months ago.
     4027         *                          If false, returns joined date value from database. Default: true.
     4028         * }
     4029         * @return string
    39864030         */
    3987         function bp_get_group_member_joined_since() {
     4031        function bp_get_group_member_joined_since( $args = array() ) {
    39884032                global $members_template;
    39894033
     4034                $r = wp_parse_args( $args, array(
     4035                        'relative' => true
     4036                ) );
     4037
     4038                // We do not want relative time, so return now.
     4039                // @todo Should the 'bp_get_group_member_joined_since' filter be applied here?
     4040                if ( false === $r['relative'] ) {
     4041                        return esc_attr( $members_template->member->date_modified );
     4042                }
     4043
    39904044                /**
    39914045                 * Filters the joined since time for the current member in the loop.
    39924046                 *
  • src/bp-groups/bp-groups-widgets.php

     
    6565                                <div class="item">
    6666                                        <div class="item-title"><a href="<?php bp_group_permalink() ?>" title="<?php bp_group_name() ?>"><?php bp_group_name() ?></a></div>
    6767                                        <div class="item-meta">
    68                                                 <span class="activity">
    69                                                         <?php
    70                                                         if ( 'newest-groups' == $_POST['filter'] ) {
    71                                                                 printf( __( 'created %s', 'buddypress' ), bp_get_group_date_created() );
    72                                                         } elseif ( 'recently-active-groups' == $_POST['filter'] ) {
    73                                                                 printf( __( 'active %s', 'buddypress' ), bp_get_group_last_active() );
    74                                                         } elseif ( 'popular-groups' == $_POST['filter'] ) {
    75                                                                 bp_group_member_count();
    76                                                         }
    77                                                         ?>
    78                                                 </span>
     68                                                <?php if ( 'newest-groups' === $_POST['filter'] ) : ?>
     69                                                        <span class="activity" data-livestamp="<?php bp_core_iso8601_date( bp_get_group_date_created( 0, array( 'relative' => false ) ) ); ?>"><?php printf( __( 'created %s', 'buddypress' ), bp_get_group_date_created() ); ?></span>
     70                                                <?php elseif ( 'recently-active-groups' === $_POST['filter'] ) : ?>
     71                                                        <span class="activity" data-livestamp="<?php bp_core_iso8601_date( bp_get_group_last_active( 0, array( 'relative' => false ) ) ); ?>"><?php printf( __( 'active %s', 'buddypress' ), bp_get_group_last_active() ); ?></span>
     72                                                <?php else : ?>
     73                                                        <span class="activity"><?php bp_group_member_count(); ?></span>
     74                                                <?php endif; ?>
    7975                                        </div>
    8076                                </div>
    8177                        </li>
  • src/bp-members/bp-members-template.php

     
    936936 *
    937937 * @since 1.2.0
    938938 *
    939  * @param array $args See {@link bp_get_member_last_active()}.
     939 * @param array $args {@see bp_get_member_last_active()}.
    940940 */
    941941function bp_member_last_active( $args = array() ) {
    942942        echo bp_get_member_last_active( $args );
     
    945945         * Return the current member's last active time.
    946946         *
    947947         * @since 1.2.0
     948         * @since 2.6.0 Added 'relative' as a parameter to $args.
    948949         *
    949950         * @param array $args {
    950951         *     Array of optional arguments.
    951          *     @type mixed $active_format If true, formatted "active 5 minutes
    952          *                                ago". If false, formatted "5 minutes ago".
    953          *                                If string, should be sprintf'able like
    954          *                                'last seen %s ago'.
     952         *     @type mixed $active_format If true, formatted "active 5 minutes ago". If false, formatted "5 minutes
     953         *                                ago". If string, should be sprintf'able like 'last seen %s ago'.
     954         *     @type bool  $relative      If true, will return relative time "5 minutes ago". If false, will return
     955         *                                date from database. Default: true.
    955956         * }
    956957         * @return string
    957958         */
     
    960961
    961962                // Parse the activity format.
    962963                $r = bp_parse_args( $args, array(
    963                         'active_format' => true
     964                        'active_format' => true,
     965                        'relative'      => true
    964966                ) );
    965967
    966968                // Backwards compatibility for anyone forcing a 'true' active_format.
     
    970972
    971973                // Member has logged in at least one time.
    972974                if ( isset( $members_template->member->last_activity ) ) {
     975                        // We do not want relative time, so return now.
     976                        // @todo Should the 'bp_member_last_active' filter be applied here?
     977                        if ( false === $r['relative'] ) {
     978                                return esc_attr( $members_template->member->last_activity );
     979                        }
    973980
    974981                        // Backwards compatibility for pre 1.5 'ago' strings.
    975982                        $last_activity = ! empty( $r['active_format'] )
    976983                                ? bp_core_get_last_activity( $members_template->member->last_activity, $r['active_format'] )
    977984                                : bp_core_time_since( $members_template->member->last_activity );
    978985
    979                         // Member has never logged in or been active.
     986                // Member has never logged in or been active.
    980987                } else {
    981988                        $last_activity = __( 'Never active', 'buddypress' );
    982989                }
     
    11481155 * Output the 'registered [x days ago]' string for the current member.
    11491156 *
    11501157 * @since 1.2.0
     1158 * @since 2.6.0 Added $args as a parameter.
     1159 *
     1160 * @param array $args {@see bp_get_member_registered()}
    11511161 */
    1152 function bp_member_registered() {
    1153         echo bp_get_member_registered();
     1162function bp_member_registered( $args = array() ) {
     1163        echo bp_get_member_registered( $args );
    11541164}
    11551165        /**
    11561166         * Get the 'registered [x days ago]' string for the current member.
    11571167         *
    11581168         * @since 1.2.0
     1169         * @since 2.6.0 Added $args as a parameter.
     1170         *
     1171         * @param array $args {
     1172         *     Array of optional parameters.
     1173         *     @type bool $relative If true, returns relative registered date. eg. registered 5 months ago.
     1174         *                          If false, returns registered date value from database.
     1175         * }
    11591176         *
    11601177         * @return string
    11611178         */
    1162         function bp_get_member_registered() {
     1179        function bp_get_member_registered( $args = array() ) {
    11631180                global $members_template;
    11641181
     1182                $r = wp_parse_args( $args, array(
     1183                        'relative' => true
     1184                ) );
     1185
     1186                // We do not want relative time, so return now.
     1187                // @todo Should the 'bp_member_registered' filter be applied here?
     1188                if ( false === $r['relative'] ) {
     1189                        return esc_attr( $members_template->member->user_registered );
     1190                }
     1191
    11651192                $registered = esc_attr( bp_core_get_last_activity( $members_template->member->user_registered, _x( 'registered %s', 'Records the timestamp that the user registered into the activity stream', 'buddypress' ) ) );
    11661193
    11671194                /**
  • src/bp-members/classes/class-bp-core-members-widget.php

     
    126126                                                <div class="item">
    127127                                                        <div class="item-title fn"><a href="<?php bp_member_permalink(); ?>" title="<?php bp_member_name(); ?>"><?php bp_member_name(); ?></a></div>
    128128                                                        <div class="item-meta">
    129                                                                 <span class="activity"><?php
    130                                                                         if ( 'newest' === $settings['member_default'] ) :
    131                                                                                 bp_member_registered();
    132                                                                         elseif ( 'active' === $settings['member_default'] ) :
    133                                                                                 bp_member_last_active();
    134                                                                         elseif ( 'popular' === $settings['member_default'] ) :
    135                                                                                 bp_member_total_friend_count();
    136                                                                         endif; ?></span>
     129                                                                <?php if ( 'newest' == $settings['member_default'] ) : ?>
     130                                                                        <span class="activity" data-livestamp="<?php bp_core_iso8601_date( bp_get_member_registered( array( 'relative' => false ) ) ); ?>"><?php bp_member_registered(); ?></span>
     131                                                                <?php elseif ( 'active' == $settings['member_default'] ) : ?>
     132                                                                        <span class="activity" data-livestamp="<?php bp_core_iso8601_date( bp_get_member_last_activity( array( 'relative' => false ) ) ); ?>"><?php bp_member_last_active(); ?></span>
     133                                                                <?php else : ?>
     134                                                                        <span class="activity"><?php bp_member_total_friend_count(); ?></span>
     135                                                                <?php endif; ?>
    137136                                                        </div>
    138137                                                </div>
    139138                                        </li>
  • src/bp-templates/bp-legacy/buddypress/activity/comment.php

     
    2525
    2626        <div class="acomment-meta">
    2727                <?php
    28                 /* translators: 1: user profile link, 2: user name, 3: activity permalink, 4: activity timestamp */
    29                 printf( __( '<a href="%1$s">%2$s</a> replied <a href="%3$s" class="activity-time-since"><span class="time-since">%4$s</span></a>', 'buddypress' ), bp_get_activity_comment_user_link(), bp_get_activity_comment_name(), bp_get_activity_comment_permalink(), bp_get_activity_comment_date_recorded() );
     28                /* translators: 1: user profile link, 2: user name, 3: activity permalink, 4: ISO8601 timestamp, 5: activity relative timestamp */
     29                printf( __( '<a href="%1$s">%2$s</a> replied <a href="%3$s" class="activity-time-since"><span class="time-since" data-livestamp="%4$s">%5$s</span></a>', 'buddypress' ), bp_get_activity_comment_user_link(), bp_get_activity_comment_name(), bp_get_activity_comment_permalink(), bp_core_get_iso8601_date( bp_get_activity_comment_date_recorded() ), bp_get_activity_comment_date_recorded() );
    3030                ?>
    3131        </div>
    3232
  • src/bp-templates/bp-legacy/buddypress/groups/groups-loop.php

     
    5959
    6060                        <div class="item">
    6161                                <div class="item-title"><a href="<?php bp_group_permalink(); ?>"><?php bp_group_name(); ?></a></div>
    62                                 <div class="item-meta"><span class="activity"><?php printf( __( 'active %s', 'buddypress' ), bp_get_group_last_active() ); ?></span></div>
     62                                <div class="item-meta"><span class="activity" data-timestamp="<?php bp_core_iso8601_date( bp_get_group_last_active( 0, array( 'relative' => false ) ) ); ?>"><?php printf( __( 'active %s', 'buddypress' ), bp_get_group_last_active() ); ?></span></div>
    6363
    6464                                <div class="item-desc"><?php bp_group_description_excerpt(); ?></div>
    6565
  • src/bp-templates/bp-legacy/buddypress/groups/single/cover-image-header.php

     
    5959                                do_action( 'bp_group_header_meta' ); ?>
    6060
    6161                                <span class="highlight"><?php bp_group_type(); ?></span>
    62                                 <span class="activity"><?php printf( __( 'active %s', 'buddypress' ), bp_get_group_last_active() ); ?></span>
     62                                <span class="activity" data-timestamp="<?php bp_core_iso8601_date( bp_get_group_last_active( 0, array( 'relative' => false ) ) ); ?>"><?php printf( __( 'active %s', 'buddypress' ), bp_get_group_last_active() ); ?></span>
    6363
    6464                                <?php bp_group_description(); ?>
    6565
  • src/bp-templates/bp-legacy/buddypress/groups/single/group-header.php

     
    6868
    6969<div id="item-header-content">
    7070        <span class="highlight"><?php bp_group_type(); ?></span>
    71         <span class="activity"><?php printf( __( 'active %s', 'buddypress' ), bp_get_group_last_active() ); ?></span>
     71        <span class="activity" data-timestamp="<?php bp_core_iso8601_date( bp_get_group_last_active( 0, array( 'relative' => false ) ) ); ?>"><?php printf( __( 'active %s', 'buddypress' ), bp_get_group_last_active() ); ?></span>
    7272
    7373        <?php
    7474
  • src/bp-templates/bp-legacy/buddypress/groups/single/members.php

     
    5656                                </a>
    5757
    5858                                <h5><?php bp_group_member_link(); ?></h5>
    59                                 <span class="activity"><?php bp_group_member_joined_since(); ?></span>
     59                                <span class="activity" data-timestamp="<?php bp_core_iso8601_date( bp_get_group_member_joined_since( array( 'relative' => false ) ) ); ?>"><?php bp_group_member_joined_since(); ?></span>
    6060
    6161                                <?php
    6262
  • src/bp-templates/bp-legacy/buddypress/members/members-loop.php

     
    6767
    6868                                </div>
    6969
    70                                 <div class="item-meta"><span class="activity"><?php bp_member_last_active(); ?></span></div>
     70                                <div class="item-meta"><span class="activity" data-timestamp="<?php bp_core_iso8601_date( bp_get_member_last_active( array( 'relative' => false ) ) ); ?>"><?php bp_member_last_active(); ?></span></div>
    7171
    7272                                <?php
    7373