NetSuite2.0 Restlet脚本时间初始化脚本

;(function (global, factory) {
typeof exports === ‘object’ && typeof module !== ‘undefined’ ? module.exports = factory() :
typeof define === ‘function’ && define.amd ? define(factory) :
global.moment = factory()
}(this, (function () { ‘use strict’;

var hookCallback;

function hooks () {
return hookCallback.apply(null, arguments);
}

// This is done to register the method called with moment()
// without creating circular dependencies.
function setHookCallback (callback) {
hookCallback = callback;
}

function isArray(input) {
return input instanceof Array || Object.prototype.toString.call(input) === ‘[object Array]’;
}

function isObject(input) {
// IE8 will treat undefined and null as object if it wasn’t for
// input != null
return input != null && Object.prototype.toString.call(input) === ‘[object Object]’;
}

function isUndefined(input) {
return input === void 0;
}

function isNumber(input) {
return typeof input === ‘number’ || Object.prototype.toString.call(input) === ‘[object Number]’;
}

function isDate(input) {
return input instanceof Date || Object.prototype.toString.call(input) === ‘[object Date]’;
}

function map(arr, fn) {
var res = [], i;
for (i = 0; i < arr.length; ++i) {
res.push(fn(arr[i], i));
}
return res;
}

function hasOwnProp(a, b) {
return Object.prototype.hasOwnProperty.call(a, b);
}

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 createUTC (input, format, locale, strict) {
return createLocalOrUTC(input, format, locale, strict, true).utc();
}

function defaultParsingFlags() {
// We need to deep clone this object.
return {
empty : false,
unusedTokens : [],
unusedInput : [],
overflow : -2,
charsLeftOver : 0,
nullInput : false,
invalidMonth : null,
invalidFormat : false,
userInvalidated : false,
iso : false,
parsedDateParts : [],
meridiem : null,
rfc2822 : false,
weekdayMismatch : false
};
}

function getParsingFlags(m) {
if (m._pf == null) {
m._pf = defaultParsingFlags();
}
return m._pf;
}

var some;
if (Array.prototype.some) {
some = Array.prototype.some;
} else {
some = function (fun) {
var t = Object(this);
var len = t.length >>> 0;

    for (var i = 0; i < len; i++) {if (i in t && fun.call(this, t[i], i, t)) {return true;}}return false;
};

}

function isValid(m) {
if (m._isValid == null) {
var flags = getParsingFlags(m);
var parsedParts = some.call(flags.parsedDateParts, function (i) {
return i != null;
});
var isNowValid = !isNaN(m._d.getTime()) &&
flags.overflow < 0 &&
!flags.empty &&
!flags.invalidMonth &&
!flags.invalidWeekday &&
!flags.weekdayMismatch &&
!flags.nullInput &&
!flags.invalidFormat &&
!flags.userInvalidated &&
(!flags.meridiem || (flags.meridiem && parsedParts));

    if (m._strict) {isNowValid = isNowValid &&flags.charsLeftOver === 0 &&flags.unusedTokens.length === 0 &&flags.bigHour === undefined;}if (Object.isFrozen == null || !Object.isFrozen(m)) {m._isValid = isNowValid;}else {return isNowValid;}
}
return m._isValid;

}

function createInvalid (flags) {
var m = createUTC(NaN);
if (flags != null) {
extend(getParsingFlags(m), flags);
}
else {
getParsingFlags(m).userInvalidated = true;
}

return m;

}

// Plugins that add properties should also add the key here (null value),
// so we can properly clone ourselves.
var momentProperties = hooks.momentProperties = [];

function copyConfig(to, from) {
var i, prop, val;

if (!isUndefined(from._isAMomentObject)) {to._isAMomentObject = from._isAMomentObject;
}
if (!isUndefined(from._i)) {to._i = from._i;
}
if (!isUndefined(from._f)) {to._f = from._f;
}
if (!isUndefined(from._l)) {to._l = from._l;
}
if (!isUndefined(from._strict)) {to._strict = from._strict;
}
if (!isUndefined(from._tzm)) {to._tzm = from._tzm;
}
if (!isUndefined(from._isUTC)) {to._isUTC = from._isUTC;
}
if (!isUndefined(from._offset)) {to._offset = from._offset;
}
if (!isUndefined(from._pf)) {to._pf = getParsingFlags(from);
}
if (!isUndefined(from._locale)) {to._locale = from._locale;
}if (momentProperties.length > 0) {for (i = 0; i < momentProperties.length; i++) {prop = momentProperties[i];val = from[prop];if (!isUndefined(val)) {to[prop] = val;}}
}return to;

}

var updateInProgress = false;

// Moment prototype object
function Moment(config) {
copyConfig(this, config);
this._d = new Date(config._d != null ? config._d.getTime() : NaN);
if (!this.isValid()) {
this._d = new Date(NaN);
}
// Prevent infinite loop in case updateOffset creates new moment
// objects.
if (updateInProgress === false) {
updateInProgress = true;
hooks.updateOffset(this);
updateInProgress = false;
}
}

function isMoment (obj) {
return obj instanceof Moment || (obj != null && obj._isAMomentObject != null);
}

function absFloor (number) {
if (number < 0) {
// -0 -> 0
return Math.ceil(number) || 0;
} else {
return Math.floor(number);
}
}

function toInt(argumentForCoercion) {
var coercedNumber = +argumentForCoercion,
value = 0;

if (coercedNumber !== 0 && isFinite(coercedNumber)) {value = absFloor(coercedNumber);
}return value;

}

// 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 warn(msg) {
if (hooks.suppressDeprecationWarnings === false &&
(typeof console !== ‘undefined’) && console.warn) {
console.warn('Deprecation warning: ’ + msg);
}
}

function deprecate(msg, fn) {
var firstTime = true;

return extend(function () {if (hooks.deprecationHandler != null) {hooks.deprecationHandler(null, msg);}if (firstTime) {var args = [];var arg;for (var i = 0; i < arguments.length; i++) {arg = '';if (typeof arguments[i] === 'object') {arg += '\n[' + i + '] ';for (var key in arguments[0]) {arg += key + ': ' + arguments[0][key] + ', ';}arg = arg.slice(0, -2); // Remove trailing comma and space} else {arg = arguments[i];}args.push(arg);}warn(msg + '\nArguments: ' + Array.prototype.slice.call(args).join('') + '\n' + (new Error()).stack);firstTime = false;}return fn.apply(this, arguments);
}, fn);

}

var deprecations = {};

function deprecateSimple(name, msg) {
if (hooks.deprecationHandler != null) {
hooks.deprecationHandler(name, msg);
}
if (!deprecations[name]) {
warn(msg);
deprecations[name] = true;
}
}

hooks.suppressDeprecationWarnings = false;
hooks.deprecationHandler = null;

function isFunction(input) {
return input instanceof Function || Object.prototype.toString.call(input) === ‘[object Function]’;
}

function Locale(config) {
if (config != null) {
this.set(config);
}
}

var keys;

if (Object.keys) {
keys = Object.keys;
} else {
keys = function (obj) {
var i, res = [];
for (i in obj) {
if (hasOwnProp(obj, i)) {
res.push(i);
}
}
return res;
};
}

var defaultCalendar = {
sameDay : ‘[Today at] LT’,
nextDay : ‘[Tomorrow at] LT’,
nextWeek : ‘dddd [at] LT’,
lastDay : ‘[Yesterday at] LT’,
lastWeek : ‘[Last] dddd [at] LT’,
sameElse : ‘L’
};

function calendar (key, mom, now) {
var output = this._calendar[key] || this._calendar[‘sameElse’];
return isFunction(output) ? output.call(mom, now) : output;
}

var defaultLongDateFormat = {
LTS : ‘h:mm:ss A’,
LT : ‘h:mm A’,
L : ‘MM/DD/YYYY’,
LL : ‘MMMM D, YYYY’,
LLL : ‘MMMM D, YYYY h:mm A’,
LLLL : ‘dddd, MMMM D, YYYY h:mm A’
};

function longDateFormat (key) {
var format = this._longDateFormat[key],
formatUpper = this._longDateFormat[key.toUpperCase()];

if (format || !formatUpper) {return format;
}this._longDateFormat[key] = formatUpper.replace(/MMMM|MM|DD|dddd/g, function (val) {return val.slice(1);
});return this._longDateFormat[key];

}

var defaultInvalidDate = ‘Invalid date’;

function invalidDate () {
return this._invalidDate;
}

var defaultOrdinal = ‘%d’;
var defaultDayOfMonthOrdinalParse = /\d{1,2}/;

function ordinal (number) {
return this._ordinal.replace(‘%d’, number);
}

var defaultRelativeTime = {
future : ‘in %s’,
past : ‘%s ago’,
s : ‘a few seconds’,
ss : ‘%d 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’
};

function relativeTime (number, withoutSuffix, string, isFuture) {
var output = this._relativeTime[string];
return (isFunction(output)) ?
output(number, withoutSuffix, string, isFuture) :
output.replace(/%d/i, number);
}

function pastFuture (diff, output) {
var format = this._relativeTime[diff > 0 ? ‘future’ : ‘past’];
return isFunction(format) ? format(output) : format.replace(/%s/i, output);
}

var aliases = {};

function addUnitAlias (unit, shorthand) {
var lowerCase = unit.toLowerCase();
aliases[lowerCase] = aliases[lowerCase + ‘s’] = aliases[shorthand] = unit;
}

function normalizeUnits(units) {
return typeof units === ‘string’ ? aliases[units] || aliases[units.toLowerCase()] : undefined;
}

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;

}

var priorities = {};

function addUnitPriority(unit, priority) {
priorities[unit] = priority;
}

function zeroFill(number, targetLength, forceSign) {
var absNumber = ‘’ + Math.abs(number),
zerosToFill = targetLength - absNumber.length,
sign = number >= 0;
return (sign ? (forceSign ? ‘+’ : ‘’) : ‘-’) +
Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) + absNumber;
}

var formattingTokens = /([[^[]*])|(\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|YYYYYY|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g;

var localFormattingTokens = /([[^[]*])|(\)?(LTS|LT|LL?L?L?|l{1,4})/g;

var formatFunctions = {};

var formatTokenFunctions = {};

// token: ‘M’
// padded: [‘MM’, 2]
// ordinal: ‘Mo’
// callback: function () { this.month() + 1 }
function addFormatToken (token, padded, ordinal, callback) {
var func = callback;
if (typeof callback === ‘string’) {
func = function () {
return thiscallback;
};
}
if (token) {
formatTokenFunctions[token] = func;
}
if (padded) {
formatTokenFunctions[padded[0]] = function () {
return zeroFill(func.apply(this, arguments), padded[1], padded[2]);
};
}
if (ordinal) {
formatTokenFunctions[ordinal] = function () {
return this.localeData().ordinal(func.apply(this, arguments), token);
};
}
}

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 = '', i;for (i = 0; i < length; i++) {output += isFunction(array[i]) ? 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());
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;

}

var matchUnsigned = /\d+/; // 0 - inf
var matchSigned = /[±]?\d+/; // -inf - inf

var matchOffset = /Z|[±]\d\d:?\d\d/gi; // +00:00 -00:00 +0000 -0000 or Z
var matchShortOffset = /Z|[±]\d\d(?::?\d\d)?/gi; // +00 -00 +00:00 -00:00 +0000 -0000 or Z

var matchTimestamp = /[±]?\d+(.\d{1,3})?/; // 123456789 123456789.123

// any word (or two) characters or numbers including two/three word month in arabic.
// includes scottish gaelic two word and hyphenated months
var matchWord = /[0-9]{0,256}['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]{1,256}|[\u0600-\u06FF/]{1,256}(\s*?[\u0600-\u06FF]{1,256}){1,2}/i;

var regexes = {};

function addRegexToken (token, regex, strictRegex) {
regexes[token] = isFunction(regex) ? regex : function (isStrict, localeData) {
return (isStrict && strictRegex) ? strictRegex : regex;
};
}

function getParseRegexForToken (token, config) {
if (!hasOwnProp(regexes, token)) {
return new RegExp(unescapeFormat(token));
}

return regexes[token](config._strict, config._locale);

}

// Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript
function unescapeFormat(s) {
return regexEscape(s.replace(‘\’, ‘’).replace(/\([)|\(])|[([^][]*)]|\(.)/g, function (matched, p1, p2, p3, p4) {
return p1 || p2 || p3 || p4;
}));
}

function regexEscape(s) {
return s.replace(/[-/\^$*+?.()|[]{}]/g, ‘\$&’);
}

var tokens = {};

function addWeekParseToken (token, callback) {
addParseToken(token, function (input, array, config, token) {
config._w = config._w || {};
callback(input, config._w, config, token);
});
}

function addTimeToArrayFromToken(token, input, config) {
if (input != null && hasOwnProp(tokens, token)) {
tokens[token](input, config._a, config, token);
}
}

var YEAR = 0;
var MONTH = 1;
var DATE = 2;
var HOUR = 3;
var MINUTE = 4;
var SECOND = 5;
var MILLISECOND = 6;
var WEEK = 7;
var WEEKDAY = 8;

// FORMATTING

addFormatToken(‘Y’, 0, 0, function () {
var y = this.year();
return y <= 9999 ? ‘’ + y : ‘+’ + y;
});

addFormatToken(0, [‘YY’, 2], 0, function () {
return this.year() % 100;
});

addFormatToken(0, [‘YYYY’, 4], 0, ‘year’);
addFormatToken(0, [‘YYYYY’, 5], 0, ‘year’);
addFormatToken(0, [‘YYYYYY’, 6, true], 0, ‘year’);

// ALIASES

addUnitAlias(‘year’, ‘y’);

// PRIORITIES

addUnitPriority(‘year’, 1);

// PARSING

addRegexToken(‘Y’, matchSigned);
addRegexToken(‘YY’, match1to2, match2);
addRegexToken(‘YYYY’, match1to4, match4);
addRegexToken(‘YYYYY’, match1to6, match6);
addRegexToken(‘YYYYYY’, match1to6, match6);

addParseToken([‘YYYYY’, ‘YYYYYY’], YEAR);
addParseToken(‘YYYY’, function (input, array) {
array[YEAR] = input.length === 2 ? hooks.parseTwoDigitYear(input) : toInt(input);
});
addParseToken(‘YY’, function (input, array) {
array[YEAR] = hooks.parseTwoDigitYear(input);
});
addParseToken(‘Y’, function (input, array) {
array[YEAR] = parseInt(input, 10);
});

// HELPERS

function daysInYear(year) {
return isLeapYear(year) ? 366 : 365;
}

function isLeapYear(year) {
return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
}

// HOOKS

hooks.parseTwoDigitYear = function (input) {
return toInt(input) + (toInt(input) > 68 ? 1900 : 2000);
};

// MOMENTS

var getSetYear = makeGetSet(‘FullYear’, true);

function getIsLeapYear () {
return isLeapYear(this.year());
}

function get (mom, unit) {
return mom.isValid() ?
mom._d’get’ + (mom._isUTC ? ‘UTC’ : ‘’) + unit : NaN;
}

function set$1 (mom, unit, value) {
if (mom.isValid() && !isNaN(value)) {
if (unit === ‘FullYear’ && isLeapYear(mom.year()) && mom.month() === 1 && mom.date() === 29) {
mom._d[‘set’ + (mom._isUTC ? ‘UTC’ : ‘’) + unit](value, mom.month(), daysInMonth(value, mom.month()));
}
else {
mom._d’set’ + (mom._isUTC ? ‘UTC’ : ‘’) + unit;
}
}
}

// MOMENTS

function stringGet (units) {
units = normalizeUnits(units);
if (isFunction(this[units])) {
return thisunits;
}
return this;
}

function mod(n, x) {
return ((n % x) + x) % x;
}

var indexOf;

if (Array.prototype.indexOf) {
indexOf = Array.prototype.indexOf;
} else {
indexOf = function (o) {
// I know
var i;
for (i = 0; i < this.length; ++i) {
if (this[i] === o) {
return i;
}
}
return -1;
};
}

function daysInMonth(year, month) {
if (isNaN(year) || isNaN(month)) {
return NaN;
}
var modMonth = mod(month, 12);
year += (month - modMonth) / 12;
return modMonth === 1 ? (isLeapYear(year) ? 29 : 28) : (31 - modMonth % 7 % 2);
}

// FORMATTING

addFormatToken(‘M’, [‘MM’, 2], ‘Mo’, function () {
return this.month() + 1;
});

addFormatToken(‘MMM’, 0, 0, function (format) {
return this.localeData().monthsShort(this, format);
});

addFormatToken(‘MMMM’, 0, 0, function (format) {
return this.localeData().months(this, format);
});

// ALIASES

addUnitAlias(‘month’, ‘M’);

// PRIORITY

addUnitPriority(‘month’, 8);

// PARSING

addRegexToken(‘M’, match1to2);
addRegexToken(‘MM’, match1to2, match2);
addRegexToken(‘MMM’, function (isStrict, locale) {
return locale.monthsShortRegex(isStrict);
});
addRegexToken(‘MMMM’, function (isStrict, locale) {
return locale.monthsRegex(isStrict);
});

addParseToken([‘M’, ‘MM’], function (input, array) {
array[MONTH] = toInt(input) - 1;
});

addParseToken([‘MMM’, ‘MMMM’], function (input, array, config, token) {
var month = config._locale.monthsParse(input, token, config._strict);
// if we didn’t find a month name, mark the date as invalid.
if (month != null) {
array[MONTH] = month;
} else {
getParsingFlags(config).invalidMonth = input;
}
});

// LOCALES

var MONTHS_IN_FORMAT = /D[oD]?([[^[]]*]|\s)+MMMM?/;
var defaultLocaleMonths = ‘January_February_March_April_May_June_July_August_September_October_November_December’.split(‘_’);
function localeMonths (m, format) {
if (!m) {
return isArray(this._months) ? this._months :
this._months[‘standalone’];
}
return isArray(this._months) ? this._months[m.month()] :
this._months[(this._months.isFormat || MONTHS_IN_FORMAT).test(format) ? ‘format’ : ‘standalone’][m.month()];
}

var defaultLocaleMonthsShort = ‘Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec’.split(‘_’);
function localeMonthsShort (m, format) {
if (!m) {
return isArray(this._monthsShort) ? this._monthsShort :
this._monthsShort[‘standalone’];
}
return isArray(this._monthsShort) ? this._monthsShort[m.month()] :
this._monthsShort[MONTHS_IN_FORMAT.test(format) ? ‘format’ : ‘standalone’][m.month()];
}

function handleStrictParse(monthName, format, strict) {
var i, ii, mom, llc = monthName.toLocaleLowerCase();
if (!this._monthsParse) {
// this is not used
this._monthsParse = [];
this._longMonthsParse = [];
this._shortMonthsParse = [];
for (i = 0; i < 12; ++i) {
mom = createUTC([2000, i]);
this._shortMonthsParse[i] = this.monthsShort(mom, ‘’).toLocaleLowerCase();
this._longMonthsParse[i] = this.months(mom, ‘’).toLocaleLowerCase();
}
}

if (strict) {if (format === 'MMM') {ii = indexOf.call(this._shortMonthsParse, llc);return ii !== -1 ? ii : null;} else {ii = indexOf.call(this._longMonthsParse, llc);return ii !== -1 ? ii : null;}
} else {if (format === 'MMM') {ii = indexOf.call(this._shortMonthsParse, llc);if (ii !== -1) {return ii;}ii = indexOf.call(this._longMonthsParse, llc);return ii !== -1 ? ii : null;} else {ii = indexOf.call(this._longMonthsParse, llc);if (ii !== -1) {return ii;}ii = indexOf.call(this._shortMonthsParse, llc);return ii !== -1 ? ii : null;}
}

}

function localeMonthsParse (monthName, format, strict) {
var i, mom, regex;

if (this._monthsParseExact) {return handleStrictParse.call(this, monthName, format, strict);
}if (!this._monthsParse) {this._monthsParse = [];this._longMonthsParse = [];this._shortMonthsParse = [];
}// TODO: add sorting
// Sorting makes sure if one month (or abbr) is a prefix of another
// see sorting in computeMonthsParse
for (i = 0; i < 12; i++) {// make the regex if we don't have it alreadymom = createUTC([2000, i]);if (strict && !this._longMonthsParse[i]) {this._longMonthsParse[i] = new RegExp('^' + this.months(mom, '').replace('.', '') + '$', 'i');this._shortMonthsParse[i] = new RegExp('^' + this.monthsShort(mom, '').replace('.', '') + '$', 'i');}if (!strict && !this._monthsParse[i]) {regex = '^' + this.months(mom, '') + '|^' + this.monthsShort(mom, '');this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i');}// test the regexif (strict && format === 'MMMM' && this._longMonthsParse[i].test(monthName)) {return i;} else if (strict && format === 'MMM' && this._shortMonthsParse[i].test(monthName)) {return i;} else if (!strict && this._monthsParse[i].test(monthName)) {return i;}
}

}

// MOMENTS

function setMonth (mom, value) {
var dayOfMonth;

if (!mom.isValid()) {// No opreturn mom;
}if (typeof value === 'string') {if (/^\d+$/.test(value)) {value = toInt(value);} else {value = mom.localeData().monthsParse(value);// TODO: Another silent failure?if (!isNumber(value)) {return mom;}}
}dayOfMonth = Math.min(mom.date(), daysInMonth(mom.year(), value));
mom._d['set' + (mom._isUTC ? 'UTC' : '') + 'Month'](value, dayOfMonth);
return mom;

}

function getSetMonth (value) {
if (value != null) {
setMonth(this, value);
hooks.updateOffset(this, true);
return this;
} else {
return get(this, ‘Month’);
}
}

function getDaysInMonth () {
return daysInMonth(this.year(), this.month());
}

function computeMonthsParse () {
function cmpLenRev(a, b) {
return b.length - a.length;
}

var shortPieces = [], longPieces = [], mixedPieces = [],i, mom;
for (i = 0; i < 12; i++) {// make the regex if we don't have it alreadymom = createUTC([2000, i]);shortPieces.push(this.monthsShort(mom, ''));longPieces.push(this.months(mom, ''));mixedPieces.push(this.months(mom, ''));mixedPieces.push(this.monthsShort(mom, ''));
}
// Sorting makes sure if one month (or abbr) is a prefix of another it
// will match the longer piece.
shortPieces.sort(cmpLenRev);
longPieces.sort(cmpLenRev);
mixedPieces.sort(cmpLenRev);
for (i = 0; i < 12; i++) {shortPieces[i] = regexEscape(shortPieces[i]);longPieces[i] = regexEscape(longPieces[i]);
}
for (i = 0; i < 24; i++) {mixedPieces[i] = regexEscape(mixedPieces[i]);
}this._monthsRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
this._monthsShortRegex = this._monthsRegex;
this._monthsStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i');
this._monthsShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i');

}

function createDate (y, m, d, h, M, s, ms) {
// can’t just apply() to create a date:
// https://stackoverflow.com/q/181348
var date = new Date(y, m, d, h, M, s, ms);

// the date constructor remaps years 0-99 to 1900-1999
if (y < 100 && y >= 0 && isFinite(date.getFullYear())) {date.setFullYear(y);
}
return date;

}

function createUTCDate (y) {
var date = new Date(Date.UTC.apply(null, arguments));

// the Date.UTC function remaps years 0-99 to 1900-1999
if (y < 100 && y >= 0 && isFinite(date.getUTCFullYear())) {date.setUTCFullYear(y);
}
return date;

}

// start-of-first-week - start-of-year
function firstWeekOffset(year, dow, doy) {
var // first-week day – which january is always in the first week (4 for iso, 1 for other)
fwd = 7 + dow - doy,
// first-week day local weekday – which local weekday is fwd
fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7;

return -fwdlw + fwd - 1;

}

// https://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday
function dayOfYearFromWeeks(year, week, weekday, dow, doy) {
var localWeekday = (7 + weekday - dow) % 7,
weekOffset = firstWeekOffset(year, dow, doy),
dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset,
resYear, resDayOfYear;

if (dayOfYear <= 0) {resYear = year - 1;resDayOfYear = daysInYear(resYear) + dayOfYear;
} else if (dayOfYear > daysInYear(year)) {resYear = year + 1;resDayOfYear = dayOfYear - daysInYear(year);
} else {resYear = year;resDayOfYear = dayOfYear;
}return {year: resYear,dayOfYear: resDayOfYear
};

}

function weekOfYear(mom, dow, doy) {
var weekOffset = firstWeekOffset(mom.year(), dow, doy),
week = Math.floor((mom.dayOfYear() - weekOffset - 1) / 7) + 1,
resWeek, resYear;

if (week < 1) {resYear = mom.year() - 1;resWeek = week + weeksInYear(resYear, dow, doy);
} else if (week > weeksInYear(mom.year(), dow, doy)) {resWeek = week - weeksInYear(mom.year(), dow, doy);resYear = mom.year() + 1;
} else {resYear = mom.year();resWeek = week;
}return {week: resWeek,year: resYear
};

}

function weeksInYear(year, dow, doy) {
var weekOffset = firstWeekOffset(year, dow, doy),
weekOffsetNext = firstWeekOffset(year + 1, dow, doy);
return (daysInYear(year) - weekOffset + weekOffsetNext) / 7;
}

// FORMATTING

addFormatToken(‘w’, [‘ww’, 2], ‘wo’, ‘week’);
addFormatToken(‘W’, [‘WW’, 2], ‘Wo’, ‘isoWeek’);

// ALIASES

addUnitAlias(‘week’, ‘w’);
addUnitAlias(‘isoWeek’, ‘W’);

// PRIORITIES

addUnitPriority(‘week’, 5);
addUnitPriority(‘isoWeek’, 5);

// PARSING

addRegexToken(‘w’, match1to2);
addRegexToken(‘ww’, match1to2, match2);
addRegexToken(‘W’, match1to2);
addRegexToken(‘WW’, match1to2, match2);

addWeekParseToken([‘w’, ‘ww’, ‘W’, ‘WW’], function (input, week, config, token) {
week[token.substr(0, 1)] = toInt(input);
});

// HELPERS

// LOCALES

function localeWeek (mom) {
return weekOfYear(mom, this._week.dow, this._week.doy).week;
}

var defaultLocaleWeek = {
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.
};

function localeFirstDayOfWeek () {
return this._week.dow;
}

function localeFirstDayOfYear () {
return this._week.doy;
}

// MOMENTS

function getSetWeek (input) {
var week = this.localeData().week(this);
return input == null ? week : this.add((input - week) * 7, ‘d’);
}

function getSetISOWeek (input) {
var week = weekOfYear(this, 1, 4).week;
return input == null ? week : this.add((input - week) * 7, ‘d’);
}

// FORMATTING

addFormatToken(‘d’, 0, ‘do’, ‘day’);

addFormatToken(‘dd’, 0, 0, function (format) {
return this.localeData().weekdaysMin(this, format);
});

addFormatToken(‘ddd’, 0, 0, function (format) {
return this.localeData().weekdaysShort(this, format);
});

addFormatToken(‘dddd’, 0, 0, function (format) {
return this.localeData().weekdays(this, format);
});

addFormatToken(‘e’, 0, 0, ‘weekday’);
addFormatToken(‘E’, 0, 0, ‘isoWeekday’);

// ALIASES

addUnitAlias(‘day’, ‘d’);
addUnitAlias(‘weekday’, ‘e’);
addUnitAlias(‘isoWeekday’, ‘E’);

// PRIORITY
addUnitPriority(‘day’, 11);
addUnitPriority(‘weekday’, 11);
addUnitPriority(‘isoWeekday’, 11);

// PARSING

addRegexToken(‘d’, match1to2);
addRegexToken(‘e’, match1to2);
addRegexToken(‘E’, match1to2);
addRegexToken(‘dd’, function (isStrict, locale) {
return locale.weekdaysMinRegex(isStrict);
});
addRegexToken(‘ddd’, function (isStrict, locale) {
return locale.weekdaysShortRegex(isStrict);
});
addRegexToken(‘dddd’, function (isStrict, locale) {
return locale.weekdaysRegex(isStrict);
});

addWeekParseToken([‘dd’, ‘ddd’, ‘dddd’], function (input, week, config, token) {
var weekday = config._locale.weekdaysParse(input, token, config._strict);
// if we didn’t get a weekday name, mark the date as invalid
if (weekday != null) {
week.d = weekday;
} else {
getParsingFlags(config).invalidWeekday = input;
}
});

addWeekParseToken([‘d’, ‘e’, ‘E’], function (input, week, config, token) {
week[token] = toInt(input);
});

// HELPERS

function parseWeekday(input, locale) {
if (typeof input !== ‘string’) {
return input;
}

if (!isNaN(input)) {return parseInt(input, 10);
}input = locale.weekdaysParse(input);
if (typeof input === 'number') {return input;
}return null;

}

function parseIsoWeekday(input, locale) {
if (typeof input === ‘string’) {
return locale.weekdaysParse(input) % 7 || 7;
}
return isNaN(input) ? null : input;
}

// LOCALES

var defaultLocaleWeekdays = ‘Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday’.split(‘_’);
function localeWeekdays (m, format) {
if (!m) {
return isArray(this._weekdays) ? this._weekdays :
this._weekdays[‘standalone’];
}
return isArray(this._weekdays) ? this._weekdays[m.day()] :
this._weekdays[this._weekdays.isFormat.test(format) ? ‘format’ : ‘standalone’][m.day()];
}

var defaultLocaleWeekdaysShort = ‘Sun_Mon_Tue_Wed_Thu_Fri_Sat’.split(‘_’);
function localeWeekdaysShort (m) {
return (m) ? this._weekdaysShort[m.day()] : this._weekdaysShort;
}

var defaultLocaleWeekdaysMin = ‘Su_Mo_Tu_We_Th_Fr_Sa’.split(‘_’);
function localeWeekdaysMin (m) {
return (m) ? this._weekdaysMin[m.day()] : this._weekdaysMin;
}

function handleStrictParse$1(weekdayName, format, strict) {
var i, ii, mom, llc = weekdayName.toLocaleLowerCase();
if (!this._weekdaysParse) {
this._weekdaysParse = [];
this._shortWeekdaysParse = [];
this._minWeekdaysParse = [];

    for (i = 0; i < 7; ++i) {mom = createUTC([2000, 1]).day(i);this._minWeekdaysParse[i] = this.weekdaysMin(mom, '').toLocaleLowerCase();this._shortWeekdaysParse[i] = this.weekdaysShort(mom, '').toLocaleLowerCase();this._weekdaysParse[i] = this.weekdays(mom, '').toLocaleLowerCase();}
}if (strict) {if (format === 'dddd') {ii = indexOf.call(this._weekdaysParse, llc);return ii !== -1 ? ii : null;} else if (format === 'ddd') {ii = indexOf.call(this._shortWeekdaysParse, llc);return ii !== -1 ? ii : null;} else {ii = indexOf.call(this._minWeekdaysParse, llc);return ii !== -1 ? ii : null;}
} else {if (format === 'dddd') {ii = indexOf.call(this._weekdaysParse, llc);if (ii !== -1) {return ii;}ii = indexOf.call(this._shortWeekdaysParse, llc);if (ii !== -1) {return ii;}ii = indexOf.call(this._minWeekdaysParse, llc);return ii !== -1 ? ii : null;} else if (format === 'ddd') {ii = indexOf.call(this._shortWeekdaysParse, llc);if (ii !== -1) {return ii;}ii = indexOf.call(this._weekdaysParse, llc);if (ii !== -1) {return ii;}ii = indexOf.call(this._minWeekdaysParse, llc);return ii !== -1 ? ii : null;} else {ii = indexOf.call(this._minWeekdaysParse, llc);if (ii !== -1) {return ii;}ii = indexOf.call(this._weekdaysParse, llc);if (ii !== -1) {return ii;}ii = indexOf.call(this._shortWeekdaysParse, llc);return ii !== -1 ? ii : null;}
}

}

function localeWeekdaysParse (weekdayName, format, strict) {
var i, mom, regex;

if (this._weekdaysParseExact) {return handleStrictParse$1.call(this, weekdayName, format, strict);
}if (!this._weekdaysParse) {this._weekdaysParse = [];this._minWeekdaysParse = [];this._shortWeekdaysParse = [];this._fullWeekdaysParse = [];
}for (i = 0; i < 7; i++) {// make the regex if we don't have it alreadymom = createUTC([2000, 1]).day(i);if (strict && !this._fullWeekdaysParse[i]) {this._fullWeekdaysParse[i] = new RegExp('^' + this.weekdays(mom, '').replace('.', '\.?') + '$', 'i');this._shortWeekdaysParse[i] = new RegExp('^' + this.weekdaysShort(mom, '').replace('.', '\.?') + '$', 'i');this._minWeekdaysParse[i] = new RegExp('^' + this.weekdaysMin(mom, '').replace('.', '\.?') + '$', 'i');}if (!this._weekdaysParse[i]) {regex = '^' + this.weekdays(mom, '') + '|^' + this.weekdaysShort(mom, '') + '|^' + this.weekdaysMin(mom, '');this._weekdaysParse[i] = new RegExp(regex.replace('.', ''), 'i');}// test the regexif (strict && format === 'dddd' && this._fullWeekdaysParse[i].test(weekdayName)) {return i;} else if (strict && format === 'ddd' && this._shortWeekdaysParse[i].test(weekdayName)) {return i;} else if (strict && format === 'dd' && this._minWeekdaysParse[i].test(weekdayName)) {return i;} else if (!strict && this._weekdaysParse[i].test(weekdayName)) {return i;}
}

}

// MOMENTS

function getSetLocaleDayOfWeek (input) {
if (!this.isValid()) {
return input != null ? this : NaN;
}
var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7;
return input == null ? weekday : this.add(input - weekday, ‘d’);
}

function getSetISODayOfWeek (input) {
if (!this.isValid()) {
return input != null ? this : NaN;
}

// 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.if (input != null) {var weekday = parseIsoWeekday(input, this.localeData());return this.day(this.day() % 7 ? weekday : weekday - 7);
} else {return this.day() || 7;
}

}

function computeWeekdaysParse () {
function cmpLenRev(a, b) {
return b.length - a.length;
}

var minPieces = [], shortPieces = [], longPieces = [], mixedPieces = [],i, mom, minp, shortp, longp;
for (i = 0; i < 7; i++) {// make the regex if we don't have it alreadymom = createUTC([2000, 1]).day(i);minp = this.weekdaysMin(mom, '');shortp = this.weekdaysShort(mom, '');longp = this.weekdays(mom, '');minPieces.push(minp);shortPieces.push(shortp);longPieces.push(longp);mixedPieces.push(minp);mixedPieces.push(shortp);mixedPieces.push(longp);
}
// Sorting makes sure if one weekday (or abbr) is a prefix of another it
// will match the longer piece.
minPieces.sort(cmpLenRev);
shortPieces.sort(cmpLenRev);
longPieces.sort(cmpLenRev);
mixedPieces.sort(cmpLenRev);
for (i = 0; i < 7; i++) {shortPieces[i] = regexEscape(shortPieces[i]);longPieces[i] = regexEscape(longPieces[i]);mixedPieces[i] = regexEscape(mixedPieces[i]);
}this._weekdaysRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
this._weekdaysShortRegex = this._weekdaysRegex;
this._weekdaysMinRegex = this._weekdaysRegex;this._weekdaysStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i');
this._weekdaysShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i');
this._weekdaysMinStrictRegex = new RegExp('^(' + minPieces.join('|') + ')', 'i');

}

// FORMATTING

function hFormat() {
return this.hours() % 12 || 12;
}

function kFormat() {
return this.hours() || 24;
}

addFormatToken(‘H’, [‘HH’, 2], 0, ‘hour’);
addFormatToken(‘h’, [‘hh’, 2], 0, hFormat);
addFormatToken(‘k’, [‘kk’, 2], 0, kFormat);

addFormatToken(‘hmm’, 0, 0, function () {
return ‘’ + hFormat.apply(this) + zeroFill(this.minutes(), 2);
});

addFormatToken(‘hmmss’, 0, 0, function () {
return ‘’ + hFormat.apply(this) + zeroFill(this.minutes(), 2) +
zeroFill(this.seconds(), 2);
});

addFormatToken(‘Hmm’, 0, 0, function () {
return ‘’ + this.hours() + zeroFill(this.minutes(), 2);
});

addFormatToken(‘Hmmss’, 0, 0, function () {
return ‘’ + this.hours() + zeroFill(this.minutes(), 2) +
zeroFill(this.seconds(), 2);
});

function meridiem (token, lowercase) {
addFormatToken(token, 0, 0, function () {
return this.localeData().meridiem(this.hours(), this.minutes(), lowercase);
});
}

meridiem(‘a’, true);
meridiem(‘A’, false);

// ALIASES

addUnitAlias(‘hour’, ‘h’);

// PRIORITY
addUnitPriority(‘hour’, 13);

// PARSING

function matchMeridiem (isStrict, locale) {
return locale._meridiemParse;
}

addRegexToken(‘a’, matchMeridiem);
addRegexToken(‘A’, matchMeridiem);
addRegexToken(‘H’, match1to2);
addRegexToken(‘h’, match1to2);
addRegexToken(‘k’, match1to2);
addRegexToken(‘HH’, match1to2, match2);
addRegexToken(‘hh’, match1to2, match2);
addRegexToken(‘kk’, match1to2, match2);

addRegexToken(‘hmm’, match3to4);
addRegexToken(‘hmmss’, match5to6);
addRegexToken(‘Hmm’, match3to4);
addRegexToken(‘Hmmss’, match5to6);

addParseToken([‘H’, ‘HH’], HOUR);
addParseToken([‘k’, ‘kk’], function (input, array, config) {
var kInput = toInt(input);
array[HOUR] = kInput === 24 ? 0 : kInput;
});
addParseToken([‘a’, ‘A’], function (input, array, config) {
config._isPm = config._locale.isPM(input);
config._meridiem = input;
});
addParseToken([‘h’, ‘hh’], function (input, array, config) {
array[HOUR] = toInt(input);
getParsingFlags(config).bigHour = true;
});
addParseToken(‘hmm’, function (input, array, config) {
var pos = input.length - 2;
array[HOUR] = toInt(input.substr(0, pos));
array[MINUTE] = toInt(input.substr(pos));
getParsingFlags(config).bigHour = true;
});
addParseToken(‘hmmss’, function (input, array, config) {
var pos1 = input.length - 4;
var pos2 = input.length - 2;
array[HOUR] = toInt(input.substr(0, pos1));
array[MINUTE] = toInt(input.substr(pos1, 2));
array[SECOND] = toInt(input.substr(pos2));
getParsingFlags(config).bigHour = true;
});
addParseToken(‘Hmm’, function (input, array, config) {
var pos = input.length - 2;
array[HOUR] = toInt(input.substr(0, pos));
array[MINUTE] = toInt(input.substr(pos));
});
addParseToken(‘Hmmss’, function (input, array, config) {
var pos1 = input.length - 4;
var pos2 = input.length - 2;
array[HOUR] = toInt(input.substr(0, pos1));
array[MINUTE] = toInt(input.substr(pos1, 2));
array[SECOND] = toInt(input.substr(pos2));
});

// LOCALES

function localeIsPM (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’);
}

// MOMENTS

// 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.
var getSetHour = makeGetSet(‘Hours’, true);

// months
// week
// weekdays
// meridiem
var baseConfig = {
calendar: defaultCalendar,
longDateFormat: defaultLongDateFormat,
invalidDate: defaultInvalidDate,
ordinal: defaultOrdinal,
dayOfMonthOrdinalParse: defaultDayOfMonthOrdinalParse,
relativeTime: defaultRelativeTime,

months: defaultLocaleMonths,
monthsShort: defaultLocaleMonthsShort,week: defaultLocaleWeek,weekdays: defaultLocaleWeekdays,
weekdaysMin: defaultLocaleWeekdaysMin,
weekdaysShort: defaultLocaleWeekdaysShort,meridiemParse: defaultLocaleMeridiemParse

};

// internal storage for locale config files
var locales = {};
var localeFamilies = {};
var globalLocale;

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 onebreak;}j--;}i++;
}
return null;

}

// 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.
function getSetGlobalLocale (key, values) {
var data;
if (key) {
if (isUndefined(values)) {
data = getLocale(key);
}
else {
data = defineLocale(key, values);
}

    if (data) {// moment.duration._locale = moment._locale = data;globalLocale = data;}
}return globalLocale._abbr;

}

    if (localeFamilies[name]) {localeFamilies[name].forEach(function (x) {defineLocale(x.name, x.config);});}// backwards compat for now: also set the locale// make sure we set the locale AFTER all child locales have been// created, so we won't end up with the child locale set.getSetGlobalLocale(name);return locales[name];
} else {// useful for testingdelete locales[name];return null;
}

}

function updateLocale(name, config) {
if (config != null) {
var locale, tmpLocale, parentConfig = baseConfig;
// MERGE
tmpLocale = loadLocale(name);
if (tmpLocale != null) {
parentConfig = tmpLocale._config;
}
config = mergeConfigs(parentConfig, config);
locale = new Locale(config);
locale.parentLocale = locales[name];
locales[name] = locale;

    // backwards compat for now: also set the localegetSetGlobalLocale(name);
} else {// pass null for config to unupdate, useful for testsif (locales[name] != null) {if (locales[name].parentLocale != null) {locales[name] = locales[name].parentLocale;} else if (locales[name] != null) {delete locales[name];}}
}
return locales[name];

}

// returns locale data
function getLocale (key) {
var locale;

if (key && key._locale && key._locale._abbr) {key = key._locale._abbr;
}if (!key) {return globalLocale;
}if (!isArray(key)) {//short-circuit everything elselocale = loadLocale(key);if (locale) {return locale;}key = [key];
}return chooseLocale(key);

}

function listLocales() {
return keys(locales);
}

function checkOverflow (m) {
var overflow;
var a = m._a;

if (a && getParsingFlags(m).overflow === -2) {overflow =a[MONTH]       < 0 || a[MONTH]       > 11  ? MONTH :a[DATE]        < 1 || a[DATE]        > daysInMonth(a[YEAR], a[MONTH]) ? DATE :a[HOUR]        < 0 || a[HOUR]        > 24 || (a[HOUR] === 24 && (a[MINUTE] !== 0 || a[SECOND] !== 0 || a[MILLISECOND] !== 0)) ? HOUR :a[MINUTE]      < 0 || a[MINUTE]      > 59  ? MINUTE :a[SECOND]      < 0 || a[SECOND]      > 59  ? SECOND :a[MILLISECOND] < 0 || a[MILLISECOND] > 999 ? MILLISECOND :-1;if (getParsingFlags(m)._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) {overflow = DATE;}if (getParsingFlags(m)._overflowWeeks && overflow === -1) {overflow = WEEK;}if (getParsingFlags(m)._overflowWeekday && overflow === -1) {overflow = WEEKDAY;}getParsingFlags(m).overflow = overflow;
}return m;

}

// Pick the first defined of two or three arguments.
function defaults(a, b, c) {
if (a != null) {
return a;
}
if (b != null) {
return b;
}
return c;
}

function currentDateArray(config) {
// hooks is actually the exported moment object
var nowValue = new Date(hooks.now());
if (config._useUTC) {
return [nowValue.getUTCFullYear(), nowValue.getUTCMonth(), nowValue.getUTCDate()];
}
return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()];
}

// 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 configFromArray (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 != null) {yearToUse = defaults(config._a[YEAR], currentDate[YEAR]);if (config._dayOfYear > daysInYear(yearToUse) || config._dayOfYear === 0) {getParsingFlags(config)._overflowDayOfYear = true;}date = createUTCDate(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];
}// Check for 24:00:00.000
if (config._a[HOUR] === 24 &&config._a[MINUTE] === 0 &&config._a[SECOND] === 0 &&config._a[MILLISECOND] === 0) {config._nextDay = true;config._a[HOUR] = 0;
}config._d = (config._useUTC ? createUTCDate : createDate).apply(null, input);
// Apply timezone offset from input. The actual utcOffset can be changed
// with parseZone.
if (config._tzm != null) {config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
}if (config._nextDay) {config._a[HOUR] = 24;
}// check for mismatching day of week
if (config._w && typeof config._w.d !== 'undefined' && config._w.d !== config._d.getDay()) {getParsingFlags(config).weekdayMismatch = true;
}

}

