momentjs-rails 1.6.2 → 1.7.0

data/README.md

@@ -24,7 +24,7 @@ If you want to include a localization file, also add the following directive:
 
 ## Versioning
 
-momentjs-rails 1.6.2 == Moment.js 1.6.2
+momentjs-rails 1.7.0 == Moment.js 1.7.0
 
 Every attempt is made to mirror the currently shipping Momentum.js version number wherever possible.
 The major, minor, and patch version numbers will always represent the Momentum.js version. Should a gem

data/changelog.md

@@ -10,3 +10,7 @@
 ### Version 1.6.2 (2012-06-07)
 - Upgraded Moment.js to 1.6.2
 - Added localization files
+
+### Version 1.7.0 (2012-08-06)
+- Upgrade Moment.js to 1.7.0
+- Upgrade localization files to 1.7.0 tagged versions.

data/vendor/assets/javascripts/moment.js

@@ -1,29 +1,38 @@
 // moment.js
-// version : 1.6.2
+// version : 1.7.0
 // author : Tim Wood
 // license : MIT
 // momentjs.com
 
 (function (Date, undefined) {
 
+    /************************************
+        Constants
+    ************************************/
+
     var moment,
-        VERSION = "1.6.2",
+        VERSION = "1.7.0",
         round = Math.round, i,
         // internal storage for language config files
         languages = {},
         currentLanguage = 'en',
 
         // check for nodeJS
-        hasModule = (typeof module !== 'undefined'),
+        hasModule = (typeof module !== 'undefined' && module.exports),
 
-        // parameters to check for on the lang config
-        langConfigProperties = 'months|monthsShort|monthsParse|weekdays|weekdaysShort|longDateFormat|calendar|relativeTime|ordinal|meridiem'.split('|'),
+        // Parameters to check for on the lang config.  This list of properties
+        // will be inherited from English if not provided in a language
+        // definition.  monthsParse is also a lang config property, but it
+        // cannot be inherited and as such cannot be enumerated here.
+        langConfigProperties = 'months|monthsShort|weekdays|weekdaysShort|weekdaysMin|longDateFormat|calendar|relativeTime|ordinal|meridiem'.split('|'),
 
         // ASP.NET json date format regex
         aspNetJsonRegex = /^\/?Date\((\-?\d+)/i,
 
         // format tokens
-        formattingTokens = /(\[[^\[]*\])|(\\)?(Mo|MM?M?M?|Do|DDDo|DD?D?D?|dddd?|do?|w[o|w]?|YYYY|YY|a|A|hh?|HH?|mm?|ss?|SS?S?|zz?|ZZ?|LT|LL?L?L?)/g,
+        formattingTokens = /(\[[^\[]*\])|(\\)?(Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|YYYY|YY|a|A|hh?|HH?|mm?|ss?|SS?S?|zz?|ZZ?)/g,
+        localFormattingTokens = /(LT|LL?L?L?)/g,
+        formattingRemoveEscapes = /(^\[)|(\\)|\]$/g,
 
         // parsing tokens
         parseMultipleFormatChunker = /([0-9a-zA-Z\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+)/gi,
@@ -32,7 +41,7 @@
         parseTokenOneOrTwoDigits = /\d\d?/, // 0 - 99
         parseTokenOneToThreeDigits = /\d{1,3}/, // 0 - 999
         parseTokenThreeDigits = /\d{3}/, // 000 - 999
-        parseTokenFourDigits = /\d{4}/, // 0000 - 9999
+        parseTokenFourDigits = /\d{1,4}/, // 0 - 9999
         parseTokenWord = /[0-9a-z\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+/i, // any word characters or numbers
         parseTokenTimezone = /Z|[\+\-]\d\d:?\d\d/i, // +00:00 -00:00 +0000 -0000 or Z
         parseTokenT = /T/i, // T (ISO seperator)
@@ -63,20 +72,77 @@
             'Days' : 864e5,
             'Months' : 2592e6,
             'Years' : 31536e6
-        };
+        },
+
+        // format function strings
+        formatFunctions = {},
+
+        /*
+         * moment.fn.format uses new Function() to create an inlined formatting function.
+         * Results are a 3x speed boost
+         * http://jsperf.com/momentjs-cached-format-functions
+         *
+         * These strings are appended into a function using replaceFormatTokens and makeFormatFunction
+         */
+        formatFunctionStrings = {
+            // a = placeholder
+            // b = placeholder
+            // t = the current moment being formatted
+            // v = getValueAtKey function
+            // o = language.ordinal function
+            // p = leftZeroFill function
+            // m = language.meridiem value or function
+            M    : '(a=t.month()+1)',
+            MMM  : 'v("monthsShort",t.month())',
+            MMMM : 'v("months",t.month())',
+            D    : '(a=t.date())',
+            DDD  : '(a=new Date(t.year(),t.month(),t.date()),b=new Date(t.year(),0,1),a=~~(((a-b)/864e5)+1.5))',
+            d    : '(a=t.day())',
+            dd   : 'v("weekdaysMin",t.day())',
+            ddd  : 'v("weekdaysShort",t.day())',
+            dddd : 'v("weekdays",t.day())',
+            w    : '(a=new Date(t.year(),t.month(),t.date()-t.day()+5),b=new Date(a.getFullYear(),0,4),a=~~((a-b)/864e5/7+1.5))',
+            YY   : 'p(t.year()%100,2)',
+            YYYY : 'p(t.year(),4)',
+            a    : 'm(t.hours(),t.minutes(),!0)',
+            A    : 'm(t.hours(),t.minutes(),!1)',
+            H    : 't.hours()',
+            h    : 't.hours()%12||12',
+            m    : 't.minutes()',
+            s    : 't.seconds()',
+            S    : '~~(t.milliseconds()/100)',
+            SS   : 'p(~~(t.milliseconds()/10),2)',
+            SSS  : 'p(t.milliseconds(),3)',
+            Z    : '((a=-t.zone())<0?((a=-a),"-"):"+")+p(~~(a/60),2)+":"+p(~~a%60,2)',
+            ZZ   : '((a=-t.zone())<0?((a=-a),"-"):"+")+p(~~(10*a/6),4)'
+        },
+
+        ordinalizeTokens = 'DDD w M D d'.split(' '),
+        paddedTokens = 'M D H h m s w'.split(' ');
+
+    while (ordinalizeTokens.length) {
+        i = ordinalizeTokens.pop();
+        formatFunctionStrings[i + 'o'] = formatFunctionStrings[i] + '+o(a)';
+    }
+    while (paddedTokens.length) {
+        i = paddedTokens.pop();
+        formatFunctionStrings[i + i] = 'p(' + formatFunctionStrings[i] + ',2)';
+    }
+    formatFunctionStrings.DDDD = 'p(' + formatFunctionStrings.DDD + ',3)';
+
+
+    /************************************
+        Constructors
+    ************************************/
+
 
     // Moment prototype object
-    function Moment(date, isUTC) {
+    function Moment(date, isUTC, lang) {
         this._d = date;
         this._isUTC = !!isUTC;
-    }
-
-    function absRound(number) {
-        if (number < 0) {
-            return Math.ceil(number);
-        } else {
-            return Math.floor(number);
-        }
+        this._a = date._a || null;
+        date._a = null;
+        this._lang = lang || false;
     }
 
     // Duration Constructor
@@ -129,6 +195,22 @@
         years += absRound(months / 12);
 
         data.years = years;
+
+        this._lang = false;
+    }
+
+
+    /************************************
+        Helpers
+    ************************************/
+
+
+    function absRound(number) {
+        if (number < 0) {
+            return Math.ceil(number);
+        } else {
+            return Math.floor(number);
+        }
     }
 
     // left zero fill a number
@@ -167,141 +249,152 @@
         return Object.prototype.toString.call(input) === '[object Array]';
     }
 
+    // compare two arrays, return the number of differences
+    function compareArrays(array1, array2) {
+        var len = Math.min(array1.length, array2.length),
+            lengthDiff = Math.abs(array1.length - array2.length),
+            diffs = 0,
+            i;
+        for (i = 0; i < len; i++) {
+            if (~~array1[i] !== ~~array2[i]) {
+                diffs++;
+            }
+        }
+        return diffs + lengthDiff;
+    }
+
     // convert an array to a date.
     // the array should mirror the parameters below
     // note: all values past the year are optional and will default to the lowest possible value.
     // [year, month, day , hour, minute, second, millisecond]
-    function dateFromArray(input) {
-        return new Date(input[0], input[1] || 0, input[2] || 1, input[3] || 0, input[4] || 0, input[5] || 0, input[6] || 0);
+    function dateFromArray(input, asUTC) {
+        var i, date;
+        for (i = 1; i < 7; i++) {
+            input[i] = (input[i] == null) ? (i === 2 ? 1 : 0) : input[i];
+        }
+        // we store whether we used utc or not in the input array
+        input[7] = asUTC;
+        date = new Date(0);
+        if (asUTC) {
+            date.setUTCFullYear(input[0], input[1], input[2]);
+            date.setUTCHours(input[3], input[4], input[5], input[6]);
+        } else {
+            date.setFullYear(input[0], input[1], input[2]);
+            date.setHours(input[3], input[4], input[5], input[6]);
+        }
+        date._a = input;
+        return date;
+    }
+
+    // Loads a language definition into the `languages` cache.  The function
+    // takes a key and optionally values.  If not in the browser and no values
+    // are provided, it will load the language file module.  As a convenience,
+    // this function also returns the language values.
+    function loadLang(key, values) {
+        var i, m,
+            parse = [];
+
+        if (!values && hasModule) {
+            values = require('./lang/' + key);
+        }
+        
+        for (i = 0; i < langConfigProperties.length; i++) {
+            // If a language definition does not provide a value, inherit
+            // from English
+            values[langConfigProperties[i]] = values[langConfigProperties[i]] ||
+              languages.en[langConfigProperties[i]];
+        }
+
+        for (i = 0; i < 12; i++) {
+            m = moment([2000, i]);
+            parse[i] = new RegExp('^' + (values.months[i] || values.months(m, '')) + 
+                '|^' + (values.monthsShort[i] || values.monthsShort(m, '')).replace('.', ''), 'i');
+        }
+        values.monthsParse = values.monthsParse || parse;
+
+        languages[key] = values;
+        
+        return values;
+    }
+
+    // Determines which language definition to use and returns it.
+    //
+    // With no parameters, it will return the global language.  If you
+    // pass in a language key, such as 'en', it will return the
+    // definition for 'en', so long as 'en' has already been loaded using
+    // moment.lang.  If you pass in a moment or duration instance, it
+    // will decide the language based on that, or default to the global
+    // language.
+    function getLangDefinition(m) {
+        var langKey = (typeof m === 'string') && m ||
+                      m && m._lang ||
+                      null;
+
+        return langKey ? (languages[langKey] || loadLang(langKey)) : moment;
+    }
+
+
+    /************************************
+        Formatting
+    ************************************/
+
+
+    // helper for building inline formatting functions
+    function replaceFormatTokens(token) {
+        return formatFunctionStrings[token] ? 
+            ("'+(" + formatFunctionStrings[token] + ")+'") :
+            token.replace(formattingRemoveEscapes, "").replace(/\\?'/g, "\\'");
+    }
+
+    // helper for recursing long date formatting tokens
+    function replaceLongDateFormatTokens(input) {
+        return getLangDefinition().longDateFormat[input] || input;
+    }
+
+    function makeFormatFunction(format) {
+        var output = "var a,b;return '" +
+            format.replace(formattingTokens, replaceFormatTokens) + "';",
+            Fn = Function; // get around jshint
+        // t = the current moment being formatted
+        // v = getValueAtKey function
+        // o = language.ordinal function
+        // p = leftZeroFill function
+        // m = language.meridiem value or function
+        return new Fn('t', 'v', 'o', 'p', 'm', output);
+    }
+
+    function makeOrGetFormatFunction(format) {
+        if (!formatFunctions[format]) {
+            formatFunctions[format] = makeFormatFunction(format);
+        }
+        return formatFunctions[format];
     }
 
     // format date using native date object
-    function formatMoment(m, inputString) {
-        var currentMonth = m.month(),
-            currentDate = m.date(),
-            currentYear = m.year(),
-            currentDay = m.day(),
-            currentHours = m.hours(),
-            currentMinutes = m.minutes(),
-            currentSeconds = m.seconds(),
-            currentMilliseconds = m.milliseconds(),
-            currentZone = -m.zone(),
-            ordinal = moment.ordinal,
-            meridiem = moment.meridiem;
-        // check if the character is a format
-        // return formatted string or non string.
-        //
-        // uses switch/case instead of an object of named functions (like http://phpjs.org/functions/date:380)
-        // for minification and performance
-        // see http://jsperf.com/object-of-functions-vs-switch for performance comparison
-        function replaceFunction(input) {
-            // create a couple variables to be used later inside one of the cases.
-            var a, b;
-            switch (input) {
-                // MONTH
-            case 'M' :
-                return currentMonth + 1;
-            case 'Mo' :
-                return (currentMonth + 1) + ordinal(currentMonth + 1);
-            case 'MM' :
-                return leftZeroFill(currentMonth + 1, 2);
-            case 'MMM' :
-                return moment.monthsShort[currentMonth];
-            case 'MMMM' :
-                return moment.months[currentMonth];
-            // DAY OF MONTH
-            case 'D' :
-                return currentDate;
-            case 'Do' :
-                return currentDate + ordinal(currentDate);
-            case 'DD' :
-                return leftZeroFill(currentDate, 2);
-            // DAY OF YEAR
-            case 'DDD' :
-                a = new Date(currentYear, currentMonth, currentDate);
-                b = new Date(currentYear, 0, 1);
-                return ~~ (((a - b) / 864e5) + 1.5);
-            case 'DDDo' :
-                a = replaceFunction('DDD');
-                return a + ordinal(a);
-            case 'DDDD' :
-                return leftZeroFill(replaceFunction('DDD'), 3);
-            // WEEKDAY
-            case 'd' :
-                return currentDay;
-            case 'do' :
-                return currentDay + ordinal(currentDay);
-            case 'ddd' :
-                return moment.weekdaysShort[currentDay];
-            case 'dddd' :
-                return moment.weekdays[currentDay];
-            // WEEK OF YEAR
-            case 'w' :
-                a = new Date(currentYear, currentMonth, currentDate - currentDay + 5);
-                b = new Date(a.getFullYear(), 0, 4);
-                return ~~ ((a - b) / 864e5 / 7 + 1.5);
-            case 'wo' :
-                a = replaceFunction('w');
-                return a + ordinal(a);
-            case 'ww' :
-                return leftZeroFill(replaceFunction('w'), 2);
-            // YEAR
-            case 'YY' :
-                return leftZeroFill(currentYear % 100, 2);
-            case 'YYYY' :
-                return currentYear;
-            // AM / PM
-            case 'a' :
-                return meridiem ? meridiem(currentHours, currentMinutes, false) : (currentHours > 11 ? 'pm' : 'am');
-            case 'A' :
-                return meridiem ? meridiem(currentHours, currentMinutes, true) : (currentHours > 11 ? 'PM' : 'AM');
-            // 24 HOUR
-            case 'H' :
-                return currentHours;
-            case 'HH' :
-                return leftZeroFill(currentHours, 2);
-            // 12 HOUR
-            case 'h' :
-                return currentHours % 12 || 12;
-            case 'hh' :
-                return leftZeroFill(currentHours % 12 || 12, 2);
-            // MINUTE
-            case 'm' :
-                return currentMinutes;
-            case 'mm' :
-                return leftZeroFill(currentMinutes, 2);
-            // SECOND
-            case 's' :
-                return currentSeconds;
-            case 'ss' :
-                return leftZeroFill(currentSeconds, 2);
-            // MILLISECONDS
-            case 'S' :
-                return ~~ (currentMilliseconds / 100);
-            case 'SS' :
-                return leftZeroFill(~~(currentMilliseconds / 10), 2);
-            case 'SSS' :
-                return leftZeroFill(currentMilliseconds, 3);
-            // TIMEZONE
-            case 'Z' :
-                return (currentZone < 0 ? '-' : '+') + leftZeroFill(~~(Math.abs(currentZone) / 60), 2) + ':' + leftZeroFill(~~(Math.abs(currentZone) % 60), 2);
-            case 'ZZ' :
-                return (currentZone < 0 ? '-' : '+') + leftZeroFill(~~(10 * Math.abs(currentZone) / 6), 4);
-            // LONG DATES
-            case 'L' :
-            case 'LL' :
-            case 'LLL' :
-            case 'LLLL' :
-            case 'LT' :
-                return formatMoment(m, moment.longDateFormat[input]);
-            // DEFAULT
-            default :
-                return input.replace(/(^\[)|(\\)|\]$/g, "");
-            }
+    function formatMoment(m, format) {
+        var lang = getLangDefinition(m);
+
+        function getValueFromArray(key, index) {
+            return lang[key].call ? lang[key](m, format) : lang[key][index];
+        }
+
+        while (localFormattingTokens.test(format)) {
+            format = format.replace(localFormattingTokens, replaceLongDateFormatTokens);
+        }
+
+        if (!formatFunctions[format]) {
+            formatFunctions[format] = makeFormatFunction(format);
         }
-        return inputString.replace(formattingTokens, replaceFunction);
+
+        return formatFunctions[format](m, getValueFromArray, lang.ordinal, leftZeroFill, lang.meridiem);
     }
 
+
+    /************************************
+        Parsing
+    ************************************/
+
+
     // get the regex to find the next token
     function getParseRegexForToken(token) {
         switch (token) {
@@ -316,6 +409,7 @@
             return parseTokenOneToThreeDigits;
         case 'MMM':
         case 'MMMM':
+        case 'dd':
         case 'ddd':
         case 'dddd':
         case 'a':
@@ -328,7 +422,6 @@
             return parseTokenT;
         case 'MM':
         case 'DD':
-        case 'dd':
         case 'YY':
         case 'HH':
         case 'hh':
@@ -360,7 +453,7 @@
         case 'MMM' : // fall through to MMMM
         case 'MMMM' :
             for (a = 0; a < 12; a++) {
-                if (moment.monthsParse[a].test(input)) {
+                if (getLangDefinition().monthsParse[a].test(input)) {
                     datePartArray[1] = a;
                     break;
                 }
@@ -371,7 +464,9 @@
         case 'DD' : // fall through to DDDD
         case 'DDD' : // fall through to DDDD
         case 'DDDD' :
-            datePartArray[2] = ~~input;
+            if (input != null) {
+                datePartArray[2] = ~~input;
+            }
             break;
         // YEAR
         case 'YY' :
@@ -456,21 +551,7 @@
         datePartArray[3] += config.tzh;
         datePartArray[4] += config.tzm;
         // return
-        return config.isUTC ? new Date(Date.UTC.apply({}, datePartArray)) : dateFromArray(datePartArray);
-    }
-
-    // compare two arrays, return the number of differences
-    function compareArrays(array1, array2) {
-        var len = Math.min(array1.length, array2.length),
-            lengthDiff = Math.abs(array1.length - array2.length),
-            diffs = 0,
-            i;
-        for (i = 0; i < len; i++) {
-            if (~~array1[i] !== ~~array2[i]) {
-                diffs++;
-            }
-        }
-        return diffs + lengthDiff;
+        return dateFromArray(datePartArray, config.isUTC);
     }
 
     // date from string and array of format strings
@@ -512,15 +593,21 @@
         return new Date(string);
     }
 
+
+    /************************************
+        Relative Time
+    ************************************/
+
+
     // helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize
-    function substituteTimeAgo(string, number, withoutSuffix, isFuture) {
-        var rt = moment.relativeTime[string];
+    function substituteTimeAgo(string, number, withoutSuffix, isFuture, lang) {
+        var rt = lang.relativeTime[string];
         return (typeof rt === 'function') ?
             rt(number || 1, !!withoutSuffix, string, isFuture) :
             rt.replace(/%d/i, number || 1);
     }
 
-    function relativeTime(milliseconds, withoutSuffix) {
+    function relativeTime(milliseconds, withoutSuffix, lang) {
         var seconds = round(Math.abs(milliseconds) / 1000),
             minutes = round(seconds / 60),
             hours = round(minutes / 60),
@@ -538,20 +625,25 @@
                 years === 1 && ['y'] || ['yy', years];
         args[2] = withoutSuffix;
         args[3] = milliseconds > 0;
+        args[4] = lang;
         return substituteTimeAgo.apply({}, args);
     }
 
+
+    /************************************
+        Top Level Functions
+    ************************************/
+
+
     moment = function (input, format) {
         if (input === null || input === '') {
             return null;
         }
         var date,
-            matched,
-            isUTC;
+            matched;
         // parse Moment object
         if (moment.isMoment(input)) {
-            date = new Date(+input._d);
-            isUTC = input._isUTC;
+            return new Moment(new Date(+input._d), input._isUTC, input._lang);
         // parse string and format
         } else if (format) {
             if (isArray(format)) {
@@ -569,17 +661,23 @@
                 typeof input === 'string' ? makeDateFromString(input) :
                 new Date(input);
         }
-        return new Moment(date, isUTC);
+
+        return new Moment(date);
     };
 
     // creating with utc
     moment.utc = function (input, format) {
         if (isArray(input)) {
-            return new Moment(new Date(Date.UTC.apply({}, input)), true);
+            return new Moment(dateFromArray(input, true), true);
+        }
+        // if we don't have a timezone, we need to add one to trigger parsing into utc
+        if (typeof input === 'string' && !parseTokenTimezone.exec(input)) {
+            input += ' +0000';
+            if (format) {
+                format += ' Z';
+            }
         }
-        return (format && input) ?
-            moment(input + ' +0000', format + ' Z').utc() :
-            moment(input && !parseTokenTimezone.exec(input) ? input + '+0000' : input).utc();
+        return moment(input, format).utc();
     };
 
     // creating with unix timestamp (in seconds)
@@ -591,7 +689,8 @@
     moment.duration = function (input, key) {
         var isDuration = moment.isDuration(input),
             isNumber = (typeof input === 'number'),
-            duration = (isDuration ? input._data : (isNumber ? {} : input));
+            duration = (isDuration ? input._data : (isNumber ? {} : input)),
+            ret;
 
         if (isNumber) {
             if (key) {
@@ -601,7 +700,13 @@
             }
         }
 
-        return new Duration(duration);
+        ret = new Duration(duration);
+
+        if (isDuration) {
+            ret._lang = input._lang;
+        }
+
+        return ret;
     };
 
     // humanizeDuration
@@ -617,40 +722,49 @@
     // default format
     moment.defaultFormat = isoFormat;
 
-    // language switching and caching
+    // This function will load languages and then set the global language.  If
+    // no arguments are passed in, it will simply return the current global
+    // language key.
     moment.lang = function (key, values) {
-        var i, req,
-            parse = [];
+        var i;
+
         if (!key) {
             return currentLanguage;
         }
-        if (values) {
-            for (i = 0; i < 12; i++) {
-                parse[i] = new RegExp('^' + values.months[i] + '|^' + values.monthsShort[i].replace('.', ''), 'i');
-            }
-            values.monthsParse = values.monthsParse || parse;
-            languages[key] = values;
+        if (values || !languages[key]) {
+            loadLang(key, values);
         }
         if (languages[key]) {
+            // deprecated, to get the language definition variables, use the
+            // moment.fn.lang method or the getLangDefinition function.
             for (i = 0; i < langConfigProperties.length; i++) {
-                moment[langConfigProperties[i]] = languages[key][langConfigProperties[i]] || 
-                    languages.en[langConfigProperties[i]];
+                moment[langConfigProperties[i]] = languages[key][langConfigProperties[i]];
             }
+            moment.monthsParse = languages[key].monthsParse;
             currentLanguage = key;
-        } else {
-            if (hasModule) {
-                req = require('./lang/' + key);
-                moment.lang(key, req);
-            }
         }
     };
 
-    // set default language
+    // returns language data
+    moment.langData = getLangDefinition;
+
+    // compare moment object
+    moment.isMoment = function (obj) {
+        return obj instanceof Moment;
+    };
+
+    // for typechecking Duration objects
+    moment.isDuration = function (obj) {
+        return obj instanceof Duration;
+    };
+
+    // Set default language, other languages will inherit from English.
     moment.lang('en', {
         months : "January_February_March_April_May_June_July_August_September_October_November_December".split("_"),
         monthsShort : "Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"),
         weekdays : "Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),
         weekdaysShort : "Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),
+        weekdaysMin : "Su_Mo_Tu_We_Th_Fr_Sa".split("_"),
         longDateFormat : {
             LT : "h:mm A",
             L : "MM/DD/YYYY",
@@ -658,7 +772,13 @@
             LLL : "MMMM D YYYY LT",
             LLLL : "dddd, MMMM D YYYY LT"
         },
-        meridiem : false,
+        meridiem : function (hours, minutes, isLower) {
+            if (hours > 11) {
+                return isLower ? 'pm' : 'PM';
+            } else {
+                return isLower ? 'am' : 'AM';
+            }
+        },
         calendar : {
             sameDay : '[Today at] LT',
             nextDay : '[Tomorrow at] LT',
@@ -691,17 +811,12 @@
         }
     });
 
-    // compare moment object
-    moment.isMoment = function (obj) {
-        return obj instanceof Moment;
-    };
 
-    // for typechecking Duration objects
-    moment.isDuration = function (obj) {
-        return obj instanceof Duration;
-    };
+    /************************************
+        Moment Prototype
+    ************************************/
+
 
-    // shortcut for prototype
     moment.fn = Moment.prototype = {
 
         clone : function () {
@@ -724,6 +839,27 @@
             return this._d;
         },
 
+        toArray : function () {
+            var m = this;
+            return [
+                m.year(),
+                m.month(),
+                m.date(),
+                m.hours(),
+                m.minutes(),
+                m.seconds(),
+                m.milliseconds(),
+                !!this._isUTC
+            ];
+        },
+
+        isValid : function () {
+            if (this._a) {
+                return !compareArrays(this._a, (this._a[7] ? moment.utc(this) : this).toArray());
+            }
+            return !isNaN(this._d.getTime());
+        },
+
         utc : function () {
             this._isUTC = true;
             return this;
@@ -774,7 +910,7 @@
         },
 
         from : function (time, withoutSuffix) {
-            return moment.duration(this.diff(time)).humanize(!withoutSuffix);
+            return moment.duration(this.diff(time)).lang(this._lang).humanize(!withoutSuffix);
         },
 
         fromNow : function (withoutSuffix) {
@@ -783,7 +919,7 @@
 
         calendar : function () {
             var diff = this.diff(moment().sod(), 'days', true),
-                calendar = moment.calendar,
+                calendar = this.lang().calendar,
                 allElse = calendar.sameElse,
                 format = diff < -6 ? allElse :
                 diff < -1 ? calendar.lastWeek :
@@ -810,20 +946,43 @@
                 this.add({ d : input - day });
         },
 
+        startOf: function (val) {
+            // the following switch intentionally omits break keywords
+            // to utilize falling through the cases.
+            switch (val.replace(/s$/, '')) {
+            case 'year':
+                this.month(0);
+                /* falls through */
+            case 'month':
+                this.date(1);
+                /* falls through */
+            case 'day':
+                this.hours(0);
+                /* falls through */
+            case 'hour':
+                this.minutes(0);
+                /* falls through */
+            case 'minute':
+                this.seconds(0);
+                /* falls through */
+            case 'second':
+                this.milliseconds(0);
+                /* falls through */
+            }
+            return this;
+        },
+
+        endOf: function (val) {
+            return this.startOf(val).add(val.replace(/s?$/, 's'), 1).subtract('ms', 1);
+        },
+        
         sod: function () {
-            return moment(this)
-                .hours(0)
-                .minutes(0)
-                .seconds(0)
-                .milliseconds(0);
+            return this.clone().startOf('day');
         },
 
         eod: function () {
             // end of day = start of day plus 1 day, minus 1 millisecond
-            return this.sod().add({
-                d : 1,
-                ms : -1
-            });
+            return this.clone().endOf('day');
         },
 
         zone : function () {
@@ -831,7 +990,19 @@
         },
 
         daysInMonth : function () {
-            return moment(this).month(this.month() + 1).date(0).date();
+            return moment.utc([this.year(), this.month() + 1, 0]).date();
+        },
+
+        // If passed a language key, it will set the language for this
+        // instance.  Otherwise, it will return the language configuration
+        // variables for this instance.
+        lang : function (lang) {
+            if (lang === undefined) {
+                return getLangDefinition(this);
+            } else {
+                this._lang = lang;
+                return this;
+            }
         }
     };
 
@@ -856,6 +1027,12 @@
     // add shortcut for year (uses different syntax than the getter/setter 'year' == 'FullYear')
     makeGetterAndSetter('year', 'FullYear');
 
+
+    /************************************
+        Duration Prototype
+    ************************************/
+
+
     moment.duration.fn = Duration.prototype = {
         weeks : function () {
             return absRound(this.days() / 7);
@@ -869,15 +1046,17 @@
 
         humanize : function (withSuffix) {
             var difference = +this,
-                rel = moment.relativeTime,
-                output = relativeTime(difference, !withSuffix);
+                rel = this.lang().relativeTime,
+                output = relativeTime(difference, !withSuffix, this.lang());
 
             if (withSuffix) {
                 output = (difference <= 0 ? rel.past : rel.future).replace(/%s/i, output);
             }
 
             return output;
-        }
+        },
+
+        lang : moment.fn.lang
     };
 
     function makeDurationGetter(name) {
@@ -901,13 +1080,22 @@
 
     makeDurationAsGetter('Weeks', 6048e5);
 
+
+    /************************************
+        Exposing Moment
+    ************************************/
+
+
     // CommonJS module is defined
     if (hasModule) {
         module.exports = moment;
     }
     /*global ender:false */
-    if (typeof window !== 'undefined' && typeof ender === 'undefined') {
-        window.moment = moment;
+    if (typeof ender === 'undefined') {
+        // here, `this` means `window` in the browser, or `global` on the server
+        // add `moment` as a global object via a string identifier,
+        // for Closure Compiler "advanced" mode
+        this['moment'] = moment;
     }
     /*global define:false */
     if (typeof define === "function" && define.amd) {
@@ -915,4 +1103,4 @@
             return moment;
         });
     }
-})(Date);
+}).call(this, Date);