ezii-os 1.1.0 → 2.0.1

data/node_modules/moment/src/lib/duration/get.js

@@ -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);
+}

data/node_modules/moment/src/lib/duration/humanize.js

@@ -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);
+}

data/node_modules/moment/src/lib/duration/iso-string.js

@@ -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' : '');
+}

data/node_modules/moment/src/lib/duration/prototype.js

@@ -0,0 +1,53 @@
+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, asQuarters, 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.asQuarters     = asQuarters;
+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;

data/node_modules/moment/src/lib/duration/valid.js

@@ -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);
+}

data/node_modules/moment/src/lib/format/format.js

@@ -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;
+}

data/node_modules/moment/src/lib/locale/base-config.js

@@ -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
+};

data/node_modules/moment/src/lib/locale/calendar.js

@@ -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;
+}

data/node_modules/moment/src/lib/locale/constructor.js

@@ -0,0 +1,5 @@
+export function Locale(config) {
+    if (config != null) {
+        this.set(config);
+    }
+}

data/node_modules/moment/src/lib/locale/en.js

@@ -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;
+    }
+});

data/node_modules/moment/src/lib/locale/formats.js

@@ -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];
+}

data/node_modules/moment/src/lib/locale/invalid.js

@@ -0,0 +1,5 @@
+export var defaultInvalidDate = 'Invalid date';
+
+export function invalidDate () {
+    return this._invalidDate;
+}

data/node_modules/moment/src/lib/locale/lists.js

@@ -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');
+}

data/node_modules/moment/src/lib/locale/locale.js

@@ -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';