uikit-sass-rails 1.3.0 → 1.4.0

data/vendor/assets/javascripts/uikit.js

@@ -1,16 +1,43 @@
 //= require uikit/uikit
 
+// Core
+//= require 'uikit/core/core'
+//= require 'uikit/core/alert'
+//= require 'uikit/core/button'
+//= require 'uikit/core/cover'
+//= require 'uikit/core/dropdown'
+//= require 'uikit/core/grid'
+//= require 'uikit/core/modal'
+//= require 'uikit/core/nav'
+//= require 'uikit/core/offcanvas'
+//= require 'uikit/core/scrollspy'
+//= require 'uikit/core/smooth-scroll'
+//= require 'uikit/core/switcher'
+//= require 'uikit/core/tab'
+//= require 'uikit/core/toggle'
+//= require 'uikit/core/touch'
+//= require 'uikit/core/utility'
+
+// Components
+//= require 'uikit/components/accordion'
 //= require 'uikit/components/autocomplete'
-//= require 'uikit/components/cover'
 //= require 'uikit/components/datepicker'
 //= require 'uikit/components/form-password'
 //= require 'uikit/components/form-select'
+//= require 'uikit/components/grid'
 //= require 'uikit/components/htmleditor'
-//= require 'uikit/components/nestable'
+//= require 'uikit/components/lightbox'
 //= require 'uikit/components/notify'
+//= require 'uikit/components/nestable'
 //= require 'uikit/components/pagination'
+//= require 'uikit/components/parallax'
 //= require 'uikit/components/search'
+//= require 'uikit/components/slider'
+//= require 'uikit/components/slideset'
+//= require 'uikit/components/slideshow-fx'
+//= require 'uikit/components/slideshow'
 //= require 'uikit/components/sortable'
 //= require 'uikit/components/sticky'
 //= require 'uikit/components/timepicker'
-//= require 'uikit/components/upload'
+//= require 'uikit/components/tooltip'
+//= require 'uikit/components/upload'

data/vendor/assets/javascripts/uikit/components/accordion.js

@@ -0,0 +1,172 @@
+/*! UIkit 2.20.3 | http://www.getuikit.com | (c) 2014 YOOtheme | MIT License */
+(function(addon) {
+    var component;
+
+    if (window.UIkit) {
+        component = addon(UIkit);
+    }
+
+    if (typeof define == "function" && define.amd) {
+        define("uikit-accordion", ["uikit"], function(){
+            return component || addon(UIkit);
+        });
+    }
+})(function(UI){
+
+    "use strict";
+
+    UI.component('accordion', {
+
+        defaults: {
+            showfirst  : true,
+            collapse   : true,
+            animate    : true,
+            easing     : 'swing',
+            duration   : 300,
+            toggle     : '.uk-accordion-title',
+            containers : '.uk-accordion-content',
+            clsactive  : 'uk-active'
+        },
+
+        boot:  function() {
+
+            // init code
+            UI.ready(function(context) {
+
+                setTimeout(function(){
+
+                    UI.$("[data-uk-accordion]", context).each(function(){
+
+                        var ele = UI.$(this);
+
+                        if(!ele.data("accordion")) {
+                            UI.accordion(ele, UI.Utils.options(ele.attr('data-uk-accordion')));
+                        }
+                    });
+
+                }, 0);
+            });
+        },
+
+        init: function() {
+
+            var $this = this;
+
+            this.element.on('click.uikit.accordion', this.options.toggle, function(e) {
+
+                e.preventDefault();
+
+                $this.toggleItem(UI.$(this).data('wrapper'), $this.options.animate, $this.options.collapse);
+            });
+
+            this.update();
+
+            if (this.options.showfirst) {
+                this.toggleItem(this.toggle.eq(0).data('wrapper'), false, false);
+            }
+        },
+
+        toggleItem: function(wrapper, animated, collapse) {
+
+            var $this = this;
+
+            wrapper.data('toggle').toggleClass(this.options.clsactive);
+
+            var active = wrapper.data('toggle').hasClass(this.options.clsactive);
+
+            if (collapse) {
+                this.toggle.not(wrapper.data('toggle')).removeClass(this.options.clsactive);
+                this.content.not(wrapper.data('content')).parent().stop().css('overflow', 'hidden').animate({ height: 0 }, {easing: this.options.easing, duration: animated ? this.options.duration : 0}).attr('aria-expanded', 'false');
+            }
+
+            wrapper.stop().css('overflow', 'hidden');
+
+            if (animated) {
+
+                wrapper.animate({ height: active ? getHeight(wrapper.data('content')) : 0 }, {easing: this.options.easing, duration: this.options.duration, complete: function() {
+
+                    if (active) {
+                        wrapper.css({'overflow': '', 'height': 'auto'});
+                        UI.Utils.checkDisplay(wrapper.data('content'));
+                    }
+
+                    $this.trigger('display.uk.check');
+                }});
+
+            } else {
+
+                wrapper.height(active ? 'auto' : 0);
+
+                if (active) {
+                    wrapper.css({'overflow': ''});
+                    UI.Utils.checkDisplay(wrapper.data('content'));
+                }
+
+                this.trigger('display.uk.check');
+            }
+
+            // Update ARIA
+            wrapper.attr('aria-expanded', active);
+
+            this.element.trigger('toggle.uk.accordion', [active, wrapper.data('toggle'), wrapper.data('content')]);
+        },
+
+        update: function() {
+
+            var $this = this, $content, $wrapper, $toggle;
+
+            this.toggle = this.find(this.options.toggle);
+            this.content = this.find(this.options.containers);
+
+            this.content.each(function(index) {
+
+                $content = UI.$(this);
+
+                if ($content.parent().data('wrapper')) {
+                    $wrapper = $content.parent();
+                } else {
+                    $wrapper = UI.$(this).wrap('<div data-wrapper="true" style="overflow:hidden;height:0;position:relative;"></div>').parent();
+
+                    // Init ARIA
+                    $wrapper.attr('aria-expanded', 'false');
+                }
+
+                $toggle = $this.toggle.eq(index);
+
+                $wrapper.data('toggle', $toggle);
+                $wrapper.data('content', $content);
+                $toggle.data('wrapper', $wrapper);
+                $content.data('wrapper', $wrapper);
+            });
+
+            this.element.trigger('update.uk.accordion', [this]);
+        }
+
+    });
+
+    // helper
+
+    function getHeight(ele) {
+
+        var $ele = UI.$(ele), height = "auto";
+
+        if ($ele.is(":visible")) {
+            height = $ele.outerHeight();
+        } else {
+
+            var tmp = {
+                position   : $ele.css("position"),
+                visibility : $ele.css("visibility"),
+                display    : $ele.css("display")
+            };
+
+            height = $ele.css({position: 'absolute', visibility: 'hidden', display: 'block'}).outerHeight();
+
+            $ele.css(tmp); // reset element
+        }
+
+        return height;
+    }
+
+    return UI.accordion;
+});

data/vendor/assets/javascripts/uikit/components/autocomplete.js

@@ -1,19 +1,21 @@
-/*! UIkit 2.11.1 | http://www.getuikit.com | (c) 2014 YOOtheme | MIT License */
+/*! UIkit 2.20.3 | http://www.getuikit.com | (c) 2014 YOOtheme | MIT License */
 (function(addon) {
 
     var component;
 
-    if (jQuery && jQuery.UIkit) {
-        component = addon(jQuery, jQuery.UIkit);
+    if (window.UIkit) {
+        component = addon(UIkit);
     }
 
     if (typeof define == "function" && define.amd) {
         define("uikit-autocomplete", ["uikit"], function(){
-            return component || addon(jQuery, jQuery.UIkit);
+            return component || addon(UIkit);
         });
     }
 
-})(function($, UI){
+})(function(UI){
+
+    "use strict";
 
     var active;
 
@@ -40,6 +42,24 @@
         value    : null,
         selected : null,
 
+        boot: function() {
+
+            // init code
+            UI.$html.on("focus.autocomplete.uikit", "[data-uk-autocomplete]", function(e) {
+
+                var ele = UI.$(this);
+
+                if (!ele.data("autocomplete")) {
+                    var obj = UI.autocomplete(ele, UI.Utils.options(ele.attr("data-uk-autocomplete")));
+                }
+            });
+
+            // register outer click for autocompletes
+            UI.$html.on("click.autocomplete.uikit", function(e) {
+                if (active && e.target!=active.input[0]) active.hide();
+            });
+        },
+
         init: function() {
 
             var $this   = this,
@@ -58,13 +78,15 @@
             this.input    = this.find("input:first").attr("autocomplete", "off");
 
             if (!this.dropdown.length) {
-               this.dropdown = $('<div class="uk-dropdown"></div>').appendTo(this.element);
+               this.dropdown = UI.$('<div class="uk-dropdown"></div>').appendTo(this.element);
             }
 
             if (this.options.flipDropdown) {
                 this.dropdown.addClass('uk-dropdown-flip');
             }
 
+            this.dropdown.attr('aria-expanded', 'false');
+
             this.input.on({
                 "keydown": function(e) {
 
@@ -105,7 +127,7 @@
             });
 
             this.dropdown.on("mouseover", ".uk-autocomplete-results > *", function(){
-                $this.pick($(this));
+                $this.pick(UI.$(this));
             });
 
             this.triggercomplete = trigger;
@@ -129,7 +151,7 @@
         pick: function(item, scrollinview) {
 
             var $this    = this,
-                items    = this.dropdown.find('.uk-autocomplete-results').children(':not(.'+this.options.skipClass+')'),
+                items    = UI.$(this.dropdown.find('.uk-autocomplete-results').children(':not(.'+this.options.skipClass+')')),
                 selected = false;
 
             if (typeof item !== "string" && !item.hasClass(this.options.skipClass)) {
@@ -148,6 +170,8 @@
                 } else {
                     selected = items[(item == 'next') ? 'first' : 'last']();
                 }
+
+                selected = UI.$(selected);
             }
 
             if (selected && selected.length) {
@@ -175,10 +199,10 @@
 
             var data = this.selected.data();
 
-            this.trigger("uk.autocomplete.select", [data, this]);
+            this.trigger("selectitem.uk.autocomplete", [data, this]);
 
             if (data.value) {
-                this.input.val(data.value);
+                this.input.val(data.value).trigger('change');
             }
 
             this.hide();
@@ -189,7 +213,15 @@
             this.visible = true;
             this.element.addClass("uk-open");
 
+            if (active && active!==this) {
+                active.hide();
+            }
+
             active = this;
+
+            // Update aria
+            this.dropdown.attr('aria-expanded', 'true');
+
             return this;
         },
 
@@ -202,6 +234,9 @@
                 active = false;
             }
 
+            // Update aria
+            this.dropdown.attr('aria-expanded', 'false');
+
             return this;
         },
 
@@ -253,7 +288,7 @@
 
                         params[this.options.param] = this.value;
 
-                        $.ajax({
+                        UI.$.ajax({
                             url: this.options.source,
                             data: params,
                             type: this.options.method,
@@ -290,26 +325,12 @@
                 this.dropdown.append(this.template({"items":data}));
                 this.show();
 
-                this.trigger('uk.autocomplete.show');
+                this.trigger('show.uk.autocomplete');
             }
 
             return this;
         }
     });
 
-    // init code
-    UI.$html.on("focus.autocomplete.uikit", "[data-uk-autocomplete]", function(e) {
-
-        var ele = $(this);
-        if (!ele.data("autocomplete")) {
-            var obj = UI.autocomplete(ele, UI.Utils.options(ele.attr("data-uk-autocomplete")));
-        }
-    });
-
-    // register outer click for autocompletes
-    UI.$html.on("click.autocomplete.uikit", function(e){
-        if (active && e.target!=active.input[0]) active.hide();
-    });
-
     return UI.autocomplete;
-});
+});

data/vendor/assets/javascripts/uikit/components/datepicker.js