function dayOfYearFromWeekInfo(config) {
var w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow;

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 = defaults(w.GG, config._a[YEAR], weekOfYear(createLocal(), 1, 4).year);week = defaults(w.W, 1);weekday = defaults(w.E, 1);if (weekday < 1 || weekday > 7) {weekdayOverflow = true;}
} else {dow = config._locale._week.dow;doy = config._locale._week.doy;var curWeek = weekOfYear(createLocal(), dow, doy);weekYear = defaults(w.gg, config._a[YEAR], curWeek.year);// Default to current week.week = defaults(w.w, curWeek.week);if (w.d != null) {// weekday -- low day numbers are considered next weekweekday = w.d;if (weekday < 0 || weekday > 6) {weekdayOverflow = true;}} else if (w.e != null) {// local weekday -- counting starts from begining of weekweekday = w.e + dow;if (w.e < 0 || w.e > 6) {weekdayOverflow = true;}} else {// default to begining of weekweekday = dow;}
}
if (week < 1 || week > weeksInYear(weekYear, dow, doy)) {getParsingFlags(config)._overflowWeeks = true;
} else if (weekdayOverflow != null) {getParsingFlags(config)._overflowWeekday = true;
} else {temp = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy);config._a[YEAR] = temp.year;config._dayOfYear = temp.dayOfYear;
}

}

