mirror of
https://github.com/RaidMax/IW4M-Admin.git
synced 2025-06-10 23:31:13 -05:00
added moment for parsing dates in profile timeline
fixed bug of duplicate penalties fixed showing timeline date for non events refresh player count on server overview fix refresh privileged users on map load fix 1h showing on tempban if manually specified
This commit is contained in:
RaidMax
@ -0,0 +1,34 @@
|
||||
import { daysInMonth } from '../units/month';
|
||||
import { YEAR, MONTH, DATE, HOUR, MINUTE, SECOND, MILLISECOND, WEEK, WEEKDAY } from '../units/constants';
|
||||
import getParsingFlags from '../create/parsing-flags';
|
||||
|
||||
export default 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;
|
||||
}
|
||||
|
||||
@ -0,0 +1,21 @@
|
||||
export 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;
|
||||
}
|
||||
|
||||
export 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;
|
||||
}
|
||||
110
WebfrontCore/wwwroot/lib/moment/src/lib/create/from-anything.js
Normal file
110
WebfrontCore/wwwroot/lib/moment/src/lib/create/from-anything.js
Normal file
@ -0,0 +1,110 @@
|
||||
import isArray from '../utils/is-array';
|
||||
import isObject from '../utils/is-object';
|
||||
import isObjectEmpty from '../utils/is-object-empty';
|
||||
import isUndefined from '../utils/is-undefined';
|
||||
import isNumber from '../utils/is-number';
|
||||
import isDate from '../utils/is-date';
|
||||
import map from '../utils/map';
|
||||
import { createInvalid } from './valid';
|
||||
import { Moment, isMoment } from '../moment/constructor';
|
||||
import { getLocale } from '../locale/locales';
|
||||
import { hooks } from '../utils/hooks';
|
||||
import checkOverflow from './check-overflow';
|
||||
import { isValid } from './valid';
|
||||
|
||||
import { configFromStringAndArray } from './from-string-and-array';
|
||||
import { configFromStringAndFormat } from './from-string-and-format';
|
||||
import { configFromString } from './from-string';
|
||||
import { configFromArray } from './from-array';
|
||||
import { configFromObject } from './from-object';
|
||||
|
||||
function createFromConfig (config) {
|
||||
var res = new Moment(checkOverflow(prepareConfig(config)));
|
||||
if (res._nextDay) {
|
||||
// Adding is smart enough around DST
|
||||
res.add(1, 'd');
|
||||
res._nextDay = undefined;
|
||||
}
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
export function prepareConfig (config) {
|
||||
var input = config._i,
|
||||
format = config._f;
|
||||
|
||||
config._locale = config._locale || getLocale(config._l);
|
||||
|
||||
if (input === null || (format === undefined && input === '')) {
|
||||
return createInvalid({nullInput: true});
|
||||
}
|
||||
|
||||
if (typeof input === 'string') {
|
||||
config._i = input = config._locale.preparse(input);
|
||||
}
|
||||
|
||||
if (isMoment(input)) {
|
||||
return new Moment(checkOverflow(input));
|
||||
} else if (isDate(input)) {
|
||||
config._d = input;
|
||||
} else if (isArray(format)) {
|
||||
configFromStringAndArray(config);
|
||||
} else if (format) {
|
||||
configFromStringAndFormat(config);
|
||||
} else {
|
||||
configFromInput(config);
|
||||
}
|
||||
|
||||
if (!isValid(config)) {
|
||||
config._d = null;
|
||||
}
|
||||
|
||||
return config;
|
||||
}
|
||||
|
||||
function configFromInput(config) {
|
||||
var input = config._i;
|
||||
if (isUndefined(input)) {
|
||||
config._d = new Date(hooks.now());
|
||||
} else if (isDate(input)) {
|
||||
config._d = new Date(input.valueOf());
|
||||
} else if (typeof input === 'string') {
|
||||
configFromString(config);
|
||||
} else if (isArray(input)) {
|
||||
config._a = map(input.slice(0), function (obj) {
|
||||
return parseInt(obj, 10);
|
||||
});
|
||||
configFromArray(config);
|
||||
} else if (isObject(input)) {
|
||||
configFromObject(config);
|
||||
} else if (isNumber(input)) {
|
||||
// from milliseconds
|
||||
config._d = new Date(input);
|
||||
} else {
|
||||
hooks.createFromInputFallback(config);
|
||||
}
|
||||
}
|
||||
|
||||
export function createLocalOrUTC (input, format, locale, strict, isUTC) {
|
||||
var c = {};
|
||||
|
||||
if (locale === true || locale === false) {
|
||||
strict = locale;
|
||||
locale = undefined;
|
||||
}
|
||||
|
||||
if ((isObject(input) && isObjectEmpty(input)) ||
|
||||
(isArray(input) && input.length === 0)) {
|
||||
input = undefined;
|
||||
}
|
||||
// object construction must be done this way.
|
||||
// https://github.com/moment/moment/issues/1423
|
||||
c._isAMomentObject = true;
|
||||
c._useUTC = c._isUTC = isUTC;
|
||||
c._l = locale;
|
||||
c._i = input;
|
||||
c._f = format;
|
||||
c._strict = strict;
|
||||
|
||||
return createFromConfig(c);
|
||||
}
|
||||
147
WebfrontCore/wwwroot/lib/moment/src/lib/create/from-array.js
Normal file
147
WebfrontCore/wwwroot/lib/moment/src/lib/create/from-array.js
Normal file
@ -0,0 +1,147 @@
|
||||
import { hooks } from '../utils/hooks';
|
||||
import { createDate, createUTCDate } from './date-from-array';
|
||||
import { daysInYear } from '../units/year';
|
||||
import { weekOfYear, weeksInYear, dayOfYearFromWeeks } from '../units/week-calendar-utils';
|
||||
import { YEAR, MONTH, DATE, HOUR, MINUTE, SECOND, MILLISECOND } from '../units/constants';
|
||||
import { createLocal } from './local';
|
||||
import defaults from '../utils/defaults';
|
||||
import getParsingFlags from './parsing-flags';
|
||||
|
||||
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]
|
||||
export function configFromArray (config) {
|
||||
var i, date, input = [], currentDate, expectedWeekday, 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);
|
||||
expectedWeekday = config._useUTC ? config._d.getUTCDay() : config._d.getDay();
|
||||
|
||||
// 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 !== expectedWeekday) {
|
||||
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 week
|
||||
weekday = w.d;
|
||||
if (weekday < 0 || weekday > 6) {
|
||||
weekdayOverflow = true;
|
||||
}
|
||||
} else if (w.e != null) {
|
||||
// local weekday -- counting starts from begining of week
|
||||
weekday = w.e + dow;
|
||||
if (w.e < 0 || w.e > 6) {
|
||||
weekdayOverflow = true;
|
||||
}
|
||||
} else {
|
||||
// default to begining of week
|
||||
weekday = 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;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,16 @@
|
||||
import { normalizeObjectUnits } from '../units/aliases';
|
||||
import { configFromArray } from './from-array';
|
||||
import map from '../utils/map';
|
||||
|
||||
export function configFromObject(config) {
|
||||
if (config._d) {
|
||||
return;
|
||||
}
|
||||
|
||||
var i = normalizeObjectUnits(config._i);
|
||||
config._a = map([i.year, i.month, i.day || i.date, i.hour, i.minute, i.second, i.millisecond], function (obj) {
|
||||
return obj && parseInt(obj, 10);
|
||||
});
|
||||
|
||||
configFromArray(config);
|
||||
}
|
||||
@ -0,0 +1,50 @@
|
||||
import { copyConfig } from '../moment/constructor';
|
||||
import { configFromStringAndFormat } from './from-string-and-format';
|
||||
import getParsingFlags from './parsing-flags';
|
||||
import { isValid } from './valid';
|
||||
import extend from '../utils/extend';
|
||||
|
||||
// date from string and array of format strings
|
||||
export function configFromStringAndArray(config) {
|
||||
var tempConfig,
|
||||
bestMoment,
|
||||
|
||||
scoreToBeat,
|
||||
i,
|
||||
currentScore;
|
||||
|
||||
if (config._f.length === 0) {
|
||||
getParsingFlags(config).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._f = config._f[i];
|
||||
configFromStringAndFormat(tempConfig);
|
||||
|
||||
if (!isValid(tempConfig)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// if there is any input that was not parsed add a penalty for that format
|
||||
currentScore += getParsingFlags(tempConfig).charsLeftOver;
|
||||
|
||||
//or tokens
|
||||
currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10;
|
||||
|
||||
getParsingFlags(tempConfig).score = currentScore;
|
||||
|
||||
if (scoreToBeat == null || currentScore < scoreToBeat) {
|
||||
scoreToBeat = currentScore;
|
||||
bestMoment = tempConfig;
|
||||
}
|
||||
}
|
||||
|
||||
extend(config, bestMoment || tempConfig);
|
||||
}
|
||||
@ -0,0 +1,113 @@
|
||||
import { configFromISO, configFromRFC2822 } from './from-string';
|
||||
import { configFromArray } from './from-array';
|
||||
import { getParseRegexForToken } from '../parse/regex';
|
||||
import { addTimeToArrayFromToken } from '../parse/token';
|
||||
import { expandFormat, formatTokenFunctions, formattingTokens } from '../format/format';
|
||||
import checkOverflow from './check-overflow';
|
||||
import { HOUR } from '../units/constants';
|
||||
import { hooks } from '../utils/hooks';
|
||||
import getParsingFlags from './parsing-flags';
|
||||
|
||||
// constant that refers to the ISO standard
|
||||
hooks.ISO_8601 = function () {};
|
||||
|
||||
// constant that refers to the RFC 2822 form
|
||||
hooks.RFC_2822 = function () {};
|
||||
|
||||
// date from string and format string
|
||||
export function configFromStringAndFormat(config) {
|
||||
// TODO: Move this to another part of the creation flow to prevent circular deps
|
||||
if (config._f === hooks.ISO_8601) {
|
||||
configFromISO(config);
|
||||
return;
|
||||
}
|
||||
if (config._f === hooks.RFC_2822) {
|
||||
configFromRFC2822(config);
|
||||
return;
|
||||
}
|
||||
config._a = [];
|
||||
getParsingFlags(config).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];
|
||||
// console.log('token', token, 'parsedInput', parsedInput,
|
||||
// 'regex', getParseRegexForToken(token, config));
|
||||
if (parsedInput) {
|
||||
skipped = string.substr(0, string.indexOf(parsedInput));
|
||||
if (skipped.length > 0) {
|
||||
getParsingFlags(config).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) {
|
||||
getParsingFlags(config).empty = false;
|
||||
}
|
||||
else {
|
||||
getParsingFlags(config).unusedTokens.push(token);
|
||||
}
|
||||
addTimeToArrayFromToken(token, parsedInput, config);
|
||||
}
|
||||
else if (config._strict && !parsedInput) {
|
||||
getParsingFlags(config).unusedTokens.push(token);
|
||||
}
|
||||
}
|
||||
|
||||
// add remaining unparsed input length to the string
|
||||
getParsingFlags(config).charsLeftOver = stringLength - totalParsedInputLength;
|
||||
if (string.length > 0) {
|
||||
getParsingFlags(config).unusedInput.push(string);
|
||||
}
|
||||
|
||||
// clear _12h flag if hour is <= 12
|
||||
if (config._a[HOUR] <= 12 &&
|
||||
getParsingFlags(config).bigHour === true &&
|
||||
config._a[HOUR] > 0) {
|
||||
getParsingFlags(config).bigHour = undefined;
|
||||
}
|
||||
|
||||
getParsingFlags(config).parsedDateParts = config._a.slice(0);
|
||||
getParsingFlags(config).meridiem = config._meridiem;
|
||||
// handle meridiem
|
||||
config._a[HOUR] = meridiemFixWrap(config._locale, config._a[HOUR], config._meridiem);
|
||||
|
||||
configFromArray(config);
|
||||
checkOverflow(config);
|
||||
}
|
||||
|
||||
|
||||
function meridiemFixWrap (locale, hour, meridiem) {
|
||||
var isPm;
|
||||
|
||||
if (meridiem == null) {
|
||||
// nothing to do
|
||||
return hour;
|
||||
}
|
||||
if (locale.meridiemHour != null) {
|
||||
return locale.meridiemHour(hour, meridiem);
|
||||
} else if (locale.isPM != null) {
|
||||
// Fallback
|
||||
isPm = locale.isPM(meridiem);
|
||||
if (isPm && hour < 12) {
|
||||
hour += 12;
|
||||
}
|
||||
if (!isPm && hour === 12) {
|
||||
hour = 0;
|
||||
}
|
||||
return hour;
|
||||
} else {
|
||||
// this is not supposed to happen
|
||||
return hour;
|
||||
}
|
||||
}
|
||||
230
WebfrontCore/wwwroot/lib/moment/src/lib/create/from-string.js
Normal file
230
WebfrontCore/wwwroot/lib/moment/src/lib/create/from-string.js
Normal file
@ -0,0 +1,230 @@
|
||||
import { configFromStringAndFormat } from './from-string-and-format';
|
||||
import { createUTCDate } from './date-from-array';
|
||||
import { configFromArray } from './from-array';
|
||||
import { hooks } from '../utils/hooks';
|
||||
import { deprecate } from '../utils/deprecate';
|
||||
import getParsingFlags from './parsing-flags';
|
||||
import {defaultLocaleMonthsShort} from '../units/month';
|
||||
import {defaultLocaleWeekdaysShort} from '../units/day-of-week';
|
||||
|
||||
// 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)?)?$/;
|
||||
var basicIsoRegex = /^\s*((?:[+-]\d{6}|\d{4})(?:\d\d\d\d|W\d\d\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?:\d\d(?:\d\d(?:[.,]\d+)?)?)?)([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?$/;
|
||||
|
||||
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
|
||||
export 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 space
|
||||
timeFormat = (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):(\d\d)(?::(\d\d))?\s(?:(UT|GMT|[ECMP][SD]T)|([Zz])|([+-]\d{4}))$/;
|
||||
|
||||
function extractFromRFC2822Strings(yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr) {
|
||||
var result = [
|
||||
untruncateYear(yearStr),
|
||||
defaultLocaleMonthsShort.indexOf(monthStr),
|
||||
parseInt(dayStr, 10),
|
||||
parseInt(hourStr, 10),
|
||||
parseInt(minuteStr, 10)
|
||||
];
|
||||
|
||||
if (secondStr) {
|
||||
result.push(parseInt(secondStr, 10));
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
function untruncateYear(yearStr) {
|
||||
var year = parseInt(yearStr, 10);
|
||||
if (year <= 49) {
|
||||
return 2000 + year;
|
||||
} else if (year <= 999) {
|
||||
return 1900 + year;
|
||||
}
|
||||
return year;
|
||||
}
|
||||
|
||||
function preprocessRFC2822(s) {
|
||||
// Remove comments and folding whitespace and replace multiple-spaces with a single space
|
||||
return s.replace(/\([^)]*\)|[\n\t]/g, ' ').replace(/(\s\s+)/g, ' ').trim();
|
||||
}
|
||||
|
||||
function checkWeekday(weekdayStr, parsedInput, config) {
|
||||
if (weekdayStr) {
|
||||
// TODO: Replace the vanilla JS Date object with an indepentent day-of-week check.
|
||||
var weekdayProvided = defaultLocaleWeekdaysShort.indexOf(weekdayStr),
|
||||
weekdayActual = new Date(parsedInput[0], parsedInput[1], parsedInput[2]).getDay();
|
||||
if (weekdayProvided !== weekdayActual) {
|
||||
getParsingFlags(config).weekdayMismatch = true;
|
||||
config._isValid = false;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
var obsOffsets = {
|
||||
UT: 0,
|
||||
GMT: 0,
|
||||
EDT: -4 * 60,
|
||||
EST: -5 * 60,
|
||||
CDT: -5 * 60,
|
||||
CST: -6 * 60,
|
||||
MDT: -6 * 60,
|
||||
MST: -7 * 60,
|
||||
PDT: -7 * 60,
|
||||
PST: -8 * 60
|
||||
};
|
||||
|
||||
function calculateOffset(obsOffset, militaryOffset, numOffset) {
|
||||
if (obsOffset) {
|
||||
return obsOffsets[obsOffset];
|
||||
} else if (militaryOffset) {
|
||||
// the only allowed military tz is Z
|
||||
return 0;
|
||||
} else {
|
||||
var hm = parseInt(numOffset, 10);
|
||||
var m = hm % 100, h = (hm - m) / 100;
|
||||
return h * 60 + m;
|
||||
}
|
||||
}
|
||||
|
||||
// date and time from ref 2822 format
|
||||
export function configFromRFC2822(config) {
|
||||
var match = rfc2822.exec(preprocessRFC2822(config._i));
|
||||
if (match) {
|
||||
var parsedArray = extractFromRFC2822Strings(match[4], match[3], match[2], match[5], match[6], match[7]);
|
||||
if (!checkWeekday(match[1], parsedArray, config)) {
|
||||
return;
|
||||
}
|
||||
|
||||
config._a = parsedArray;
|
||||
config._tzm = calculateOffset(match[8], match[9], match[10]);
|
||||
|
||||
config._d = createUTCDate.apply(null, config._a);
|
||||
config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
|
||||
|
||||
getParsingFlags(config).rfc2822 = true;
|
||||
} else {
|
||||
config._isValid = false;
|
||||
}
|
||||
}
|
||||
|
||||
// date from iso format or fallback
|
||||
export function configFromString(config) {
|
||||
var matched = aspNetJsonRegex.exec(config._i);
|
||||
|
||||
if (matched !== null) {
|
||||
config._d = new Date(+matched[1]);
|
||||
return;
|
||||
}
|
||||
|
||||
configFromISO(config);
|
||||
if (config._isValid === false) {
|
||||
delete config._isValid;
|
||||
} else {
|
||||
return;
|
||||
}
|
||||
|
||||
configFromRFC2822(config);
|
||||
if (config._isValid === false) {
|
||||
delete config._isValid;
|
||||
} else {
|
||||
return;
|
||||
}
|
||||
|
||||
// Final attempt, use Input Fallback
|
||||
hooks.createFromInputFallback(config);
|
||||
}
|
||||
|
||||
hooks.createFromInputFallback = deprecate(
|
||||
'value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), ' +
|
||||
'which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are ' +
|
||||
'discouraged and will be removed in an upcoming major release. Please refer to ' +
|
||||
'http://momentjs.com/guides/#/warnings/js-date/ for more info.',
|
||||
function (config) {
|
||||
config._d = new Date(config._i + (config._useUTC ? ' UTC' : ''));
|
||||
}
|
||||
);
|
||||
5
WebfrontCore/wwwroot/lib/moment/src/lib/create/local.js
Normal file
5
WebfrontCore/wwwroot/lib/moment/src/lib/create/local.js
Normal file
@ -0,0 +1,5 @@
|
||||
import { createLocalOrUTC } from './from-anything';
|
||||
|
||||
export function createLocal (input, format, locale, strict) {
|
||||
return createLocalOrUTC(input, format, locale, strict, false);
|
||||
}
|
||||
@ -0,0 +1,26 @@
|
||||
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
|
||||
};
|
||||
}
|
||||
|
||||
export default function getParsingFlags(m) {
|
||||
if (m._pf == null) {
|
||||
m._pf = defaultParsingFlags();
|
||||
}
|
||||
return m._pf;
|
||||
}
|
||||
5
WebfrontCore/wwwroot/lib/moment/src/lib/create/utc.js
Normal file
5
WebfrontCore/wwwroot/lib/moment/src/lib/create/utc.js
Normal file
@ -0,0 +1,5 @@
|
||||
import { createLocalOrUTC } from './from-anything';
|
||||
|
||||
export function createUTC (input, format, locale, strict) {
|
||||
return createLocalOrUTC(input, format, locale, strict, true).utc();
|
||||
}
|
||||
50
WebfrontCore/wwwroot/lib/moment/src/lib/create/valid.js
Normal file
50
WebfrontCore/wwwroot/lib/moment/src/lib/create/valid.js
Normal file
@ -0,0 +1,50 @@
|
||||
import extend from '../utils/extend';
|
||||
import { createUTC } from './utc';
|
||||
import getParsingFlags from '../create/parsing-flags';
|
||||
import some from '../utils/some';
|
||||
|
||||
export 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;
|
||||
}
|
||||
|
||||
export function createInvalid (flags) {
|
||||
var m = createUTC(NaN);
|
||||
if (flags != null) {
|
||||
extend(getParsingFlags(m), flags);
|
||||
}
|
||||
else {
|
||||
getParsingFlags(m).userInvalidated = true;
|
||||
}
|
||||
|
||||
return m;
|
||||
}
|
||||
18
WebfrontCore/wwwroot/lib/moment/src/lib/duration/abs.js
Normal file
18
WebfrontCore/wwwroot/lib/moment/src/lib/duration/abs.js
Normal file
@ -0,0 +1,18 @@
|
||||
var mathAbs = Math.abs;
|
||||
|
||||
export function abs () {
|
||||
var data = this._data;
|
||||
|
||||
this._milliseconds = mathAbs(this._milliseconds);
|
||||
this._days = mathAbs(this._days);
|
||||
this._months = mathAbs(this._months);
|
||||
|
||||
data.milliseconds = mathAbs(data.milliseconds);
|
||||
data.seconds = mathAbs(data.seconds);
|
||||
data.minutes = mathAbs(data.minutes);
|
||||
data.hours = mathAbs(data.hours);
|
||||
data.months = mathAbs(data.months);
|
||||
data.years = mathAbs(data.years);
|
||||
|
||||
return this;
|
||||
}
|
||||
@ -0,0 +1,21 @@
|
||||
import { createDuration } from './create';
|
||||
|
||||
function addSubtract (duration, input, value, direction) {
|
||||
var other = createDuration(input, value);
|
||||
|
||||
duration._milliseconds += direction * other._milliseconds;
|
||||
duration._days += direction * other._days;
|
||||
duration._months += direction * other._months;
|
||||
|
||||
return duration._bubble();
|
||||
}
|
||||
|
||||
// supports only 2.0-style add(1, 's') or add(duration)
|
||||
export function add (input, value) {
|
||||
return addSubtract(this, input, value, 1);
|
||||
}
|
||||
|
||||
// supports only 2.0-style subtract(1, 's') or subtract(duration)
|
||||
export function subtract (input, value) {
|
||||
return addSubtract(this, input, value, -1);
|
||||
}
|
||||
61
WebfrontCore/wwwroot/lib/moment/src/lib/duration/as.js
Normal file
61
WebfrontCore/wwwroot/lib/moment/src/lib/duration/as.js
Normal file
@ -0,0 +1,61 @@
|
||||
import { daysToMonths, monthsToDays } from './bubble';
|
||||
import { normalizeUnits } from '../units/aliases';
|
||||
import toInt from '../utils/to-int';
|
||||
|
||||
export function as (units) {
|
||||
if (!this.isValid()) {
|
||||
return NaN;
|
||||
}
|
||||
var days;
|
||||
var months;
|
||||
var milliseconds = this._milliseconds;
|
||||
|
||||
units = normalizeUnits(units);
|
||||
|
||||
if (units === 'month' || units === 'year') {
|
||||
days = this._days + milliseconds / 864e5;
|
||||
months = this._months + daysToMonths(days);
|
||||
return units === 'month' ? months : months / 12;
|
||||
} else {
|
||||
// handle milliseconds separately because of floating point math errors (issue #1867)
|
||||
days = this._days + Math.round(monthsToDays(this._months));
|
||||
switch (units) {
|
||||
case 'week' : return days / 7 + milliseconds / 6048e5;
|
||||
case 'day' : return days + milliseconds / 864e5;
|
||||
case 'hour' : return days * 24 + milliseconds / 36e5;
|
||||
case 'minute' : return days * 1440 + milliseconds / 6e4;
|
||||
case 'second' : return days * 86400 + milliseconds / 1000;
|
||||
// Math.floor prevents floating point math errors here
|
||||
case 'millisecond': return Math.floor(days * 864e5) + milliseconds;
|
||||
default: throw new Error('Unknown unit ' + units);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TODO: Use this.as('ms')?
|
||||
export function valueOf () {
|
||||
if (!this.isValid()) {
|
||||
return NaN;
|
||||
}
|
||||
return (
|
||||
this._milliseconds +
|
||||
this._days * 864e5 +
|
||||
(this._months % 12) * 2592e6 +
|
||||
toInt(this._months / 12) * 31536e6
|
||||
);
|
||||
}
|
||||
|
||||
function makeAs (alias) {
|
||||
return function () {
|
||||
return this.as(alias);
|
||||
};
|
||||
}
|
||||
|
||||
export var asMilliseconds = makeAs('ms');
|
||||
export var asSeconds = makeAs('s');
|
||||
export var asMinutes = makeAs('m');
|
||||
export var asHours = makeAs('h');
|
||||
export var asDays = makeAs('d');
|
||||
export var asWeeks = makeAs('w');
|
||||
export var asMonths = makeAs('M');
|
||||
export var asYears = makeAs('y');
|
||||
61
WebfrontCore/wwwroot/lib/moment/src/lib/duration/bubble.js
Normal file
61
WebfrontCore/wwwroot/lib/moment/src/lib/duration/bubble.js
Normal file
@ -0,0 +1,61 @@
|
||||
import absFloor from '../utils/abs-floor';
|
||||
import absCeil from '../utils/abs-ceil';
|
||||
import { createUTCDate } from '../create/date-from-array';
|
||||
|
||||
export function bubble () {
|
||||
var milliseconds = this._milliseconds;
|
||||
var days = this._days;
|
||||
var months = this._months;
|
||||
var data = this._data;
|
||||
var seconds, minutes, hours, years, monthsFromDays;
|
||||
|
||||
// if we have a mix of positive and negative values, bubble down first
|
||||
// check: https://github.com/moment/moment/issues/2166
|
||||
if (!((milliseconds >= 0 && days >= 0 && months >= 0) ||
|
||||
(milliseconds <= 0 && days <= 0 && months <= 0))) {
|
||||
milliseconds += absCeil(monthsToDays(months) + days) * 864e5;
|
||||
days = 0;
|
||||
months = 0;
|
||||
}
|
||||
|
||||
// The following code bubbles up values, see the tests for
|
||||
// examples of what that means.
|
||||
data.milliseconds = milliseconds % 1000;
|
||||
|
||||
seconds = absFloor(milliseconds / 1000);
|
||||
data.seconds = seconds % 60;
|
||||
|
||||
minutes = absFloor(seconds / 60);
|
||||
data.minutes = minutes % 60;
|
||||
|
||||
hours = absFloor(minutes / 60);
|
||||
data.hours = hours % 24;
|
||||
|
||||
days += absFloor(hours / 24);
|
||||
|
||||
// convert days to months
|
||||
monthsFromDays = absFloor(daysToMonths(days));
|
||||
months += monthsFromDays;
|
||||
days -= absCeil(monthsToDays(monthsFromDays));
|
||||
|
||||
// 12 months -> 1 year
|
||||
years = absFloor(months / 12);
|
||||
months %= 12;
|
||||
|
||||
data.days = days;
|
||||
data.months = months;
|
||||
data.years = years;
|
||||
|
||||
return this;
|
||||
}
|
||||
|
||||
export function daysToMonths (days) {
|
||||
// 400 years have 146097 days (taking into account leap year rules)
|
||||
// 400 years have 12 months === 4800
|
||||
return days * 4800 / 146097;
|
||||
}
|
||||
|
||||
export function monthsToDays (months) {
|
||||
// the reverse of daysToMonths
|
||||
return months * 146097 / 4800;
|
||||
}
|
||||
@ -0,0 +1,6 @@
|
||||
import { createDuration } from './create';
|
||||
|
||||
export function clone () {
|
||||
return createDuration(this);
|
||||
}
|
||||
|
||||
@ -0,0 +1,44 @@
|
||||
import { normalizeObjectUnits } from '../units/aliases';
|
||||
import { getLocale } from '../locale/locales';
|
||||
import isDurationValid from './valid.js';
|
||||
|
||||
export 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;
|
||||
|
||||
this._isValid = isDurationValid(normalizedInput);
|
||||
|
||||
// representation for dateAddRemove
|
||||
this._milliseconds = +milliseconds +
|
||||
seconds * 1e3 + // 1000
|
||||
minutes * 6e4 + // 1000 * 60
|
||||
hours * 1000 * 60 * 60; //using 1000 * 60 * 60 instead of 36e5 to avoid floating point rounding errors https://github.com/moment/moment/issues/2978
|
||||
// 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 to 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 = getLocale();
|
||||
|
||||
this._bubble();
|
||||
}
|
||||
|
||||
export function isDuration (obj) {
|
||||
return obj instanceof Duration;
|
||||
}
|
||||
122
WebfrontCore/wwwroot/lib/moment/src/lib/duration/create.js
Normal file
122
WebfrontCore/wwwroot/lib/moment/src/lib/duration/create.js
Normal file
@ -0,0 +1,122 @@
|
||||
import { Duration, isDuration } from './constructor';
|
||||
import isNumber from '../utils/is-number';
|
||||
import toInt from '../utils/to-int';
|
||||
import absRound from '../utils/abs-round';
|
||||
import hasOwnProp from '../utils/has-own-prop';
|
||||
import { DATE, HOUR, MINUTE, SECOND, MILLISECOND } from '../units/constants';
|
||||
import { cloneWithOffset } from '../units/offset';
|
||||
import { createLocal } from '../create/local';
|
||||
import { createInvalid as invalid } from './valid';
|
||||
|
||||
// ASP.NET json date format regex
|
||||
var aspNetRegex = /^(\-|\+)?(?:(\d*)[. ])?(\d+)\:(\d+)(?:\:(\d+)(\.\d*)?)?$/;
|
||||
|
||||
// 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
|
||||
// and further modified to allow for strings containing both week and day
|
||||
var isoRegex = /^(-|\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/;
|
||||
|
||||
export function createDuration (input, key) {
|
||||
var duration = input,
|
||||
// matching against regexp is expensive, do it on demand
|
||||
match = null,
|
||||
sign,
|
||||
ret,
|
||||
diffRes;
|
||||
|
||||
if (isDuration(input)) {
|
||||
duration = {
|
||||
ms : input._milliseconds,
|
||||
d : input._days,
|
||||
M : input._months
|
||||
};
|
||||
} else if (isNumber(input)) {
|
||||
duration = {};
|
||||
if (key) {
|
||||
duration[key] = input;
|
||||
} else {
|
||||
duration.milliseconds = input;
|
||||
}
|
||||
} else if (!!(match = aspNetRegex.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(absRound(match[MILLISECOND] * 1000)) * sign // the millisecond decimal point is included in the match
|
||||
};
|
||||
} else if (!!(match = isoRegex.exec(input))) {
|
||||
sign = (match[1] === '-') ? -1 : (match[1] === '+') ? 1 : 1;
|
||||
duration = {
|
||||
y : parseIso(match[2], sign),
|
||||
M : parseIso(match[3], sign),
|
||||
w : parseIso(match[4], sign),
|
||||
d : parseIso(match[5], sign),
|
||||
h : parseIso(match[6], sign),
|
||||
m : parseIso(match[7], sign),
|
||||
s : parseIso(match[8], sign)
|
||||
};
|
||||
} else if (duration == null) {// checks for null or undefined
|
||||
duration = {};
|
||||
} else if (typeof duration === 'object' && ('from' in duration || 'to' in duration)) {
|
||||
diffRes = momentsDifference(createLocal(duration.from), createLocal(duration.to));
|
||||
|
||||
duration = {};
|
||||
duration.ms = diffRes.milliseconds;
|
||||
duration.M = diffRes.months;
|
||||
}
|
||||
|
||||
ret = new Duration(duration);
|
||||
|
||||
if (isDuration(input) && hasOwnProp(input, '_locale')) {
|
||||
ret._locale = input._locale;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
createDuration.fn = Duration.prototype;
|
||||
createDuration.invalid = invalid;
|
||||
|
||||
function parseIso (inp, sign) {
|
||||
// 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;
|
||||
}
|
||||
|
||||
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;
|
||||
if (!(base.isValid() && other.isValid())) {
|
||||
return {milliseconds: 0, months: 0};
|
||||
}
|
||||
|
||||
other = cloneWithOffset(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;
|
||||
}
|
||||
16
WebfrontCore/wwwroot/lib/moment/src/lib/duration/duration.js
Normal file
16
WebfrontCore/wwwroot/lib/moment/src/lib/duration/duration.js
Normal file
@ -0,0 +1,16 @@
|
||||
// Side effect imports
|
||||
import './prototype';
|
||||
|
||||
import { createDuration } from './create';
|
||||
import { isDuration } from './constructor';
|
||||
import {
|
||||
getSetRelativeTimeRounding,
|
||||
getSetRelativeTimeThreshold
|
||||
} from './humanize';
|
||||
|
||||
export {
|
||||
createDuration,
|
||||
isDuration,
|
||||
getSetRelativeTimeRounding,
|
||||
getSetRelativeTimeThreshold
|
||||
};
|
||||
25
WebfrontCore/wwwroot/lib/moment/src/lib/duration/get.js
Normal file
25
WebfrontCore/wwwroot/lib/moment/src/lib/duration/get.js
Normal file
@ -0,0 +1,25 @@
|
||||
import { normalizeUnits } from '../units/aliases';
|
||||
import absFloor from '../utils/abs-floor';
|
||||
|
||||
export function get (units) {
|
||||
units = normalizeUnits(units);
|
||||
return this.isValid() ? this[units + 's']() : NaN;
|
||||
}
|
||||
|
||||
function makeGetter(name) {
|
||||
return function () {
|
||||
return this.isValid() ? this._data[name] : NaN;
|
||||
};
|
||||
}
|
||||
|
||||
export var milliseconds = makeGetter('milliseconds');
|
||||
export var seconds = makeGetter('seconds');
|
||||
export var minutes = makeGetter('minutes');
|
||||
export var hours = makeGetter('hours');
|
||||
export var days = makeGetter('days');
|
||||
export var months = makeGetter('months');
|
||||
export var years = makeGetter('years');
|
||||
|
||||
export function weeks () {
|
||||
return absFloor(this.days() / 7);
|
||||
}
|
||||
85
WebfrontCore/wwwroot/lib/moment/src/lib/duration/humanize.js
Normal file
85
WebfrontCore/wwwroot/lib/moment/src/lib/duration/humanize.js
Normal file
@ -0,0 +1,85 @@
|
||||
import { createDuration } from './create';
|
||||
|
||||
var round = Math.round;
|
||||
var thresholds = {
|
||||
ss: 44, // a few seconds to seconds
|
||||
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
|
||||
};
|
||||
|
||||
// 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 = createDuration(posNegDuration).abs();
|
||||
var seconds = round(duration.as('s'));
|
||||
var minutes = round(duration.as('m'));
|
||||
var hours = round(duration.as('h'));
|
||||
var days = round(duration.as('d'));
|
||||
var months = round(duration.as('M'));
|
||||
var years = round(duration.as('y'));
|
||||
|
||||
var a = seconds <= thresholds.ss && ['s', seconds] ||
|
||||
seconds < thresholds.s && ['ss', seconds] ||
|
||||
minutes <= 1 && ['m'] ||
|
||||
minutes < thresholds.m && ['mm', minutes] ||
|
||||
hours <= 1 && ['h'] ||
|
||||
hours < thresholds.h && ['hh', hours] ||
|
||||
days <= 1 && ['d'] ||
|
||||
days < thresholds.d && ['dd', days] ||
|
||||
months <= 1 && ['M'] ||
|
||||
months < thresholds.M && ['MM', months] ||
|
||||
years <= 1 && ['y'] || ['yy', years];
|
||||
|
||||
a[2] = withoutSuffix;
|
||||
a[3] = +posNegDuration > 0;
|
||||
a[4] = locale;
|
||||
return substituteTimeAgo.apply(null, a);
|
||||
}
|
||||
|
||||
// This function allows you to set the rounding function for relative time strings
|
||||
export function getSetRelativeTimeRounding (roundingFunction) {
|
||||
if (roundingFunction === undefined) {
|
||||
return round;
|
||||
}
|
||||
if (typeof(roundingFunction) === 'function') {
|
||||
round = roundingFunction;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
// This function allows you to set a threshold for relative time strings
|
||||
export function getSetRelativeTimeThreshold (threshold, limit) {
|
||||
if (thresholds[threshold] === undefined) {
|
||||
return false;
|
||||
}
|
||||
if (limit === undefined) {
|
||||
return thresholds[threshold];
|
||||
}
|
||||
thresholds[threshold] = limit;
|
||||
if (threshold === 's') {
|
||||
thresholds.ss = limit - 1;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
export function humanize (withSuffix) {
|
||||
if (!this.isValid()) {
|
||||
return this.localeData().invalidDate();
|
||||
}
|
||||
|
||||
var locale = this.localeData();
|
||||
var output = relativeTime(this, !withSuffix, locale);
|
||||
|
||||
if (withSuffix) {
|
||||
output = locale.pastFuture(+this, output);
|
||||
}
|
||||
|
||||
return locale.postformat(output);
|
||||
}
|
||||
@ -0,0 +1,64 @@
|
||||
import absFloor from '../utils/abs-floor';
|
||||
var abs = Math.abs;
|
||||
|
||||
function sign(x) {
|
||||
return ((x > 0) - (x < 0)) || +x;
|
||||
}
|
||||
|
||||
export function toISOString() {
|
||||
// for ISO strings we do not use the normal bubbling rules:
|
||||
// * milliseconds bubble up until they become hours
|
||||
// * days do not bubble at all
|
||||
// * months bubble up until they become years
|
||||
// This is because there is no context-free conversion between hours and days
|
||||
// (think of clock changes)
|
||||
// and also not between days and months (28-31 days per month)
|
||||
if (!this.isValid()) {
|
||||
return this.localeData().invalidDate();
|
||||
}
|
||||
|
||||
var seconds = abs(this._milliseconds) / 1000;
|
||||
var days = abs(this._days);
|
||||
var months = abs(this._months);
|
||||
var minutes, hours, years;
|
||||
|
||||
// 3600 seconds -> 60 minutes -> 1 hour
|
||||
minutes = absFloor(seconds / 60);
|
||||
hours = absFloor(minutes / 60);
|
||||
seconds %= 60;
|
||||
minutes %= 60;
|
||||
|
||||
// 12 months -> 1 year
|
||||
years = absFloor(months / 12);
|
||||
months %= 12;
|
||||
|
||||
|
||||
// inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js
|
||||
var Y = years;
|
||||
var M = months;
|
||||
var D = days;
|
||||
var h = hours;
|
||||
var m = minutes;
|
||||
var s = seconds ? seconds.toFixed(3).replace(/\.?0+$/, '') : '';
|
||||
var total = this.asSeconds();
|
||||
|
||||
if (!total) {
|
||||
// this is the same as C#'s (Noda) and python (isodate)...
|
||||
// but not other JS (goog.date)
|
||||
return 'P0D';
|
||||
}
|
||||
|
||||
var totalSign = total < 0 ? '-' : '';
|
||||
var ymSign = sign(this._months) !== sign(total) ? '-' : '';
|
||||
var daysSign = sign(this._days) !== sign(total) ? '-' : '';
|
||||
var hmsSign = sign(this._milliseconds) !== sign(total) ? '-' : '';
|
||||
|
||||
return totalSign + 'P' +
|
||||
(Y ? ymSign + Y + 'Y' : '') +
|
||||
(M ? ymSign + M + 'M' : '') +
|
||||
(D ? daysSign + D + 'D' : '') +
|
||||
((h || m || s) ? 'T' : '') +
|
||||
(h ? hmsSign + h + 'H' : '') +
|
||||
(m ? hmsSign + m + 'M' : '') +
|
||||
(s ? hmsSign + s + 'S' : '');
|
||||
}
|
||||
52
WebfrontCore/wwwroot/lib/moment/src/lib/duration/prototype.js
vendored
Normal file
52
WebfrontCore/wwwroot/lib/moment/src/lib/duration/prototype.js
vendored
Normal file
@ -0,0 +1,52 @@
|
||||
import { Duration } from './constructor';
|
||||
|
||||
var proto = Duration.prototype;
|
||||
|
||||
import { abs } from './abs';
|
||||
import { add, subtract } from './add-subtract';
|
||||
import { as, asMilliseconds, asSeconds, asMinutes, asHours, asDays, asWeeks, asMonths, asYears, valueOf } from './as';
|
||||
import { bubble } from './bubble';
|
||||
import { clone } from './clone';
|
||||
import { get, milliseconds, seconds, minutes, hours, days, months, years, weeks } from './get';
|
||||
import { humanize } from './humanize';
|
||||
import { toISOString } from './iso-string';
|
||||
import { lang, locale, localeData } from '../moment/locale';
|
||||
import { isValid } from './valid';
|
||||
|
||||
proto.isValid = isValid;
|
||||
proto.abs = abs;
|
||||
proto.add = add;
|
||||
proto.subtract = subtract;
|
||||
proto.as = as;
|
||||
proto.asMilliseconds = asMilliseconds;
|
||||
proto.asSeconds = asSeconds;
|
||||
proto.asMinutes = asMinutes;
|
||||
proto.asHours = asHours;
|
||||
proto.asDays = asDays;
|
||||
proto.asWeeks = asWeeks;
|
||||
proto.asMonths = asMonths;
|
||||
proto.asYears = asYears;
|
||||
proto.valueOf = valueOf;
|
||||
proto._bubble = bubble;
|
||||
proto.clone = clone;
|
||||
proto.get = get;
|
||||
proto.milliseconds = milliseconds;
|
||||
proto.seconds = seconds;
|
||||
proto.minutes = minutes;
|
||||
proto.hours = hours;
|
||||
proto.days = days;
|
||||
proto.weeks = weeks;
|
||||
proto.months = months;
|
||||
proto.years = years;
|
||||
proto.humanize = humanize;
|
||||
proto.toISOString = toISOString;
|
||||
proto.toString = toISOString;
|
||||
proto.toJSON = toISOString;
|
||||
proto.locale = locale;
|
||||
proto.localeData = localeData;
|
||||
|
||||
// Deprecations
|
||||
import { deprecate } from '../utils/deprecate';
|
||||
|
||||
proto.toIsoString = deprecate('toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)', toISOString);
|
||||
proto.lang = lang;
|
||||
36
WebfrontCore/wwwroot/lib/moment/src/lib/duration/valid.js
Normal file
36
WebfrontCore/wwwroot/lib/moment/src/lib/duration/valid.js
Normal file
@ -0,0 +1,36 @@
|
||||
import toInt from '../utils/to-int';
|
||||
import indexOf from '../utils/index-of';
|
||||
import {Duration} from './constructor';
|
||||
import {createDuration} from './create';
|
||||
|
||||
var ordering = ['year', 'quarter', 'month', 'week', 'day', 'hour', 'minute', 'second', 'millisecond'];
|
||||
|
||||
export default function isDurationValid(m) {
|
||||
for (var key in m) {
|
||||
if (!(indexOf.call(ordering, key) !== -1 && (m[key] == null || !isNaN(m[key])))) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
var unitHasDecimal = false;
|
||||
for (var i = 0; i < ordering.length; ++i) {
|
||||
if (m[ordering[i]]) {
|
||||
if (unitHasDecimal) {
|
||||
return false; // only allow non-integers for smallest unit
|
||||
}
|
||||
if (parseFloat(m[ordering[i]]) !== toInt(m[ordering[i]])) {
|
||||
unitHasDecimal = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
export function isValid() {
|
||||
return this._isValid;
|
||||
}
|
||||
|
||||
export function createInvalid() {
|
||||
return createDuration(NaN);
|
||||
}
|
||||
92
WebfrontCore/wwwroot/lib/moment/src/lib/format/format.js
Normal file
92
WebfrontCore/wwwroot/lib/moment/src/lib/format/format.js
Normal file
@ -0,0 +1,92 @@
|
||||
import zeroFill from '../utils/zero-fill';
|
||||
import isFunction from '../utils/is-function';
|
||||
|
||||
export 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 = {};
|
||||
|
||||
export var formatTokenFunctions = {};
|
||||
|
||||
// token: 'M'
|
||||
// padded: ['MM', 2]
|
||||
// ordinal: 'Mo'
|
||||
// callback: function () { this.month() + 1 }
|
||||
export function addFormatToken (token, padded, ordinal, callback) {
|
||||
var func = callback;
|
||||
if (typeof callback === 'string') {
|
||||
func = function () {
|
||||
return this[callback]();
|
||||
};
|
||||
}
|
||||
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
|
||||
export 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);
|
||||
}
|
||||
|
||||
export 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;
|
||||
}
|
||||
@ -0,0 +1,44 @@
|
||||
import { defaultCalendar } from './calendar';
|
||||
import { defaultLongDateFormat } from './formats';
|
||||
import { defaultInvalidDate } from './invalid';
|
||||
import { defaultOrdinal, defaultDayOfMonthOrdinalParse } from './ordinal';
|
||||
import { defaultRelativeTime } from './relative';
|
||||
|
||||
// months
|
||||
import {
|
||||
defaultLocaleMonths,
|
||||
defaultLocaleMonthsShort,
|
||||
} from '../units/month';
|
||||
|
||||
// week
|
||||
import { defaultLocaleWeek } from '../units/week';
|
||||
|
||||
// weekdays
|
||||
import {
|
||||
defaultLocaleWeekdays,
|
||||
defaultLocaleWeekdaysMin,
|
||||
defaultLocaleWeekdaysShort,
|
||||
} from '../units/day-of-week';
|
||||
|
||||
// meridiem
|
||||
import { defaultLocaleMeridiemParse } from '../units/hour';
|
||||
|
||||
export 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
|
||||
};
|
||||
15
WebfrontCore/wwwroot/lib/moment/src/lib/locale/calendar.js
Normal file
15
WebfrontCore/wwwroot/lib/moment/src/lib/locale/calendar.js
Normal file
@ -0,0 +1,15 @@
|
||||
export 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'
|
||||
};
|
||||
|
||||
import isFunction from '../utils/is-function';
|
||||
|
||||
export function calendar (key, mom, now) {
|
||||
var output = this._calendar[key] || this._calendar['sameElse'];
|
||||
return isFunction(output) ? output.call(mom, now) : output;
|
||||
}
|
||||
@ -0,0 +1,5 @@
|
||||
export function Locale(config) {
|
||||
if (config != null) {
|
||||
this.set(config);
|
||||
}
|
||||
}
|
||||
15
WebfrontCore/wwwroot/lib/moment/src/lib/locale/en.js
Normal file
15
WebfrontCore/wwwroot/lib/moment/src/lib/locale/en.js
Normal file
@ -0,0 +1,15 @@
|
||||
import './prototype';
|
||||
import { getSetGlobalLocale } from './locales';
|
||||
import toInt from '../utils/to-int';
|
||||
|
||||
getSetGlobalLocale('en', {
|
||||
dayOfMonthOrdinalParse: /\d{1,2}(th|st|nd|rd)/,
|
||||
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;
|
||||
}
|
||||
});
|
||||
23
WebfrontCore/wwwroot/lib/moment/src/lib/locale/formats.js
Normal file
23
WebfrontCore/wwwroot/lib/moment/src/lib/locale/formats.js
Normal file
@ -0,0 +1,23 @@
|
||||
export 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'
|
||||
};
|
||||
|
||||
export 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];
|
||||
}
|
||||
@ -0,0 +1,5 @@
|
||||
export var defaultInvalidDate = 'Invalid date';
|
||||
|
||||
export function invalidDate () {
|
||||
return this._invalidDate;
|
||||
}
|
||||
93
WebfrontCore/wwwroot/lib/moment/src/lib/locale/lists.js
Normal file
93
WebfrontCore/wwwroot/lib/moment/src/lib/locale/lists.js
Normal file
@ -0,0 +1,93 @@
|
||||
import isNumber from '../utils/is-number';
|
||||
import { getLocale } from './locales';
|
||||
import { createUTC } from '../create/utc';
|
||||
|
||||
function get (format, index, field, setter) {
|
||||
var locale = getLocale();
|
||||
var utc = createUTC().set(setter, index);
|
||||
return locale[field](utc, format);
|
||||
}
|
||||
|
||||
function listMonthsImpl (format, index, field) {
|
||||
if (isNumber(format)) {
|
||||
index = format;
|
||||
format = undefined;
|
||||
}
|
||||
|
||||
format = format || '';
|
||||
|
||||
if (index != null) {
|
||||
return get(format, index, field, 'month');
|
||||
}
|
||||
|
||||
var i;
|
||||
var out = [];
|
||||
for (i = 0; i < 12; i++) {
|
||||
out[i] = get(format, i, field, 'month');
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
// ()
|
||||
// (5)
|
||||
// (fmt, 5)
|
||||
// (fmt)
|
||||
// (true)
|
||||
// (true, 5)
|
||||
// (true, fmt, 5)
|
||||
// (true, fmt)
|
||||
function listWeekdaysImpl (localeSorted, format, index, field) {
|
||||
if (typeof localeSorted === 'boolean') {
|
||||
if (isNumber(format)) {
|
||||
index = format;
|
||||
format = undefined;
|
||||
}
|
||||
|
||||
format = format || '';
|
||||
} else {
|
||||
format = localeSorted;
|
||||
index = format;
|
||||
localeSorted = false;
|
||||
|
||||
if (isNumber(format)) {
|
||||
index = format;
|
||||
format = undefined;
|
||||
}
|
||||
|
||||
format = format || '';
|
||||
}
|
||||
|
||||
var locale = getLocale(),
|
||||
shift = localeSorted ? locale._week.dow : 0;
|
||||
|
||||
if (index != null) {
|
||||
return get(format, (index + shift) % 7, field, 'day');
|
||||
}
|
||||
|
||||
var i;
|
||||
var out = [];
|
||||
for (i = 0; i < 7; i++) {
|
||||
out[i] = get(format, (i + shift) % 7, field, 'day');
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
export function listMonths (format, index) {
|
||||
return listMonthsImpl(format, index, 'months');
|
||||
}
|
||||
|
||||
export function listMonthsShort (format, index) {
|
||||
return listMonthsImpl(format, index, 'monthsShort');
|
||||
}
|
||||
|
||||
export function listWeekdays (localeSorted, format, index) {
|
||||
return listWeekdaysImpl(localeSorted, format, index, 'weekdays');
|
||||
}
|
||||
|
||||
export function listWeekdaysShort (localeSorted, format, index) {
|
||||
return listWeekdaysImpl(localeSorted, format, index, 'weekdaysShort');
|
||||
}
|
||||
|
||||
export function listWeekdaysMin (localeSorted, format, index) {
|
||||
return listWeekdaysImpl(localeSorted, format, index, 'weekdaysMin');
|
||||
}
|
||||
39
WebfrontCore/wwwroot/lib/moment/src/lib/locale/locale.js
Normal file
39
WebfrontCore/wwwroot/lib/moment/src/lib/locale/locale.js
Normal file
@ -0,0 +1,39 @@
|
||||
// Side effect imports
|
||||
import './prototype';
|
||||
|
||||
import {
|
||||
getSetGlobalLocale,
|
||||
defineLocale,
|
||||
updateLocale,
|
||||
getLocale,
|
||||
listLocales
|
||||
} from './locales';
|
||||
|
||||
import {
|
||||
listMonths,
|
||||
listMonthsShort,
|
||||
listWeekdays,
|
||||
listWeekdaysShort,
|
||||
listWeekdaysMin
|
||||
} from './lists';
|
||||
|
||||
export {
|
||||
getSetGlobalLocale,
|
||||
defineLocale,
|
||||
updateLocale,
|
||||
getLocale,
|
||||
listLocales,
|
||||
listMonths,
|
||||
listMonthsShort,
|
||||
listWeekdays,
|
||||
listWeekdaysShort,
|
||||
listWeekdaysMin
|
||||
};
|
||||
|
||||
import { deprecate } from '../utils/deprecate';
|
||||
import { hooks } from '../utils/hooks';
|
||||
|
||||
hooks.lang = deprecate('moment.lang is deprecated. Use moment.locale instead.', getSetGlobalLocale);
|
||||
hooks.langData = deprecate('moment.langData is deprecated. Use moment.localeData instead.', getLocale);
|
||||
|
||||
import './en';
|
||||
197
WebfrontCore/wwwroot/lib/moment/src/lib/locale/locales.js
Normal file
197
WebfrontCore/wwwroot/lib/moment/src/lib/locale/locales.js
Normal file
@ -0,0 +1,197 @@
|
||||
import isArray from '../utils/is-array';
|
||||
import hasOwnProp from '../utils/has-own-prop';
|
||||
import isUndefined from '../utils/is-undefined';
|
||||
import compareArrays from '../utils/compare-arrays';
|
||||
import { deprecateSimple } from '../utils/deprecate';
|
||||
import { mergeConfigs } from './set';
|
||||
import { Locale } from './constructor';
|
||||
import keys from '../utils/keys';
|
||||
|
||||
import { baseConfig } from './base-config';
|
||||
|
||||
// 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 one
|
||||
break;
|
||||
}
|
||||
j--;
|
||||
}
|
||||
i++;
|
||||
}
|
||||
return globalLocale;
|
||||
}
|
||||
|
||||
function loadLocale(name) {
|
||||
var oldLocale = null;
|
||||
// TODO: Find a better way to register and load all the locales in Node
|
||||
if (!locales[name] && (typeof module !== 'undefined') &&
|
||||
module && module.exports) {
|
||||
try {
|
||||
oldLocale = globalLocale._abbr;
|
||||
var aliasedRequire = require;
|
||||
aliasedRequire('./locale/' + name);
|
||||
getSetGlobalLocale(oldLocale);
|
||||
} catch (e) {}
|
||||
}
|
||||
return locales[name];
|
||||
}
|
||||
|
||||
// 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.
|
||||
export 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;
|
||||
}
|
||||
else {
|
||||
if ((typeof console !== 'undefined') && console.warn) {
|
||||
//warn user if arguments are passed but the locale could not be set
|
||||
console.warn('Locale ' + key + ' not found. Did you forget to load it?');
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return globalLocale._abbr;
|
||||
}
|
||||
|
||||
export function defineLocale (name, config) {
|
||||
if (config !== null) {
|
||||
var locale, parentConfig = baseConfig;
|
||||
config.abbr = name;
|
||||
if (locales[name] != null) {
|
||||
deprecateSimple('defineLocaleOverride',
|
||||
'use moment.updateLocale(localeName, config) to change ' +
|
||||
'an existing locale. moment.defineLocale(localeName, ' +
|
||||
'config) should only be used for creating a new locale ' +
|
||||
'See http://momentjs.com/guides/#/warnings/define-locale/ for more info.');
|
||||
parentConfig = locales[name]._config;
|
||||
} else if (config.parentLocale != null) {
|
||||
if (locales[config.parentLocale] != null) {
|
||||
parentConfig = locales[config.parentLocale]._config;
|
||||
} else {
|
||||
locale = loadLocale(config.parentLocale);
|
||||
if (locale != null) {
|
||||
parentConfig = locale._config;
|
||||
} else {
|
||||
if (!localeFamilies[config.parentLocale]) {
|
||||
localeFamilies[config.parentLocale] = [];
|
||||
}
|
||||
localeFamilies[config.parentLocale].push({
|
||||
name: name,
|
||||
config: config
|
||||
});
|
||||
return null;
|
||||
}
|
||||
}
|
||||
}
|
||||
locales[name] = new Locale(mergeConfigs(parentConfig, config));
|
||||
|
||||
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 testing
|
||||
delete locales[name];
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
export 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 locale
|
||||
getSetGlobalLocale(name);
|
||||
} else {
|
||||
// pass null for config to unupdate, useful for tests
|
||||
if (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
|
||||
export 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 else
|
||||
locale = loadLocale(key);
|
||||
if (locale) {
|
||||
return locale;
|
||||
}
|
||||
key = [key];
|
||||
}
|
||||
|
||||
return chooseLocale(key);
|
||||
}
|
||||
|
||||
export function listLocales() {
|
||||
return keys(locales);
|
||||
}
|
||||
@ -0,0 +1,7 @@
|
||||
export var defaultOrdinal = '%d';
|
||||
export var defaultDayOfMonthOrdinalParse = /\d{1,2}/;
|
||||
|
||||
export function ordinal (number) {
|
||||
return this._ordinal.replace('%d', number);
|
||||
}
|
||||
|
||||
@ -0,0 +1,3 @@
|
||||
export function preParsePostFormat (string) {
|
||||
return string;
|
||||
}
|
||||
69
WebfrontCore/wwwroot/lib/moment/src/lib/locale/prototype.js
vendored
Normal file
69
WebfrontCore/wwwroot/lib/moment/src/lib/locale/prototype.js
vendored
Normal file
@ -0,0 +1,69 @@
|
||||
import { Locale } from './constructor';
|
||||
|
||||
var proto = Locale.prototype;
|
||||
|
||||
import { calendar } from './calendar';
|
||||
import { longDateFormat } from './formats';
|
||||
import { invalidDate } from './invalid';
|
||||
import { ordinal } from './ordinal';
|
||||
import { preParsePostFormat } from './pre-post-format';
|
||||
import { relativeTime, pastFuture } from './relative';
|
||||
import { set } from './set';
|
||||
|
||||
proto.calendar = calendar;
|
||||
proto.longDateFormat = longDateFormat;
|
||||
proto.invalidDate = invalidDate;
|
||||
proto.ordinal = ordinal;
|
||||
proto.preparse = preParsePostFormat;
|
||||
proto.postformat = preParsePostFormat;
|
||||
proto.relativeTime = relativeTime;
|
||||
proto.pastFuture = pastFuture;
|
||||
proto.set = set;
|
||||
|
||||
// Month
|
||||
import {
|
||||
localeMonthsParse,
|
||||
localeMonths,
|
||||
localeMonthsShort,
|
||||
monthsRegex,
|
||||
monthsShortRegex
|
||||
} from '../units/month';
|
||||
|
||||
proto.months = localeMonths;
|
||||
proto.monthsShort = localeMonthsShort;
|
||||
proto.monthsParse = localeMonthsParse;
|
||||
proto.monthsRegex = monthsRegex;
|
||||
proto.monthsShortRegex = monthsShortRegex;
|
||||
|
||||
// Week
|
||||
import { localeWeek, localeFirstDayOfYear, localeFirstDayOfWeek } from '../units/week';
|
||||
proto.week = localeWeek;
|
||||
proto.firstDayOfYear = localeFirstDayOfYear;
|
||||
proto.firstDayOfWeek = localeFirstDayOfWeek;
|
||||
|
||||
// Day of Week
|
||||
import {
|
||||
localeWeekdaysParse,
|
||||
localeWeekdays,
|
||||
localeWeekdaysMin,
|
||||
localeWeekdaysShort,
|
||||
|
||||
weekdaysRegex,
|
||||
weekdaysShortRegex,
|
||||
weekdaysMinRegex
|
||||
} from '../units/day-of-week';
|
||||
|
||||
proto.weekdays = localeWeekdays;
|
||||
proto.weekdaysMin = localeWeekdaysMin;
|
||||
proto.weekdaysShort = localeWeekdaysShort;
|
||||
proto.weekdaysParse = localeWeekdaysParse;
|
||||
|
||||
proto.weekdaysRegex = weekdaysRegex;
|
||||
proto.weekdaysShortRegex = weekdaysShortRegex;
|
||||
proto.weekdaysMinRegex = weekdaysMinRegex;
|
||||
|
||||
// Hours
|
||||
import { localeIsPM, localeMeridiem } from '../units/hour';
|
||||
|
||||
proto.isPM = localeIsPM;
|
||||
proto.meridiem = localeMeridiem;
|
||||
30
WebfrontCore/wwwroot/lib/moment/src/lib/locale/relative.js
Normal file
30
WebfrontCore/wwwroot/lib/moment/src/lib/locale/relative.js
Normal file
@ -0,0 +1,30 @@
|
||||
export 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'
|
||||
};
|
||||
|
||||
import isFunction from '../utils/is-function';
|
||||
|
||||
export function relativeTime (number, withoutSuffix, string, isFuture) {
|
||||
var output = this._relativeTime[string];
|
||||
return (isFunction(output)) ?
|
||||
output(number, withoutSuffix, string, isFuture) :
|
||||
output.replace(/%d/i, number);
|
||||
}
|
||||
|
||||
export function pastFuture (diff, output) {
|
||||
var format = this._relativeTime[diff > 0 ? 'future' : 'past'];
|
||||
return isFunction(format) ? format(output) : format.replace(/%s/i, output);
|
||||
}
|
||||
49
WebfrontCore/wwwroot/lib/moment/src/lib/locale/set.js
Normal file
49
WebfrontCore/wwwroot/lib/moment/src/lib/locale/set.js
Normal file
@ -0,0 +1,49 @@
|
||||
import isFunction from '../utils/is-function';
|
||||
import extend from '../utils/extend';
|
||||
import isObject from '../utils/is-object';
|
||||
import hasOwnProp from '../utils/has-own-prop';
|
||||
|
||||
export function set (config) {
|
||||
var prop, i;
|
||||
for (i in config) {
|
||||
prop = config[i];
|
||||
if (isFunction(prop)) {
|
||||
this[i] = prop;
|
||||
} else {
|
||||
this['_' + i] = prop;
|
||||
}
|
||||
}
|
||||
this._config = config;
|
||||
// Lenient ordinal parsing accepts just a number in addition to
|
||||
// number + (possibly) stuff coming from _dayOfMonthOrdinalParse.
|
||||
// TODO: Remove "ordinalParse" fallback in next major release.
|
||||
this._dayOfMonthOrdinalParseLenient = new RegExp(
|
||||
(this._dayOfMonthOrdinalParse.source || this._ordinalParse.source) +
|
||||
'|' + (/\d{1,2}/).source);
|
||||
}
|
||||
|
||||
export function mergeConfigs(parentConfig, childConfig) {
|
||||
var res = extend({}, parentConfig), prop;
|
||||
for (prop in childConfig) {
|
||||
if (hasOwnProp(childConfig, prop)) {
|
||||
if (isObject(parentConfig[prop]) && isObject(childConfig[prop])) {
|
||||
res[prop] = {};
|
||||
extend(res[prop], parentConfig[prop]);
|
||||
extend(res[prop], childConfig[prop]);
|
||||
} else if (childConfig[prop] != null) {
|
||||
res[prop] = childConfig[prop];
|
||||
} else {
|
||||
delete res[prop];
|
||||
}
|
||||
}
|
||||
}
|
||||
for (prop in parentConfig) {
|
||||
if (hasOwnProp(parentConfig, prop) &&
|
||||
!hasOwnProp(childConfig, prop) &&
|
||||
isObject(parentConfig[prop])) {
|
||||
// make sure changes to properties don't modify parent config
|
||||
res[prop] = extend({}, res[prop]);
|
||||
}
|
||||
}
|
||||
return res;
|
||||
}
|
||||
@ -0,0 +1,55 @@
|
||||
import { get, set } from './get-set';
|
||||
import { setMonth } from '../units/month';
|
||||
import { createDuration } from '../duration/create';
|
||||
import { deprecateSimple } from '../utils/deprecate';
|
||||
import { hooks } from '../utils/hooks';
|
||||
import absRound from '../utils/abs-round';
|
||||
|
||||
|
||||
// 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). ' +
|
||||
'See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info.');
|
||||
tmp = val; val = period; period = tmp;
|
||||
}
|
||||
|
||||
val = typeof val === 'string' ? +val : val;
|
||||
dur = createDuration(val, period);
|
||||
addSubtract(this, dur, direction);
|
||||
return this;
|
||||
};
|
||||
}
|
||||
|
||||
export function addSubtract (mom, duration, isAdding, updateOffset) {
|
||||
var milliseconds = duration._milliseconds,
|
||||
days = absRound(duration._days),
|
||||
months = absRound(duration._months);
|
||||
|
||||
if (!mom.isValid()) {
|
||||
// No op
|
||||
return;
|
||||
}
|
||||
|
||||
updateOffset = updateOffset == null ? true : updateOffset;
|
||||
|
||||
if (months) {
|
||||
setMonth(mom, get(mom, 'Month') + months * isAdding);
|
||||
}
|
||||
if (days) {
|
||||
set(mom, 'Date', get(mom, 'Date') + days * isAdding);
|
||||
}
|
||||
if (milliseconds) {
|
||||
mom._d.setTime(mom._d.valueOf() + milliseconds * isAdding);
|
||||
}
|
||||
if (updateOffset) {
|
||||
hooks.updateOffset(mom, days || months);
|
||||
}
|
||||
}
|
||||
|
||||
export var add = createAdder(1, 'add');
|
||||
export var subtract = createAdder(-1, 'subtract');
|
||||
|
||||
26
WebfrontCore/wwwroot/lib/moment/src/lib/moment/calendar.js
Normal file
26
WebfrontCore/wwwroot/lib/moment/src/lib/moment/calendar.js
Normal file
@ -0,0 +1,26 @@
|
||||
import { createLocal } from '../create/local';
|
||||
import { cloneWithOffset } from '../units/offset';
|
||||
import isFunction from '../utils/is-function';
|
||||
import { hooks } from '../utils/hooks';
|
||||
|
||||
export function getCalendarFormat(myMoment, now) {
|
||||
var diff = myMoment.diff(now, 'days', true);
|
||||
return diff < -6 ? 'sameElse' :
|
||||
diff < -1 ? 'lastWeek' :
|
||||
diff < 0 ? 'lastDay' :
|
||||
diff < 1 ? 'sameDay' :
|
||||
diff < 2 ? 'nextDay' :
|
||||
diff < 7 ? 'nextWeek' : 'sameElse';
|
||||
}
|
||||
|
||||
export function calendar (time, formats) {
|
||||
// We want to compare the start of today, vs this.
|
||||
// Getting start-of-today depends on whether we're local/utc/offset or not.
|
||||
var now = time || createLocal(),
|
||||
sod = cloneWithOffset(now, this).startOf('day'),
|
||||
format = hooks.calendarFormat(this, sod) || 'sameElse';
|
||||
|
||||
var output = formats && (isFunction(formats[format]) ? formats[format].call(this, now) : formats[format]);
|
||||
|
||||
return this.format(output || this.localeData().calendar(format, this, createLocal(now)));
|
||||
}
|
||||
5
WebfrontCore/wwwroot/lib/moment/src/lib/moment/clone.js
Normal file
5
WebfrontCore/wwwroot/lib/moment/src/lib/moment/clone.js
Normal file
@ -0,0 +1,5 @@
|
||||
import { Moment } from './constructor';
|
||||
|
||||
export function clone () {
|
||||
return new Moment(this);
|
||||
}
|
||||
59
WebfrontCore/wwwroot/lib/moment/src/lib/moment/compare.js
Normal file
59
WebfrontCore/wwwroot/lib/moment/src/lib/moment/compare.js
Normal file
@ -0,0 +1,59 @@
|
||||
import { isMoment } from './constructor';
|
||||
import { normalizeUnits } from '../units/aliases';
|
||||
import { createLocal } from '../create/local';
|
||||
import isUndefined from '../utils/is-undefined';
|
||||
|
||||
export function isAfter (input, units) {
|
||||
var localInput = isMoment(input) ? input : createLocal(input);
|
||||
if (!(this.isValid() && localInput.isValid())) {
|
||||
return false;
|
||||
}
|
||||
units = normalizeUnits(!isUndefined(units) ? units : 'millisecond');
|
||||
if (units === 'millisecond') {
|
||||
return this.valueOf() > localInput.valueOf();
|
||||
} else {
|
||||
return localInput.valueOf() < this.clone().startOf(units).valueOf();
|
||||
}
|
||||
}
|
||||
|
||||
export function isBefore (input, units) {
|
||||
var localInput = isMoment(input) ? input : createLocal(input);
|
||||
if (!(this.isValid() && localInput.isValid())) {
|
||||
return false;
|
||||
}
|
||||
units = normalizeUnits(!isUndefined(units) ? units : 'millisecond');
|
||||
if (units === 'millisecond') {
|
||||
return this.valueOf() < localInput.valueOf();
|
||||
} else {
|
||||
return this.clone().endOf(units).valueOf() < localInput.valueOf();
|
||||
}
|
||||
}
|
||||
|
||||
export function isBetween (from, to, units, inclusivity) {
|
||||
inclusivity = inclusivity || '()';
|
||||
return (inclusivity[0] === '(' ? this.isAfter(from, units) : !this.isBefore(from, units)) &&
|
||||
(inclusivity[1] === ')' ? this.isBefore(to, units) : !this.isAfter(to, units));
|
||||
}
|
||||
|
||||
export function isSame (input, units) {
|
||||
var localInput = isMoment(input) ? input : createLocal(input),
|
||||
inputMs;
|
||||
if (!(this.isValid() && localInput.isValid())) {
|
||||
return false;
|
||||
}
|
||||
units = normalizeUnits(units || 'millisecond');
|
||||
if (units === 'millisecond') {
|
||||
return this.valueOf() === localInput.valueOf();
|
||||
} else {
|
||||
inputMs = localInput.valueOf();
|
||||
return this.clone().startOf(units).valueOf() <= inputMs && inputMs <= this.clone().endOf(units).valueOf();
|
||||
}
|
||||
}
|
||||
|
||||
export function isSameOrAfter (input, units) {
|
||||
return this.isSame(input, units) || this.isAfter(input,units);
|
||||
}
|
||||
|
||||
export function isSameOrBefore (input, units) {
|
||||
return this.isSame(input, units) || this.isBefore(input,units);
|
||||
}
|
||||
@ -0,0 +1,77 @@
|
||||
import { hooks } from '../utils/hooks';
|
||||
import hasOwnProp from '../utils/has-own-prop';
|
||||
import isUndefined from '../utils/is-undefined';
|
||||
import getParsingFlags from '../create/parsing-flags';
|
||||
|
||||
// Plugins that add properties should also add the key here (null value),
|
||||
// so we can properly clone ourselves.
|
||||
var momentProperties = hooks.momentProperties = [];
|
||||
|
||||
export 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
|
||||
export 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;
|
||||
}
|
||||
}
|
||||
|
||||
export function isMoment (obj) {
|
||||
return obj instanceof Moment || (obj != null && obj._isAMomentObject != null);
|
||||
}
|
||||
@ -0,0 +1,9 @@
|
||||
export function creationData() {
|
||||
return {
|
||||
input: this._i,
|
||||
format: this._f,
|
||||
locale: this._locale,
|
||||
isUTC: this._isUTC,
|
||||
strict: this._strict
|
||||
};
|
||||
}
|
||||
58
WebfrontCore/wwwroot/lib/moment/src/lib/moment/diff.js
Normal file
58
WebfrontCore/wwwroot/lib/moment/src/lib/moment/diff.js
Normal file
@ -0,0 +1,58 @@
|
||||
import absFloor from '../utils/abs-floor';
|
||||
import { cloneWithOffset } from '../units/offset';
|
||||
import { normalizeUnits } from '../units/aliases';
|
||||
|
||||
export function diff (input, units, asFloat) {
|
||||
var that,
|
||||
zoneDelta,
|
||||
delta, output;
|
||||
|
||||
if (!this.isValid()) {
|
||||
return NaN;
|
||||
}
|
||||
|
||||
that = cloneWithOffset(input, this);
|
||||
|
||||
if (!that.isValid()) {
|
||||
return NaN;
|
||||
}
|
||||
|
||||
zoneDelta = (that.utcOffset() - this.utcOffset()) * 6e4;
|
||||
|
||||
units = normalizeUnits(units);
|
||||
|
||||
switch (units) {
|
||||
case 'year': output = monthDiff(this, that) / 12; break;
|
||||
case 'month': output = monthDiff(this, that); break;
|
||||
case 'quarter': output = monthDiff(this, that) / 3; break;
|
||||
case 'second': output = (this - that) / 1e3; break; // 1000
|
||||
case 'minute': output = (this - that) / 6e4; break; // 1000 * 60
|
||||
case 'hour': output = (this - that) / 36e5; break; // 1000 * 60 * 60
|
||||
case 'day': output = (this - that - zoneDelta) / 864e5; break; // 1000 * 60 * 60 * 24, negate dst
|
||||
case 'week': output = (this - that - zoneDelta) / 6048e5; break; // 1000 * 60 * 60 * 24 * 7, negate dst
|
||||
default: output = this - that;
|
||||
}
|
||||
|
||||
return asFloat ? output : absFloor(output);
|
||||
}
|
||||
|
||||
function monthDiff (a, b) {
|
||||
// difference in months
|
||||
var wholeMonthDiff = ((b.year() - a.year()) * 12) + (b.month() - a.month()),
|
||||
// b is in (anchor - 1 month, anchor + 1 month)
|
||||
anchor = a.clone().add(wholeMonthDiff, 'months'),
|
||||
anchor2, adjust;
|
||||
|
||||
if (b - anchor < 0) {
|
||||
anchor2 = a.clone().add(wholeMonthDiff - 1, 'months');
|
||||
// linear across the month
|
||||
adjust = (b - anchor) / (anchor - anchor2);
|
||||
} else {
|
||||
anchor2 = a.clone().add(wholeMonthDiff + 1, 'months');
|
||||
// linear across the month
|
||||
adjust = (b - anchor) / (anchor2 - anchor);
|
||||
}
|
||||
|
||||
//check for negative zero, return zero if negative zero
|
||||
return -(wholeMonthDiff + adjust) || 0;
|
||||
}
|
||||
62
WebfrontCore/wwwroot/lib/moment/src/lib/moment/format.js
Normal file
62
WebfrontCore/wwwroot/lib/moment/src/lib/moment/format.js
Normal file
@ -0,0 +1,62 @@
|
||||
import { formatMoment } from '../format/format';
|
||||
import { hooks } from '../utils/hooks';
|
||||
import isFunction from '../utils/is-function';
|
||||
|
||||
hooks.defaultFormat = 'YYYY-MM-DDTHH:mm:ssZ';
|
||||
hooks.defaultFormatUtc = 'YYYY-MM-DDTHH:mm:ss[Z]';
|
||||
|
||||
export function toString () {
|
||||
return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ');
|
||||
}
|
||||
|
||||
export function toISOString(keepOffset) {
|
||||
if (!this.isValid()) {
|
||||
return null;
|
||||
}
|
||||
var utc = keepOffset !== true;
|
||||
var m = utc ? this.clone().utc() : this;
|
||||
if (m.year() < 0 || m.year() > 9999) {
|
||||
return formatMoment(m, utc ? 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]' : 'YYYYYY-MM-DD[T]HH:mm:ss.SSSZ');
|
||||
}
|
||||
if (isFunction(Date.prototype.toISOString)) {
|
||||
// native implementation is ~50x faster, use it when we can
|
||||
if (utc) {
|
||||
return this.toDate().toISOString();
|
||||
} else {
|
||||
return new Date(this.valueOf() + this.utcOffset() * 60 * 1000).toISOString().replace('Z', formatMoment(m, 'Z'));
|
||||
}
|
||||
}
|
||||
return formatMoment(m, utc ? 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]' : 'YYYY-MM-DD[T]HH:mm:ss.SSSZ');
|
||||
}
|
||||
|
||||
/**
|
||||
* Return a human readable representation of a moment that can
|
||||
* also be evaluated to get a new moment which is the same
|
||||
*
|
||||
* @link https://nodejs.org/dist/latest/docs/api/util.html#util_custom_inspect_function_on_objects
|
||||
*/
|
||||
export function inspect () {
|
||||
if (!this.isValid()) {
|
||||
return 'moment.invalid(/* ' + this._i + ' */)';
|
||||
}
|
||||
var func = 'moment';
|
||||
var zone = '';
|
||||
if (!this.isLocal()) {
|
||||
func = this.utcOffset() === 0 ? 'moment.utc' : 'moment.parseZone';
|
||||
zone = 'Z';
|
||||
}
|
||||
var prefix = '[' + func + '("]';
|
||||
var year = (0 <= this.year() && this.year() <= 9999) ? 'YYYY' : 'YYYYYY';
|
||||
var datetime = '-MM-DD[T]HH:mm:ss.SSS';
|
||||
var suffix = zone + '[")]';
|
||||
|
||||
return this.format(prefix + year + datetime + suffix);
|
||||
}
|
||||
|
||||
export function format (inputString) {
|
||||
if (!inputString) {
|
||||
inputString = this.isUtc() ? hooks.defaultFormatUtc : hooks.defaultFormat;
|
||||
}
|
||||
var output = formatMoment(this, inputString);
|
||||
return this.localeData().postformat(output);
|
||||
}
|
||||
17
WebfrontCore/wwwroot/lib/moment/src/lib/moment/from.js
Normal file
17
WebfrontCore/wwwroot/lib/moment/src/lib/moment/from.js
Normal file
@ -0,0 +1,17 @@
|
||||
import { createDuration } from '../duration/create';
|
||||
import { createLocal } from '../create/local';
|
||||
import { isMoment } from '../moment/constructor';
|
||||
|
||||
export function from (time, withoutSuffix) {
|
||||
if (this.isValid() &&
|
||||
((isMoment(time) && time.isValid()) ||
|
||||
createLocal(time).isValid())) {
|
||||
return createDuration({to: this, from: time}).locale(this.locale()).humanize(!withoutSuffix);
|
||||
} else {
|
||||
return this.localeData().invalidDate();
|
||||
}
|
||||
}
|
||||
|
||||
export function fromNow (withoutSuffix) {
|
||||
return this.from(createLocal(), withoutSuffix);
|
||||
}
|
||||
61
WebfrontCore/wwwroot/lib/moment/src/lib/moment/get-set.js
Normal file
61
WebfrontCore/wwwroot/lib/moment/src/lib/moment/get-set.js
Normal file
@ -0,0 +1,61 @@
|
||||
import { normalizeUnits, normalizeObjectUnits } from '../units/aliases';
|
||||
import { getPrioritizedUnits } from '../units/priorities';
|
||||
import { hooks } from '../utils/hooks';
|
||||
import isFunction from '../utils/is-function';
|
||||
import { daysInMonth } from '../units/month';
|
||||
import { isLeapYear } from '../units/year';
|
||||
|
||||
export function makeGetSet (unit, keepTime) {
|
||||
return function (value) {
|
||||
if (value != null) {
|
||||
set(this, unit, value);
|
||||
hooks.updateOffset(this, keepTime);
|
||||
return this;
|
||||
} else {
|
||||
return get(this, unit);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
export function get (mom, unit) {
|
||||
return mom.isValid() ?
|
||||
mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]() : NaN;
|
||||
}
|
||||
|
||||
export function set (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](value);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// MOMENTS
|
||||
|
||||
export function stringGet (units) {
|
||||
units = normalizeUnits(units);
|
||||
if (isFunction(this[units])) {
|
||||
return this[units]();
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
|
||||
export function stringSet (units, value) {
|
||||
if (typeof units === 'object') {
|
||||
units = normalizeObjectUnits(units);
|
||||
var prioritized = getPrioritizedUnits(units);
|
||||
for (var i = 0; i < prioritized.length; i++) {
|
||||
this[prioritized[i].unit](units[prioritized[i].unit]);
|
||||
}
|
||||
} else {
|
||||
units = normalizeUnits(units);
|
||||
if (isFunction(this[units])) {
|
||||
return this[units](value);
|
||||
}
|
||||
}
|
||||
return this;
|
||||
}
|
||||
34
WebfrontCore/wwwroot/lib/moment/src/lib/moment/locale.js
Normal file
34
WebfrontCore/wwwroot/lib/moment/src/lib/moment/locale.js
Normal file
@ -0,0 +1,34 @@
|
||||
import { getLocale } from '../locale/locales';
|
||||
import { deprecate } from '../utils/deprecate';
|
||||
|
||||
// If passed a locale key, it will set the locale for this
|
||||
// instance. Otherwise, it will return the locale configuration
|
||||
// variables for this instance.
|
||||
export function locale (key) {
|
||||
var newLocaleData;
|
||||
|
||||
if (key === undefined) {
|
||||
return this._locale._abbr;
|
||||
} else {
|
||||
newLocaleData = getLocale(key);
|
||||
if (newLocaleData != null) {
|
||||
this._locale = newLocaleData;
|
||||
}
|
||||
return this;
|
||||
}
|
||||
}
|
||||
|
||||
export var lang = deprecate(
|
||||
'moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.',
|
||||
function (key) {
|
||||
if (key === undefined) {
|
||||
return this.localeData();
|
||||
} else {
|
||||
return this.locale(key);
|
||||
}
|
||||
}
|
||||
);
|
||||
|
||||
export function localeData () {
|
||||
return this._locale;
|
||||
}
|
||||
63
WebfrontCore/wwwroot/lib/moment/src/lib/moment/min-max.js
Normal file
63
WebfrontCore/wwwroot/lib/moment/src/lib/moment/min-max.js
Normal file
@ -0,0 +1,63 @@
|
||||
import { deprecate } from '../utils/deprecate';
|
||||
import isArray from '../utils/is-array';
|
||||
import { createLocal } from '../create/local';
|
||||
import { createInvalid } from '../create/valid';
|
||||
|
||||
export var prototypeMin = deprecate(
|
||||
'moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/',
|
||||
function () {
|
||||
var other = createLocal.apply(null, arguments);
|
||||
if (this.isValid() && other.isValid()) {
|
||||
return other < this ? this : other;
|
||||
} else {
|
||||
return createInvalid();
|
||||
}
|
||||
}
|
||||
);
|
||||
|
||||
export var prototypeMax = deprecate(
|
||||
'moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/',
|
||||
function () {
|
||||
var other = createLocal.apply(null, arguments);
|
||||
if (this.isValid() && other.isValid()) {
|
||||
return other > this ? this : other;
|
||||
} else {
|
||||
return createInvalid();
|
||||
}
|
||||
}
|
||||
);
|
||||
|
||||
// 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 createLocal();
|
||||
}
|
||||
res = moments[0];
|
||||
for (i = 1; i < moments.length; ++i) {
|
||||
if (!moments[i].isValid() || moments[i][fn](res)) {
|
||||
res = moments[i];
|
||||
}
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
// TODO: Use [].sort instead?
|
||||
export function min () {
|
||||
var args = [].slice.call(arguments, 0);
|
||||
|
||||
return pickBy('isBefore', args);
|
||||
}
|
||||
|
||||
export function max () {
|
||||
var args = [].slice.call(arguments, 0);
|
||||
|
||||
return pickBy('isAfter', args);
|
||||
}
|
||||
28
WebfrontCore/wwwroot/lib/moment/src/lib/moment/moment.js
Normal file
28
WebfrontCore/wwwroot/lib/moment/src/lib/moment/moment.js
Normal file
@ -0,0 +1,28 @@
|
||||
import { createLocal } from '../create/local';
|
||||
import { createUTC } from '../create/utc';
|
||||
import { createInvalid } from '../create/valid';
|
||||
import { isMoment } from './constructor';
|
||||
import { min, max } from './min-max';
|
||||
import { now } from './now';
|
||||
import momentPrototype from './prototype';
|
||||
|
||||
function createUnix (input) {
|
||||
return createLocal(input * 1000);
|
||||
}
|
||||
|
||||
function createInZone () {
|
||||
return createLocal.apply(null, arguments).parseZone();
|
||||
}
|
||||
|
||||
export {
|
||||
now,
|
||||
min,
|
||||
max,
|
||||
isMoment,
|
||||
createUTC,
|
||||
createUnix,
|
||||
createLocal,
|
||||
createInZone,
|
||||
createInvalid,
|
||||
momentPrototype
|
||||
};
|
||||
3
WebfrontCore/wwwroot/lib/moment/src/lib/moment/now.js
Normal file
3
WebfrontCore/wwwroot/lib/moment/src/lib/moment/now.js
Normal file
@ -0,0 +1,3 @@
|
||||
export var now = function () {
|
||||
return Date.now ? Date.now() : +(new Date());
|
||||
};
|
||||
150
WebfrontCore/wwwroot/lib/moment/src/lib/moment/prototype.js
vendored
Normal file
150
WebfrontCore/wwwroot/lib/moment/src/lib/moment/prototype.js
vendored
Normal file
@ -0,0 +1,150 @@
|
||||
import { Moment } from './constructor';
|
||||
|
||||
var proto = Moment.prototype;
|
||||
|
||||
import { add, subtract } from './add-subtract';
|
||||
import { calendar, getCalendarFormat } from './calendar';
|
||||
import { clone } from './clone';
|
||||
import { isBefore, isBetween, isSame, isAfter, isSameOrAfter, isSameOrBefore } from './compare';
|
||||
import { diff } from './diff';
|
||||
import { format, toString, toISOString, inspect } from './format';
|
||||
import { from, fromNow } from './from';
|
||||
import { to, toNow } from './to';
|
||||
import { stringGet, stringSet } from './get-set';
|
||||
import { locale, localeData, lang } from './locale';
|
||||
import { prototypeMin, prototypeMax } from './min-max';
|
||||
import { startOf, endOf } from './start-end-of';
|
||||
import { valueOf, toDate, toArray, toObject, toJSON, unix } from './to-type';
|
||||
import { isValid, parsingFlags, invalidAt } from './valid';
|
||||
import { creationData } from './creation-data';
|
||||
|
||||
proto.add = add;
|
||||
proto.calendar = calendar;
|
||||
proto.clone = clone;
|
||||
proto.diff = diff;
|
||||
proto.endOf = endOf;
|
||||
proto.format = format;
|
||||
proto.from = from;
|
||||
proto.fromNow = fromNow;
|
||||
proto.to = to;
|
||||
proto.toNow = toNow;
|
||||
proto.get = stringGet;
|
||||
proto.invalidAt = invalidAt;
|
||||
proto.isAfter = isAfter;
|
||||
proto.isBefore = isBefore;
|
||||
proto.isBetween = isBetween;
|
||||
proto.isSame = isSame;
|
||||
proto.isSameOrAfter = isSameOrAfter;
|
||||
proto.isSameOrBefore = isSameOrBefore;
|
||||
proto.isValid = isValid;
|
||||
proto.lang = lang;
|
||||
proto.locale = locale;
|
||||
proto.localeData = localeData;
|
||||
proto.max = prototypeMax;
|
||||
proto.min = prototypeMin;
|
||||
proto.parsingFlags = parsingFlags;
|
||||
proto.set = stringSet;
|
||||
proto.startOf = startOf;
|
||||
proto.subtract = subtract;
|
||||
proto.toArray = toArray;
|
||||
proto.toObject = toObject;
|
||||
proto.toDate = toDate;
|
||||
proto.toISOString = toISOString;
|
||||
proto.inspect = inspect;
|
||||
proto.toJSON = toJSON;
|
||||
proto.toString = toString;
|
||||
proto.unix = unix;
|
||||
proto.valueOf = valueOf;
|
||||
proto.creationData = creationData;
|
||||
|
||||
// Year
|
||||
import { getSetYear, getIsLeapYear } from '../units/year';
|
||||
proto.year = getSetYear;
|
||||
proto.isLeapYear = getIsLeapYear;
|
||||
|
||||
// Week Year
|
||||
import { getSetWeekYear, getSetISOWeekYear, getWeeksInYear, getISOWeeksInYear } from '../units/week-year';
|
||||
proto.weekYear = getSetWeekYear;
|
||||
proto.isoWeekYear = getSetISOWeekYear;
|
||||
|
||||
// Quarter
|
||||
import { getSetQuarter } from '../units/quarter';
|
||||
proto.quarter = proto.quarters = getSetQuarter;
|
||||
|
||||
// Month
|
||||
import { getSetMonth, getDaysInMonth } from '../units/month';
|
||||
proto.month = getSetMonth;
|
||||
proto.daysInMonth = getDaysInMonth;
|
||||
|
||||
// Week
|
||||
import { getSetWeek, getSetISOWeek } from '../units/week';
|
||||
proto.week = proto.weeks = getSetWeek;
|
||||
proto.isoWeek = proto.isoWeeks = getSetISOWeek;
|
||||
proto.weeksInYear = getWeeksInYear;
|
||||
proto.isoWeeksInYear = getISOWeeksInYear;
|
||||
|
||||
// Day
|
||||
import { getSetDayOfMonth } from '../units/day-of-month';
|
||||
import { getSetDayOfWeek, getSetISODayOfWeek, getSetLocaleDayOfWeek } from '../units/day-of-week';
|
||||
import { getSetDayOfYear } from '../units/day-of-year';
|
||||
proto.date = getSetDayOfMonth;
|
||||
proto.day = proto.days = getSetDayOfWeek;
|
||||
proto.weekday = getSetLocaleDayOfWeek;
|
||||
proto.isoWeekday = getSetISODayOfWeek;
|
||||
proto.dayOfYear = getSetDayOfYear;
|
||||
|
||||
// Hour
|
||||
import { getSetHour } from '../units/hour';
|
||||
proto.hour = proto.hours = getSetHour;
|
||||
|
||||
// Minute
|
||||
import { getSetMinute } from '../units/minute';
|
||||
proto.minute = proto.minutes = getSetMinute;
|
||||
|
||||
// Second
|
||||
import { getSetSecond } from '../units/second';
|
||||
proto.second = proto.seconds = getSetSecond;
|
||||
|
||||
// Millisecond
|
||||
import { getSetMillisecond } from '../units/millisecond';
|
||||
proto.millisecond = proto.milliseconds = getSetMillisecond;
|
||||
|
||||
// Offset
|
||||
import {
|
||||
getSetOffset,
|
||||
setOffsetToUTC,
|
||||
setOffsetToLocal,
|
||||
setOffsetToParsedOffset,
|
||||
hasAlignedHourOffset,
|
||||
isDaylightSavingTime,
|
||||
isDaylightSavingTimeShifted,
|
||||
getSetZone,
|
||||
isLocal,
|
||||
isUtcOffset,
|
||||
isUtc
|
||||
} from '../units/offset';
|
||||
proto.utcOffset = getSetOffset;
|
||||
proto.utc = setOffsetToUTC;
|
||||
proto.local = setOffsetToLocal;
|
||||
proto.parseZone = setOffsetToParsedOffset;
|
||||
proto.hasAlignedHourOffset = hasAlignedHourOffset;
|
||||
proto.isDST = isDaylightSavingTime;
|
||||
proto.isLocal = isLocal;
|
||||
proto.isUtcOffset = isUtcOffset;
|
||||
proto.isUtc = isUtc;
|
||||
proto.isUTC = isUtc;
|
||||
|
||||
// Timezone
|
||||
import { getZoneAbbr, getZoneName } from '../units/timezone';
|
||||
proto.zoneAbbr = getZoneAbbr;
|
||||
proto.zoneName = getZoneName;
|
||||
|
||||
// Deprecations
|
||||
import { deprecate } from '../utils/deprecate';
|
||||
proto.dates = deprecate('dates accessor is deprecated. Use date instead.', getSetDayOfMonth);
|
||||
proto.months = deprecate('months accessor is deprecated. Use month instead', getSetMonth);
|
||||
proto.years = deprecate('years accessor is deprecated. Use year instead', getSetYear);
|
||||
proto.zone = deprecate('moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/', getSetZone);
|
||||
proto.isDSTShifted = deprecate('isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information', isDaylightSavingTimeShifted);
|
||||
|
||||
export default proto;
|
||||
@ -0,0 +1,59 @@
|
||||
import { normalizeUnits } from '../units/aliases';
|
||||
|
||||
export function startOf (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':
|
||||
case 'date':
|
||||
this.hours(0);
|
||||
/* falls through */
|
||||
case 'hour':
|
||||
this.minutes(0);
|
||||
/* falls through */
|
||||
case 'minute':
|
||||
this.seconds(0);
|
||||
/* falls through */
|
||||
case 'second':
|
||||
this.milliseconds(0);
|
||||
}
|
||||
|
||||
// weeks are a special case
|
||||
if (units === 'week') {
|
||||
this.weekday(0);
|
||||
}
|
||||
if (units === 'isoWeek') {
|
||||
this.isoWeekday(1);
|
||||
}
|
||||
|
||||
// quarters are also special
|
||||
if (units === 'quarter') {
|
||||
this.month(Math.floor(this.month() / 3) * 3);
|
||||
}
|
||||
|
||||
return this;
|
||||
}
|
||||
|
||||
export function endOf (units) {
|
||||
units = normalizeUnits(units);
|
||||
if (units === undefined || units === 'millisecond') {
|
||||
return this;
|
||||
}
|
||||
|
||||
// 'date' is an alias for 'day', so it should be considered as such.
|
||||
if (units === 'date') {
|
||||
units = 'day';
|
||||
}
|
||||
|
||||
return this.startOf(units).add(1, (units === 'isoWeek' ? 'week' : units)).subtract(1, 'ms');
|
||||
}
|
||||
34
WebfrontCore/wwwroot/lib/moment/src/lib/moment/to-type.js
Normal file
34
WebfrontCore/wwwroot/lib/moment/src/lib/moment/to-type.js
Normal file
@ -0,0 +1,34 @@
|
||||
export function valueOf () {
|
||||
return this._d.valueOf() - ((this._offset || 0) * 60000);
|
||||
}
|
||||
|
||||
export function unix () {
|
||||
return Math.floor(this.valueOf() / 1000);
|
||||
}
|
||||
|
||||
export function toDate () {
|
||||
return new Date(this.valueOf());
|
||||
}
|
||||
|
||||
export function toArray () {
|
||||
var m = this;
|
||||
return [m.year(), m.month(), m.date(), m.hour(), m.minute(), m.second(), m.millisecond()];
|
||||
}
|
||||
|
||||
export function toObject () {
|
||||
var m = this;
|
||||
return {
|
||||
years: m.year(),
|
||||
months: m.month(),
|
||||
date: m.date(),
|
||||
hours: m.hours(),
|
||||
minutes: m.minutes(),
|
||||
seconds: m.seconds(),
|
||||
milliseconds: m.milliseconds()
|
||||
};
|
||||
}
|
||||
|
||||
export function toJSON () {
|
||||
// new Date(NaN).toJSON() === null
|
||||
return this.isValid() ? this.toISOString() : null;
|
||||
}
|
||||
17
WebfrontCore/wwwroot/lib/moment/src/lib/moment/to.js
Normal file
17
WebfrontCore/wwwroot/lib/moment/src/lib/moment/to.js
Normal file
@ -0,0 +1,17 @@
|
||||
import { createDuration } from '../duration/create';
|
||||
import { createLocal } from '../create/local';
|
||||
import { isMoment } from '../moment/constructor';
|
||||
|
||||
export function to (time, withoutSuffix) {
|
||||
if (this.isValid() &&
|
||||
((isMoment(time) && time.isValid()) ||
|
||||
createLocal(time).isValid())) {
|
||||
return createDuration({from: this, to: time}).locale(this.locale()).humanize(!withoutSuffix);
|
||||
} else {
|
||||
return this.localeData().invalidDate();
|
||||
}
|
||||
}
|
||||
|
||||
export function toNow (withoutSuffix) {
|
||||
return this.to(createLocal(), withoutSuffix);
|
||||
}
|
||||
15
WebfrontCore/wwwroot/lib/moment/src/lib/moment/valid.js
Normal file
15
WebfrontCore/wwwroot/lib/moment/src/lib/moment/valid.js
Normal file
@ -0,0 +1,15 @@
|
||||
import { isValid as _isValid } from '../create/valid';
|
||||
import extend from '../utils/extend';
|
||||
import getParsingFlags from '../create/parsing-flags';
|
||||
|
||||
export function isValid () {
|
||||
return _isValid(this);
|
||||
}
|
||||
|
||||
export function parsingFlags () {
|
||||
return extend({}, getParsingFlags(this));
|
||||
}
|
||||
|
||||
export function invalidAt () {
|
||||
return getParsingFlags(this).overflow;
|
||||
}
|
||||
54
WebfrontCore/wwwroot/lib/moment/src/lib/parse/regex.js
Normal file
54
WebfrontCore/wwwroot/lib/moment/src/lib/parse/regex.js
Normal file
@ -0,0 +1,54 @@
|
||||
export var match1 = /\d/; // 0 - 9
|
||||
export var match2 = /\d\d/; // 00 - 99
|
||||
export var match3 = /\d{3}/; // 000 - 999
|
||||
export var match4 = /\d{4}/; // 0000 - 9999
|
||||
export var match6 = /[+-]?\d{6}/; // -999999 - 999999
|
||||
export var match1to2 = /\d\d?/; // 0 - 99
|
||||
export var match3to4 = /\d\d\d\d?/; // 999 - 9999
|
||||
export var match5to6 = /\d\d\d\d\d\d?/; // 99999 - 999999
|
||||
export var match1to3 = /\d{1,3}/; // 0 - 999
|
||||
export var match1to4 = /\d{1,4}/; // 0 - 9999
|
||||
export var match1to6 = /[+-]?\d{1,6}/; // -999999 - 999999
|
||||
|
||||
export var matchUnsigned = /\d+/; // 0 - inf
|
||||
export var matchSigned = /[+-]?\d+/; // -inf - inf
|
||||
|
||||
export var matchOffset = /Z|[+-]\d\d:?\d\d/gi; // +00:00 -00:00 +0000 -0000 or Z
|
||||
export var matchShortOffset = /Z|[+-]\d\d(?::?\d\d)?/gi; // +00 -00 +00:00 -00:00 +0000 -0000 or Z
|
||||
|
||||
export 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
|
||||
export var matchWord = /[0-9]{0,256}['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFF07\uFF10-\uFFEF]{1,256}|[\u0600-\u06FF\/]{1,256}(\s*?[\u0600-\u06FF]{1,256}){1,2}/i;
|
||||
|
||||
|
||||
import hasOwnProp from '../utils/has-own-prop';
|
||||
import isFunction from '../utils/is-function';
|
||||
|
||||
var regexes = {};
|
||||
|
||||
export function addRegexToken (token, regex, strictRegex) {
|
||||
regexes[token] = isFunction(regex) ? regex : function (isStrict, localeData) {
|
||||
return (isStrict && strictRegex) ? strictRegex : regex;
|
||||
};
|
||||
}
|
||||
|
||||
export 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;
|
||||
}));
|
||||
}
|
||||
|
||||
export function regexEscape(s) {
|
||||
return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
|
||||
}
|
||||
33
WebfrontCore/wwwroot/lib/moment/src/lib/parse/token.js
Normal file
33
WebfrontCore/wwwroot/lib/moment/src/lib/parse/token.js
Normal file
@ -0,0 +1,33 @@
|
||||
import hasOwnProp from '../utils/has-own-prop';
|
||||
import isNumber from '../utils/is-number';
|
||||
import toInt from '../utils/to-int';
|
||||
|
||||
var tokens = {};
|
||||
|
||||
export function addParseToken (token, callback) {
|
||||
var i, func = callback;
|
||||
if (typeof token === 'string') {
|
||||
token = [token];
|
||||
}
|
||||
if (isNumber(callback)) {
|
||||
func = function (input, array) {
|
||||
array[callback] = toInt(input);
|
||||
};
|
||||
}
|
||||
for (i = 0; i < token.length; i++) {
|
||||
tokens[token[i]] = func;
|
||||
}
|
||||
}
|
||||
|
||||
export function addWeekParseToken (token, callback) {
|
||||
addParseToken(token, function (input, array, config, token) {
|
||||
config._w = config._w || {};
|
||||
callback(input, config._w, config, token);
|
||||
});
|
||||
}
|
||||
|
||||
export function addTimeToArrayFromToken(token, input, config) {
|
||||
if (input != null && hasOwnProp(tokens, token)) {
|
||||
tokens[token](input, config._a, config, token);
|
||||
}
|
||||
}
|
||||
30
WebfrontCore/wwwroot/lib/moment/src/lib/units/aliases.js
Normal file
30
WebfrontCore/wwwroot/lib/moment/src/lib/units/aliases.js
Normal file
@ -0,0 +1,30 @@
|
||||
import hasOwnProp from '../utils/has-own-prop';
|
||||
|
||||
var aliases = {};
|
||||
|
||||
export function addUnitAlias (unit, shorthand) {
|
||||
var lowerCase = unit.toLowerCase();
|
||||
aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit;
|
||||
}
|
||||
|
||||
export function normalizeUnits(units) {
|
||||
return typeof units === 'string' ? aliases[units] || aliases[units.toLowerCase()] : undefined;
|
||||
}
|
||||
|
||||
export 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;
|
||||
}
|
||||
|
||||
@ -0,0 +1,9 @@
|
||||
export var YEAR = 0;
|
||||
export var MONTH = 1;
|
||||
export var DATE = 2;
|
||||
export var HOUR = 3;
|
||||
export var MINUTE = 4;
|
||||
export var SECOND = 5;
|
||||
export var MILLISECOND = 6;
|
||||
export var WEEK = 7;
|
||||
export var WEEKDAY = 8;
|
||||
@ -0,0 +1,39 @@
|
||||
import { makeGetSet } from '../moment/get-set';
|
||||
import { addFormatToken } from '../format/format';
|
||||
import { addUnitAlias } from './aliases';
|
||||
import { addUnitPriority } from './priorities';
|
||||
import { addRegexToken, match1to2, match2 } from '../parse/regex';
|
||||
import { addParseToken } from '../parse/token';
|
||||
import { DATE } from './constants';
|
||||
import toInt from '../utils/to-int';
|
||||
|
||||
// FORMATTING
|
||||
|
||||
addFormatToken('D', ['DD', 2], 'Do', 'date');
|
||||
|
||||
// ALIASES
|
||||
|
||||
addUnitAlias('date', 'D');
|
||||
|
||||
// PRIOROITY
|
||||
addUnitPriority('date', 9);
|
||||
|
||||
// PARSING
|
||||
|
||||
addRegexToken('D', match1to2);
|
||||
addRegexToken('DD', match1to2, match2);
|
||||
addRegexToken('Do', function (isStrict, locale) {
|
||||
// TODO: Remove "ordinalParse" fallback in next major release.
|
||||
return isStrict ?
|
||||
(locale._dayOfMonthOrdinalParse || locale._ordinalParse) :
|
||||
locale._dayOfMonthOrdinalParseLenient;
|
||||
});
|
||||
|
||||
addParseToken(['D', 'DD'], DATE);
|
||||
addParseToken('Do', function (input, array) {
|
||||
array[DATE] = toInt(input.match(match1to2)[0]);
|
||||
});
|
||||
|
||||
// MOMENTS
|
||||
|
||||
export var getSetDayOfMonth = makeGetSet('Date', true);
|
||||
364
WebfrontCore/wwwroot/lib/moment/src/lib/units/day-of-week.js
Normal file
364
WebfrontCore/wwwroot/lib/moment/src/lib/units/day-of-week.js
Normal file
@ -0,0 +1,364 @@
|
||||
import { addFormatToken } from '../format/format';
|
||||
import { addUnitAlias } from './aliases';
|
||||
import { addUnitPriority } from './priorities';
|
||||
import { addRegexToken, match1to2, matchWord, regexEscape } from '../parse/regex';
|
||||
import { addWeekParseToken } from '../parse/token';
|
||||
import toInt from '../utils/to-int';
|
||||
import isArray from '../utils/is-array';
|
||||
import indexOf from '../utils/index-of';
|
||||
import hasOwnProp from '../utils/has-own-prop';
|
||||
import { createUTC } from '../create/utc';
|
||||
import getParsingFlags from '../create/parsing-flags';
|
||||
|
||||
// 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
|
||||
|
||||
export var defaultLocaleWeekdays = 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_');
|
||||
export 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()];
|
||||
}
|
||||
|
||||
export var defaultLocaleWeekdaysShort = 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_');
|
||||
export function localeWeekdaysShort (m) {
|
||||
return (m) ? this._weekdaysShort[m.day()] : this._weekdaysShort;
|
||||
}
|
||||
|
||||
export var defaultLocaleWeekdaysMin = 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_');
|
||||
export function localeWeekdaysMin (m) {
|
||||
return (m) ? this._weekdaysMin[m.day()] : this._weekdaysMin;
|
||||
}
|
||||
|
||||
function handleStrictParse(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;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
export function localeWeekdaysParse (weekdayName, format, strict) {
|
||||
var i, mom, regex;
|
||||
|
||||
if (this._weekdaysParseExact) {
|
||||
return handleStrictParse.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 already
|
||||
|
||||
mom = 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 regex
|
||||
if (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
|
||||
|
||||
export function getSetDayOfWeek (input) {
|
||||
if (!this.isValid()) {
|
||||
return input != null ? this : NaN;
|
||||
}
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
||||
export 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');
|
||||
}
|
||||
|
||||
export 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;
|
||||
}
|
||||
}
|
||||
|
||||
var defaultWeekdaysRegex = matchWord;
|
||||
export function weekdaysRegex (isStrict) {
|
||||
if (this._weekdaysParseExact) {
|
||||
if (!hasOwnProp(this, '_weekdaysRegex')) {
|
||||
computeWeekdaysParse.call(this);
|
||||
}
|
||||
if (isStrict) {
|
||||
return this._weekdaysStrictRegex;
|
||||
} else {
|
||||
return this._weekdaysRegex;
|
||||
}
|
||||
} else {
|
||||
if (!hasOwnProp(this, '_weekdaysRegex')) {
|
||||
this._weekdaysRegex = defaultWeekdaysRegex;
|
||||
}
|
||||
return this._weekdaysStrictRegex && isStrict ?
|
||||
this._weekdaysStrictRegex : this._weekdaysRegex;
|
||||
}
|
||||
}
|
||||
|
||||
var defaultWeekdaysShortRegex = matchWord;
|
||||
export function weekdaysShortRegex (isStrict) {
|
||||
if (this._weekdaysParseExact) {
|
||||
if (!hasOwnProp(this, '_weekdaysRegex')) {
|
||||
computeWeekdaysParse.call(this);
|
||||
}
|
||||
if (isStrict) {
|
||||
return this._weekdaysShortStrictRegex;
|
||||
} else {
|
||||
return this._weekdaysShortRegex;
|
||||
}
|
||||
} else {
|
||||
if (!hasOwnProp(this, '_weekdaysShortRegex')) {
|
||||
this._weekdaysShortRegex = defaultWeekdaysShortRegex;
|
||||
}
|
||||
return this._weekdaysShortStrictRegex && isStrict ?
|
||||
this._weekdaysShortStrictRegex : this._weekdaysShortRegex;
|
||||
}
|
||||
}
|
||||
|
||||
var defaultWeekdaysMinRegex = matchWord;
|
||||
export function weekdaysMinRegex (isStrict) {
|
||||
if (this._weekdaysParseExact) {
|
||||
if (!hasOwnProp(this, '_weekdaysRegex')) {
|
||||
computeWeekdaysParse.call(this);
|
||||
}
|
||||
if (isStrict) {
|
||||
return this._weekdaysMinStrictRegex;
|
||||
} else {
|
||||
return this._weekdaysMinRegex;
|
||||
}
|
||||
} else {
|
||||
if (!hasOwnProp(this, '_weekdaysMinRegex')) {
|
||||
this._weekdaysMinRegex = defaultWeekdaysMinRegex;
|
||||
}
|
||||
return this._weekdaysMinStrictRegex && isStrict ?
|
||||
this._weekdaysMinStrictRegex : this._weekdaysMinRegex;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
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 already
|
||||
mom = 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');
|
||||
}
|
||||
36
WebfrontCore/wwwroot/lib/moment/src/lib/units/day-of-year.js
Normal file
36
WebfrontCore/wwwroot/lib/moment/src/lib/units/day-of-year.js
Normal file
@ -0,0 +1,36 @@
|
||||
import { addFormatToken } from '../format/format';
|
||||
import { addUnitAlias } from './aliases';
|
||||
import { addUnitPriority } from './priorities';
|
||||
import { addRegexToken, match3, match1to3 } from '../parse/regex';
|
||||
import { daysInYear } from './year';
|
||||
import { createUTCDate } from '../create/date-from-array';
|
||||
import { addParseToken } from '../parse/token';
|
||||
import toInt from '../utils/to-int';
|
||||
|
||||
// FORMATTING
|
||||
|
||||
addFormatToken('DDD', ['DDDD', 3], 'DDDo', 'dayOfYear');
|
||||
|
||||
// ALIASES
|
||||
|
||||
addUnitAlias('dayOfYear', 'DDD');
|
||||
|
||||
// PRIORITY
|
||||
addUnitPriority('dayOfYear', 4);
|
||||
|
||||
// PARSING
|
||||
|
||||
addRegexToken('DDD', match1to3);
|
||||
addRegexToken('DDDD', match3);
|
||||
addParseToken(['DDD', 'DDDD'], function (input, array, config) {
|
||||
config._dayOfYear = toInt(input);
|
||||
});
|
||||
|
||||
// HELPERS
|
||||
|
||||
// MOMENTS
|
||||
|
||||
export function getSetDayOfYear (input) {
|
||||
var dayOfYear = Math.round((this.clone().startOf('day') - this.clone().startOf('year')) / 864e5) + 1;
|
||||
return input == null ? dayOfYear : this.add((input - dayOfYear), 'd');
|
||||
}
|
||||
144
WebfrontCore/wwwroot/lib/moment/src/lib/units/hour.js
Normal file
144
WebfrontCore/wwwroot/lib/moment/src/lib/units/hour.js
Normal file
@ -0,0 +1,144 @@
|
||||
import { makeGetSet } from '../moment/get-set';
|
||||
import { addFormatToken } from '../format/format';
|
||||
import { addUnitAlias } from './aliases';
|
||||
import { addUnitPriority } from './priorities';
|
||||
import { addRegexToken, match1to2, match2, match3to4, match5to6 } from '../parse/regex';
|
||||
import { addParseToken } from '../parse/token';
|
||||
import { HOUR, MINUTE, SECOND } from './constants';
|
||||
import toInt from '../utils/to-int';
|
||||
import zeroFill from '../utils/zero-fill';
|
||||
import getParsingFlags from '../create/parsing-flags';
|
||||
|
||||
// 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
|
||||
|
||||
export 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');
|
||||
}
|
||||
|
||||
export var defaultLocaleMeridiemParse = /[ap]\.?m?\.?/i;
|
||||
export function localeMeridiem (hours, minutes, isLower) {
|
||||
if (hours > 11) {
|
||||
return isLower ? 'pm' : 'PM';
|
||||
} else {
|
||||
return isLower ? 'am' : 'AM';
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// 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.
|
||||
export var getSetHour = makeGetSet('Hours', true);
|
||||
69
WebfrontCore/wwwroot/lib/moment/src/lib/units/millisecond.js
Normal file
69
WebfrontCore/wwwroot/lib/moment/src/lib/units/millisecond.js
Normal file
@ -0,0 +1,69 @@
|
||||
import { makeGetSet } from '../moment/get-set';
|
||||
import { addFormatToken } from '../format/format';
|
||||
import { addUnitAlias } from './aliases';
|
||||
import { addUnitPriority } from './priorities';
|
||||
import { addRegexToken, match1, match2, match3, match1to3, matchUnsigned } from '../parse/regex';
|
||||
import { addParseToken } from '../parse/token';
|
||||
import { MILLISECOND } from './constants';
|
||||
import toInt from '../utils/to-int';
|
||||
|
||||
// FORMATTING
|
||||
|
||||
addFormatToken('S', 0, 0, function () {
|
||||
return ~~(this.millisecond() / 100);
|
||||
});
|
||||
|
||||
addFormatToken(0, ['SS', 2], 0, function () {
|
||||
return ~~(this.millisecond() / 10);
|
||||
});
|
||||
|
||||
addFormatToken(0, ['SSS', 3], 0, 'millisecond');
|
||||
addFormatToken(0, ['SSSS', 4], 0, function () {
|
||||
return this.millisecond() * 10;
|
||||
});
|
||||
addFormatToken(0, ['SSSSS', 5], 0, function () {
|
||||
return this.millisecond() * 100;
|
||||
});
|
||||
addFormatToken(0, ['SSSSSS', 6], 0, function () {
|
||||
return this.millisecond() * 1000;
|
||||
});
|
||||
addFormatToken(0, ['SSSSSSS', 7], 0, function () {
|
||||
return this.millisecond() * 10000;
|
||||
});
|
||||
addFormatToken(0, ['SSSSSSSS', 8], 0, function () {
|
||||
return this.millisecond() * 100000;
|
||||
});
|
||||
addFormatToken(0, ['SSSSSSSSS', 9], 0, function () {
|
||||
return this.millisecond() * 1000000;
|
||||
});
|
||||
|
||||
|
||||
// ALIASES
|
||||
|
||||
addUnitAlias('millisecond', 'ms');
|
||||
|
||||
// PRIORITY
|
||||
|
||||
addUnitPriority('millisecond', 16);
|
||||
|
||||
// PARSING
|
||||
|
||||
addRegexToken('S', match1to3, match1);
|
||||
addRegexToken('SS', match1to3, match2);
|
||||
addRegexToken('SSS', match1to3, match3);
|
||||
|
||||
var token;
|
||||
for (token = 'SSSS'; token.length <= 9; token += 'S') {
|
||||
addRegexToken(token, matchUnsigned);
|
||||
}
|
||||
|
||||
function parseMs(input, array) {
|
||||
array[MILLISECOND] = toInt(('0.' + input) * 1000);
|
||||
}
|
||||
|
||||
for (token = 'S'; token.length <= 9; token += 'S') {
|
||||
addParseToken(token, parseMs);
|
||||
}
|
||||
// MOMENTS
|
||||
|
||||
export var getSetMillisecond = makeGetSet('Milliseconds', false);
|
||||
29
WebfrontCore/wwwroot/lib/moment/src/lib/units/minute.js
Normal file
29
WebfrontCore/wwwroot/lib/moment/src/lib/units/minute.js
Normal file
@ -0,0 +1,29 @@
|
||||
import { makeGetSet } from '../moment/get-set';
|
||||
import { addFormatToken } from '../format/format';
|
||||
import { addUnitAlias } from './aliases';
|
||||
import { addUnitPriority } from './priorities';
|
||||
import { addRegexToken, match1to2, match2 } from '../parse/regex';
|
||||
import { addParseToken } from '../parse/token';
|
||||
import { MINUTE } from './constants';
|
||||
|
||||
// FORMATTING
|
||||
|
||||
addFormatToken('m', ['mm', 2], 0, 'minute');
|
||||
|
||||
// ALIASES
|
||||
|
||||
addUnitAlias('minute', 'm');
|
||||
|
||||
// PRIORITY
|
||||
|
||||
addUnitPriority('minute', 14);
|
||||
|
||||
// PARSING
|
||||
|
||||
addRegexToken('m', match1to2);
|
||||
addRegexToken('mm', match1to2, match2);
|
||||
addParseToken(['m', 'mm'], MINUTE);
|
||||
|
||||
// MOMENTS
|
||||
|
||||
export var getSetMinute = makeGetSet('Minutes', false);
|
||||
290
WebfrontCore/wwwroot/lib/moment/src/lib/units/month.js
Normal file
290
WebfrontCore/wwwroot/lib/moment/src/lib/units/month.js
Normal file
@ -0,0 +1,290 @@
|
||||
import { get } from '../moment/get-set';
|
||||
import hasOwnProp from '../utils/has-own-prop';
|
||||
import { addFormatToken } from '../format/format';
|
||||
import { addUnitAlias } from './aliases';
|
||||
import { addUnitPriority } from './priorities';
|
||||
import { addRegexToken, match1to2, match2, matchWord, regexEscape } from '../parse/regex';
|
||||
import { addParseToken } from '../parse/token';
|
||||
import { hooks } from '../utils/hooks';
|
||||
import { MONTH } from './constants';
|
||||
import toInt from '../utils/to-int';
|
||||
import isArray from '../utils/is-array';
|
||||
import isNumber from '../utils/is-number';
|
||||
import mod from '../utils/mod';
|
||||
import indexOf from '../utils/index-of';
|
||||
import { createUTC } from '../create/utc';
|
||||
import getParsingFlags from '../create/parsing-flags';
|
||||
import { isLeapYear } from '../units/year';
|
||||
|
||||
export 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?/;
|
||||
export var defaultLocaleMonths = 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_');
|
||||
export 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()];
|
||||
}
|
||||
|
||||
export var defaultLocaleMonthsShort = 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_');
|
||||
export 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;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
export 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 already
|
||||
mom = 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 regex
|
||||
if (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
|
||||
|
||||
export function setMonth (mom, value) {
|
||||
var dayOfMonth;
|
||||
|
||||
if (!mom.isValid()) {
|
||||
// No op
|
||||
return 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;
|
||||
}
|
||||
|
||||
export function getSetMonth (value) {
|
||||
if (value != null) {
|
||||
setMonth(this, value);
|
||||
hooks.updateOffset(this, true);
|
||||
return this;
|
||||
} else {
|
||||
return get(this, 'Month');
|
||||
}
|
||||
}
|
||||
|
||||
export function getDaysInMonth () {
|
||||
return daysInMonth(this.year(), this.month());
|
||||
}
|
||||
|
||||
var defaultMonthsShortRegex = matchWord;
|
||||
export function monthsShortRegex (isStrict) {
|
||||
if (this._monthsParseExact) {
|
||||
if (!hasOwnProp(this, '_monthsRegex')) {
|
||||
computeMonthsParse.call(this);
|
||||
}
|
||||
if (isStrict) {
|
||||
return this._monthsShortStrictRegex;
|
||||
} else {
|
||||
return this._monthsShortRegex;
|
||||
}
|
||||
} else {
|
||||
if (!hasOwnProp(this, '_monthsShortRegex')) {
|
||||
this._monthsShortRegex = defaultMonthsShortRegex;
|
||||
}
|
||||
return this._monthsShortStrictRegex && isStrict ?
|
||||
this._monthsShortStrictRegex : this._monthsShortRegex;
|
||||
}
|
||||
}
|
||||
|
||||
var defaultMonthsRegex = matchWord;
|
||||
export function monthsRegex (isStrict) {
|
||||
if (this._monthsParseExact) {
|
||||
if (!hasOwnProp(this, '_monthsRegex')) {
|
||||
computeMonthsParse.call(this);
|
||||
}
|
||||
if (isStrict) {
|
||||
return this._monthsStrictRegex;
|
||||
} else {
|
||||
return this._monthsRegex;
|
||||
}
|
||||
} else {
|
||||
if (!hasOwnProp(this, '_monthsRegex')) {
|
||||
this._monthsRegex = defaultMonthsRegex;
|
||||
}
|
||||
return this._monthsStrictRegex && isStrict ?
|
||||
this._monthsStrictRegex : this._monthsRegex;
|
||||
}
|
||||
}
|
||||
|
||||
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 already
|
||||
mom = 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');
|
||||
}
|
||||
235
WebfrontCore/wwwroot/lib/moment/src/lib/units/offset.js
Normal file
235
WebfrontCore/wwwroot/lib/moment/src/lib/units/offset.js
Normal file
@ -0,0 +1,235 @@
|
||||
import zeroFill from '../utils/zero-fill';
|
||||
import { createDuration } from '../duration/create';
|
||||
import { addSubtract } from '../moment/add-subtract';
|
||||
import { isMoment, copyConfig } from '../moment/constructor';
|
||||
import { addFormatToken } from '../format/format';
|
||||
import { addRegexToken, matchOffset, matchShortOffset } from '../parse/regex';
|
||||
import { addParseToken } from '../parse/token';
|
||||
import { createLocal } from '../create/local';
|
||||
import { prepareConfig } from '../create/from-anything';
|
||||
import { createUTC } from '../create/utc';
|
||||
import isDate from '../utils/is-date';
|
||||
import toInt from '../utils/to-int';
|
||||
import isUndefined from '../utils/is-undefined';
|
||||
import compareArrays from '../utils/compare-arrays';
|
||||
import { hooks } from '../utils/hooks';
|
||||
|
||||
// FORMATTING
|
||||
|
||||
function offset (token, separator) {
|
||||
addFormatToken(token, 0, 0, function () {
|
||||
var offset = this.utcOffset();
|
||||
var sign = '+';
|
||||
if (offset < 0) {
|
||||
offset = -offset;
|
||||
sign = '-';
|
||||
}
|
||||
return sign + zeroFill(~~(offset / 60), 2) + separator + zeroFill(~~(offset) % 60, 2);
|
||||
});
|
||||
}
|
||||
|
||||
offset('Z', ':');
|
||||
offset('ZZ', '');
|
||||
|
||||
// PARSING
|
||||
|
||||
addRegexToken('Z', matchShortOffset);
|
||||
addRegexToken('ZZ', matchShortOffset);
|
||||
addParseToken(['Z', 'ZZ'], function (input, array, config) {
|
||||
config._useUTC = true;
|
||||
config._tzm = offsetFromString(matchShortOffset, input);
|
||||
});
|
||||
|
||||
// HELPERS
|
||||
|
||||
// timezone chunker
|
||||
// '+10:00' > ['10', '00']
|
||||
// '-1530' > ['-15', '30']
|
||||
var chunkOffset = /([\+\-]|\d\d)/gi;
|
||||
|
||||
function offsetFromString(matcher, string) {
|
||||
var matches = (string || '').match(matcher);
|
||||
|
||||
if (matches === null) {
|
||||
return null;
|
||||
}
|
||||
|
||||
var chunk = matches[matches.length - 1] || [];
|
||||
var parts = (chunk + '').match(chunkOffset) || ['-', 0, 0];
|
||||
var minutes = +(parts[1] * 60) + toInt(parts[2]);
|
||||
|
||||
return minutes === 0 ?
|
||||
0 :
|
||||
parts[0] === '+' ? minutes : -minutes;
|
||||
}
|
||||
|
||||
// Return a moment from input, that is local/utc/zone equivalent to model.
|
||||
export function cloneWithOffset(input, model) {
|
||||
var res, diff;
|
||||
if (model._isUTC) {
|
||||
res = model.clone();
|
||||
diff = (isMoment(input) || isDate(input) ? input.valueOf() : createLocal(input).valueOf()) - res.valueOf();
|
||||
// Use low-level api, because this fn is low-level api.
|
||||
res._d.setTime(res._d.valueOf() + diff);
|
||||
hooks.updateOffset(res, false);
|
||||
return res;
|
||||
} else {
|
||||
return createLocal(input).local();
|
||||
}
|
||||
}
|
||||
|
||||
function getDateOffset (m) {
|
||||
// On Firefox.24 Date#getTimezoneOffset returns a floating point.
|
||||
// https://github.com/moment/moment/pull/1871
|
||||
return -Math.round(m._d.getTimezoneOffset() / 15) * 15;
|
||||
}
|
||||
|
||||
// HOOKS
|
||||
|
||||
// This function will be called whenever a moment is mutated.
|
||||
// It is intended to keep the offset in sync with the timezone.
|
||||
hooks.updateOffset = function () {};
|
||||
|
||||
// MOMENTS
|
||||
|
||||
// keepLocalTime = true means only change the timezone, without
|
||||
// affecting the local hour. So 5:31:26 +0300 --[utcOffset(2, true)]-->
|
||||
// 5:31:26 +0200 It is possible that 5:31:26 doesn't exist with offset
|
||||
// +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.
|
||||
export function getSetOffset (input, keepLocalTime, keepMinutes) {
|
||||
var offset = this._offset || 0,
|
||||
localAdjust;
|
||||
if (!this.isValid()) {
|
||||
return input != null ? this : NaN;
|
||||
}
|
||||
if (input != null) {
|
||||
if (typeof input === 'string') {
|
||||
input = offsetFromString(matchShortOffset, input);
|
||||
if (input === null) {
|
||||
return this;
|
||||
}
|
||||
} else if (Math.abs(input) < 16 && !keepMinutes) {
|
||||
input = input * 60;
|
||||
}
|
||||
if (!this._isUTC && keepLocalTime) {
|
||||
localAdjust = getDateOffset(this);
|
||||
}
|
||||
this._offset = input;
|
||||
this._isUTC = true;
|
||||
if (localAdjust != null) {
|
||||
this.add(localAdjust, 'm');
|
||||
}
|
||||
if (offset !== input) {
|
||||
if (!keepLocalTime || this._changeInProgress) {
|
||||
addSubtract(this, createDuration(input - offset, 'm'), 1, false);
|
||||
} else if (!this._changeInProgress) {
|
||||
this._changeInProgress = true;
|
||||
hooks.updateOffset(this, true);
|
||||
this._changeInProgress = null;
|
||||
}
|
||||
}
|
||||
return this;
|
||||
} else {
|
||||
return this._isUTC ? offset : getDateOffset(this);
|
||||
}
|
||||
}
|
||||
|
||||
export function getSetZone (input, keepLocalTime) {
|
||||
if (input != null) {
|
||||
if (typeof input !== 'string') {
|
||||
input = -input;
|
||||
}
|
||||
|
||||
this.utcOffset(input, keepLocalTime);
|
||||
|
||||
return this;
|
||||
} else {
|
||||
return -this.utcOffset();
|
||||
}
|
||||
}
|
||||
|
||||
export function setOffsetToUTC (keepLocalTime) {
|
||||
return this.utcOffset(0, keepLocalTime);
|
||||
}
|
||||
|
||||
export function setOffsetToLocal (keepLocalTime) {
|
||||
if (this._isUTC) {
|
||||
this.utcOffset(0, keepLocalTime);
|
||||
this._isUTC = false;
|
||||
|
||||
if (keepLocalTime) {
|
||||
this.subtract(getDateOffset(this), 'm');
|
||||
}
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
export function setOffsetToParsedOffset () {
|
||||
if (this._tzm != null) {
|
||||
this.utcOffset(this._tzm, false, true);
|
||||
} else if (typeof this._i === 'string') {
|
||||
var tZone = offsetFromString(matchOffset, this._i);
|
||||
if (tZone != null) {
|
||||
this.utcOffset(tZone);
|
||||
}
|
||||
else {
|
||||
this.utcOffset(0, true);
|
||||
}
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
export function hasAlignedHourOffset (input) {
|
||||
if (!this.isValid()) {
|
||||
return false;
|
||||
}
|
||||
input = input ? createLocal(input).utcOffset() : 0;
|
||||
|
||||
return (this.utcOffset() - input) % 60 === 0;
|
||||
}
|
||||
|
||||
export function isDaylightSavingTime () {
|
||||
return (
|
||||
this.utcOffset() > this.clone().month(0).utcOffset() ||
|
||||
this.utcOffset() > this.clone().month(5).utcOffset()
|
||||
);
|
||||
}
|
||||
|
||||
export function isDaylightSavingTimeShifted () {
|
||||
if (!isUndefined(this._isDSTShifted)) {
|
||||
return this._isDSTShifted;
|
||||
}
|
||||
|
||||
var c = {};
|
||||
|
||||
copyConfig(c, this);
|
||||
c = prepareConfig(c);
|
||||
|
||||
if (c._a) {
|
||||
var other = c._isUTC ? createUTC(c._a) : createLocal(c._a);
|
||||
this._isDSTShifted = this.isValid() &&
|
||||
compareArrays(c._a, other.toArray()) > 0;
|
||||
} else {
|
||||
this._isDSTShifted = false;
|
||||
}
|
||||
|
||||
return this._isDSTShifted;
|
||||
}
|
||||
|
||||
export function isLocal () {
|
||||
return this.isValid() ? !this._isUTC : false;
|
||||
}
|
||||
|
||||
export function isUtcOffset () {
|
||||
return this.isValid() ? this._isUTC : false;
|
||||
}
|
||||
|
||||
export function isUtc () {
|
||||
return this.isValid() ? this._isUTC && this._offset === 0 : false;
|
||||
}
|
||||
16
WebfrontCore/wwwroot/lib/moment/src/lib/units/priorities.js
Normal file
16
WebfrontCore/wwwroot/lib/moment/src/lib/units/priorities.js
Normal file
@ -0,0 +1,16 @@
|
||||
var priorities = {};
|
||||
|
||||
export function addUnitPriority(unit, priority) {
|
||||
priorities[unit] = priority;
|
||||
}
|
||||
|
||||
export function getPrioritizedUnits(unitsObj) {
|
||||
var units = [];
|
||||
for (var u in unitsObj) {
|
||||
units.push({unit: u, priority: priorities[u]});
|
||||
}
|
||||
units.sort(function (a, b) {
|
||||
return a.priority - b.priority;
|
||||
});
|
||||
return units;
|
||||
}
|
||||
32
WebfrontCore/wwwroot/lib/moment/src/lib/units/quarter.js
Normal file
32
WebfrontCore/wwwroot/lib/moment/src/lib/units/quarter.js
Normal file
@ -0,0 +1,32 @@
|
||||
import { addFormatToken } from '../format/format';
|
||||
import { addUnitAlias } from './aliases';
|
||||
import { addUnitPriority } from './priorities';
|
||||
import { addRegexToken, match1 } from '../parse/regex';
|
||||
import { addParseToken } from '../parse/token';
|
||||
import { MONTH } from './constants';
|
||||
import toInt from '../utils/to-int';
|
||||
|
||||
// FORMATTING
|
||||
|
||||
addFormatToken('Q', 0, 'Qo', 'quarter');
|
||||
|
||||
// ALIASES
|
||||
|
||||
addUnitAlias('quarter', 'Q');
|
||||
|
||||
// PRIORITY
|
||||
|
||||
addUnitPriority('quarter', 7);
|
||||
|
||||
// PARSING
|
||||
|
||||
addRegexToken('Q', match1);
|
||||
addParseToken('Q', function (input, array) {
|
||||
array[MONTH] = (toInt(input) - 1) * 3;
|
||||
});
|
||||
|
||||
// MOMENTS
|
||||
|
||||
export function getSetQuarter (input) {
|
||||
return input == null ? Math.ceil((this.month() + 1) / 3) : this.month((input - 1) * 3 + this.month() % 3);
|
||||
}
|
||||
29
WebfrontCore/wwwroot/lib/moment/src/lib/units/second.js
Normal file
29
WebfrontCore/wwwroot/lib/moment/src/lib/units/second.js
Normal file
@ -0,0 +1,29 @@
|
||||
import { makeGetSet } from '../moment/get-set';
|
||||
import { addFormatToken } from '../format/format';
|
||||
import { addUnitAlias } from './aliases';
|
||||
import { addUnitPriority } from './priorities';
|
||||
import { addRegexToken, match1to2, match2 } from '../parse/regex';
|
||||
import { addParseToken } from '../parse/token';
|
||||
import { SECOND } from './constants';
|
||||
|
||||
// FORMATTING
|
||||
|
||||
addFormatToken('s', ['ss', 2], 0, 'second');
|
||||
|
||||
// ALIASES
|
||||
|
||||
addUnitAlias('second', 's');
|
||||
|
||||
// PRIORITY
|
||||
|
||||
addUnitPriority('second', 15);
|
||||
|
||||
// PARSING
|
||||
|
||||
addRegexToken('s', match1to2);
|
||||
addRegexToken('ss', match1to2, match2);
|
||||
addParseToken(['s', 'ss'], SECOND);
|
||||
|
||||
// MOMENTS
|
||||
|
||||
export var getSetSecond = makeGetSet('Seconds', false);
|
||||
20
WebfrontCore/wwwroot/lib/moment/src/lib/units/timestamp.js
Normal file
20
WebfrontCore/wwwroot/lib/moment/src/lib/units/timestamp.js
Normal file
@ -0,0 +1,20 @@
|
||||
import { addFormatToken } from '../format/format';
|
||||
import { addRegexToken, matchTimestamp, matchSigned } from '../parse/regex';
|
||||
import { addParseToken } from '../parse/token';
|
||||
import toInt from '../utils/to-int';
|
||||
|
||||
// FORMATTING
|
||||
|
||||
addFormatToken('X', 0, 0, 'unix');
|
||||
addFormatToken('x', 0, 0, 'valueOf');
|
||||
|
||||
// PARSING
|
||||
|
||||
addRegexToken('x', matchSigned);
|
||||
addRegexToken('X', matchTimestamp);
|
||||
addParseToken('X', function (input, array, config) {
|
||||
config._d = new Date(parseFloat(input, 10) * 1000);
|
||||
});
|
||||
addParseToken('x', function (input, array, config) {
|
||||
config._d = new Date(toInt(input));
|
||||
});
|
||||
16
WebfrontCore/wwwroot/lib/moment/src/lib/units/timezone.js
Normal file
16
WebfrontCore/wwwroot/lib/moment/src/lib/units/timezone.js
Normal file
@ -0,0 +1,16 @@
|
||||
import { addFormatToken } from '../format/format';
|
||||
|
||||
// FORMATTING
|
||||
|
||||
addFormatToken('z', 0, 0, 'zoneAbbr');
|
||||
addFormatToken('zz', 0, 0, 'zoneName');
|
||||
|
||||
// MOMENTS
|
||||
|
||||
export function getZoneAbbr () {
|
||||
return this._isUTC ? 'UTC' : '';
|
||||
}
|
||||
|
||||
export function getZoneName () {
|
||||
return this._isUTC ? 'Coordinated Universal Time' : '';
|
||||
}
|
||||
20
WebfrontCore/wwwroot/lib/moment/src/lib/units/units.js
Normal file
20
WebfrontCore/wwwroot/lib/moment/src/lib/units/units.js
Normal file
@ -0,0 +1,20 @@
|
||||
// Side effect imports
|
||||
import './day-of-month';
|
||||
import './day-of-week';
|
||||
import './day-of-year';
|
||||
import './hour';
|
||||
import './millisecond';
|
||||
import './minute';
|
||||
import './month';
|
||||
import './offset';
|
||||
import './quarter';
|
||||
import './second';
|
||||
import './timestamp';
|
||||
import './timezone';
|
||||
import './week-year';
|
||||
import './week';
|
||||
import './year';
|
||||
|
||||
import { normalizeUnits } from './aliases';
|
||||
|
||||
export { normalizeUnits };
|
||||
@ -0,0 +1,65 @@
|
||||
import { daysInYear } from './year';
|
||||
import { createLocal } from '../create/local';
|
||||
import { createUTCDate } from '../create/date-from-array';
|
||||
|
||||
// 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
|
||||
export 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
|
||||
};
|
||||
}
|
||||
|
||||
export 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
|
||||
};
|
||||
}
|
||||
|
||||
export function weeksInYear(year, dow, doy) {
|
||||
var weekOffset = firstWeekOffset(year, dow, doy),
|
||||
weekOffsetNext = firstWeekOffset(year + 1, dow, doy);
|
||||
return (daysInYear(year) - weekOffset + weekOffsetNext) / 7;
|
||||
}
|
||||
107
WebfrontCore/wwwroot/lib/moment/src/lib/units/week-year.js
Normal file
107
WebfrontCore/wwwroot/lib/moment/src/lib/units/week-year.js
Normal file
@ -0,0 +1,107 @@
|
||||
import { addFormatToken } from '../format/format';
|
||||
import { addUnitAlias } from './aliases';
|
||||
import { addUnitPriority } from './priorities';
|
||||
import { addRegexToken, match1to2, match1to4, match1to6, match2, match4, match6, matchSigned } from '../parse/regex';
|
||||
import { addWeekParseToken } from '../parse/token';
|
||||
import { weekOfYear, weeksInYear, dayOfYearFromWeeks } from './week-calendar-utils';
|
||||
import toInt from '../utils/to-int';
|
||||
import { hooks } from '../utils/hooks';
|
||||
import { createLocal } from '../create/local';
|
||||
import { createUTCDate } from '../create/date-from-array';
|
||||
|
||||
// FORMATTING
|
||||
|
||||
addFormatToken(0, ['gg', 2], 0, function () {
|
||||
return this.weekYear() % 100;
|
||||
});
|
||||
|
||||
addFormatToken(0, ['GG', 2], 0, function () {
|
||||
return this.isoWeekYear() % 100;
|
||||
});
|
||||
|
||||
function addWeekYearFormatToken (token, getter) {
|
||||
addFormatToken(0, [token, token.length], 0, getter);
|
||||
}
|
||||
|
||||
addWeekYearFormatToken('gggg', 'weekYear');
|
||||
addWeekYearFormatToken('ggggg', 'weekYear');
|
||||
addWeekYearFormatToken('GGGG', 'isoWeekYear');
|
||||
addWeekYearFormatToken('GGGGG', 'isoWeekYear');
|
||||
|
||||
// ALIASES
|
||||
|
||||
addUnitAlias('weekYear', 'gg');
|
||||
addUnitAlias('isoWeekYear', 'GG');
|
||||
|
||||
// PRIORITY
|
||||
|
||||
addUnitPriority('weekYear', 1);
|
||||
addUnitPriority('isoWeekYear', 1);
|
||||
|
||||
|
||||
// PARSING
|
||||
|
||||
addRegexToken('G', matchSigned);
|
||||
addRegexToken('g', matchSigned);
|
||||
addRegexToken('GG', match1to2, match2);
|
||||
addRegexToken('gg', match1to2, match2);
|
||||
addRegexToken('GGGG', match1to4, match4);
|
||||
addRegexToken('gggg', match1to4, match4);
|
||||
addRegexToken('GGGGG', match1to6, match6);
|
||||
addRegexToken('ggggg', match1to6, match6);
|
||||
|
||||
addWeekParseToken(['gggg', 'ggggg', 'GGGG', 'GGGGG'], function (input, week, config, token) {
|
||||
week[token.substr(0, 2)] = toInt(input);
|
||||
});
|
||||
|
||||
addWeekParseToken(['gg', 'GG'], function (input, week, config, token) {
|
||||
week[token] = hooks.parseTwoDigitYear(input);
|
||||
});
|
||||
|
||||
// MOMENTS
|
||||
|
||||
export function getSetWeekYear (input) {
|
||||
return getSetWeekYearHelper.call(this,
|
||||
input,
|
||||
this.week(),
|
||||
this.weekday(),
|
||||
this.localeData()._week.dow,
|
||||
this.localeData()._week.doy);
|
||||
}
|
||||
|
||||
export function getSetISOWeekYear (input) {
|
||||
return getSetWeekYearHelper.call(this,
|
||||
input, this.isoWeek(), this.isoWeekday(), 1, 4);
|
||||
}
|
||||
|
||||
export function getISOWeeksInYear () {
|
||||
return weeksInYear(this.year(), 1, 4);
|
||||
}
|
||||
|
||||
export function getWeeksInYear () {
|
||||
var weekInfo = this.localeData()._week;
|
||||
return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy);
|
||||
}
|
||||
|
||||
function getSetWeekYearHelper(input, week, weekday, dow, doy) {
|
||||
var weeksTarget;
|
||||
if (input == null) {
|
||||
return weekOfYear(this, dow, doy).year;
|
||||
} else {
|
||||
weeksTarget = weeksInYear(input, dow, doy);
|
||||
if (week > weeksTarget) {
|
||||
week = weeksTarget;
|
||||
}
|
||||
return setWeekAll.call(this, input, week, weekday, dow, doy);
|
||||
}
|
||||
}
|
||||
|
||||
function setWeekAll(weekYear, week, weekday, dow, doy) {
|
||||
var dayOfYearData = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy),
|
||||
date = createUTCDate(dayOfYearData.year, 0, dayOfYearData.dayOfYear);
|
||||
|
||||
this.year(date.getUTCFullYear());
|
||||
this.month(date.getUTCMonth());
|
||||
this.date(date.getUTCDate());
|
||||
return this;
|
||||
}
|
||||
67
WebfrontCore/wwwroot/lib/moment/src/lib/units/week.js
Normal file
67
WebfrontCore/wwwroot/lib/moment/src/lib/units/week.js
Normal file
@ -0,0 +1,67 @@
|
||||
import { addFormatToken } from '../format/format';
|
||||
import { addUnitAlias } from './aliases';
|
||||
import { addUnitPriority } from './priorities';
|
||||
import { addRegexToken, match1to2, match2 } from '../parse/regex';
|
||||
import { addWeekParseToken } from '../parse/token';
|
||||
import toInt from '../utils/to-int';
|
||||
import { createLocal } from '../create/local';
|
||||
import { weekOfYear } from './week-calendar-utils';
|
||||
|
||||
// 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
|
||||
|
||||
export function localeWeek (mom) {
|
||||
return weekOfYear(mom, this._week.dow, this._week.doy).week;
|
||||
}
|
||||
|
||||
export 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.
|
||||
};
|
||||
|
||||
export function localeFirstDayOfWeek () {
|
||||
return this._week.dow;
|
||||
}
|
||||
|
||||
export function localeFirstDayOfYear () {
|
||||
return this._week.doy;
|
||||
}
|
||||
|
||||
// MOMENTS
|
||||
|
||||
export function getSetWeek (input) {
|
||||
var week = this.localeData().week(this);
|
||||
return input == null ? week : this.add((input - week) * 7, 'd');
|
||||
}
|
||||
|
||||
export function getSetISOWeek (input) {
|
||||
var week = weekOfYear(this, 1, 4).week;
|
||||
return input == null ? week : this.add((input - week) * 7, 'd');
|
||||
}
|
||||
75
WebfrontCore/wwwroot/lib/moment/src/lib/units/year.js
Normal file
75
WebfrontCore/wwwroot/lib/moment/src/lib/units/year.js
Normal file
@ -0,0 +1,75 @@
|
||||
import { makeGetSet } from '../moment/get-set';
|
||||
import { addFormatToken } from '../format/format';
|
||||
import { addUnitAlias } from './aliases';
|
||||
import { addUnitPriority } from './priorities';
|
||||
import { addRegexToken, match1to2, match1to4, match1to6, match2, match4, match6, matchSigned } from '../parse/regex';
|
||||
import { addParseToken } from '../parse/token';
|
||||
import { hooks } from '../utils/hooks';
|
||||
import { YEAR } from './constants';
|
||||
import toInt from '../utils/to-int';
|
||||
|
||||
// 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
|
||||
|
||||
export function daysInYear(year) {
|
||||
return isLeapYear(year) ? 366 : 365;
|
||||
}
|
||||
|
||||
export 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
|
||||
|
||||
export var getSetYear = makeGetSet('FullYear', true);
|
||||
|
||||
export function getIsLeapYear () {
|
||||
return isLeapYear(this.year());
|
||||
}
|
||||
@ -0,0 +1,7 @@
|
||||
export default function absCeil (number) {
|
||||
if (number < 0) {
|
||||
return Math.floor(number);
|
||||
} else {
|
||||
return Math.ceil(number);
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,8 @@
|
||||
export default function absFloor (number) {
|
||||
if (number < 0) {
|
||||
// -0 -> 0
|
||||
return Math.ceil(number) || 0;
|
||||
} else {
|
||||
return Math.floor(number);
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,7 @@
|
||||
export default function absRound (number) {
|
||||
if (number < 0) {
|
||||
return Math.round(-1 * number) * -1;
|
||||
} else {
|
||||
return Math.round(number);
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,16 @@
|
||||
import toInt from './to-int';
|
||||
|
||||
// compare two arrays, return the number of differences
|
||||
export default 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;
|
||||
}
|
||||
10
WebfrontCore/wwwroot/lib/moment/src/lib/utils/defaults.js
Normal file
10
WebfrontCore/wwwroot/lib/moment/src/lib/utils/defaults.js
Normal file
@ -0,0 +1,10 @@
|
||||
// Pick the first defined of two or three arguments.
|
||||
export default function defaults(a, b, c) {
|
||||
if (a != null) {
|
||||
return a;
|
||||
}
|
||||
if (b != null) {
|
||||
return b;
|
||||
}
|
||||
return c;
|
||||
}
|
||||
55
WebfrontCore/wwwroot/lib/moment/src/lib/utils/deprecate.js
Normal file
55
WebfrontCore/wwwroot/lib/moment/src/lib/utils/deprecate.js
Normal file
@ -0,0 +1,55 @@
|
||||
import extend from './extend';
|
||||
import { hooks } from './hooks';
|
||||
import isUndefined from './is-undefined';
|
||||
|
||||
function warn(msg) {
|
||||
if (hooks.suppressDeprecationWarnings === false &&
|
||||
(typeof console !== 'undefined') && console.warn) {
|
||||
console.warn('Deprecation warning: ' + msg);
|
||||
}
|
||||
}
|
||||
|
||||
export 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 = {};
|
||||
|
||||
export 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;
|
||||
19
WebfrontCore/wwwroot/lib/moment/src/lib/utils/extend.js
Normal file
19
WebfrontCore/wwwroot/lib/moment/src/lib/utils/extend.js
Normal file
@ -0,0 +1,19 @@
|
||||
import hasOwnProp from './has-own-prop';
|
||||
|
||||
export default 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;
|
||||
}
|
||||
@ -0,0 +1,3 @@
|
||||
export default function hasOwnProp(a, b) {
|
||||
return Object.prototype.hasOwnProperty.call(a, b);
|
||||
}
|
||||
13
WebfrontCore/wwwroot/lib/moment/src/lib/utils/hooks.js
Normal file
13
WebfrontCore/wwwroot/lib/moment/src/lib/utils/hooks.js
Normal file
@ -0,0 +1,13 @@
|
||||
export { hooks, setHookCallback };
|
||||
|
||||
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;
|
||||
}
|
||||
18
WebfrontCore/wwwroot/lib/moment/src/lib/utils/index-of.js
Normal file
18
WebfrontCore/wwwroot/lib/moment/src/lib/utils/index-of.js
Normal file
@ -0,0 +1,18 @@
|
||||
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;
|
||||
};
|
||||
}
|
||||
|
||||
export { indexOf as default };
|
||||
@ -0,0 +1,3 @@
|
||||
export default function isArray(input) {
|
||||
return input instanceof Array || Object.prototype.toString.call(input) === '[object Array]';
|
||||
}
|
||||
3
WebfrontCore/wwwroot/lib/moment/src/lib/utils/is-date.js
Normal file
3
WebfrontCore/wwwroot/lib/moment/src/lib/utils/is-date.js
Normal file
@ -0,0 +1,3 @@
|
||||
export default function isDate(input) {
|
||||
return input instanceof Date || Object.prototype.toString.call(input) === '[object Date]';
|
||||
}
|
||||
@ -0,0 +1,3 @@
|
||||
export default function isFunction(input) {
|
||||
return input instanceof Function || Object.prototype.toString.call(input) === '[object Function]';
|
||||
}
|
||||
@ -0,0 +1,3 @@
|
||||
export default function isNumber(input) {
|
||||
return typeof input === 'number' || Object.prototype.toString.call(input) === '[object Number]';
|
||||
}
|
||||
@ -0,0 +1,13 @@
|
||||
export default function isObjectEmpty(obj) {
|
||||
if (Object.getOwnPropertyNames) {
|
||||
return (Object.getOwnPropertyNames(obj).length === 0);
|
||||
} else {
|
||||
var k;
|
||||
for (k in obj) {
|
||||
if (obj.hasOwnProperty(k)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,5 @@
|
||||
export default 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]';
|
||||
}
|
||||
@ -0,0 +1,3 @@
|
||||
export default function isUndefined(input) {
|
||||
return input === void 0;
|
||||
}
|
||||
19
WebfrontCore/wwwroot/lib/moment/src/lib/utils/keys.js
Normal file
19
WebfrontCore/wwwroot/lib/moment/src/lib/utils/keys.js
Normal file
@ -0,0 +1,19 @@
|
||||
import hasOwnProp from './has-own-prop';
|
||||
|
||||
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;
|
||||
};
|
||||
}
|
||||
|
||||
export { keys as default };
|
||||
7
WebfrontCore/wwwroot/lib/moment/src/lib/utils/map.js
Normal file
7
WebfrontCore/wwwroot/lib/moment/src/lib/utils/map.js
Normal file
@ -0,0 +1,7 @@
|
||||
export default function map(arr, fn) {
|
||||
var res = [], i;
|
||||
for (i = 0; i < arr.length; ++i) {
|
||||
res.push(fn(arr[i], i));
|
||||
}
|
||||
return res;
|
||||
}
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user