@@ -1,19 +1,21 @@
-/*! UIkit 2.11.1 | http://www.getuikit.com | (c) 2014 YOOtheme | MIT License */
+/*! UIkit 2.20.3 | http://www.getuikit.com | (c) 2014 YOOtheme | MIT License */
 (function(addon) {
 
     var component;
 
-    if (jQuery && jQuery.UIkit) {
-        component = addon(jQuery, jQuery.UIkit);
+    if (window.UIkit) {
+        component = addon(UIkit);
     }
 
     if (typeof define == "function" && define.amd) {
         define("uikit-datepicker", ["uikit"], function(){
-            return component || addon(jQuery, jQuery.UIkit);
+            return component || addon(UIkit);
         });
     }
 
-})(function($, UI){
+})(function(UI){
+
+    "use strict";
 
     // Datepicker
 
@@ -22,6 +24,7 @@
     UI.component('datepicker', {
 
         defaults: {
+            mobile: false,
             weekstart: 1,
             i18n: {
                 months        : ['January','February','March','April','May','June','July','August','September','October','November','December'],
@@ -31,16 +34,17 @@
             offsettop: 5,
             maxDate: false,
             minDate: false,
+            pos: 'auto',
             template: function(data, opts) {
 
-                var content = '', maxDate, minDate;
+                var content = '', maxDate, minDate, i;
 
                 if (opts.maxDate!==false){
-                    maxDate = isNaN(opts.maxDate) ? moment(opts.maxDate, opts.format) : moment().add('days', opts.maxDate);
+                    maxDate = isNaN(opts.maxDate) ? moment(opts.maxDate, opts.format) : moment().add(opts.maxDate, 'days');
                 }
 
                 if (opts.minDate!==false){
-                    minDate = isNaN(opts.minDate) ? moment(opts.minDate, opts.format) : moment().add('days',opts.minDate-1);
+                    minDate = isNaN(opts.minDate) ? moment(opts.minDate, opts.format) : moment().add(opts.minDate-1, 'days');
                 }
 
                 content += '<div class="uk-datepicker-nav">';
@@ -49,7 +53,7 @@
 
                 if (UI.formSelect) {
 
-                    var i, currentyear = (new Date()).getFullYear(), options = [], months, years, minYear, maxYear;
+                    var currentyear = (new Date()).getFullYear(), options = [], months, years, minYear, maxYear;
 
                     for (i=0;i<opts.i18n.months.length;i++) {
                         if(i==data.month) {
@@ -88,7 +92,7 @@
 
                 content += '<table class="uk-datepicker-table">';
                 content += '<thead>';
-                for(var i = 0; i < data.weekdays.length; i++) {
+                for(i = 0; i < data.weekdays.length; i++) {
                     if (data.weekdays[i]) {
                         content += '<th>'+data.weekdays[i]+'</th>';
                     }
@@ -96,7 +100,7 @@
                 content += '</thead>';
 
                 content += '<tbody>';
-                for(var i = 0; i < data.days.length; i++) {
+                for(i = 0; i < data.days.length; i++) {
                     if (data.days[i] && data.days[i].length){
                         content += '<tr>';
                         for(var d = 0; d < data.days[i].length; d++) {
@@ -124,47 +128,83 @@
             }
         },
 
+        boot: function() {
+
+            UI.$win.on("resize orientationchange", function() {
+
+                if (active) {
+                    active.hide();
+                }
+            });
+
+            // init code
+            UI.$html.on("focus.datepicker.uikit", "[data-uk-datepicker]", function(e) {
+
+                var ele = UI.$(this);
+
+                if (!ele.data("datepicker")) {
+                    e.preventDefault();
+                    var obj = UI.datepicker(ele, UI.Utils.options(ele.attr("data-uk-datepicker")));
+                    ele.trigger("focus");
+                }
+            });
+
+            UI.$html.on("click.datepicker.uikit", function(e) {
+
+                var target = UI.$(e.target);
+
+                if (active && target[0] != dropdown[0] && !target.data("datepicker") && !target.parents(".uk-datepicker:first").length) {
+                    active.hide();
+                }
+            });
+        },
+
         init: function() {
 
+            // use native datepicker on touch devices
+            if (UI.support.touch && this.element.attr('type')=='date' && !this.options.mobile) {
+                return;
+            }
+
             var $this = this;
 
             this.current  = this.element.val() ? moment(this.element.val(), this.options.format) : moment();
 
-            this.on("click", function(){
-                if(active!==$this) $this.pick(this.value);
+            this.on("click focus", function(){
+                if (active!==$this) $this.pick(this.value ? this.value:($this.options.minDate ? $this.options.minDate :''));
             }).on("change", function(){
 
-                if($this.element.val() && !moment($this.element.val(), $this.options.format).isValid()) {
+                if ($this.element.val() && !moment($this.element.val(), $this.options.format).isValid()) {
                    $this.element.val(moment().format($this.options.format));
                 }
-
             });
 
             // init dropdown
             if (!dropdown) {
 
-                dropdown = $('<div class="uk-dropdown uk-datepicker"></div>');
+                dropdown = UI.$('<div class="uk-dropdown uk-datepicker"></div>');
 
                 dropdown.on("click", ".uk-datepicker-next, .uk-datepicker-previous, [data-date]", function(e){
+
                     e.stopPropagation();
                     e.preventDefault();
 
-                    var ele = $(this);
+                    var ele = UI.$(this);
 
                     if (ele.hasClass('uk-datepicker-date-disabled')) return false;
 
-                    if(ele.is('[data-date]')) {
+                    if (ele.is('[data-date]')) {
                         active.element.val(moment(ele.data("date")).format(active.options.format)).trigger("change");
                         dropdown.hide();
                         active = false;
                     } else {
-                       active.add("months", 1 * (ele.hasClass("uk-datepicker-next") ? 1:-1));
+                       active.add(1 * (ele.hasClass("uk-datepicker-next") ? 1:-1), "months");
                     }
                 });
 
                 dropdown.on('change', '.update-picker-month, .update-picker-year', function(){
 
-                    var select = $(this);
+                    var select = UI.$(this);
                     active[select.is('.update-picker-year') ? 'setYear':'setMonth'](Number(select.val()));
                 });
 
@@ -175,19 +215,31 @@
         pick: function(initdate) {
 
             var offset = this.element.offset(),
-                css    = {"top": offset.top + this.element.outerHeight() + this.options.offsettop, "left": offset.left, "right":""};
+                css    = {"left": offset.left, "right":""};
 
             this.current  = initdate ? moment(initdate, this.options.format):moment();
             this.initdate = this.current.format("YYYY-MM-DD");
 
             this.update();
 
-            if ($.UIkit.langdirection == 'right') {
+            if (UI.langdirection == 'right') {
                 css.right = window.innerWidth - (css.left + this.element.outerWidth());
                 css.left  = "";
             }
 
+            var posTop    = (offset.top - this.element.outerHeight() + this.element.height()) - this.options.offsettop - dropdown.outerHeight(),
+                posBottom = offset.top + this.element.outerHeight() + this.options.offsettop;
+
+            css.top = posBottom;
+
+            if (this.options.pos == 'top') {
+                css.top = posTop;
+            } else if(this.options.pos == 'auto' && (window.innerHeight - posBottom - dropdown.outerHeight() < 0 && posTop >= 0) ) {
+                css.top = posTop;
+            }
+
             dropdown.css(css).show();
+            this.trigger('show.uk.datepicker');
 
             active = this;
         },
@@ -213,6 +265,8 @@
                 tpl  = this.options.template(data, this.options);
 
             dropdown.html(tpl);
+
+            this.trigger('update.uk.datepicker');
         },
 
         getRows: function(year, month) {
@@ -283,96 +337,2832 @@
             if (active && active === this) {
                 dropdown.hide();
                 active = false;
+
+                this.trigger('hide.uk.datepicker');
             }
         }
     });
 
-    UI.$win.on("resize orientationchange", function() {
+    //! moment.js
+    //! version : 2.8.3
+    //! authors : Tim Wood, Iskren Chernev, Moment.js contributors
+    //! license : MIT
+    //! momentjs.com
+
+    moment = (function (undefined) {
+        /************************************
+            Constants
+        ************************************/
+        var moment,
+            VERSION = '2.8.3',
+            // the global-scope this is NOT the global object in Node.js
+            globalScope = typeof global !== 'undefined' ? global : this,
+            oldGlobalMoment,
+            round = Math.round,
+            hasOwnProperty = Object.prototype.hasOwnProperty,
+            i,
+
+            YEAR = 0,
+            MONTH = 1,
+            DATE = 2,
+            HOUR = 3,
+            MINUTE = 4,
+            SECOND = 5,
+            MILLISECOND = 6,
+
+            // internal storage for locale config files
+            locales = {},
+
+            // extra moment internal properties (plugins register props here)
+            momentProperties = [],
+
+            // check for nodeJS
+            hasModule = (typeof module !== 'undefined' && module.exports),
+
+            // ASP.NET json date format regex
+            aspNetJsonRegex = /^\/?Date\((\-?\d+)/i,
+            aspNetTimeSpanJsonRegex = /(\-)?(?:(\d*)\.)?(\d+)\:(\d+)(?:\:(\d+)\.?(\d{3})?)?/,
+
+            // from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html
+            // somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere
+            isoDurationRegex = /^(-)?P(?:(?:([0-9,.]*)Y)?(?:([0-9,.]*)M)?(?:([0-9,.]*)D)?(?:T(?:([0-9,.]*)H)?(?:([0-9,.]*)M)?(?:([0-9,.]*)S)?)?|([0-9,.]*)W)$/,
+
+            // format tokens
+            formattingTokens = /(\[[^\[]*\])|(\\)?(Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Q|YYYYYY|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|mm?|ss?|S{1,4}|X|zz?|ZZ?|.)/g,
+            localFormattingTokens = /(\[[^\[]*\])|(\\)?(LT|LL?L?L?|l{1,4})/g,
+
+            // parsing token regexes
+            parseTokenOneOrTwoDigits = /\d\d?/, // 0 - 99
+            parseTokenOneToThreeDigits = /\d{1,3}/, // 0 - 999
+            parseTokenOneToFourDigits = /\d{1,4}/, // 0 - 9999
+            parseTokenOneToSixDigits = /[+\-]?\d{1,6}/, // -999,999 - 999,999
+            parseTokenDigits = /\d+/, // nonzero number of digits
+            parseTokenWord = /[0-9]*['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+|[\u0600-\u06FF\/]+(\s*?[\u0600-\u06FF]+){1,2}/i, // any word (or two) characters or numbers including two/three word month in arabic.
+            parseTokenTimezone = /Z|[\+\-]\d\d:?\d\d/gi, // +00:00 -00:00 +0000 -0000 or Z
+            parseTokenT = /T/i, // T (ISO separator)
+            parseTokenTimestampMs = /[\+\-]?\d+(\.\d{1,3})?/, // 123456789 123456789.123
+            parseTokenOrdinal = /\d{1,2}/,
+
+            //strict parsing regexes
+            parseTokenOneDigit = /\d/, // 0 - 9
+            parseTokenTwoDigits = /\d\d/, // 00 - 99
+            parseTokenThreeDigits = /\d{3}/, // 000 - 999
+            parseTokenFourDigits = /\d{4}/, // 0000 - 9999
+            parseTokenSixDigits = /[+-]?\d{6}/, // -999,999 - 999,999
+            parseTokenSignedNumber = /[+-]?\d+/, // -inf - inf
+
+            // iso 8601 regex
+            // 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)
+            isoRegex = /^\s*(?:[+-]\d{6}|\d{4})-(?:(\d\d-\d\d)|(W\d\d$)|(W\d\d-\d)|(\d\d\d))((T| )(\d\d(:\d\d(:\d\d(\.\d+)?)?)?)?([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?$/,
+
+            isoFormat = 'YYYY-MM-DDTHH:mm:ssZ',
+
+            isoDates = [
+                ['YYYYYY-MM-DD', /[+-]\d{6}-\d{2}-\d{2}/],
+                ['YYYY-MM-DD', /\d{4}-\d{2}-\d{2}/],
+                ['GGGG-[W]WW-E', /\d{4}-W\d{2}-\d/],
+                ['GGGG-[W]WW', /\d{4}-W\d{2}/],
+                ['YYYY-DDD', /\d{4}-\d{3}/]
+            ],
+
+            // iso time formats and regexes
+            isoTimes = [
+                ['HH:mm:ss.SSSS', /(T| )\d\d:\d\d:\d\d\.\d+/],
+                ['HH:mm:ss', /(T| )\d\d:\d\d:\d\d/],
+                ['HH:mm', /(T| )\d\d:\d\d/],
+                ['HH', /(T| )\d\d/]
+            ],
+
+            // timezone chunker '+10:00' > ['10', '00'] or '-1530' > ['-15', '30']
+            parseTimezoneChunker = /([\+\-]|\d\d)/gi,
+
+            // getter and setter names
+            proxyGettersAndSetters = 'Date|Hours|Minutes|Seconds|Milliseconds'.split('|'),
+            unitMillisecondFactors = {
+                'Milliseconds' : 1,
+                'Seconds' : 1e3,
+                'Minutes' : 6e4,
+                'Hours' : 36e5,
+                'Days' : 864e5,
+                'Months' : 2592e6,
+                'Years' : 31536e6
+            },
+
+            unitAliases = {
+                ms : 'millisecond',
+                s : 'second',
+                m : 'minute',
+                h : 'hour',
+                d : 'day',
+                D : 'date',
+                w : 'week',
+                W : 'isoWeek',
+                M : 'month',
+                Q : 'quarter',
+                y : 'year',
+                DDD : 'dayOfYear',
+                e : 'weekday',
+                E : 'isoWeekday',
+                gg: 'weekYear',
+                GG: 'isoWeekYear'
+            },
+
+            camelFunctions = {
+                dayofyear : 'dayOfYear',
+                isoweekday : 'isoWeekday',
+                isoweek : 'isoWeek',
+                weekyear : 'weekYear',
+                isoweekyear : 'isoWeekYear'
+            },
+
+            // format function strings
+            formatFunctions = {},
+
+            // default relative time thresholds
+            relativeTimeThresholds = {
+                s: 45,  // seconds to minute
+                m: 45,  // minutes to hour
+                h: 22,  // hours to day
+                d: 26,  // days to month
+                M: 11   // months to year
+            },
+
+            // tokens to ordinalize and pad
+            ordinalizeTokens = 'DDD w W M D d'.split(' '),
+            paddedTokens = 'M D H h m s w W'.split(' '),
+
+            formatTokenFunctions = {
+                M    : function () {
+                    return this.month() + 1;
+                },
+                MMM  : function (format) {
+                    return this.localeData().monthsShort(this, format);
+                },
+                MMMM : function (format) {
+                    return this.localeData().months(this, format);
+                },
+                D    : function () {
+                    return this.date();
+                },
+                DDD  : function () {
+                    return this.dayOfYear();
+                },
+                d    : function () {
+                    return this.day();
+                },
+                dd   : function (format) {
+                    return this.localeData().weekdaysMin(this, format);
+                },
+                ddd  : function (format) {
+                    return this.localeData().weekdaysShort(this, format);
+                },
+                dddd : function (format) {
+                    return this.localeData().weekdays(this, format);
+                },
+                w    : function () {
+                    return this.week();
+                },
+                W    : function () {
+                    return this.isoWeek();
+                },
+                YY   : function () {
+                    return leftZeroFill(this.year() % 100, 2);
+                },
+                YYYY : function () {
+                    return leftZeroFill(this.year(), 4);
+                },
+                YYYYY : function () {
+                    return leftZeroFill(this.year(), 5);
+                },
+                YYYYYY : function () {
+                    var y = this.year(), sign = y >= 0 ? '+' : '-';
+                    return sign + leftZeroFill(Math.abs(y), 6);
+                },
+                gg   : function () {
+                    return leftZeroFill(this.weekYear() % 100, 2);
+                },
+                gggg : function () {
+                    return leftZeroFill(this.weekYear(), 4);
+                },
+                ggggg : function () {
+                    return leftZeroFill(this.weekYear(), 5);
+                },
+                GG   : function () {
+                    return leftZeroFill(this.isoWeekYear() % 100, 2);
+                },
+                GGGG : function () {
+                    return leftZeroFill(this.isoWeekYear(), 4);
+                },
+                GGGGG : function () {
+                    return leftZeroFill(this.isoWeekYear(), 5);
+                },
+                e : function () {
+                    return this.weekday();
+                },
+                E : function () {
+                    return this.isoWeekday();
+                },
+                a    : function () {
+                    return this.localeData().meridiem(this.hours(), this.minutes(), true);
+                },
+                A    : function () {
+                    return this.localeData().meridiem(this.hours(), this.minutes(), false);
+                },
+                H    : function () {
+                    return this.hours();
+                },
+                h    : function () {
+                    return this.hours() % 12 || 12;
+                },
+                m    : function () {
+                    return this.minutes();
+                },
+                s    : function () {
+                    return this.seconds();
+                },
+                S    : function () {
+                    return toInt(this.milliseconds() / 100);
+                },
+                SS   : function () {
+                    return leftZeroFill(toInt(this.milliseconds() / 10), 2);
+                },
+                SSS  : function () {
+                    return leftZeroFill(this.milliseconds(), 3);
+                },
+                SSSS : function () {
+                    return leftZeroFill(this.milliseconds(), 3);
+                },
+                Z    : function () {
+                    var a = -this.zone(),
+                        b = '+';
+                    if (a < 0) {
+                        a = -a;
+                        b = '-';
+                    }
+                    return b + leftZeroFill(toInt(a / 60), 2) + ':' + leftZeroFill(toInt(a) % 60, 2);
+                },
+                ZZ   : function () {
+                    var a = -this.zone(),
+                        b = '+';
+                    if (a < 0) {
+                        a = -a;
+                        b = '-';
+                    }
+                    return b + leftZeroFill(toInt(a / 60), 2) + leftZeroFill(toInt(a) % 60, 2);
+                },
+                z : function () {
+                    return this.zoneAbbr();
+                },
+                zz : function () {
+                    return this.zoneName();
+                },
+                X    : function () {
+                    return this.unix();
+                },
+                Q : function () {
+                    return this.quarter();
+                }
+            },
+
+            deprecations = {},
+
+            lists = ['months', 'monthsShort', 'weekdays', 'weekdaysShort', 'weekdaysMin'];
 
-        if (active) {
-            active.hide();
+        // Pick the first defined of two or three arguments. dfl comes from
+        // default.
+        function dfl(a, b, c) {
+            switch (arguments.length) {
+                case 2: return a != null ? a : b;
+                case 3: return a != null ? a : b != null ? b : c;
+                default: throw new Error('Implement me');
+            }
         }
-    });
 
+        function hasOwnProp(a, b) {
+            return hasOwnProperty.call(a, b);
+        }
 
-    // init code
-    UI.$html.on("focus.datepicker.uikit", "[data-uk-datepicker]", function(e) {
+        function defaultParsingFlags() {
+            // We need to deep clone this object, and es5 standard is not very
+            // helpful.
+            return {
+                empty : false,
+                unusedTokens : [],
+                unusedInput : [],
+                overflow : -2,
+                charsLeftOver : 0,
+                nullInput : false,
+                invalidMonth : null,
+                invalidFormat : false,
+                userInvalidated : false,
+                iso: false
+            };
+        }
 
-        var ele = $(this);
-        if (!ele.data("datepicker")) {
-            e.preventDefault();
-            var obj = UI.datepicker(ele, UI.Utils.options(ele.attr("data-uk-datepicker")));
-            ele.trigger("focus");
+        function printMsg(msg) {
+            if (moment.suppressDeprecationWarnings === false &&
+                    typeof console !== 'undefined' && console.warn) {
+                console.warn('Deprecation warning: ' + msg);
+            }
         }
-    });
 
-    UI.$html.on("click.datepicker.uikit", function(e) {
+        function deprecate(msg, fn) {
+            var firstTime = true;
+            return extend(function () {
+                if (firstTime) {
+                    printMsg(msg);
+                    firstTime = false;
+                }
+                return fn.apply(this, arguments);
+            }, fn);
+        }
 
-        var target = $(e.target);
+        function deprecateSimple(name, msg) {
+            if (!deprecations[name]) {
+                printMsg(msg);
+                deprecations[name] = true;
+            }
+        }
 
-        if (active && target[0] != dropdown[0] && !target.data("datepicker") && !target.parents(".uk-datepicker:first").length) {
-            active.hide();
+        function padToken(func, count) {
+            return function (a) {
+                return leftZeroFill(func.call(this, a), count);
+            };
+        }
+        function ordinalizeToken(func, period) {
+            return function (a) {
+                return this.localeData().ordinal(func.call(this, a), period);
+            };
         }
-    });
 
-    //! moment.js
-    //! version : 2.5.1
-    //! authors : Tim Wood, Iskren Chernev, Moment.js contributors
-    //! license : MIT
-    //! momentjs.com
+        while (ordinalizeTokens.length) {
+            i = ordinalizeTokens.pop();
+            formatTokenFunctions[i + 'o'] = ordinalizeToken(formatTokenFunctions[i], i);
+        }
+        while (paddedTokens.length) {
+            i = paddedTokens.pop();
+            formatTokenFunctions[i + i] = padToken(formatTokenFunctions[i], 2);
+        }
+        formatTokenFunctions.DDDD = padToken(formatTokenFunctions.DDD, 3);
+
+
+        /************************************
+            Constructors
+        ************************************/
+
+        function Locale() {
+        }
+
+        // Moment prototype object
+        function Moment(config, skipOverflow) {
+            if (skipOverflow !== false) {
+                checkOverflow(config);
+            }
+            copyConfig(this, config);
+            this._d = new Date(+config._d);
+        }
+
+        // Duration Constructor
+        function Duration(duration) {
+            var normalizedInput = normalizeObjectUnits(duration),
+                years = normalizedInput.year || 0,
+                quarters = normalizedInput.quarter || 0,
+                months = normalizedInput.month || 0,
+                weeks = normalizedInput.week || 0,
+                days = normalizedInput.day || 0,
+                hours = normalizedInput.hour || 0,
+                minutes = normalizedInput.minute || 0,
+                seconds = normalizedInput.second || 0,
+                milliseconds = normalizedInput.millisecond || 0;
+
+            // representation for dateAddRemove
+            this._milliseconds = +milliseconds +
+                seconds * 1e3 + // 1000
+                minutes * 6e4 + // 1000 * 60
+                hours * 36e5; // 1000 * 60 * 60
+            // Because of dateAddRemove treats 24 hours as different from a
+            // day when working around DST, we need to store them separately
+            this._days = +days +
+                weeks * 7;
+            // It is impossible translate months into days without knowing
+            // which months you are are talking about, so we have to store
+            // it separately.
+            this._months = +months +
+                quarters * 3 +
+                years * 12;
+
+            this._data = {};
+
+            this._locale = moment.localeData();
+
+            this._bubble();
+        }
+
+        /************************************
+            Helpers
+        ************************************/
+
+
+        function extend(a, b) {
+            for (var i in b) {
+                if (hasOwnProp(b, i)) {
+                    a[i] = b[i];
+                }
+            }
+
+            if (hasOwnProp(b, 'toString')) {
+                a.toString = b.toString;
+            }
+
+            if (hasOwnProp(b, 'valueOf')) {
+                a.valueOf = b.valueOf;
+            }
+
+            return a;
+        }
+
+        function copyConfig(to, from) {
+            var i, prop, val;
+
+            if (typeof from._isAMomentObject !== 'undefined') {
+                to._isAMomentObject = from._isAMomentObject;
+            }
+            if (typeof from._i !== 'undefined') {
+                to._i = from._i;
+            }
+            if (typeof from._f !== 'undefined') {
+                to._f = from._f;
+            }
+            if (typeof from._l !== 'undefined') {
+                to._l = from._l;
+            }
+            if (typeof from._strict !== 'undefined') {
+                to._strict = from._strict;
+            }
+            if (typeof from._tzm !== 'undefined') {
+                to._tzm = from._tzm;
+            }
+            if (typeof from._isUTC !== 'undefined') {
+                to._isUTC = from._isUTC;
+            }
+            if (typeof from._offset !== 'undefined') {
+                to._offset = from._offset;
+            }
+            if (typeof from._pf !== 'undefined') {
+                to._pf = from._pf;
+            }
+            if (typeof from._locale !== 'undefined') {
+                to._locale = from._locale;
+            }
+
+            if (momentProperties.length > 0) {
+                for (i in momentProperties) {
+                    prop = momentProperties[i];
+                    val = from[prop];
+                    if (typeof val !== 'undefined') {
+                        to[prop] = val;
+                    }
+                }
+            }
+
+            return to;
+        }
+
+        function absRound(number) {
+            if (number < 0) {
+                return Math.ceil(number);
+            } else {
+                return Math.floor(number);
+            }
+        }
+
+        // left zero fill a number
+        // see http://jsperf.com/left-zero-filling for performance comparison
+        function leftZeroFill(number, targetLength, forceSign) {
+            var output = '' + Math.abs(number),
+                sign = number >= 0;
+
+            while (output.length < targetLength) {
+                output = '0' + output;
+            }
+            return (sign ? (forceSign ? '+' : '') : '-') + output;
+        }
+
+        function positiveMomentsDifference(base, other) {
+            var res = {milliseconds: 0, months: 0};
+
+            res.months = other.month() - base.month() +
+                (other.year() - base.year()) * 12;
+            if (base.clone().add(res.months, 'M').isAfter(other)) {
+                --res.months;
+            }
+
+            res.milliseconds = +other - +(base.clone().add(res.months, 'M'));
+
+            return res;
+        }
+
+        function momentsDifference(base, other) {
+            var res;
+            other = makeAs(other, base);
+            if (base.isBefore(other)) {
+                res = positiveMomentsDifference(base, other);
+            } else {
+                res = positiveMomentsDifference(other, base);
+                res.milliseconds = -res.milliseconds;
+                res.months = -res.months;
+            }
+
+            return res;
+        }
+
+        // TODO: remove 'name' arg after deprecation is removed
+        function createAdder(direction, name) {
+            return function (val, period) {
+                var dur, tmp;
+                //invert the arguments, but complain about it
+                if (period !== null && !isNaN(+period)) {
+                    deprecateSimple(name, 'moment().' + name  + '(period, number) is deprecated. Please use moment().' + name + '(number, period).');
+                    tmp = val; val = period; period = tmp;
+                }
+
+                val = typeof val === 'string' ? +val : val;
+                dur = moment.duration(val, period);
+                addOrSubtractDurationFromMoment(this, dur, direction);
+                return this;
+            };
+        }
+
+        function addOrSubtractDurationFromMoment(mom, duration, isAdding, updateOffset) {
+            var milliseconds = duration._milliseconds,
+                days = duration._days,
+                months = duration._months;
+            updateOffset = updateOffset == null ? true : updateOffset;
+
+            if (milliseconds) {
+                mom._d.setTime(+mom._d + milliseconds * isAdding);
+            }
+            if (days) {
+                rawSetter(mom, 'Date', rawGetter(mom, 'Date') + days * isAdding);
+            }
+            if (months) {
+                rawMonthSetter(mom, rawGetter(mom, 'Month') + months * isAdding);
+            }
+            if (updateOffset) {
+                moment.updateOffset(mom, days || months);
+            }
+        }
+
+        // check if is an array
+        function isArray(input) {
+            return Object.prototype.toString.call(input) === '[object Array]';
+        }
+
+        function isDate(input) {
+            return Object.prototype.toString.call(input) === '[object Date]' ||
+                input instanceof Date;
+        }
+
+        // compare two arrays, return the number of differences
+        function compareArrays(array1, array2, dontConvert) {
+            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 ((dontConvert && array1[i] !== array2[i]) ||
+                    (!dontConvert && toInt(array1[i]) !== toInt(array2[i]))) {
+                    diffs++;
+                }
+            }
+            return diffs + lengthDiff;
+        }
+
+        function normalizeUnits(units) {
+            if (units) {
+                var lowered = units.toLowerCase().replace(/(.)s$/, '$1');
+                units = unitAliases[units] || camelFunctions[lowered] || lowered;
+            }
+            return units;
+        }
+
+        function normalizeObjectUnits(inputObject) {
+            var normalizedInput = {},
+                normalizedProp,
+                prop;
+
+            for (prop in inputObject) {
+                if (hasOwnProp(inputObject, prop)) {
+                    normalizedProp = normalizeUnits(prop);
+                    if (normalizedProp) {
+                        normalizedInput[normalizedProp] = inputObject[prop];
+                    }
+                }
+            }
+
+            return normalizedInput;
+        }
+
+        function makeList(field) {
+            var count, setter;
+
+            if (field.indexOf('week') === 0) {
+                count = 7;
+                setter = 'day';
+            }
+            else if (field.indexOf('month') === 0) {
+                count = 12;
+                setter = 'month';
+            }
+            else {
+                return;
+            }
+
+            moment[field] = function (format, index) {
+                var i, getter,
+                    method = moment._locale[field],
+                    results = [];
+
+                if (typeof format === 'number') {
+                    index = format;
+                    format = undefined;
+                }
+
+                getter = function (i) {
+                    var m = moment().utc().set(setter, i);
+                    return method.call(moment._locale, m, format || '');
+                };
+
+                if (index != null) {
+                    return getter(index);
+                }
+                else {
+                    for (i = 0; i < count; i++) {
+                        results.push(getter(i));
+                    }
+                    return results;
+                }
+            };
+        }
+
+        function toInt(argumentForCoercion) {
+            var coercedNumber = +argumentForCoercion,
+                value = 0;
+
+            if (coercedNumber !== 0 && isFinite(coercedNumber)) {
+                if (coercedNumber >= 0) {
+                    value = Math.floor(coercedNumber);
+                } else {
+                    value = Math.ceil(coercedNumber);
+                }
+            }
+
+            return value;
+        }
+
+        function daysInMonth(year, month) {
+            return new Date(Date.UTC(year, month + 1, 0)).getUTCDate();
+        }
+
+        function weeksInYear(year, dow, doy) {
+            return weekOfYear(moment([year, 11, 31 + dow - doy]), dow, doy).week;
+        }
+
+        function daysInYear(year) {
+            return isLeapYear(year) ? 366 : 365;
+        }
+
+        function isLeapYear(year) {
+            return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
+        }
+
+        function checkOverflow(m) {
+            var overflow;
+            if (m._a && m._pf.overflow === -2) {
+                overflow =
+                    m._a[MONTH] < 0 || m._a[MONTH] > 11 ? MONTH :
+                    m._a[DATE] < 1 || m._a[DATE] > daysInMonth(m._a[YEAR], m._a[MONTH]) ? DATE :
+                    m._a[HOUR] < 0 || m._a[HOUR] > 23 ? HOUR :
+                    m._a[MINUTE] < 0 || m._a[MINUTE] > 59 ? MINUTE :
+                    m._a[SECOND] < 0 || m._a[SECOND] > 59 ? SECOND :
+                    m._a[MILLISECOND] < 0 || m._a[MILLISECOND] > 999 ? MILLISECOND :
+                    -1;
+
+                if (m._pf._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) {
+                    overflow = DATE;
+                }
+
+                m._pf.overflow = overflow;
+            }
+        }
+
+        function isValid(m) {
+            if (m._isValid == null) {
+                m._isValid = !isNaN(m._d.getTime()) &&
+                    m._pf.overflow < 0 &&
+                    !m._pf.empty &&
+                    !m._pf.invalidMonth &&
+                    !m._pf.nullInput &&
+                    !m._pf.invalidFormat &&
+                    !m._pf.userInvalidated;
+
+                if (m._strict) {
+                    m._isValid = m._isValid &&
+                        m._pf.charsLeftOver === 0 &&
+                        m._pf.unusedTokens.length === 0;
+                }
+            }
+            return m._isValid;
+        }
+
+        function normalizeLocale(key) {
+            return key ? key.toLowerCase().replace('_', '-') : key;
+        }
+
+        // pick the locale from the array
+        // try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each
+        // substring from most specific to least, but move to the next array item if it's a more specific variant than the current root
+        function chooseLocale(names) {
+            var i = 0, j, next, locale, split;
+
+            while (i < names.length) {
+                split = normalizeLocale(names[i]).split('-');
+                j = split.length;
+                next = normalizeLocale(names[i + 1]);
+                next = next ? next.split('-') : null;
+                while (j > 0) {
+                    locale = loadLocale(split.slice(0, j).join('-'));
+                    if (locale) {
+                        return locale;
+                    }
+                    if (next && next.length >= j && compareArrays(split, next, true) >= j - 1) {
+                        //the next array item is better than a shallower substring of this one
+                        break;
+                    }
+                    j--;
+                }
+                i++;
+            }
+            return null;
+        }
+
+        function loadLocale(name) {
+            var oldLocale = null;
+            if (!locales[name] && hasModule) {
+                try {
+                    oldLocale = moment.locale();
+                    require('./locale/' + name);
+                    // because defineLocale currently also sets the global locale, we want to undo that for lazy loaded locales
+                    moment.locale(oldLocale);
+                } catch (e) { }
+            }
+            return locales[name];
+        }
+
+        // Return a moment from input, that is local/utc/zone equivalent to model.
+        function makeAs(input, model) {
+            return model._isUTC ? moment(input).zone(model._offset || 0) :
+                moment(input).local();
+        }
+
+        /************************************
+            Locale
+        ************************************/
+
+
+        extend(Locale.prototype, {
+
+            set : function (config) {
+                var prop, i;
+                for (i in config) {
+                    prop = config[i];
+                    if (typeof prop === 'function') {
+                        this[i] = prop;
+                    } else {
+                        this['_' + i] = prop;
+                    }
+                }
+            },
+
+            _months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
+            months : function (m) {
+                return this._months[m.month()];
+            },
+
+            _monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
+            monthsShort : function (m) {
+                return this._monthsShort[m.month()];
+            },
+
+            monthsParse : function (monthName) {
+                var i, mom, regex;
+
+                if (!this._monthsParse) {
+                    this._monthsParse = [];
+                }
+
+                for (i = 0; i < 12; i++) {
+                    // make the regex if we don't have it already
+                    if (!this._monthsParse[i]) {
+                        mom = moment.utc([2000, i]);
+                        regex = '^' + this.months(mom, '') + '|^' + this.monthsShort(mom, '');
+                        this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i');
+                    }
+                    // test the regex
+                    if (this._monthsParse[i].test(monthName)) {
+                        return i;
+                    }
+                }
+            },
+
+            _weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
+            weekdays : function (m) {
+                return this._weekdays[m.day()];
+            },
+
+            _weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
+            weekdaysShort : function (m) {
+                return this._weekdaysShort[m.day()];
+            },
+
+            _weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
+            weekdaysMin : function (m) {
+                return this._weekdaysMin[m.day()];
+            },
+
+            weekdaysParse : function (weekdayName) {
+                var i, mom, regex;
+
+                if (!this._weekdaysParse) {
+                    this._weekdaysParse = [];
+                }
+
+                for (i = 0; i < 7; i++) {
+                    // make the regex if we don't have it already
+                    if (!this._weekdaysParse[i]) {
+                        mom = moment([2000, 1]).day(i);
+                        regex = '^' + this.weekdays(mom, '') + '|^' + this.weekdaysShort(mom, '') + '|^' + this.weekdaysMin(mom, '');
+                        this._weekdaysParse[i] = new RegExp(regex.replace('.', ''), 'i');
+                    }
+                    // test the regex
+                    if (this._weekdaysParse[i].test(weekdayName)) {
+                        return i;
+                    }
+                }
+            },
+
+            _longDateFormat : {
+                LT : 'h:mm A',
+                L : 'MM/DD/YYYY',
+                LL : 'MMMM D, YYYY',
+                LLL : 'MMMM D, YYYY LT',
+                LLLL : 'dddd, MMMM D, YYYY LT'
+            },
+            longDateFormat : function (key) {
+                var output = this._longDateFormat[key];
+                if (!output && this._longDateFormat[key.toUpperCase()]) {
+                    output = this._longDateFormat[key.toUpperCase()].replace(/MMMM|MM|DD|dddd/g, function (val) {
+                        return val.slice(1);
+                    });
+                    this._longDateFormat[key] = output;
+                }
+                return output;
+            },
+
+            isPM : function (input) {
+                // IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays
+                // Using charAt should be more compatible.
+                return ((input + '').toLowerCase().charAt(0) === 'p');
+            },
+
+            _meridiemParse : /[ap]\.?m?\.?/i,
+            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',
+                nextWeek : 'dddd [at] LT',
+                lastDay : '[Yesterday at] LT',
+                lastWeek : '[Last] dddd [at] LT',
+                sameElse : 'L'
+            },
+            calendar : function (key, mom) {
+                var output = this._calendar[key];
+                return typeof output === 'function' ? output.apply(mom) : output;
+            },
+
+            _relativeTime : {
+                future : 'in %s',
+                past : '%s ago',
+                s : 'a few seconds',
+                m : 'a minute',
+                mm : '%d minutes',
+                h : 'an hour',
+                hh : '%d hours',
+                d : 'a day',
+                dd : '%d days',
+                M : 'a month',
+                MM : '%d months',
+                y : 'a year',
+                yy : '%d years'
+            },
+
+            relativeTime : function (number, withoutSuffix, string, isFuture) {
+                var output = this._relativeTime[string];
+                return (typeof output === 'function') ?
+                    output(number, withoutSuffix, string, isFuture) :
+                    output.replace(/%d/i, number);
+            },
+
+            pastFuture : function (diff, output) {
+                var format = this._relativeTime[diff > 0 ? 'future' : 'past'];
+                return typeof format === 'function' ? format(output) : format.replace(/%s/i, output);
+            },
+
+            ordinal : function (number) {
+                return this._ordinal.replace('%d', number);
+            },
+            _ordinal : '%d',
+
+            preparse : function (string) {
+                return string;
+            },
+
+            postformat : function (string) {
+                return string;
+            },
+
+            week : function (mom) {
+                return weekOfYear(mom, this._week.dow, this._week.doy).week;
+            },
+
+            _week : {
+                dow : 0, // Sunday is the first day of the week.
+                doy : 6  // The week that contains Jan 1st is the first week of the year.
+            },
+
+            _invalidDate: 'Invalid date',
+            invalidDate: function () {
+                return this._invalidDate;
+            }
+        });
+
+        /************************************
+            Formatting
+        ************************************/
+
+
+        function removeFormattingTokens(input) {
+            if (input.match(/\[[\s\S]/)) {
+                return input.replace(/^\[|\]$/g, '');
+            }
+            return input.replace(/\\/g, '');
+        }
+
+        function makeFormatFunction(format) {
+            var array = format.match(formattingTokens), i, length;
+
+            for (i = 0, length = array.length; i < length; i++) {
+                if (formatTokenFunctions[array[i]]) {
+                    array[i] = formatTokenFunctions[array[i]];
+                } else {
+                    array[i] = removeFormattingTokens(array[i]);
+                }
+            }
+
+            return function (mom) {
+                var output = '';
+                for (i = 0; i < length; i++) {
+                    output += array[i] instanceof Function ? array[i].call(mom, format) : array[i];
+                }
+                return output;
+            };
+        }
+
+        // format date using native date object
+        function formatMoment(m, format) {
+            if (!m.isValid()) {
+                return m.localeData().invalidDate();
+            }
+
+            format = expandFormat(format, m.localeData());
+
+            if (!formatFunctions[format]) {
+                formatFunctions[format] = makeFormatFunction(format);
+            }
+
+            return formatFunctions[format](m);
+        }
+
+        function expandFormat(format, locale) {
+            var i = 5;
+
+            function replaceLongDateFormatTokens(input) {
+                return locale.longDateFormat(input) || input;
+            }
+
+            localFormattingTokens.lastIndex = 0;
+            while (i >= 0 && localFormattingTokens.test(format)) {
+                format = format.replace(localFormattingTokens, replaceLongDateFormatTokens);
+                localFormattingTokens.lastIndex = 0;
+                i -= 1;
+            }
+
+            return format;
+        }
+
+
+        /************************************
+            Parsing
+        ************************************/
+
+
+        // get the regex to find the next token
+        function getParseRegexForToken(token, config) {
+            var a, strict = config._strict;
+            switch (token) {
+            case 'Q':
+                return parseTokenOneDigit;
+            case 'DDDD':
+                return parseTokenThreeDigits;
+            case 'YYYY':
+            case 'GGGG':
+            case 'gggg':
+                return strict ? parseTokenFourDigits : parseTokenOneToFourDigits;
+            case 'Y':
+            case 'G':
+            case 'g':
+                return parseTokenSignedNumber;
+            case 'YYYYYY':
+            case 'YYYYY':
+            case 'GGGGG':
+            case 'ggggg':
+                return strict ? parseTokenSixDigits : parseTokenOneToSixDigits;
+            case 'S':
+                if (strict) {
+                    return parseTokenOneDigit;
+                }
+                /* falls through */
+            case 'SS':
+                if (strict) {
+                    return parseTokenTwoDigits;
+                }
+                /* falls through */
+            case 'SSS':
+                if (strict) {
+                    return parseTokenThreeDigits;
+                }
+                /* falls through */
+            case 'DDD':
+                return parseTokenOneToThreeDigits;
+            case 'MMM':
+            case 'MMMM':
+            case 'dd':
+            case 'ddd':
+            case 'dddd':
+                return parseTokenWord;
+            case 'a':
+            case 'A':
+                return config._locale._meridiemParse;
+            case 'X':
+                return parseTokenTimestampMs;
+            case 'Z':
+            case 'ZZ':
+                return parseTokenTimezone;
+            case 'T':
+                return parseTokenT;
+            case 'SSSS':
+                return parseTokenDigits;
+            case 'MM':
+            case 'DD':
+            case 'YY':
+            case 'GG':
+            case 'gg':
+            case 'HH':
+            case 'hh':
+            case 'mm':
+            case 'ss':
+            case 'ww':
+            case 'WW':
+                return strict ? parseTokenTwoDigits : parseTokenOneOrTwoDigits;
+            case 'M':
+            case 'D':
+            case 'd':
+            case 'H':
+            case 'h':
+            case 'm':
+            case 's':
+            case 'w':
+            case 'W':
+            case 'e':
+            case 'E':
+                return parseTokenOneOrTwoDigits;
+            case 'Do':
+                return parseTokenOrdinal;
+            default :
+                a = new RegExp(regexpEscape(unescapeFormat(token.replace('\\', '')), 'i'));
+                return a;
+            }
+        }
+
+        function timezoneMinutesFromString(string) {
+            string = string || '';
+            var possibleTzMatches = (string.match(parseTokenTimezone) || []),
+                tzChunk = possibleTzMatches[possibleTzMatches.length - 1] || [],
+                parts = (tzChunk + '').match(parseTimezoneChunker) || ['-', 0, 0],
+                minutes = +(parts[1] * 60) + toInt(parts[2]);
+
+            return parts[0] === '+' ? -minutes : minutes;
+        }
+
+        // function to convert string input to date
+        function addTimeToArrayFromToken(token, input, config) {
+            var a, datePartArray = config._a;
+
+            switch (token) {
+            // QUARTER
+            case 'Q':
+                if (input != null) {
+                    datePartArray[MONTH] = (toInt(input) - 1) * 3;
+                }
+                break;
+            // MONTH
+            case 'M' : // fall through to MM
+            case 'MM' :
+                if (input != null) {
+                    datePartArray[MONTH] = toInt(input) - 1;
+                }
+                break;
+            case 'MMM' : // fall through to MMMM
+            case 'MMMM' :
+                a = config._locale.monthsParse(input);
+                // if we didn't find a month name, mark the date as invalid.
+                if (a != null) {
+                    datePartArray[MONTH] = a;
+                } else {
+                    config._pf.invalidMonth = input;
+                }
+                break;
+            // DAY OF MONTH
+            case 'D' : // fall through to DD
+            case 'DD' :
+                if (input != null) {
+                    datePartArray[DATE] = toInt(input);
+                }
+                break;
+            case 'Do' :
+                if (input != null) {
+                    datePartArray[DATE] = toInt(parseInt(input, 10));
+                }
+                break;
+            // DAY OF YEAR
+            case 'DDD' : // fall through to DDDD
+            case 'DDDD' :
+                if (input != null) {
+                    config._dayOfYear = toInt(input);
+                }
+
+                break;
+            // YEAR
+            case 'YY' :
+                datePartArray[YEAR] = moment.parseTwoDigitYear(input);
+                break;
+            case 'YYYY' :
+            case 'YYYYY' :
+            case 'YYYYYY' :
+                datePartArray[YEAR] = toInt(input);
+                break;
+            // AM / PM
+            case 'a' : // fall through to A
+            case 'A' :
+                config._isPm = config._locale.isPM(input);
+                break;
+            // 24 HOUR
+            case 'H' : // fall through to hh
+            case 'HH' : // fall through to hh
+            case 'h' : // fall through to hh
+            case 'hh' :
+                datePartArray[HOUR] = toInt(input);
+                break;
+            // MINUTE
+            case 'm' : // fall through to mm
+            case 'mm' :
+                datePartArray[MINUTE] = toInt(input);
+                break;
+            // SECOND
+            case 's' : // fall through to ss
+            case 'ss' :
+                datePartArray[SECOND] = toInt(input);
+                break;
+            // MILLISECOND
+            case 'S' :
+            case 'SS' :
+            case 'SSS' :
+            case 'SSSS' :
+                datePartArray[MILLISECOND] = toInt(('0.' + input) * 1000);
+                break;
+            // UNIX TIMESTAMP WITH MS
+            case 'X':
+                config._d = new Date(parseFloat(input) * 1000);
+                break;
+            // TIMEZONE
+            case 'Z' : // fall through to ZZ
+            case 'ZZ' :
+                config._useUTC = true;
+                config._tzm = timezoneMinutesFromString(input);
+                break;
+            // WEEKDAY - human
+            case 'dd':
+            case 'ddd':
+            case 'dddd':
+                a = config._locale.weekdaysParse(input);
+                // if we didn't get a weekday name, mark the date as invalid
+                if (a != null) {
+                    config._w = config._w || {};
+                    config._w['d'] = a;
+                } else {
+                    config._pf.invalidWeekday = input;
+                }
+                break;
+            // WEEK, WEEK DAY - numeric
+            case 'w':
+            case 'ww':
+            case 'W':
+            case 'WW':
+            case 'd':
+            case 'e':
+            case 'E':
+                token = token.substr(0, 1);
+                /* falls through */
+            case 'gggg':
+            case 'GGGG':
+            case 'GGGGG':
+                token = token.substr(0, 2);
+                if (input) {
+                    config._w = config._w || {};
+                    config._w[token] = toInt(input);
+                }
+                break;
+            case 'gg':
+            case 'GG':
+                config._w = config._w || {};
+                config._w[token] = moment.parseTwoDigitYear(input);
+            }
+        }
+
+        function dayOfYearFromWeekInfo(config) {
+            var w, weekYear, week, weekday, dow, doy, temp;
+
+            w = config._w;
+            if (w.GG != null || w.W != null || w.E != null) {
+                dow = 1;
+                doy = 4;
+
+                // TODO: We need to take the current isoWeekYear, but that depends on
+                // how we interpret now (local, utc, fixed offset). So create
+                // a now version of current config (take local/utc/offset flags, and
+                // create now).
+                weekYear = dfl(w.GG, config._a[YEAR], weekOfYear(moment(), 1, 4).year);
+                week = dfl(w.W, 1);
+                weekday = dfl(w.E, 1);
+            } else {
+                dow = config._locale._week.dow;
+                doy = config._locale._week.doy;
+
+                weekYear = dfl(w.gg, config._a[YEAR], weekOfYear(moment(), dow, doy).year);
+                week = dfl(w.w, 1);
+
+                if (w.d != null) {
+                    // weekday -- low day numbers are considered next week
+                    weekday = w.d;
+                    if (weekday < dow) {
+                        ++week;
+                    }
+                } else if (w.e != null) {
+                    // local weekday -- counting starts from begining of week
+                    weekday = w.e + dow;
+                } else {
+                    // default to begining of week
+                    weekday = dow;
+                }
+            }
+            temp = dayOfYearFromWeeks(weekYear, week, weekday, doy, dow);
+
+            config._a[YEAR] = temp.year;
+            config._dayOfYear = temp.dayOfYear;
+        }
+
+        // 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 dateFromConfig(config) {
+            var i, date, input = [], currentDate, yearToUse;
+
+            if (config._d) {
+                return;
+            }
+
+            currentDate = currentDateArray(config);
+
+            //compute day of the year from weeks and weekdays
+            if (config._w && config._a[DATE] == null && config._a[MONTH] == null) {
+                dayOfYearFromWeekInfo(config);
+            }
+
+            //if the day of the year is set, figure out what it is
+            if (config._dayOfYear) {
+                yearToUse = dfl(config._a[YEAR], currentDate[YEAR]);
+
+                if (config._dayOfYear > daysInYear(yearToUse)) {
+                    config._pf._overflowDayOfYear = true;
+                }
+
+                date = makeUTCDate(yearToUse, 0, config._dayOfYear);
+                config._a[MONTH] = date.getUTCMonth();
+                config._a[DATE] = date.getUTCDate();
+            }
+
+            // Default to current date.
+            // * if no year, month, day of month are given, default to today
+            // * if day of month is given, default month and year
+            // * if month is given, default only year
+            // * if year is given, don't default anything
+            for (i = 0; i < 3 && config._a[i] == null; ++i) {
+                config._a[i] = input[i] = currentDate[i];
+            }
+
+            // Zero out whatever was not defaulted, including time
+            for (; i < 7; i++) {
+                config._a[i] = input[i] = (config._a[i] == null) ? (i === 2 ? 1 : 0) : config._a[i];
+            }
+
+            config._d = (config._useUTC ? makeUTCDate : makeDate).apply(null, input);
+            // Apply timezone offset from input. The actual zone can be changed
+            // with parseZone.
+            if (config._tzm != null) {
+                config._d.setUTCMinutes(config._d.getUTCMinutes() + config._tzm);
+            }
+        }
+
+        function dateFromObject(config) {
+            var normalizedInput;
+
+            if (config._d) {
+                return;
+            }
+
+            normalizedInput = normalizeObjectUnits(config._i);
+            config._a = [
+                normalizedInput.year,
+                normalizedInput.month,
+                normalizedInput.day,
+                normalizedInput.hour,
+                normalizedInput.minute,
+                normalizedInput.second,
+                normalizedInput.millisecond
+            ];
+
+            dateFromConfig(config);
+        }
+
+        function currentDateArray(config) {
+            var now = new Date();
+            if (config._useUTC) {
+                return [
+                    now.getUTCFullYear(),
+                    now.getUTCMonth(),
+                    now.getUTCDate()
+                ];
+            } else {
+                return [now.getFullYear(), now.getMonth(), now.getDate()];
+            }
+        }
+
+        // date from string and format string
+        function makeDateFromStringAndFormat(config) {
+            if (config._f === moment.ISO_8601) {
+                parseISO(config);
+                return;
+            }
+
+            config._a = [];
+            config._pf.empty = true;
+
+            // This array is used to make a Date, either with `new Date` or `Date.UTC`
+            var string = '' + config._i,
+                i, parsedInput, tokens, token, skipped,
+                stringLength = string.length,
+                totalParsedInputLength = 0;
+
+            tokens = expandFormat(config._f, config._locale).match(formattingTokens) || [];
+
+            for (i = 0; i < tokens.length; i++) {
+                token = tokens[i];
+                parsedInput = (string.match(getParseRegexForToken(token, config)) || [])[0];
+                if (parsedInput) {
+                    skipped = string.substr(0, string.indexOf(parsedInput));
+                    if (skipped.length > 0) {
+                        config._pf.unusedInput.push(skipped);
+                    }
+                    string = string.slice(string.indexOf(parsedInput) + parsedInput.length);
+                    totalParsedInputLength += parsedInput.length;
+                }
+                // don't parse if it's not a known token
+                if (formatTokenFunctions[token]) {
+                    if (parsedInput) {
+                        config._pf.empty = false;
+                    }
+                    else {
+                        config._pf.unusedTokens.push(token);
+                    }
+                    addTimeToArrayFromToken(token, parsedInput, config);
+                }
+                else if (config._strict && !parsedInput) {
+                    config._pf.unusedTokens.push(token);
+                }
+            }
+
+            // add remaining unparsed input length to the string
+            config._pf.charsLeftOver = stringLength - totalParsedInputLength;
+            if (string.length > 0) {
+                config._pf.unusedInput.push(string);
+            }
+
+            // handle am pm
+            if (config._isPm && config._a[HOUR] < 12) {
+                config._a[HOUR] += 12;
+            }
+            // if is 12 am, change hours to 0
+            if (config._isPm === false && config._a[HOUR] === 12) {
+                config._a[HOUR] = 0;
+            }
+
+            dateFromConfig(config);
+            checkOverflow(config);
+        }
+
+        function unescapeFormat(s) {
+            return s.replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, function (matched, p1, p2, p3, p4) {
+                return p1 || p2 || p3 || p4;
+            });
+        }
+
+        // Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript
+        function regexpEscape(s) {
+            return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
+        }
+
+        // date from string and array of format strings
+        function makeDateFromStringAndArray(config) {
+            var tempConfig,
+                bestMoment,
+
+                scoreToBeat,
+                i,
+                currentScore;
+
+            if (config._f.length === 0) {
+                config._pf.invalidFormat = true;
+                config._d = new Date(NaN);
+                return;
+            }
+
+            for (i = 0; i < config._f.length; i++) {
+                currentScore = 0;
+                tempConfig = copyConfig({}, config);
+                if (config._useUTC != null) {
+                    tempConfig._useUTC = config._useUTC;
+                }
+                tempConfig._pf = defaultParsingFlags();
+                tempConfig._f = config._f[i];
+                makeDateFromStringAndFormat(tempConfig);
+
+                if (!isValid(tempConfig)) {
+                    continue;
+                }
+
+                // if there is any input that was not parsed add a penalty for that format
+                currentScore += tempConfig._pf.charsLeftOver;
+
+                //or tokens
+                currentScore += tempConfig._pf.unusedTokens.length * 10;
+
+                tempConfig._pf.score = currentScore;
+
+                if (scoreToBeat == null || currentScore < scoreToBeat) {
+                    scoreToBeat = currentScore;
+                    bestMoment = tempConfig;
+                }
+            }
+
+            extend(config, bestMoment || tempConfig);
+        }
+
+        // date from iso format
+        function parseISO(config) {
+            var i, l,
+                string = config._i,
+                match = isoRegex.exec(string);
+
+            if (match) {
+                config._pf.iso = true;
+                for (i = 0, l = isoDates.length; i < l; i++) {
+                    if (isoDates[i][1].exec(string)) {
+                        // match[5] should be 'T' or undefined
+                        config._f = isoDates[i][0] + (match[6] || ' ');
+                        break;
+                    }
+                }
+                for (i = 0, l = isoTimes.length; i < l; i++) {
+                    if (isoTimes[i][1].exec(string)) {
+                        config._f += isoTimes[i][0];
+                        break;
+                    }
+                }
+                if (string.match(parseTokenTimezone)) {
+                    config._f += 'Z';
+                }
+                makeDateFromStringAndFormat(config);
+            } else {
+                config._isValid = false;
+            }
+        }
+
+        // date from iso format or fallback
+        function makeDateFromString(config) {
+            parseISO(config);
+            if (config._isValid === false) {
+                delete config._isValid;
+                moment.createFromInputFallback(config);
+            }
+        }
+
+        function map(arr, fn) {
+            var res = [], i;
+            for (i = 0; i < arr.length; ++i) {
+                res.push(fn(arr[i], i));
+            }
+            return res;
+        }
+
+        function makeDateFromInput(config) {
+            var input = config._i, matched;
+            if (input === undefined) {
+                config._d = new Date();
+            } else if (isDate(input)) {
+                config._d = new Date(+input);
+            } else if ((matched = aspNetJsonRegex.exec(input)) !== null) {
+                config._d = new Date(+matched[1]);
+            } else if (typeof input === 'string') {
+                makeDateFromString(config);
+            } else if (isArray(input)) {
+                config._a = map(input.slice(0), function (obj) {
+                    return parseInt(obj, 10);
+                });
+                dateFromConfig(config);
+            } else if (typeof(input) === 'object') {
+                dateFromObject(config);
+            } else if (typeof(input) === 'number') {
+                // from milliseconds
+                config._d = new Date(input);
+            } else {
+                moment.createFromInputFallback(config);
+            }
+        }
+
+        function makeDate(y, m, d, h, M, s, ms) {
+            //can't just apply() to create a date:
+            //http://stackoverflow.com/questions/181348/instantiating-a-javascript-object-by-calling-prototype-constructor-apply
+            var date = new Date(y, m, d, h, M, s, ms);
+
+            //the date constructor doesn't accept years < 1970
+            if (y < 1970) {
+                date.setFullYear(y);
+            }
+            return date;
+        }
+
+        function makeUTCDate(y) {
+            var date = new Date(Date.UTC.apply(null, arguments));
+            if (y < 1970) {
+                date.setUTCFullYear(y);
+            }
+            return date;
+        }
+
+        function parseWeekday(input, locale) {
+            if (typeof input === 'string') {
+                if (!isNaN(input)) {
+                    input = parseInt(input, 10);
+                }
+                else {
+                    input = locale.weekdaysParse(input);
+                    if (typeof input !== 'number') {
+                        return null;
+                    }
+                }
+            }
+            return input;
+        }
+
+        /************************************
+            Relative Time
+        ************************************/
+
+
+        // helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize
+        function substituteTimeAgo(string, number, withoutSuffix, isFuture, locale) {
+            return locale.relativeTime(number || 1, !!withoutSuffix, string, isFuture);
+        }
+
+        function relativeTime(posNegDuration, withoutSuffix, locale) {
+            var duration = moment.duration(posNegDuration).abs(),
+                seconds = round(duration.as('s')),
+                minutes = round(duration.as('m')),
+                hours = round(duration.as('h')),
+                days = round(duration.as('d')),
+                months = round(duration.as('M')),
+                years = round(duration.as('y')),
+
+                args = seconds < relativeTimeThresholds.s && ['s', seconds] ||
+                    minutes === 1 && ['m'] ||
+                    minutes < relativeTimeThresholds.m && ['mm', minutes] ||
+                    hours === 1 && ['h'] ||
+                    hours < relativeTimeThresholds.h && ['hh', hours] ||
+                    days === 1 && ['d'] ||
+                    days < relativeTimeThresholds.d && ['dd', days] ||
+                    months === 1 && ['M'] ||
+                    months < relativeTimeThresholds.M && ['MM', months] ||
+                    years === 1 && ['y'] || ['yy', years];
+
+            args[2] = withoutSuffix;
+            args[3] = +posNegDuration > 0;
+            args[4] = locale;
+            return substituteTimeAgo.apply({}, args);
+        }
+
+
+        /************************************
+            Week of Year
+        ************************************/
+
+
+        // firstDayOfWeek       0 = sun, 6 = sat
+        //                      the day of the week that starts the week
+        //                      (usually sunday or monday)
+        // firstDayOfWeekOfYear 0 = sun, 6 = sat
+        //                      the first week is the week that contains the first
+        //                      of this day of the week
+        //                      (eg. ISO weeks use thursday (4))
+        function weekOfYear(mom, firstDayOfWeek, firstDayOfWeekOfYear) {
+            var end = firstDayOfWeekOfYear - firstDayOfWeek,
+                daysToDayOfWeek = firstDayOfWeekOfYear - mom.day(),
+                adjustedMoment;
+
+
+            if (daysToDayOfWeek > end) {
+                daysToDayOfWeek -= 7;
+            }
+
+            if (daysToDayOfWeek < end - 7) {
+                daysToDayOfWeek += 7;
+            }
+
+            adjustedMoment = moment(mom).add(daysToDayOfWeek, 'd');
+            return {
+                week: Math.ceil(adjustedMoment.dayOfYear() / 7),
+                year: adjustedMoment.year()
+            };
+        }
+
+        //http://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday
+        function dayOfYearFromWeeks(year, week, weekday, firstDayOfWeekOfYear, firstDayOfWeek) {
+            var d = makeUTCDate(year, 0, 1).getUTCDay(), daysToAdd, dayOfYear;
+
+            d = d === 0 ? 7 : d;
+            weekday = weekday != null ? weekday : firstDayOfWeek;
+            daysToAdd = firstDayOfWeek - d + (d > firstDayOfWeekOfYear ? 7 : 0) - (d < firstDayOfWeek ? 7 : 0);
+            dayOfYear = 7 * (week - 1) + (weekday - firstDayOfWeek) + daysToAdd + 1;
+
+            return {
+                year: dayOfYear > 0 ? year : year - 1,
+                dayOfYear: dayOfYear > 0 ?  dayOfYear : daysInYear(year - 1) + dayOfYear
+            };
+        }
+
+        /************************************
+            Top Level Functions
+        ************************************/
+
+        function makeMoment(config) {
+            var input = config._i,
+                format = config._f;
+
+            config._locale = config._locale || moment.localeData(config._l);
+
+            if (input === null || (format === undefined && input === '')) {
+                return moment.invalid({nullInput: true});
+            }
+
+            if (typeof input === 'string') {
+                config._i = input = config._locale.preparse(input);
+            }
+
+            if (moment.isMoment(input)) {
+                return new Moment(input, true);
+            } else if (format) {
+                if (isArray(format)) {
+                    makeDateFromStringAndArray(config);
+                } else {
+                    makeDateFromStringAndFormat(config);
+                }
+            } else {
+                makeDateFromInput(config);
+            }
+
+            return new Moment(config);
+        }
+
+        moment = function (input, format, locale, strict) {
+            var c;
+
+            if (typeof(locale) === 'boolean') {
+                strict = locale;
+                locale = undefined;
+            }
+            // object construction must be done this way.
+            // https://github.com/moment/moment/issues/1423
+            c = {};
+            c._isAMomentObject = true;
+            c._i = input;
+            c._f = format;
+            c._l = locale;
+            c._strict = strict;
+            c._isUTC = false;
+            c._pf = defaultParsingFlags();
+
+            return makeMoment(c);
+        };
+
+        moment.suppressDeprecationWarnings = false;
+
+        moment.createFromInputFallback = deprecate(
+            'moment construction falls back to js Date. This is ' +
+            'discouraged and will be removed in upcoming major ' +
+            'release. Please refer to ' +
+            'https://github.com/moment/moment/issues/1407 for more info.',
+            function (config) {
+                config._d = new Date(config._i);
+            }
+        );
+
+        // Pick a moment m from moments so that m[fn](other) is true for all
+        // other. This relies on the function fn to be transitive.
+        //
+        // moments should either be an array of moment objects or an array, whose
+        // first element is an array of moment objects.
+        function pickBy(fn, moments) {
+            var res, i;
+            if (moments.length === 1 && isArray(moments[0])) {
+                moments = moments[0];
+            }
+            if (!moments.length) {
+                return moment();
+            }
+            res = moments[0];
+            for (i = 1; i < moments.length; ++i) {
+                if (moments[i][fn](res)) {
+                    res = moments[i];
+                }
+            }
+            return res;
+        }
+
+        moment.min = function () {
+            var args = [].slice.call(arguments, 0);
+
+            return pickBy('isBefore', args);
+        };
+
+        moment.max = function () {
+            var args = [].slice.call(arguments, 0);
+
+            return pickBy('isAfter', args);
+        };
+
+        // creating with utc
+        moment.utc = function (input, format, locale, strict) {
+            var c;
+
+            if (typeof(locale) === 'boolean') {
+                strict = locale;
+                locale = undefined;
+            }
+            // object construction must be done this way.
+            // https://github.com/moment/moment/issues/1423
+            c = {};
+            c._isAMomentObject = true;
+            c._useUTC = true;
+            c._isUTC = true;
+            c._l = locale;
+            c._i = input;
+            c._f = format;
+            c._strict = strict;
+            c._pf = defaultParsingFlags();
+
+            return makeMoment(c).utc();
+        };
+
+        // creating with unix timestamp (in seconds)
+        moment.unix = function (input) {
+            return moment(input * 1000);
+        };
+
+        // duration
+        moment.duration = function (input, key) {
+            var duration = input,
+                // matching against regexp is expensive, do it on demand
+                match = null,
+                sign,
+                ret,
+                parseIso,
+                diffRes;
+
+            if (moment.isDuration(input)) {
+                duration = {
+                    ms: input._milliseconds,
+                    d: input._days,
+                    M: input._months
+                };
+            } else if (typeof input === 'number') {
+                duration = {};
+                if (key) {
+                    duration[key] = input;
+                } else {
+                    duration.milliseconds = input;
+                }
+            } else if (!!(match = aspNetTimeSpanJsonRegex.exec(input))) {
+                sign = (match[1] === '-') ? -1 : 1;
+                duration = {
+                    y: 0,
+                    d: toInt(match[DATE]) * sign,
+                    h: toInt(match[HOUR]) * sign,
+                    m: toInt(match[MINUTE]) * sign,
+                    s: toInt(match[SECOND]) * sign,
+                    ms: toInt(match[MILLISECOND]) * sign
+                };
+            } else if (!!(match = isoDurationRegex.exec(input))) {
+                sign = (match[1] === '-') ? -1 : 1;
+                parseIso = function (inp) {
+                    // We'd normally use ~~inp for this, but unfortunately it also
+                    // converts floats to ints.
+                    // inp may be undefined, so careful calling replace on it.
+                    var res = inp && parseFloat(inp.replace(',', '.'));
+                    // apply sign while we're at it
+                    return (isNaN(res) ? 0 : res) * sign;
+                };
+                duration = {
+                    y: parseIso(match[2]),
+                    M: parseIso(match[3]),
+                    d: parseIso(match[4]),
+                    h: parseIso(match[5]),
+                    m: parseIso(match[6]),
+                    s: parseIso(match[7]),
+                    w: parseIso(match[8])
+                };
+            } else if (typeof duration === 'object' &&
+                    ('from' in duration || 'to' in duration)) {
+                diffRes = momentsDifference(moment(duration.from), moment(duration.to));
+
+                duration = {};
+                duration.ms = diffRes.milliseconds;
+                duration.M = diffRes.months;
+            }
+
+            ret = new Duration(duration);
+
+            if (moment.isDuration(input) && hasOwnProp(input, '_locale')) {
+                ret._locale = input._locale;
+            }
+
+            return ret;
+        };
+
+        // version number
+        moment.version = VERSION;
+
+        // default format
+        moment.defaultFormat = isoFormat;
+
+        // constant that refers to the ISO standard
+        moment.ISO_8601 = function () {};
+
+        // Plugins that add properties should also add the key here (null value),
+        // so we can properly clone ourselves.
+        moment.momentProperties = momentProperties;
+
+        // This function will be called whenever a moment is mutated.
+        // It is intended to keep the offset in sync with the timezone.
+        moment.updateOffset = function () {};
+
+        // This function allows you to set a threshold for relative time strings
+        moment.relativeTimeThreshold = function (threshold, limit) {
+            if (relativeTimeThresholds[threshold] === undefined) {
+                return false;
+            }
+            if (limit === undefined) {
+                return relativeTimeThresholds[threshold];
+            }
+            relativeTimeThresholds[threshold] = limit;
+            return true;
+        };
+
+        moment.lang = deprecate(
+            'moment.lang is deprecated. Use moment.locale instead.',
+            function (key, value) {
+                return moment.locale(key, value);
+            }
+        );
+
+        // This function will load locale and then set the global locale.  If
+        // no arguments are passed in, it will simply return the current global
+        // locale key.
+        moment.locale = function (key, values) {
+            var data;
+            if (key) {
+                if (typeof(values) !== 'undefined') {
+                    data = moment.defineLocale(key, values);
+                }
+                else {
+                    data = moment.localeData(key);
+                }
+
+                if (data) {
+                    moment.duration._locale = moment._locale = data;
+                }
+            }
+
+            return moment._locale._abbr;
+        };
+
+        moment.defineLocale = function (name, values) {
+            if (values !== null) {
+                values.abbr = name;
+                if (!locales[name]) {
+                    locales[name] = new Locale();
+                }
+                locales[name].set(values);
+
+                // backwards compat for now: also set the locale
+                moment.locale(name);
+
+                return locales[name];
+            } else {
+                // useful for testing
+                delete locales[name];
+                return null;
+            }
+        };
+
+        moment.langData = deprecate(
+            'moment.langData is deprecated. Use moment.localeData instead.',
+            function (key) {
+                return moment.localeData(key);
+            }
+        );
+
+        // returns locale data
+        moment.localeData = function (key) {
+            var locale;
+
+            if (key && key._locale && key._locale._abbr) {
+                key = key._locale._abbr;
+            }
+
+            if (!key) {
+                return moment._locale;
+            }
+
+            if (!isArray(key)) {
+                //short-circuit everything else
+                locale = loadLocale(key);
+                if (locale) {
+                    return locale;
+                }
+                key = [key];
+            }
+
+            return chooseLocale(key);
+        };
+
+        // compare moment object
+        moment.isMoment = function (obj) {
+            return obj instanceof Moment ||
+                (obj != null && hasOwnProp(obj, '_isAMomentObject'));
+        };
+
+        // for typechecking Duration objects
+        moment.isDuration = function (obj) {
+            return obj instanceof Duration;
+        };
+
+        for (i = lists.length - 1; i >= 0; --i) {
+            makeList(lists[i]);
+        }
+
+        moment.normalizeUnits = function (units) {
+            return normalizeUnits(units);
+        };
+
+        moment.invalid = function (flags) {
+            var m = moment.utc(NaN);
+            if (flags != null) {
+                extend(m._pf, flags);
+            }
+            else {
+                m._pf.userInvalidated = true;
+            }
+
+            return m;
+        };
+
+        moment.parseZone = function () {
+            return moment.apply(null, arguments).parseZone();
+        };
+
+        moment.parseTwoDigitYear = function (input) {
+            return toInt(input) + (toInt(input) > 68 ? 1900 : 2000);
+        };
+
+        /************************************
+            Moment Prototype
+        ************************************/
+
+
+        extend(moment.fn = Moment.prototype, {
+
+            clone : function () {
+                return moment(this);
+            },
+
+            valueOf : function () {
+                return +this._d + ((this._offset || 0) * 60000);
+            },
+
+            unix : function () {
+                return Math.floor(+this / 1000);
+            },
+
+            toString : function () {
+                return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ');
+            },
+
+            toDate : function () {
+                return this._offset ? new Date(+this) : this._d;
+            },
+
+            toISOString : function () {
+                var m = moment(this).utc();
+                if (0 < m.year() && m.year() <= 9999) {
+                    return formatMoment(m, 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]');
+                } else {
+                    return formatMoment(m, 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]');
+                }
+            },
+
+            toArray : function () {
+                var m = this;
+                return [
+                    m.year(),
+                    m.month(),
+                    m.date(),
+                    m.hours(),
+                    m.minutes(),
+                    m.seconds(),
+                    m.milliseconds()
+                ];
+            },
+
+            isValid : function () {
+                return isValid(this);
+            },
+
+            isDSTShifted : function () {
+                if (this._a) {
+                    return this.isValid() && compareArrays(this._a, (this._isUTC ? moment.utc(this._a) : moment(this._a)).toArray()) > 0;
+                }
+
+                return false;
+            },
+
+            parsingFlags : function () {
+                return extend({}, this._pf);
+            },
+
+            invalidAt: function () {
+                return this._pf.overflow;
+            },
+
+            utc : function (keepLocalTime) {
+                return this.zone(0, keepLocalTime);
+            },
+
+            local : function (keepLocalTime) {
+                if (this._isUTC) {
+                    this.zone(0, keepLocalTime);
+                    this._isUTC = false;
+
+                    if (keepLocalTime) {
+                        this.add(this._dateTzOffset(), 'm');
+                    }
+                }
+                return this;
+            },
+
+            format : function (inputString) {
+                var output = formatMoment(this, inputString || moment.defaultFormat);
+                return this.localeData().postformat(output);
+            },
+
+            add : createAdder(1, 'add'),
+
+            subtract : createAdder(-1, 'subtract'),
+
+            diff : function (input, units, asFloat) {
+                var that = makeAs(input, this),
+                    zoneDiff = (this.zone() - that.zone()) * 6e4,
+                    diff, output, daysAdjust;
+
+                units = normalizeUnits(units);
+
+                if (units === 'year' || units === 'month') {
+                    // average number of days in the months in the given dates
+                    diff = (this.daysInMonth() + that.daysInMonth()) * 432e5; // 24 * 60 * 60 * 1000 / 2
+                    // difference in months
+                    output = ((this.year() - that.year()) * 12) + (this.month() - that.month());
+                    // adjust by taking difference in days, average number of days
+                    // and dst in the given months.
+                    daysAdjust = (this - moment(this).startOf('month')) -
+                        (that - moment(that).startOf('month'));
+                    // same as above but with zones, to negate all dst
+                    daysAdjust -= ((this.zone() - moment(this).startOf('month').zone()) -
+                            (that.zone() - moment(that).startOf('month').zone())) * 6e4;
+                    output += daysAdjust / diff;
+                    if (units === 'year') {
+                        output = output / 12;
+                    }
+                } else {
+                    diff = (this - that);
+                    output = units === 'second' ? diff / 1e3 : // 1000
+                        units === 'minute' ? diff / 6e4 : // 1000 * 60
+                        units === 'hour' ? diff / 36e5 : // 1000 * 60 * 60
+                        units === 'day' ? (diff - zoneDiff) / 864e5 : // 1000 * 60 * 60 * 24, negate dst
+                        units === 'week' ? (diff - zoneDiff) / 6048e5 : // 1000 * 60 * 60 * 24 * 7, negate dst
+                        diff;
+                }
+                return asFloat ? output : absRound(output);
+            },
+
+            from : function (time, withoutSuffix) {
+                return moment.duration({to: this, from: time}).locale(this.locale()).humanize(!withoutSuffix);
+            },
+
+            fromNow : function (withoutSuffix) {
+                return this.from(moment(), withoutSuffix);
+            },
+
+            calendar : function (time) {
+                // We want to compare the start of today, vs this.
+                // Getting start-of-today depends on whether we're zone'd or not.
+                var now = time || moment(),
+                    sod = makeAs(now, this).startOf('day'),
+                    diff = this.diff(sod, 'days', true),
+                    format = diff < -6 ? 'sameElse' :
+                        diff < -1 ? 'lastWeek' :
+                        diff < 0 ? 'lastDay' :
+                        diff < 1 ? 'sameDay' :
+                        diff < 2 ? 'nextDay' :
+                        diff < 7 ? 'nextWeek' : 'sameElse';
+                return this.format(this.localeData().calendar(format, this));
+            },
+
+            isLeapYear : function () {
+                return isLeapYear(this.year());
+            },
+
+            isDST : function () {
+                return (this.zone() < this.clone().month(0).zone() ||
+                    this.zone() < this.clone().month(5).zone());
+            },
+
+            day : function (input) {
+                var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay();
+                if (input != null) {
+                    input = parseWeekday(input, this.localeData());
+                    return this.add(input - day, 'd');
+                } else {
+                    return day;
+                }
+            },
+
+            month : makeAccessor('Month', true),
+
+            startOf : function (units) {
+                units = normalizeUnits(units);
+                // the following switch intentionally omits break keywords
+                // to utilize falling through the cases.
+                switch (units) {
+                case 'year':
+                    this.month(0);
+                    /* falls through */
+                case 'quarter':
+                case 'month':
+                    this.date(1);
+                    /* falls through */
+                case 'week':
+                case 'isoWeek':
+                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 */
+                }
+
+                // weeks are a special case
+                if (units === 'week') {
+                    this.weekday(0);
+                } else if (units === 'isoWeek') {
+                    this.isoWeekday(1);
+                }
+
+                // quarters are also special
+                if (units === 'quarter') {
+                    this.month(Math.floor(this.month() / 3) * 3);
+                }
+
+                return this;
+            },
+
+            endOf: function (units) {
+                units = normalizeUnits(units);
+                return this.startOf(units).add(1, (units === 'isoWeek' ? 'week' : units)).subtract(1, 'ms');
+            },
+
+            isAfter: function (input, units) {
+                units = normalizeUnits(typeof units !== 'undefined' ? units : 'millisecond');
+                if (units === 'millisecond') {
+                    input = moment.isMoment(input) ? input : moment(input);
+                    return +this > +input;
+                } else {
+                    return +this.clone().startOf(units) > +moment(input).startOf(units);
+                }
+            },
+
+            isBefore: function (input, units) {
+                units = normalizeUnits(typeof units !== 'undefined' ? units : 'millisecond');
+                if (units === 'millisecond') {
+                    input = moment.isMoment(input) ? input : moment(input);
+                    return +this < +input;
+                } else {
+                    return +this.clone().startOf(units) < +moment(input).startOf(units);
+                }
+            },
+
+            isSame: function (input, units) {
+                units = normalizeUnits(units || 'millisecond');
+                if (units === 'millisecond') {
+                    input = moment.isMoment(input) ? input : moment(input);
+                    return +this === +input;
+                } else {
+                    return +this.clone().startOf(units) === +makeAs(input, this).startOf(units);
+                }
+            },
+
+            min: deprecate(
+                     'moment().min is deprecated, use moment.min instead. https://github.com/moment/moment/issues/1548',
+                     function (other) {
+                         other = moment.apply(null, arguments);
+                         return other < this ? this : other;
+                     }
+             ),
+
+            max: deprecate(
+                    'moment().max is deprecated, use moment.max instead. https://github.com/moment/moment/issues/1548',
+                    function (other) {
+                        other = moment.apply(null, arguments);
+                        return other > this ? this : other;
+                    }
+            ),
+
+            // keepLocalTime = true means only change the timezone, without
+            // affecting the local hour. So 5:31:26 +0300 --[zone(2, true)]-->
+            // 5:31:26 +0200 It is possible that 5:31:26 doesn't exist int zone
+            // +0200, so we adjust the time as needed, to be valid.
+            //
+            // Keeping the time actually adds/subtracts (one hour)
+            // from the actual represented time. That is why we call updateOffset
+            // a second time. In case it wants us to change the offset again
+            // _changeInProgress == true case, then we have to adjust, because
+            // there is no such time in the given timezone.
+            zone : function (input, keepLocalTime) {
+                var offset = this._offset || 0,
+                    localAdjust;
+                if (input != null) {
+                    if (typeof input === 'string') {
+                        input = timezoneMinutesFromString(input);
+                    }
+                    if (Math.abs(input) < 16) {
+                        input = input * 60;
+                    }
+                    if (!this._isUTC && keepLocalTime) {
+                        localAdjust = this._dateTzOffset();
+                    }
+                    this._offset = input;
+                    this._isUTC = true;
+                    if (localAdjust != null) {
+                        this.subtract(localAdjust, 'm');
+                    }
+                    if (offset !== input) {
+                        if (!keepLocalTime || this._changeInProgress) {
+                            addOrSubtractDurationFromMoment(this,
+                                    moment.duration(offset - input, 'm'), 1, false);
+                        } else if (!this._changeInProgress) {
+                            this._changeInProgress = true;
+                            moment.updateOffset(this, true);
+                            this._changeInProgress = null;
+                        }
+                    }
+                } else {
+                    return this._isUTC ? offset : this._dateTzOffset();
+                }
+                return this;
+            },
+
+            zoneAbbr : function () {
+                return this._isUTC ? 'UTC' : '';
+            },
+
+            zoneName : function () {
+                return this._isUTC ? 'Coordinated Universal Time' : '';
+            },
+
+            parseZone : function () {
+                if (this._tzm) {
+                    this.zone(this._tzm);
+                } else if (typeof this._i === 'string') {
+                    this.zone(this._i);
+                }
+                return this;
+            },
+
+            hasAlignedHourOffset : function (input) {
+                if (!input) {
+                    input = 0;
+                }
+                else {
+                    input = moment(input).zone();
+                }
+
+                return (this.zone() - input) % 60 === 0;
+            },
+
+            daysInMonth : function () {
+                return daysInMonth(this.year(), this.month());
+            },
+
+            dayOfYear : function (input) {
+                var dayOfYear = round((moment(this).startOf('day') - moment(this).startOf('year')) / 864e5) + 1;
+                return input == null ? dayOfYear : this.add((input - dayOfYear), 'd');
+            },
+
+            quarter : function (input) {
+                return input == null ? Math.ceil((this.month() + 1) / 3) : this.month((input - 1) * 3 + this.month() % 3);
+            },
+
+            weekYear : function (input) {
+                var year = weekOfYear(this, this.localeData()._week.dow, this.localeData()._week.doy).year;
+                return input == null ? year : this.add((input - year), 'y');
+            },
+
+            isoWeekYear : function (input) {
+                var year = weekOfYear(this, 1, 4).year;
+                return input == null ? year : this.add((input - year), 'y');
+            },
+
+            week : function (input) {
+                var week = this.localeData().week(this);
+                return input == null ? week : this.add((input - week) * 7, 'd');
+            },
+
+            isoWeek : function (input) {
+                var week = weekOfYear(this, 1, 4).week;
+                return input == null ? week : this.add((input - week) * 7, 'd');
+            },
+
+            weekday : function (input) {
+                var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7;
+                return input == null ? weekday : this.add(input - weekday, 'd');
+            },
+
+            isoWeekday : function (input) {
+                // behaves the same as moment#day except
+                // as a getter, returns 7 instead of 0 (1-7 range instead of 0-6)
+                // as a setter, sunday should belong to the previous week.
+                return input == null ? this.day() || 7 : this.day(this.day() % 7 ? input : input - 7);
+            },
+
+            isoWeeksInYear : function () {
+                return weeksInYear(this.year(), 1, 4);
+            },
+
+            weeksInYear : function () {
+                var weekInfo = this.localeData()._week;
+                return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy);
+            },
+
+            get : function (units) {
+                units = normalizeUnits(units);
+                return this[units]();
+            },
+
+            set : function (units, value) {
+                units = normalizeUnits(units);
+                if (typeof this[units] === 'function') {
+                    this[units](value);
+                }
+                return this;
+            },
+
+            // If passed a locale key, it will set the locale for this
+            // instance.  Otherwise, it will return the locale configuration
+            // variables for this instance.
+            locale : function (key) {
+                var newLocaleData;
+
+                if (key === undefined) {
+                    return this._locale._abbr;
+                } else {
+                    newLocaleData = moment.localeData(key);
+                    if (newLocaleData != null) {
+                        this._locale = newLocaleData;
+                    }
+                    return this;
+                }
+            },
+
+            lang : deprecate(
+                'moment().lang() is deprecated. Use moment().localeData() instead.',
+                function (key) {
+                    if (key === undefined) {
+                        return this.localeData();
+                    } else {
+                        return this.locale(key);
+                    }
+                }
+            ),
+
+            localeData : function () {
+                return this._locale;
+            },
+
+            _dateTzOffset : function () {
+                // On Firefox.24 Date#getTimezoneOffset returns a floating point.
+                // https://github.com/moment/moment/pull/1871
+                return Math.round(this._d.getTimezoneOffset() / 15) * 15;
+            }
+        });
+
+        function rawMonthSetter(mom, value) {
+            var dayOfMonth;
+
+            // TODO: Move this out of here!
+            if (typeof value === 'string') {
+                value = mom.localeData().monthsParse(value);
+                // TODO: Another silent failure?
+                if (typeof value !== 'number') {
+                    return mom;
+                }
+            }
+
+            dayOfMonth = Math.min(mom.date(),
+                    daysInMonth(mom.year(), value));
+            mom._d['set' + (mom._isUTC ? 'UTC' : '') + 'Month'](value, dayOfMonth);
+            return mom;
+        }
+
+        function rawGetter(mom, unit) {
+            return mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]();
+        }
+
+        function rawSetter(mom, unit, value) {
+            if (unit === 'Month') {
+                return rawMonthSetter(mom, value);
+            } else {
+                return mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value);
+            }
+        }
+
+        function makeAccessor(unit, keepTime) {
+            return function (value) {
+                if (value != null) {
+                    rawSetter(this, unit, value);
+                    moment.updateOffset(this, keepTime);
+                    return this;
+                } else {
+                    return rawGetter(this, unit);
+                }
+            };
+        }
+
+        moment.fn.millisecond = moment.fn.milliseconds = makeAccessor('Milliseconds', false);
+        moment.fn.second = moment.fn.seconds = makeAccessor('Seconds', false);
+        moment.fn.minute = moment.fn.minutes = makeAccessor('Minutes', false);
+        // Setting the hour should keep the time, because the user explicitly
+        // specified which hour he wants. So trying to maintain the same hour (in
+        // a new timezone) makes sense. Adding/subtracting hours does not follow
+        // this rule.
+        moment.fn.hour = moment.fn.hours = makeAccessor('Hours', true);
+        // moment.fn.month is defined separately
+        moment.fn.date = makeAccessor('Date', true);
+        moment.fn.dates = deprecate('dates accessor is deprecated. Use date instead.', makeAccessor('Date', true));
+        moment.fn.year = makeAccessor('FullYear', true);
+        moment.fn.years = deprecate('years accessor is deprecated. Use year instead.', makeAccessor('FullYear', true));
+
+        // add plural methods
+        moment.fn.days = moment.fn.day;
+        moment.fn.months = moment.fn.month;
+        moment.fn.weeks = moment.fn.week;
+        moment.fn.isoWeeks = moment.fn.isoWeek;
+        moment.fn.quarters = moment.fn.quarter;
+
+        // add aliased format methods
+        moment.fn.toJSON = moment.fn.toISOString;
+
+        /************************************
+            Duration Prototype
+        ************************************/
+
+
+        function daysToYears (days) {
+            // 400 years have 146097 days (taking into account leap year rules)
+            return days * 400 / 146097;
+        }
+
+        function yearsToDays (years) {
+            // years * 365 + absRound(years / 4) -
+            //     absRound(years / 100) + absRound(years / 400);
+            return years * 146097 / 400;
+        }
+
+        extend(moment.duration.fn = Duration.prototype, {
+
+            _bubble : function () {
+                var milliseconds = this._milliseconds,
+                    days = this._days,
+                    months = this._months,
+                    data = this._data,
+                    seconds, minutes, hours, years = 0;
+
+                // The following code bubbles up values, see the tests for
+                // examples of what that means.
+                data.milliseconds = milliseconds % 1000;
+
+                seconds = absRound(milliseconds / 1000);
+                data.seconds = seconds % 60;
+
+                minutes = absRound(seconds / 60);
+                data.minutes = minutes % 60;
+
+                hours = absRound(minutes / 60);
+                data.hours = hours % 24;
+
+                days += absRound(hours / 24);
+
+                // Accurately convert days to years, assume start from year 0.
+                years = absRound(daysToYears(days));
+                days -= absRound(yearsToDays(years));
+
+                // 30 days to a month
+                // TODO (iskren): Use anchor date (like 1st Jan) to compute this.
+                months += absRound(days / 30);
+                days %= 30;
+
+                // 12 months -> 1 year
+                years += absRound(months / 12);
+                months %= 12;
+
+                data.days = days;
+                data.months = months;
+                data.years = years;
+            },
+
+            abs : function () {
+                this._milliseconds = Math.abs(this._milliseconds);
+                this._days = Math.abs(this._days);
+                this._months = Math.abs(this._months);
+
+                this._data.milliseconds = Math.abs(this._data.milliseconds);
+                this._data.seconds = Math.abs(this._data.seconds);
+                this._data.minutes = Math.abs(this._data.minutes);
+                this._data.hours = Math.abs(this._data.hours);
+                this._data.months = Math.abs(this._data.months);
+                this._data.years = Math.abs(this._data.years);
+
+                return this;
+            },
+
+            weeks : function () {
+                return absRound(this.days() / 7);
+            },
+
+            valueOf : function () {
+                return this._milliseconds +
+                  this._days * 864e5 +
+                  (this._months % 12) * 2592e6 +
+                  toInt(this._months / 12) * 31536e6;
+            },
+
+            humanize : function (withSuffix) {
+                var output = relativeTime(this, !withSuffix, this.localeData());
+
+                if (withSuffix) {
+                    output = this.localeData().pastFuture(+this, output);
+                }
+
+                return this.localeData().postformat(output);
+            },
+
+            add : function (input, val) {
+                // supports only 2.0-style add(1, 's') or add(moment)
+                var dur = moment.duration(input, val);
+
+                this._milliseconds += dur._milliseconds;
+                this._days += dur._days;
+                this._months += dur._months;
+
+                this._bubble();
+
+                return this;
+            },
+
+            subtract : function (input, val) {
+                var dur = moment.duration(input, val);
+
+                this._milliseconds -= dur._milliseconds;
+                this._days -= dur._days;
+                this._months -= dur._months;
+
+                this._bubble();
+
+                return this;
+            },
+
+            get : function (units) {
+                units = normalizeUnits(units);
+                return this[units.toLowerCase() + 's']();
+            },
+
+            as : function (units) {
+                var days, months;
+                units = normalizeUnits(units);
+
+                if (units === 'month' || units === 'year') {
+                    days = this._days + this._milliseconds / 864e5;
+                    months = this._months + daysToYears(days) * 12;
+                    return units === 'month' ? months : months / 12;
+                } else {
+                    // handle milliseconds separately because of floating point math errors (issue #1867)
+                    days = this._days + yearsToDays(this._months / 12);
+                    switch (units) {
+                        case 'week': return days / 7 + this._milliseconds / 6048e5;
+                        case 'day': return days + this._milliseconds / 864e5;
+                        case 'hour': return days * 24 + this._milliseconds / 36e5;
+                        case 'minute': return days * 24 * 60 + this._milliseconds / 6e4;
+                        case 'second': return days * 24 * 60 * 60 + this._milliseconds / 1000;
+                        // Math.floor prevents floating point math errors here
+                        case 'millisecond': return Math.floor(days * 24 * 60 * 60 * 1000) + this._milliseconds;
+                        default: throw new Error('Unknown unit ' + units);
+                    }
+                }
+            },
+
+            lang : moment.fn.lang,
+            locale : moment.fn.locale,
+
+            toIsoString : deprecate(
+                'toIsoString() is deprecated. Please use toISOString() instead ' +
+                '(notice the capitals)',
+                function () {
+                    return this.toISOString();
+                }
+            ),
+
+            toISOString : function () {
+                // inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js
+                var years = Math.abs(this.years()),
+                    months = Math.abs(this.months()),
+                    days = Math.abs(this.days()),
+                    hours = Math.abs(this.hours()),
+                    minutes = Math.abs(this.minutes()),
+                    seconds = Math.abs(this.seconds() + this.milliseconds() / 1000);
+
+                if (!this.asSeconds()) {
+                    // this is the same as C#'s (Noda) and python (isodate)...
+                    // but not other JS (goog.date)
+                    return 'P0D';
+                }
+
+                return (this.asSeconds() < 0 ? '-' : '') +
+                    'P' +
+                    (years ? years + 'Y' : '') +
+                    (months ? months + 'M' : '') +
+                    (days ? days + 'D' : '') +
+                    ((hours || minutes || seconds) ? 'T' : '') +
+                    (hours ? hours + 'H' : '') +
+                    (minutes ? minutes + 'M' : '') +
+                    (seconds ? seconds + 'S' : '');
+            },
+
+            localeData : function () {
+                return this._locale;
+            }
+        });
+
+        moment.duration.fn.toString = moment.duration.fn.toISOString;
+
+        function makeDurationGetter(name) {
+            moment.duration.fn[name] = function () {
+                return this._data[name];
+            };
+        }
+
+        for (i in unitMillisecondFactors) {
+            if (hasOwnProp(unitMillisecondFactors, i)) {
+                makeDurationGetter(i.toLowerCase());
+            }
+        }
+
+        moment.duration.fn.asMilliseconds = function () {
+            return this.as('ms');
+        };
+        moment.duration.fn.asSeconds = function () {
+            return this.as('s');
+        };
+        moment.duration.fn.asMinutes = function () {
+            return this.as('m');
+        };
+        moment.duration.fn.asHours = function () {
+            return this.as('h');
+        };
+        moment.duration.fn.asDays = function () {
+            return this.as('d');
+        };
+        moment.duration.fn.asWeeks = function () {
+            return this.as('weeks');
+        };
+        moment.duration.fn.asMonths = function () {
+            return this.as('M');
+        };
+        moment.duration.fn.asYears = function () {
+            return this.as('y');
+        };
+
+        /************************************
+            Default Locale
+        ************************************/
+
+
+        // Set default locale, other locale will inherit from English.
+        moment.locale('en', {
+            ordinal : function (number) {
+                var b = number % 10,
+                    output = (toInt(number % 100 / 10) === 1) ? 'th' :
+                    (b === 1) ? 'st' :
+                    (b === 2) ? 'nd' :
+                    (b === 3) ? 'rd' : 'th';
+                return number + output;
+            }
+        });
+
+        return moment;
+
+    }).call(this);
 
-    moment = (function(B){function G(){return{empty:!1,unusedTokens:[],unusedInput:[],overflow:-2,charsLeftOver:0,nullInput:!1,invalidMonth:null,invalidFormat:!1,userInvalidated:!1,iso:!1}}function Z(a,b){return function(c){return l(a.call(this,c),b)}}function ta(a,b){return function(c){return this.lang().ordinal(a.call(this,c),b)}}function $(){}function H(a){aa(a);v(this,a)}function I(a){a=ba(a);var b=a.year||0,c=a.month||0,d=a.week||0,f=a.day||0;this._milliseconds=+(a.millisecond||0)+1E3*(a.second||0)+6E4*(a.minute||
-    0)+36E5*(a.hour||0);this._days=+f+7*d;this._months=+c+12*b;this._data={};this._bubble()}function v(a,b){for(var c in b)b.hasOwnProperty(c)&&(a[c]=b[c]);b.hasOwnProperty("toString")&&(a.toString=b.toString);b.hasOwnProperty("valueOf")&&(a.valueOf=b.valueOf);return a}function w(a){return 0>a?Math.ceil(a):Math.floor(a)}function l(a,b,c){for(var d=""+Math.abs(a);d.length<b;)d="0"+d;return(0<=a?c?"+":"":"-")+d}function J(a,b,c,d){var f=b._milliseconds,g=b._days;b=b._months;var m,h;f&&a._d.setTime(+a._d+
-    f*c);if(g||b)m=a.minute(),h=a.hour();g&&a.date(a.date()+g*c);b&&a.month(a.month()+b*c);f&&!d&&e.updateOffset(a,g||b);if(g||b)a.minute(m),a.hour(h)}function K(a){return"[object Array]"===Object.prototype.toString.call(a)}function ca(a,b,c){var d=Math.min(a.length,b.length),f=Math.abs(a.length-b.length),g=0,e;for(e=0;e<d;e++)(c&&a[e]!==b[e]||!c&&h(a[e])!==h(b[e]))&&g++;return g+f}function n(a){if(a){var b=a.toLowerCase().replace(/(.)s$/,"$1");a=ua[a]||va[b]||b}return a}function ba(a){var b={},c,d;for(d in a)a.hasOwnProperty(d)&&
-    (c=n(d))&&(b[c]=a[d]);return b}function wa(a){var b,c;if(0===a.indexOf("week"))b=7,c="day";else if(0===a.indexOf("month"))b=12,c="month";else return;e[a]=function(d,f){var g,m,h=e.fn._lang[a],k=[];"number"===typeof d&&(f=d,d=B);m=function(a){a=e().utc().set(c,a);return h.call(e.fn._lang,a,d||"")};if(null!=f)return m(f);for(g=0;g<b;g++)k.push(m(g));return k}}function h(a){a=+a;var b=0;0!==a&&isFinite(a)&&(b=0<=a?Math.floor(a):Math.ceil(a));return b}function L(a,b){return(new Date(Date.UTC(a,b+1,0))).getUTCDate()}
-    function da(a,b,c){return C(e([a,11,31+b-c]),b,c).week}function M(a){return 0===a%4&&0!==a%100||0===a%400}function aa(a){var b;a._a&&-2===a._pf.overflow&&(b=0>a._a[x]||11<a._a[x]?x:1>a._a[q]||a._a[q]>L(a._a[r],a._a[x])?q:0>a._a[p]||23<a._a[p]?p:0>a._a[y]||59<a._a[y]?y:0>a._a[D]||59<a._a[D]?D:0>a._a[E]||999<a._a[E]?E:-1,a._pf._overflowDayOfYear&&(b<r||b>q)&&(b=q),a._pf.overflow=b)}function ea(a){null==a._isValid&&(a._isValid=!isNaN(a._d.getTime())&&0>a._pf.overflow&&!a._pf.empty&&!a._pf.invalidMonth&&
-    !a._pf.nullInput&&!a._pf.invalidFormat&&!a._pf.userInvalidated,a._strict&&(a._isValid=a._isValid&&0===a._pf.charsLeftOver&&0===a._pf.unusedTokens.length));return a._isValid}function N(a){return a?a.toLowerCase().replace("_","-"):a}function O(a,b){return b._isUTC?e(a).zone(b._offset||0):e(a).local()}function s(a){var b=0,c,d,f,g,m=function(a){if(!z[a]&&xa)try{require("./lang/"+a)}catch(b){}return z[a]};if(!a)return e.fn._lang;if(!K(a)){if(d=m(a))return d;a=[a]}for(;b<a.length;){g=N(a[b]).split("-");
-    c=g.length;for(f=(f=N(a[b+1]))?f.split("-"):null;0<c;){if(d=m(g.slice(0,c).join("-")))return d;if(f&&f.length>=c&&ca(g,f,!0)>=c-1)break;c--}b++}return e.fn._lang}function ya(a){return a.match(/\[[\s\S]/)?a.replace(/^\[|\]$/g,""):a.replace(/\\/g,"")}function za(a){var b=a.match(fa),c,d;c=0;for(d=b.length;c<d;c++)b[c]=u[b[c]]?u[b[c]]:ya(b[c]);return function(f){var g="";for(c=0;c<d;c++)g+=b[c]instanceof Function?b[c].call(f,a):b[c];return g}}function P(a,b){if(!a.isValid())return a.lang().invalidDate();
-    b=ga(b,a.lang());Q[b]||(Q[b]=za(b));return Q[b](a)}function ga(a,b){function c(a){return b.longDateFormat(a)||a}var d=5;for(F.lastIndex=0;0<=d&&F.test(a);)a=a.replace(F,c),F.lastIndex=0,d-=1;return a}function Aa(a,b){var c=b._strict;switch(a){case "DDDD":return ha;case "YYYY":case "GGGG":case "gggg":return c?Ba:Ca;case "Y":case "G":case "g":return Da;case "YYYYYY":case "YYYYY":case "GGGGG":case "ggggg":return c?Ea:Fa;case "S":if(c)return Ga;case "SS":if(c)return ia;case "SSS":if(c)return ha;case "DDD":return Ha;
-    case "MMM":case "MMMM":case "dd":case "ddd":case "dddd":return Ia;case "a":case "A":return s(b._l)._meridiemParse;case "X":return Ja;case "Z":case "ZZ":return R;case "T":return Ka;case "SSSS":return La;case "MM":case "DD":case "YY":case "GG":case "gg":case "HH":case "hh":case "mm":case "ss":case "ww":case "WW":return c?ia:ja;case "M":case "D":case "d":case "H":case "h":case "m":case "s":case "w":case "W":case "e":case "E":return ja;case "Do":return Ma;default:var c=RegExp,d;d=Na(a.replace("\\","")).replace(/[-\/\\^$*+?.()|[\]{}]/g,
-    "\\$&");return new c(d)}}function ka(a){a=(a||"").match(R)||[];a=((a[a.length-1]||[])+"").match(Oa)||["-",0,0];var b=+(60*a[1])+h(a[2]);return"+"===a[0]?-b:b}function S(a){var b,c=[],d,f,g,m,k;if(!a._d){d=Pa(a);a._w&&null==a._a[q]&&null==a._a[x]&&(b=function(b){var c=parseInt(b,10);return b?3>b.length?68<c?1900+c:2E3+c:c:null==a._a[r]?e().weekYear():a._a[r]},f=a._w,null!=f.GG||null!=f.W||null!=f.E?b=la(b(f.GG),f.W||1,f.E,4,1):(g=s(a._l),m=null!=f.d?ma(f.d,g):null!=f.e?parseInt(f.e,10)+g._week.dow:
-    0,k=parseInt(f.w,10)||1,null!=f.d&&m<g._week.dow&&k++,b=la(b(f.gg),k,m,g._week.doy,g._week.dow)),a._a[r]=b.year,a._dayOfYear=b.dayOfYear);a._dayOfYear&&(b=null==a._a[r]?d[r]:a._a[r],a._dayOfYear>(M(b)?366:365)&&(a._pf._overflowDayOfYear=!0),b=T(b,0,a._dayOfYear),a._a[x]=b.getUTCMonth(),a._a[q]=b.getUTCDate());for(b=0;3>b&&null==a._a[b];++b)a._a[b]=c[b]=d[b];for(;7>b;b++)a._a[b]=c[b]=null==a._a[b]?2===b?1:0:a._a[b];c[p]+=h((a._tzm||0)/60);c[y]+=h((a._tzm||0)%60);a._d=(a._useUTC?T:Qa).apply(null,c)}}
-    function Pa(a){var b=new Date;return a._useUTC?[b.getUTCFullYear(),b.getUTCMonth(),b.getUTCDate()]:[b.getFullYear(),b.getMonth(),b.getDate()]}function U(a){a._a=[];a._pf.empty=!0;var b=s(a._l),c=""+a._i,d,f,g,e,k=c.length,l=0;f=ga(a._f,b).match(fa)||[];for(b=0;b<f.length;b++){g=f[b];if(d=(c.match(Aa(g,a))||[])[0])e=c.substr(0,c.indexOf(d)),0<e.length&&a._pf.unusedInput.push(e),c=c.slice(c.indexOf(d)+d.length),l+=d.length;if(u[g]){d?a._pf.empty=!1:a._pf.unusedTokens.push(g);e=a;var n=void 0,t=e._a;
-    switch(g){case "M":case "MM":null!=d&&(t[x]=h(d)-1);break;case "MMM":case "MMMM":n=s(e._l).monthsParse(d);null!=n?t[x]=n:e._pf.invalidMonth=d;break;case "D":case "DD":null!=d&&(t[q]=h(d));break;case "Do":null!=d&&(t[q]=h(parseInt(d,10)));break;case "DDD":case "DDDD":null!=d&&(e._dayOfYear=h(d));break;case "YY":t[r]=h(d)+(68<h(d)?1900:2E3);break;case "YYYY":case "YYYYY":case "YYYYYY":t[r]=h(d);break;case "a":case "A":e._isPm=s(e._l).isPM(d);break;case "H":case "HH":case "h":case "hh":t[p]=h(d);break;
-    case "m":case "mm":t[y]=h(d);break;case "s":case "ss":t[D]=h(d);break;case "S":case "SS":case "SSS":case "SSSS":t[E]=h(1E3*("0."+d));break;case "X":e._d=new Date(1E3*parseFloat(d));break;case "Z":case "ZZ":e._useUTC=!0;e._tzm=ka(d);break;case "w":case "ww":case "W":case "WW":case "d":case "dd":case "ddd":case "dddd":case "e":case "E":g=g.substr(0,1);case "gg":case "gggg":case "GG":case "GGGG":case "GGGGG":g=g.substr(0,2),d&&(e._w=e._w||{},e._w[g]=d)}}else a._strict&&!d&&a._pf.unusedTokens.push(g)}a._pf.charsLeftOver=
-    k-l;0<c.length&&a._pf.unusedInput.push(c);a._isPm&&12>a._a[p]&&(a._a[p]+=12);!1===a._isPm&&12===a._a[p]&&(a._a[p]=0);S(a);aa(a)}function Na(a){return a.replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g,function(a,c,d,f,e){return c||d||f||e})}function Qa(a,b,c,d,f,e,h){b=new Date(a,b,c,d,f,e,h);1970>a&&b.setFullYear(a);return b}function T(a){var b=new Date(Date.UTC.apply(null,arguments));1970>a&&b.setUTCFullYear(a);return b}function ma(a,b){if("string"===typeof a)if(isNaN(a)){if(a=b.weekdaysParse(a),"number"!==
-    typeof a)return null}else a=parseInt(a,10);return a}function Ra(a,b,c,d,f){return f.relativeTime(b||1,!!c,a,d)}function C(a,b,c){b=c-b;c-=a.day();c>b&&(c-=7);c<b-7&&(c+=7);a=e(a).add("d",c);return{week:Math.ceil(a.dayOfYear()/7),year:a.year()}}function la(a,b,c,d,f){var e=T(a,0,1).getUTCDay();b=7*(b-1)+((null!=c?c:f)-f)+(f-e+(e>d?7:0)-(e<f?7:0))+1;return{year:0<b?a:a-1,dayOfYear:0<b?b:(M(a-1)?366:365)+b}}function na(a){var b=a._i,c=a._f;if(null===b)return e.invalid({nullInput:!0});"string"===typeof b&&
-    (a._i=b=s().preparse(b));if(e.isMoment(b)){a=b;var d={},f;for(f in a)a.hasOwnProperty(f)&&Sa.hasOwnProperty(f)&&(d[f]=a[f]);a=d;a._d=new Date(+b._d)}else if(c)if(K(c)){var b=a,g,h;if(0===b._f.length)b._pf.invalidFormat=!0,b._d=new Date(NaN);else{for(f=0;f<b._f.length;f++)if(c=0,d=v({},b),d._pf=G(),d._f=b._f[f],U(d),ea(d)&&(c+=d._pf.charsLeftOver,c+=10*d._pf.unusedTokens.length,d._pf.score=c,null==h||c<h))h=c,g=d;v(b,g||d)}}else U(a);else if(d=a,g=d._i,h=Ta.exec(g),g===B)d._d=new Date;else if(h)d._d=
-    new Date(+h[1]);else if("string"===typeof g)if(b=d._i,f=Ua.exec(b)){d._pf.iso=!0;g=0;for(h=V.length;g<h;g++)if(V[g][1].exec(b)){d._f=V[g][0]+(f[6]||" ");break}g=0;for(h=W.length;g<h;g++)if(W[g][1].exec(b)){d._f+=W[g][0];break}b.match(R)&&(d._f+="Z");U(d)}else d._d=new Date(b);else K(g)?(d._a=g.slice(0),S(d)):"[object Date]"===Object.prototype.toString.call(g)||g instanceof Date?d._d=new Date(+g):"object"===typeof g?d._d||(g=ba(d._i),d._a=[g.year,g.month,g.day,g.hour,g.minute,g.second,g.millisecond],
-    S(d)):d._d=new Date(g);return new H(a)}function oa(a,b){var c="date"===b||"month"===b||"year"===b;e.fn[a]=e.fn[a+"s"]=function(a,f){var g=this._isUTC?"UTC":"";null==f&&(f=c);return null!=a?(this._d["set"+g+b](a),e.updateOffset(this,f),this):this._d["get"+g+b]()}}function Va(a){e.duration.fn[a]=function(){return this._data[a]}}function pa(a,b){e.duration.fn["as"+a]=function(){return+this/b}}for(var e,A=Math.round,k,r=0,x=1,q=2,p=3,y=4,D=5,E=6,z={},Sa={_isAMomentObject:null,_i:null,_f:null,_l:null,
-    _strict:null,_isUTC:null,_offset:null,_pf:null,_lang:null},xa="undefined"!==typeof module&&module.exports&&"undefined"!==typeof require,Ta=/^\/?Date\((\-?\d+)/i,Wa=/(\-)?(?:(\d*)\.)?(\d+)\:(\d+)(?:\:(\d+)\.?(\d{3})?)?/,Xa=/^(-)?P(?:(?:([0-9,.]*)Y)?(?:([0-9,.]*)M)?(?:([0-9,.]*)D)?(?:T(?:([0-9,.]*)H)?(?:([0-9,.]*)M)?(?:([0-9,.]*)S)?)?|([0-9,.]*)W)$/,fa=/(\[[^\[]*\])|(\\)?(Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|YYYYYY|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|mm?|ss?|S{1,4}|X|zz?|ZZ?|.)/g,
-    F=/(\[[^\[]*\])|(\\)?(LT|LL?L?L?|l{1,4})/g,ja=/\d\d?/,Ha=/\d{1,3}/,Ca=/\d{1,4}/,Fa=/[+\-]?\d{1,6}/,La=/\d+/,Ia=/[0-9]*['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+|[\u0600-\u06FF\/]+(\s*?[\u0600-\u06FF]+){1,2}/i,R=/Z|[\+\-]\d\d:?\d\d/gi,Ka=/T/i,Ja=/[\+\-]?\d+(\.\d{1,3})?/,Ma=/\d{1,2}/,Ga=/\d/,ia=/\d\d/,ha=/\d{3}/,Ba=/\d{4}/,Ea=/[+-]?\d{6}/,Da=/[+-]?\d+/,Ua=/^\s*(?:[+-]\d{6}|\d{4})-(?:(\d\d-\d\d)|(W\d\d$)|(W\d\d-\d)|(\d\d\d))((T| )(\d\d(:\d\d(:\d\d(\.\d+)?)?)?)?([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?$/,
-    V=[["YYYYYY-MM-DD",/[+-]\d{6}-\d{2}-\d{2}/],["YYYY-MM-DD",/\d{4}-\d{2}-\d{2}/],["GGGG-[W]WW-E",/\d{4}-W\d{2}-\d/],["GGGG-[W]WW",/\d{4}-W\d{2}/],["YYYY-DDD",/\d{4}-\d{3}/]],W=[["HH:mm:ss.SSSS",/(T| )\d\d:\d\d:\d\d\.\d{1,3}/],["HH:mm:ss",/(T| )\d\d:\d\d:\d\d/],["HH:mm",/(T| )\d\d:\d\d/],["HH",/(T| )\d\d/]],Oa=/([\+\-]|\d\d)/gi,X=["Date","Hours","Minutes","Seconds","Milliseconds"],Y={Milliseconds:1,Seconds:1E3,Minutes:6E4,Hours:36E5,Days:864E5,Months:2592E6,Years:31536E6},ua={ms:"millisecond",s:"second",
-    m:"minute",h:"hour",d:"day",D:"date",w:"week",W:"isoWeek",M:"month",y:"year",DDD:"dayOfYear",e:"weekday",E:"isoWeekday",gg:"weekYear",GG:"isoWeekYear"},va={dayofyear:"dayOfYear",isoweekday:"isoWeekday",isoweek:"isoWeek",weekyear:"weekYear",isoweekyear:"isoWeekYear"},Q={},qa="DDD w W M D d".split(" "),ra="MDHhmswW".split(""),u={M:function(){return this.month()+1},MMM:function(a){return this.lang().monthsShort(this,a)},MMMM:function(a){return this.lang().months(this,a)},D:function(){return this.date()},
-    DDD:function(){return this.dayOfYear()},d:function(){return this.day()},dd:function(a){return this.lang().weekdaysMin(this,a)},ddd:function(a){return this.lang().weekdaysShort(this,a)},dddd:function(a){return this.lang().weekdays(this,a)},w:function(){return this.week()},W:function(){return this.isoWeek()},YY:function(){return l(this.year()%100,2)},YYYY:function(){return l(this.year(),4)},YYYYY:function(){return l(this.year(),5)},YYYYYY:function(){var a=this.year();return(0<=a?"+":"-")+l(Math.abs(a),
-    6)},gg:function(){return l(this.weekYear()%100,2)},gggg:function(){return l(this.weekYear(),4)},ggggg:function(){return l(this.weekYear(),5)},GG:function(){return l(this.isoWeekYear()%100,2)},GGGG:function(){return l(this.isoWeekYear(),4)},GGGGG:function(){return l(this.isoWeekYear(),5)},e:function(){return this.weekday()},E:function(){return this.isoWeekday()},a:function(){return this.lang().meridiem(this.hours(),this.minutes(),!0)},A:function(){return this.lang().meridiem(this.hours(),this.minutes(),
-    !1)},H:function(){return this.hours()},h:function(){return this.hours()%12||12},m:function(){return this.minutes()},s:function(){return this.seconds()},S:function(){return h(this.milliseconds()/100)},SS:function(){return l(h(this.milliseconds()/10),2)},SSS:function(){return l(this.milliseconds(),3)},SSSS:function(){return l(this.milliseconds(),3)},Z:function(){var a=-this.zone(),b="+";0>a&&(a=-a,b="-");return b+l(h(a/60),2)+":"+l(h(a)%60,2)},ZZ:function(){var a=-this.zone(),b="+";0>a&&(a=-a,b="-");
-    return b+l(h(a/60),2)+l(h(a)%60,2)},z:function(){return this.zoneAbbr()},zz:function(){return this.zoneName()},X:function(){return this.unix()},Q:function(){return this.quarter()}},sa=["months","monthsShort","weekdays","weekdaysShort","weekdaysMin"];qa.length;)k=qa.pop(),u[k+"o"]=ta(u[k],k);for(;ra.length;)k=ra.pop(),u[k+k]=Z(u[k],2);u.DDDD=Z(u.DDD,3);v($.prototype,{set:function(a){var b,c;for(c in a)b=a[c],"function"===typeof b?this[c]=b:this["_"+c]=b},_months:"January February March April May June July August September October November December".split(" "),
-    months:function(a){return this._months[a.month()]},_monthsShort:"Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec".split(" "),monthsShort:function(a){return this._monthsShort[a.month()]},monthsParse:function(a){var b,c;this._monthsParse||(this._monthsParse=[]);for(b=0;12>b;b++)if(this._monthsParse[b]||(c=e.utc([2E3,b]),c="^"+this.months(c,"")+"|^"+this.monthsShort(c,""),this._monthsParse[b]=RegExp(c.replace(".",""),"i")),this._monthsParse[b].test(a))return b},_weekdays:"Sunday Monday Tuesday Wednesday Thursday Friday Saturday".split(" "),
-    weekdays:function(a){return this._weekdays[a.day()]},_weekdaysShort:"Sun Mon Tue Wed Thu Fri Sat".split(" "),weekdaysShort:function(a){return this._weekdaysShort[a.day()]},_weekdaysMin:"Su Mo Tu We Th Fr Sa".split(" "),weekdaysMin:function(a){return this._weekdaysMin[a.day()]},weekdaysParse:function(a){var b,c;this._weekdaysParse||(this._weekdaysParse=[]);for(b=0;7>b;b++)if(this._weekdaysParse[b]||(c=e([2E3,1]).day(b),c="^"+this.weekdays(c,"")+"|^"+this.weekdaysShort(c,"")+"|^"+this.weekdaysMin(c,
-    ""),this._weekdaysParse[b]=RegExp(c.replace(".",""),"i")),this._weekdaysParse[b].test(a))return b},_longDateFormat:{LT:"h:mm A",L:"MM/DD/YYYY",LL:"MMMM D YYYY",LLL:"MMMM D YYYY LT",LLLL:"dddd, MMMM D YYYY LT"},longDateFormat:function(a){var b=this._longDateFormat[a];!b&&this._longDateFormat[a.toUpperCase()]&&(b=this._longDateFormat[a.toUpperCase()].replace(/MMMM|MM|DD|dddd/g,function(a){return a.slice(1)}),this._longDateFormat[a]=b);return b},isPM:function(a){return"p"===(a+"").toLowerCase().charAt(0)},
-    _meridiemParse:/[ap]\.?m?\.?/i,meridiem:function(a,b,c){return 11<a?c?"pm":"PM":c?"am":"AM"},_calendar:{sameDay:"[Today at] LT",nextDay:"[Tomorrow at] LT",nextWeek:"dddd [at] LT",lastDay:"[Yesterday at] LT",lastWeek:"[Last] dddd [at] LT",sameElse:"L"},calendar:function(a,b){var c=this._calendar[a];return"function"===typeof c?c.apply(b):c},_relativeTime:{future:"in %s",past:"%s ago",s:"a few seconds",m:"a minute",mm:"%d minutes",h:"an hour",hh:"%d hours",d:"a day",dd:"%d days",M:"a month",MM:"%d months",
-    y:"a year",yy:"%d years"},relativeTime:function(a,b,c,d){var f=this._relativeTime[c];return"function"===typeof f?f(a,b,c,d):f.replace(/%d/i,a)},pastFuture:function(a,b){var c=this._relativeTime[0<a?"future":"past"];return"function"===typeof c?c(b):c.replace(/%s/i,b)},ordinal:function(a){return this._ordinal.replace("%d",a)},_ordinal:"%d",preparse:function(a){return a},postformat:function(a){return a},week:function(a){return C(a,this._week.dow,this._week.doy).week},_week:{dow:0,doy:6},_invalidDate:"Invalid date",
-    invalidDate:function(){return this._invalidDate}});e=function(a,b,c,d){var f;"boolean"===typeof c&&(d=c,c=B);f={_isAMomentObject:!0};f._i=a;f._f=b;f._l=c;f._strict=d;f._isUTC=!1;f._pf=G();return na(f)};e.utc=function(a,b,c,d){var f;"boolean"===typeof c&&(d=c,c=B);f={_isAMomentObject:!0,_useUTC:!0,_isUTC:!0};f._l=c;f._i=a;f._f=b;f._strict=d;f._pf=G();return na(f).utc()};e.unix=function(a){return e(1E3*a)};e.duration=function(a,b){var c=a,d=null,f;if(e.isDuration(a))c={ms:a._milliseconds,d:a._days,
-    M:a._months};else if("number"===typeof a)c={},b?c[b]=a:c.milliseconds=a;else if(d=Wa.exec(a))f="-"===d[1]?-1:1,c={y:0,d:h(d[q])*f,h:h(d[p])*f,m:h(d[y])*f,s:h(d[D])*f,ms:h(d[E])*f};else if(d=Xa.exec(a))f="-"===d[1]?-1:1,c=function(a){a=a&&parseFloat(a.replace(",","."));return(isNaN(a)?0:a)*f},c={y:c(d[2]),M:c(d[3]),d:c(d[4]),h:c(d[5]),m:c(d[6]),s:c(d[7]),w:c(d[8])};d=new I(c);e.isDuration(a)&&a.hasOwnProperty("_lang")&&(d._lang=a._lang);return d};e.version="2.5.1";e.defaultFormat="YYYY-MM-DDTHH:mm:ssZ";
-    e.updateOffset=function(){};e.lang=function(a,b){if(!a)return e.fn._lang._abbr;if(b){var c=N(a);b.abbr=c;z[c]||(z[c]=new $);z[c].set(b)}else null===b?(delete z[a],a="en"):z[a]||s(a);return(e.duration.fn._lang=e.fn._lang=s(a))._abbr};e.langData=function(a){a&&a._lang&&a._lang._abbr&&(a=a._lang._abbr);return s(a)};e.isMoment=function(a){return a instanceof H||null!=a&&a.hasOwnProperty("_isAMomentObject")};e.isDuration=function(a){return a instanceof I};for(k=sa.length-1;0<=k;--k)wa(sa[k]);e.normalizeUnits=
-    function(a){return n(a)};e.invalid=function(a){var b=e.utc(NaN);null!=a?v(b._pf,a):b._pf.userInvalidated=!0;return b};e.parseZone=function(){return e.apply(null,arguments).parseZone()};v(e.fn=H.prototype,{clone:function(){return e(this)},valueOf:function(){return+this._d+6E4*(this._offset||0)},unix:function(){return Math.floor(+this/1E3)},toString:function(){return this.clone().lang("en").format("ddd MMM DD YYYY HH:mm:ss [GMT]ZZ")},toDate:function(){return this._offset?new Date(+this):this._d},toISOString:function(){var a=
-    e(this).utc();return 0<a.year()&&9999>=a.year()?P(a,"YYYY-MM-DD[T]HH:mm:ss.SSS[Z]"):P(a,"YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]")},toArray:function(){return[this.year(),this.month(),this.date(),this.hours(),this.minutes(),this.seconds(),this.milliseconds()]},isValid:function(){return ea(this)},isDSTShifted:function(){return this._a?this.isValid()&&0<ca(this._a,(this._isUTC?e.utc(this._a):e(this._a)).toArray()):!1},parsingFlags:function(){return v({},this._pf)},invalidAt:function(){return this._pf.overflow},
-    utc:function(){return this.zone(0)},local:function(){this.zone(0);this._isUTC=!1;return this},format:function(a){a=P(this,a||e.defaultFormat);return this.lang().postformat(a)},add:function(a,b){var c;c="string"===typeof a?e.duration(+b,a):e.duration(a,b);J(this,c,1);return this},subtract:function(a,b){var c;c="string"===typeof a?e.duration(+b,a):e.duration(a,b);J(this,c,-1);return this},diff:function(a,b,c){a=O(a,this);var d=6E4*(this.zone()-a.zone()),f;b=n(b);"year"===b||"month"===b?(f=432E5*(this.daysInMonth()+
-    a.daysInMonth()),d=12*(this.year()-a.year())+(this.month()-a.month()),d+=(this-e(this).startOf("month")-(a-e(a).startOf("month")))/f,d-=6E4*(this.zone()-e(this).startOf("month").zone()-(a.zone()-e(a).startOf("month").zone()))/f,"year"===b&&(d/=12)):(f=this-a,d="second"===b?f/1E3:"minute"===b?f/6E4:"hour"===b?f/36E5:"day"===b?(f-d)/864E5:"week"===b?(f-d)/6048E5:f);return c?d:w(d)},from:function(a,b){return e.duration(this.diff(a)).lang(this.lang()._abbr).humanize(!b)},fromNow:function(a){return this.from(e(),
-    a)},calendar:function(){var a=O(e(),this).startOf("day"),a=this.diff(a,"days",!0),a=-6>a?"sameElse":-1>a?"lastWeek":0>a?"lastDay":1>a?"sameDay":2>a?"nextDay":7>a?"nextWeek":"sameElse";return this.format(this.lang().calendar(a,this))},isLeapYear:function(){return M(this.year())},isDST:function(){return this.zone()<this.clone().month(0).zone()||this.zone()<this.clone().month(5).zone()},day:function(a){var b=this._isUTC?this._d.getUTCDay():this._d.getDay();return null!=a?(a=ma(a,this.lang()),this.add({d:a-
-    b})):b},month:function(a){var b=this._isUTC?"UTC":"",c;if(null!=a){if("string"===typeof a&&(a=this.lang().monthsParse(a),"number"!==typeof a))return this;c=Math.min(this.date(),L(this.year(),a));this._d["set"+b+"Month"](a,c);e.updateOffset(this,!0);return this}return this._d["get"+b+"Month"]()},startOf:function(a){a=n(a);switch(a){case "year":this.month(0);case "month":this.date(1);case "week":case "isoWeek":case "day":this.hours(0);case "hour":this.minutes(0);case "minute":this.seconds(0);case "second":this.milliseconds(0)}"week"===
-    a?this.weekday(0):"isoWeek"===a&&this.isoWeekday(1);return this},endOf:function(a){a=n(a);return this.startOf(a).add("isoWeek"===a?"week":a,1).subtract("ms",1)},isAfter:function(a,b){b="undefined"!==typeof b?b:"millisecond";return+this.clone().startOf(b)>+e(a).startOf(b)},isBefore:function(a,b){b="undefined"!==typeof b?b:"millisecond";return+this.clone().startOf(b)<+e(a).startOf(b)},isSame:function(a,b){b=b||"ms";return+this.clone().startOf(b)===+O(a,this).startOf(b)},min:function(a){a=e.apply(null,
-    arguments);return a<this?this:a},max:function(a){a=e.apply(null,arguments);return a>this?this:a},zone:function(a,b){b=null==b?!0:!1;var c=this._offset||0;if(null!=a)"string"===typeof a&&(a=ka(a)),16>Math.abs(a)&&(a*=60),this._offset=a,this._isUTC=!0,c!==a&&b&&J(this,e.duration(c-a,"m"),1,!0);else return this._isUTC?c:this._d.getTimezoneOffset();return this},zoneAbbr:function(){return this._isUTC?"UTC":""},zoneName:function(){return this._isUTC?"Coordinated Universal Time":""},parseZone:function(){this._tzm?
-    this.zone(this._tzm):"string"===typeof this._i&&this.zone(this._i);return this},hasAlignedHourOffset:function(a){a=a?e(a).zone():0;return 0===(this.zone()-a)%60},daysInMonth:function(){return L(this.year(),this.month())},dayOfYear:function(a){var b=A((e(this).startOf("day")-e(this).startOf("year"))/864E5)+1;return null==a?b:this.add("d",a-b)},quarter:function(){return Math.ceil((this.month()+1)/3)},weekYear:function(a){var b=C(this,this.lang()._week.dow,this.lang()._week.doy).year;return null==a?
-    b:this.add("y",a-b)},isoWeekYear:function(a){var b=C(this,1,4).year;return null==a?b:this.add("y",a-b)},week:function(a){var b=this.lang().week(this);return null==a?b:this.add("d",7*(a-b))},isoWeek:function(a){var b=C(this,1,4).week;return null==a?b:this.add("d",7*(a-b))},weekday:function(a){var b=(this.day()+7-this.lang()._week.dow)%7;return null==a?b:this.add("d",a-b)},isoWeekday:function(a){return null==a?this.day()||7:this.day(this.day()%7?a:a-7)},isoWeeksInYear:function(){return da(this.year(),
-    1,4)},weeksInYear:function(){var a=this._lang._week;return da(this.year(),a.dow,a.doy)},get:function(a){a=n(a);return this[a]()},set:function(a,b){a=n(a);if("function"===typeof this[a])this[a](b);return this},lang:function(a){if(a===B)return this._lang;this._lang=s(a);return this}});for(k=0;k<X.length;k++)oa(X[k].toLowerCase().replace(/s$/,""),X[k]);oa("year","FullYear");e.fn.days=e.fn.day;e.fn.months=e.fn.month;e.fn.weeks=e.fn.week;e.fn.isoWeeks=e.fn.isoWeek;e.fn.toJSON=e.fn.toISOString;v(e.duration.fn=
-    I.prototype,{_bubble:function(){var a=this._milliseconds,b=this._days,c=this._months,d=this._data;d.milliseconds=a%1E3;a=w(a/1E3);d.seconds=a%60;a=w(a/60);d.minutes=a%60;a=w(a/60);d.hours=a%24;b+=w(a/24);d.days=b%30;c+=w(b/30);d.months=c%12;b=w(c/12);d.years=b},weeks:function(){return w(this.days()/7)},valueOf:function(){return this._milliseconds+864E5*this._days+this._months%12*2592E6+31536E6*h(this._months/12)},humanize:function(a){var b=+this,c;c=!a;var d=this.lang(),f=A(Math.abs(b)/1E3),e=A(f/
-    60),h=A(e/60),k=A(h/24),l=A(k/365),f=45>f&&["s",f]||1===e&&["m"]||45>e&&["mm",e]||1===h&&["h"]||22>h&&["hh",h]||1===k&&["d"]||25>=k&&["dd",k]||45>=k&&["M"]||345>k&&["MM",A(k/30)]||1===l&&["y"]||["yy",l];f[2]=c;f[3]=0<b;f[4]=d;c=Ra.apply({},f);a&&(c=this.lang().pastFuture(b,c));return this.lang().postformat(c)},add:function(a,b){var c=e.duration(a,b);this._milliseconds+=c._milliseconds;this._days+=c._days;this._months+=c._months;this._bubble();return this},subtract:function(a,b){var c=e.duration(a,
-    b);this._milliseconds-=c._milliseconds;this._days-=c._days;this._months-=c._months;this._bubble();return this},get:function(a){a=n(a);return this[a.toLowerCase()+"s"]()},as:function(a){a=n(a);return this["as"+a.charAt(0).toUpperCase()+a.slice(1)+"s"]()},lang:e.fn.lang,toIsoString:function(){var a=Math.abs(this.years()),b=Math.abs(this.months()),c=Math.abs(this.days()),d=Math.abs(this.hours()),e=Math.abs(this.minutes()),g=Math.abs(this.seconds()+this.milliseconds()/1E3);return this.asSeconds()?(0>
-    this.asSeconds()?"-":"")+"P"+(a?a+"Y":"")+(b?b+"M":"")+(c?c+"D":"")+(d||e||g?"T":"")+(d?d+"H":"")+(e?e+"M":"")+(g?g+"S":""):"P0D"}});for(k in Y)Y.hasOwnProperty(k)&&(pa(k,Y[k]),Va(k.toLowerCase()));pa("Weeks",6048E5);e.duration.fn.asMonths=function(){return(+this-31536E6*this.years())/2592E6+12*this.years()};e.lang("en",{ordinal:function(a){var b=a%10,b=1===h(a%100/10)?"th":1===b?"st":2===b?"nd":3===b?"rd":"th";return a+b}});return e}).call(this);
-
-    UI.datepicker.moment = moment;
+    UI.Utils.moment = moment;
 
     return UI.datepicker;
-});
+});