// 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)
var extendedIsoRegex = /^\s*((?:[±]\d{6}|\d{4})-(?:\d\d-\d\d|W\d\d-\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?::\d\d(?::\d\d(?:[.,]\d+)?)?)?)([±]\d\d(?::?\d\d)?|\s*Z)?)?KaTeX parse error: Undefined control sequence: \s at position 26: …icIsoRegex = /^\̲s̲*((?:[+-]\d{6}|…/;

var tzRegex = /Z|[±]\d\d(?::?\d\d)?/;

var isoDates = [
[‘YYYYYY-MM-DD’, /[±]\d{6}-\d\d-\d\d/],
[‘YYYY-MM-DD’, /\d{4}-\d\d-\d\d/],
[‘GGGG-[W]WW-E’, /\d{4}-W\d\d-\d/],
[‘GGGG-[W]WW’, /\d{4}-W\d\d/, false],
[‘YYYY-DDD’, /\d{4}-\d{3}/],
[‘YYYY-MM’, /\d{4}-\d\d/, false],
[‘YYYYYYMMDD’, /[±]\d{10}/],
[‘YYYYMMDD’, /\d{8}/],
// YYYYMM is NOT allowed by the standard
[‘GGGG[W]WWE’, /\d{4}W\d{3}/],
[‘GGGG[W]WW’, /\d{4}W\d{2}/, false],
[‘YYYYDDD’, /\d{7}/]
];

// iso time formats and regexes
var isoTimes = [
[‘HH:mm:ss.SSSS’, /\d\d:\d\d:\d\d.\d+/],
[‘HH:mm:ss,SSSS’, /\d\d:\d\d:\d\d,\d+/],
[‘HH:mm:ss’, /\d\d:\d\d:\d\d/],
[‘HH:mm’, /\d\d:\d\d/],
[‘HHmmss.SSSS’, /\d\d\d\d\d\d.\d+/],
[‘HHmmss,SSSS’, /\d\d\d\d\d\d,\d+/],
[‘HHmmss’, /\d\d\d\d\d\d/],
[‘HHmm’, /\d\d\d\d/],
[‘HH’, /\d\d/]
];

var aspNetJsonRegex = /^/?Date((-?\d+)/i;

// date from iso format
function configFromISO(config) {
var i, l,
string = config._i,
match = extendedIsoRegex.exec(string) || basicIsoRegex.exec(string),
allowTime, dateFormat, timeFormat, tzFormat;

if (match) {getParsingFlags(config).iso = true;for (i = 0, l = isoDates.length; i < l; i++) {if (isoDates[i][1].exec(match[1])) {dateFormat = isoDates[i][0];allowTime = isoDates[i][2] !== false;break;}}if (dateFormat == null) {config._isValid = false;return;}if (match[3]) {for (i = 0, l = isoTimes.length; i < l; i++) {if (isoTimes[i][1].exec(match[3])) {// match[2] should be 'T' or spacetimeFormat = (match[2] || ' ') + isoTimes[i][0];break;}}if (timeFormat == null) {config._isValid = false;return;}}if (!allowTime && timeFormat != null) {config._isValid = false;return;}if (match[4]) {if (tzRegex.exec(match[4])) {tzFormat = 'Z';} else {config._isValid = false;return;}}config._f = dateFormat + (timeFormat || '') + (tzFormat || '');configFromStringAndFormat(config);
} else {config._isValid = false;
}

}

// RFC 2822 regex: For details see https://tools.ietf.org/html/rfc2822#section-3.3
var rfc2822 = /^(?:(Mon|Tue|Wed|Thu|Fri|Sat|Sun),?\s)?(\d{1,2})\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(\d{2,4})\s(\d\d)

NetSuite2.0 Restlet脚本时间初始化脚本相关推荐

NetSuite2.0 Restlet脚本货品新增
/** @NApiVersion 2.x @NScriptType Restlet */ define(['N/log', 'N/record'], function (log, record) { ...
Linux Shell脚本专栏_服务器系统配置初始化脚本_01
文章目录一.服务器系统配置初始化 1. 设置时区并同步时间 ① 脚本编写 ②脚本说明 2. 禁用selinux ① 脚本编写 ②脚本说明 3. 关闭防火墙 ① 脚本编写 ②脚本说明 4. 历史命令显 ...
Centos 7初始化脚本
今天跟大家分享一个我自己写的Linux初始化脚本,自认为写的不是很好.希望看到这篇文章的你,能暂时停留下你的脚步,给些修改意见,或者有什么需要补充的地方都可以提出来,大家共同进步,谢谢! 此脚本主要功 ...
centos6——初始化脚本
服务器centos6初始化脚本,包含几个方面: 修改主机名添加用户秘钥 ssh 端口修改 ulimit值修改防火墙修改添加追踪日志时间同步安装一些基础软件包 nagios客户端安装 zabb ...
zabbix1.8和2.0版本通用的安装脚本
用zabbix监控服务器2年多了,早就写好了服务器端的安装部署脚本,现在拿出来和大家分享一下.zabbix1.8和2.0版本通用的安装脚本,默认的为1.8.9的版本,大家要是想安装2.0以上的版本,只 ...
Swift2.0语言教程之下标脚本
Swift2.0语言教程之下标脚本下标脚本下标脚本是访问对象.集合或者序列的快速方式.开发者不需要调用实例特定的赋值和访问方法,就可以直接访问所需要的数值.例如在数组中,可以直接使用下标去访问或者 ...
【ijkplayer】编译 Android 版本的 ijkplayer ② ( 切换到 k0.8.8 分支 | 执行 init-android.sh 脚本进行初始化操作 )
文章目录一.进入 ijkplayer-android 目录二.切换到 k0.8.8 分支三.执行 init-android.sh 脚本进行初始化操作参考 https://github.com/ ...
s5.CentOS、Ubuntu、Rocky Linux系统初始化脚本
CentOS.Ubuntu.Rocky Linux系统初始化脚本 Shell脚本源码地址 Gitee:https://gitee.com/raymond9/shell Github:https://g ...
linux 账户初始化脚本,linux 系统初始化脚本
服务器初始化脚本,可以参考一下. #!/bin/env bash exportPATH=$PATH:/bin:/sbin:/usr/sbin # Require root to run thisscr ...

NetSuite2.0 Restlet脚本时间初始化脚本

NetSuite2.0 Restlet脚本时间初始化脚本相关推荐

最新文章

热门文章

NetSuite2.0 Restlet脚本 时间初始化脚本

NetSuite2.0 Restlet脚本 时间初始化脚本相关推荐

最新文章

热门文章

NetSuite2.0 Restlet脚本时间初始化脚本

NetSuite2.0 Restlet脚本时间初始化脚本相关推荐