import { c as commonjsRequire, r as requireMoment } from './moment-DhvPC9Jt.js';

var da$1 = {exports: {}};

var da = da$1.exports;

var hasRequiredDa;

function requireDa () {
	if (hasRequiredDa) return da$1.exports;
	hasRequiredDa = 1;
	(function (module, exports) {
(function (global, factory) {
		   typeof commonjsRequire === 'function' ? factory(requireMoment()) :
		   factory(global.moment);
		}(da, (function (moment) {
		    //! moment.js locale configuration

		    var da = moment.defineLocale('da', {
		        months: 'januar_februar_marts_april_maj_juni_juli_august_september_oktober_november_december'.split(
		            '_'
		        ),
		        monthsShort: 'jan_feb_mar_apr_maj_jun_jul_aug_sep_okt_nov_dec'.split('_'),
		        weekdays: 'søndag_mandag_tirsdag_onsdag_torsdag_fredag_lørdag'.split('_'),
		        weekdaysShort: 'søn_man_tir_ons_tor_fre_lør'.split('_'),
		        weekdaysMin: 'sø_ma_ti_on_to_fr_lø'.split('_'),
		        longDateFormat: {
		            LT: 'HH:mm',
		            LTS: 'HH:mm:ss',
		            L: 'DD.MM.YYYY',
		            LL: 'D. MMMM YYYY',
		            LLL: 'D. MMMM YYYY HH:mm',
		            LLLL: 'dddd [d.] D. MMMM YYYY [kl.] HH:mm',
		        },
		        calendar: {
		            sameDay: '[i dag kl.] LT',
		            nextDay: '[i morgen kl.] LT',
		            nextWeek: 'på dddd [kl.] LT',
		            lastDay: '[i går kl.] LT',
		            lastWeek: '[i] dddd[s kl.] LT',
		            sameElse: 'L',
		        },
		        relativeTime: {
		            future: 'om %s',
		            past: '%s siden',
		            s: 'få sekunder',
		            ss: '%d sekunder',
		            m: 'et minut',
		            mm: '%d minutter',
		            h: 'en time',
		            hh: '%d timer',
		            d: 'en dag',
		            dd: '%d dage',
		            M: 'en måned',
		            MM: '%d måneder',
		            y: 'et år',
		            yy: '%d år',
		        },
		        dayOfMonthOrdinalParse: /\d{1,2}\./,
		        ordinal: '%d.',
		        week: {
		            dow: 1, // Monday is the first day of the week.
		            doy: 4, // The week that contains Jan 4th is the first week of the year.
		        },
		    });

		    return da;

		}))); 
	} ());
	return da$1.exports;
}

requireDa();

var de$1 = {exports: {}};

var de = de$1.exports;

var hasRequiredDe;

function requireDe () {
	if (hasRequiredDe) return de$1.exports;
	hasRequiredDe = 1;
	(function (module, exports) {
(function (global, factory) {
		   typeof commonjsRequire === 'function' ? factory(requireMoment()) :
		   factory(global.moment);
		}(de, (function (moment) {
		    //! moment.js locale configuration

		    function processRelativeTime(number, withoutSuffix, key, isFuture) {
		        var format = {
		            m: ['eine Minute', 'einer Minute'],
		            h: ['eine Stunde', 'einer Stunde'],
		            d: ['ein Tag', 'einem Tag'],
		            dd: [number + ' Tage', number + ' Tagen'],
		            w: ['eine Woche', 'einer Woche'],
		            M: ['ein Monat', 'einem Monat'],
		            MM: [number + ' Monate', number + ' Monaten'],
		            y: ['ein Jahr', 'einem Jahr'],
		            yy: [number + ' Jahre', number + ' Jahren'],
		        };
		        return withoutSuffix ? format[key][0] : format[key][1];
		    }

		    var de = moment.defineLocale('de', {
		        months: 'Januar_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember'.split(
		            '_'
		        ),
		        monthsShort:
		            'Jan._Feb._März_Apr._Mai_Juni_Juli_Aug._Sep._Okt._Nov._Dez.'.split('_'),
		        monthsParseExact: true,
		        weekdays:
		            'Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag'.split(
		                '_'
		            ),
		        weekdaysShort: 'So._Mo._Di._Mi._Do._Fr._Sa.'.split('_'),
		        weekdaysMin: 'So_Mo_Di_Mi_Do_Fr_Sa'.split('_'),
		        weekdaysParseExact: true,
		        longDateFormat: {
		            LT: 'HH:mm',
		            LTS: 'HH:mm:ss',
		            L: 'DD.MM.YYYY',
		            LL: 'D. MMMM YYYY',
		            LLL: 'D. MMMM YYYY HH:mm',
		            LLLL: 'dddd, D. MMMM YYYY HH:mm',
		        },
		        calendar: {
		            sameDay: '[heute um] LT [Uhr]',
		            sameElse: 'L',
		            nextDay: '[morgen um] LT [Uhr]',
		            nextWeek: 'dddd [um] LT [Uhr]',
		            lastDay: '[gestern um] LT [Uhr]',
		            lastWeek: '[letzten] dddd [um] LT [Uhr]',
		        },
		        relativeTime: {
		            future: 'in %s',
		            past: 'vor %s',
		            s: 'ein paar Sekunden',
		            ss: '%d Sekunden',
		            m: processRelativeTime,
		            mm: '%d Minuten',
		            h: processRelativeTime,
		            hh: '%d Stunden',
		            d: processRelativeTime,
		            dd: processRelativeTime,
		            w: processRelativeTime,
		            ww: '%d Wochen',
		            M: processRelativeTime,
		            MM: processRelativeTime,
		            y: processRelativeTime,
		            yy: processRelativeTime,
		        },
		        dayOfMonthOrdinalParse: /\d{1,2}\./,
		        ordinal: '%d.',
		        week: {
		            dow: 1, // Monday is the first day of the week.
		            doy: 4, // The week that contains Jan 4th is the first week of the year.
		        },
		    });

		    return de;

		}))); 
	} ());
	return de$1.exports;
}

requireDe();

var fi$1 = {exports: {}};

var fi = fi$1.exports;

var hasRequiredFi;

function requireFi () {
	if (hasRequiredFi) return fi$1.exports;
	hasRequiredFi = 1;
	(function (module, exports) {
(function (global, factory) {
		   typeof commonjsRequire === 'function' ? factory(requireMoment()) :
		   factory(global.moment);
		}(fi, (function (moment) {
		    //! moment.js locale configuration

		    var numbersPast =
		            'nolla yksi kaksi kolme neljä viisi kuusi seitsemän kahdeksan yhdeksän'.split(
		                ' '
		            ),
		        numbersFuture = [
		            'nolla',
		            'yhden',
		            'kahden',
		            'kolmen',
		            'neljän',
		            'viiden',
		            'kuuden',
		            numbersPast[7],
		            numbersPast[8],
		            numbersPast[9],
		        ];
		    function translate(number, withoutSuffix, key, isFuture) {
		        var result = '';
		        switch (key) {
		            case 's':
		                return isFuture ? 'muutaman sekunnin' : 'muutama sekunti';
		            case 'ss':
		                result = isFuture ? 'sekunnin' : 'sekuntia';
		                break;
		            case 'm':
		                return isFuture ? 'minuutin' : 'minuutti';
		            case 'mm':
		                result = isFuture ? 'minuutin' : 'minuuttia';
		                break;
		            case 'h':
		                return isFuture ? 'tunnin' : 'tunti';
		            case 'hh':
		                result = isFuture ? 'tunnin' : 'tuntia';
		                break;
		            case 'd':
		                return isFuture ? 'päivän' : 'päivä';
		            case 'dd':
		                result = isFuture ? 'päivän' : 'päivää';
		                break;
		            case 'M':
		                return isFuture ? 'kuukauden' : 'kuukausi';
		            case 'MM':
		                result = isFuture ? 'kuukauden' : 'kuukautta';
		                break;
		            case 'y':
		                return isFuture ? 'vuoden' : 'vuosi';
		            case 'yy':
		                result = isFuture ? 'vuoden' : 'vuotta';
		                break;
		        }
		        result = verbalNumber(number, isFuture) + ' ' + result;
		        return result;
		    }
		    function verbalNumber(number, isFuture) {
		        return number < 10
		            ? isFuture
		                ? numbersFuture[number]
		                : numbersPast[number]
		            : number;
		    }

		    var fi = moment.defineLocale('fi', {
		        months: 'tammikuu_helmikuu_maaliskuu_huhtikuu_toukokuu_kesäkuu_heinäkuu_elokuu_syyskuu_lokakuu_marraskuu_joulukuu'.split(
		            '_'
		        ),
		        monthsShort:
		            'tammi_helmi_maalis_huhti_touko_kesä_heinä_elo_syys_loka_marras_joulu'.split(
		                '_'
		            ),
		        weekdays:
		            'sunnuntai_maanantai_tiistai_keskiviikko_torstai_perjantai_lauantai'.split(
		                '_'
		            ),
		        weekdaysShort: 'su_ma_ti_ke_to_pe_la'.split('_'),
		        weekdaysMin: 'su_ma_ti_ke_to_pe_la'.split('_'),
		        longDateFormat: {
		            LT: 'HH.mm',
		            LTS: 'HH.mm.ss',
		            L: 'DD.MM.YYYY',
		            LL: 'Do MMMM[ta] YYYY',
		            LLL: 'Do MMMM[ta] YYYY, [klo] HH.mm',
		            LLLL: 'dddd, Do MMMM[ta] YYYY, [klo] HH.mm',
		            l: 'D.M.YYYY',
		            ll: 'Do MMM YYYY',
		            lll: 'Do MMM YYYY, [klo] HH.mm',
		            llll: 'ddd, Do MMM YYYY, [klo] HH.mm',
		        },
		        calendar: {
		            sameDay: '[tänään] [klo] LT',
		            nextDay: '[huomenna] [klo] LT',
		            nextWeek: 'dddd [klo] LT',
		            lastDay: '[eilen] [klo] LT',
		            lastWeek: '[viime] dddd[na] [klo] LT',
		            sameElse: 'L',
		        },
		        relativeTime: {
		            future: '%s päästä',
		            past: '%s sitten',
		            s: translate,
		            ss: translate,
		            m: translate,
		            mm: translate,
		            h: translate,
		            hh: translate,
		            d: translate,
		            dd: translate,
		            M: translate,
		            MM: translate,
		            y: translate,
		            yy: translate,
		        },
		        dayOfMonthOrdinalParse: /\d{1,2}\./,
		        ordinal: '%d.',
		        week: {
		            dow: 1, // Monday is the first day of the week.
		            doy: 4, // The week that contains Jan 4th is the first week of the year.
		        },
		    });

		    return fi;

		}))); 
	} ());
	return fi$1.exports;
}

requireFi();

var fr$1 = {exports: {}};

var fr = fr$1.exports;

var hasRequiredFr;

function requireFr () {
	if (hasRequiredFr) return fr$1.exports;
	hasRequiredFr = 1;
	(function (module, exports) {
(function (global, factory) {
		   typeof commonjsRequire === 'function' ? factory(requireMoment()) :
		   factory(global.moment);
		}(fr, (function (moment) {
		    //! moment.js locale configuration

		    var monthsStrictRegex =
		            /^(janvier|février|mars|avril|mai|juin|juillet|août|septembre|octobre|novembre|décembre)/i,
		        monthsShortStrictRegex =
		            /(janv\.?|févr\.?|mars|avr\.?|mai|juin|juil\.?|août|sept\.?|oct\.?|nov\.?|déc\.?)/i,
		        monthsRegex =
		            /(janv\.?|févr\.?|mars|avr\.?|mai|juin|juil\.?|août|sept\.?|oct\.?|nov\.?|déc\.?|janvier|février|mars|avril|mai|juin|juillet|août|septembre|octobre|novembre|décembre)/i,
		        monthsParse = [
		            /^janv/i,
		            /^févr/i,
		            /^mars/i,
		            /^avr/i,
		            /^mai/i,
		            /^juin/i,
		            /^juil/i,
		            /^août/i,
		            /^sept/i,
		            /^oct/i,
		            /^nov/i,
		            /^déc/i,
		        ];

		    var fr = moment.defineLocale('fr', {
		        months: 'janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre'.split(
		            '_'
		        ),
		        monthsShort:
		            'janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.'.split(
		                '_'
		            ),
		        monthsRegex: monthsRegex,
		        monthsShortRegex: monthsRegex,
		        monthsStrictRegex: monthsStrictRegex,
		        monthsShortStrictRegex: monthsShortStrictRegex,
		        monthsParse: monthsParse,
		        longMonthsParse: monthsParse,
		        shortMonthsParse: monthsParse,
		        weekdays: 'dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi'.split('_'),
		        weekdaysShort: 'dim._lun._mar._mer._jeu._ven._sam.'.split('_'),
		        weekdaysMin: 'di_lu_ma_me_je_ve_sa'.split('_'),
		        weekdaysParseExact: true,
		        longDateFormat: {
		            LT: 'HH:mm',
		            LTS: 'HH:mm:ss',
		            L: 'DD/MM/YYYY',
		            LL: 'D MMMM YYYY',
		            LLL: 'D MMMM YYYY HH:mm',
		            LLLL: 'dddd D MMMM YYYY HH:mm',
		        },
		        calendar: {
		            sameDay: '[Aujourd’hui à] LT',
		            nextDay: '[Demain à] LT',
		            nextWeek: 'dddd [à] LT',
		            lastDay: '[Hier à] LT',
		            lastWeek: 'dddd [dernier à] LT',
		            sameElse: 'L',
		        },
		        relativeTime: {
		            future: 'dans %s',
		            past: 'il y a %s',
		            s: 'quelques secondes',
		            ss: '%d secondes',
		            m: 'une minute',
		            mm: '%d minutes',
		            h: 'une heure',
		            hh: '%d heures',
		            d: 'un jour',
		            dd: '%d jours',
		            w: 'une semaine',
		            ww: '%d semaines',
		            M: 'un mois',
		            MM: '%d mois',
		            y: 'un an',
		            yy: '%d ans',
		        },
		        dayOfMonthOrdinalParse: /\d{1,2}(er|)/,
		        ordinal: function (number, period) {
		            switch (period) {
		                // TODO: Return 'e' when day of month > 1. Move this case inside
		                // block for masculine words below.
		                // See https://github.com/moment/moment/issues/3375
		                case 'D':
		                    return number + (number === 1 ? 'er' : '');

		                // Words with masculine grammatical gender: mois, trimestre, jour
		                default:
		                case 'M':
		                case 'Q':
		                case 'DDD':
		                case 'd':
		                    return number + (number === 1 ? 'er' : 'e');

		                // Words with feminine grammatical gender: semaine
		                case 'w':
		                case 'W':
		                    return number + (number === 1 ? 're' : 'e');
		            }
		        },
		        week: {
		            dow: 1, // Monday is the first day of the week.
		            doy: 4, // The week that contains Jan 4th is the first week of the year.
		        },
		    });

		    return fr;

		}))); 
	} ());
	return fr$1.exports;
}

requireFr();

var nb$1 = {exports: {}};

var nb = nb$1.exports;

var hasRequiredNb;

function requireNb () {
	if (hasRequiredNb) return nb$1.exports;
	hasRequiredNb = 1;
	(function (module, exports) {
(function (global, factory) {
		   typeof commonjsRequire === 'function' ? factory(requireMoment()) :
		   factory(global.moment);
		}(nb, (function (moment) {
		    //! moment.js locale configuration

		    var nb = moment.defineLocale('nb', {
		        months: 'januar_februar_mars_april_mai_juni_juli_august_september_oktober_november_desember'.split(
		            '_'
		        ),
		        monthsShort:
		            'jan._feb._mars_apr._mai_juni_juli_aug._sep._okt._nov._des.'.split('_'),
		        monthsParseExact: true,
		        weekdays: 'søndag_mandag_tirsdag_onsdag_torsdag_fredag_lørdag'.split('_'),
		        weekdaysShort: 'sø._ma._ti._on._to._fr._lø.'.split('_'),
		        weekdaysMin: 'sø_ma_ti_on_to_fr_lø'.split('_'),
		        weekdaysParseExact: true,
		        longDateFormat: {
		            LT: 'HH:mm',
		            LTS: 'HH:mm:ss',
		            L: 'DD.MM.YYYY',
		            LL: 'D. MMMM YYYY',
		            LLL: 'D. MMMM YYYY [kl.] HH:mm',
		            LLLL: 'dddd D. MMMM YYYY [kl.] HH:mm',
		        },
		        calendar: {
		            sameDay: '[i dag kl.] LT',
		            nextDay: '[i morgen kl.] LT',
		            nextWeek: 'dddd [kl.] LT',
		            lastDay: '[i går kl.] LT',
		            lastWeek: '[forrige] dddd [kl.] LT',
		            sameElse: 'L',
		        },
		        relativeTime: {
		            future: 'om %s',
		            past: '%s siden',
		            s: 'noen sekunder',
		            ss: '%d sekunder',
		            m: 'ett minutt',
		            mm: '%d minutter',
		            h: 'én time',
		            hh: '%d timer',
		            d: 'én dag',
		            dd: '%d dager',
		            w: 'én uke',
		            ww: '%d uker',
		            M: 'én måned',
		            MM: '%d måneder',
		            y: 'ett år',
		            yy: '%d år',
		        },
		        dayOfMonthOrdinalParse: /\d{1,2}\./,
		        ordinal: '%d.',
		        week: {
		            dow: 1, // Monday is the first day of the week.
		            doy: 4, // The week that contains Jan 4th is the first week of the year.
		        },
		    });

		    return nb;

		}))); 
	} ());
	return nb$1.exports;
}

requireNb();

var nl$1 = {exports: {}};

var nl = nl$1.exports;

var hasRequiredNl;

function requireNl () {
	if (hasRequiredNl) return nl$1.exports;
	hasRequiredNl = 1;
	(function (module, exports) {
(function (global, factory) {
		   typeof commonjsRequire === 'function' ? factory(requireMoment()) :
		   factory(global.moment);
		}(nl, (function (moment) {
		    //! moment.js locale configuration

		    var monthsShortWithDots =
		            'jan._feb._mrt._apr._mei_jun._jul._aug._sep._okt._nov._dec.'.split('_'),
		        monthsShortWithoutDots =
		            'jan_feb_mrt_apr_mei_jun_jul_aug_sep_okt_nov_dec'.split('_'),
		        monthsParse = [
		            /^jan/i,
		            /^feb/i,
		            /^(maart|mrt\.?)$/i,
		            /^apr/i,
		            /^mei$/i,
		            /^jun[i.]?$/i,
		            /^jul[i.]?$/i,
		            /^aug/i,
		            /^sep/i,
		            /^okt/i,
		            /^nov/i,
		            /^dec/i,
		        ],
		        monthsRegex =
		            /^(januari|februari|maart|april|mei|ju[nl]i|augustus|september|oktober|november|december|jan\.?|feb\.?|mrt\.?|apr\.?|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i;

		    var nl = moment.defineLocale('nl', {
		        months: 'januari_februari_maart_april_mei_juni_juli_augustus_september_oktober_november_december'.split(
		            '_'
		        ),
		        monthsShort: function (m, format) {
		            if (!m) {
		                return monthsShortWithDots;
		            } else if (/-MMM-/.test(format)) {
		                return monthsShortWithoutDots[m.month()];
		            } else {
		                return monthsShortWithDots[m.month()];
		            }
		        },

		        monthsRegex: monthsRegex,
		        monthsShortRegex: monthsRegex,
		        monthsStrictRegex:
		            /^(januari|februari|maart|april|mei|ju[nl]i|augustus|september|oktober|november|december)/i,
		        monthsShortStrictRegex:
		            /^(jan\.?|feb\.?|mrt\.?|apr\.?|mei|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i,

		        monthsParse: monthsParse,
		        longMonthsParse: monthsParse,
		        shortMonthsParse: monthsParse,

		        weekdays:
		            'zondag_maandag_dinsdag_woensdag_donderdag_vrijdag_zaterdag'.split('_'),
		        weekdaysShort: 'zo._ma._di._wo._do._vr._za.'.split('_'),
		        weekdaysMin: 'zo_ma_di_wo_do_vr_za'.split('_'),
		        weekdaysParseExact: true,
		        longDateFormat: {
		            LT: 'HH:mm',
		            LTS: 'HH:mm:ss',
		            L: 'DD-MM-YYYY',
		            LL: 'D MMMM YYYY',
		            LLL: 'D MMMM YYYY HH:mm',
		            LLLL: 'dddd D MMMM YYYY HH:mm',
		        },
		        calendar: {
		            sameDay: '[vandaag om] LT',
		            nextDay: '[morgen om] LT',
		            nextWeek: 'dddd [om] LT',
		            lastDay: '[gisteren om] LT',
		            lastWeek: '[afgelopen] dddd [om] LT',
		            sameElse: 'L',
		        },
		        relativeTime: {
		            future: 'over %s',
		            past: '%s geleden',
		            s: 'een paar seconden',
		            ss: '%d seconden',
		            m: 'één minuut',
		            mm: '%d minuten',
		            h: 'één uur',
		            hh: '%d uur',
		            d: 'één dag',
		            dd: '%d dagen',
		            w: 'één week',
		            ww: '%d weken',
		            M: 'één maand',
		            MM: '%d maanden',
		            y: 'één jaar',
		            yy: '%d jaar',
		        },
		        dayOfMonthOrdinalParse: /\d{1,2}(ste|de)/,
		        ordinal: function (number) {
		            return (
		                number +
		                (number === 1 || number === 8 || number >= 20 ? 'ste' : 'de')
		            );
		        },
		        week: {
		            dow: 1, // Monday is the first day of the week.
		            doy: 4, // The week that contains Jan 4th is the first week of the year.
		        },
		    });

		    return nl;

		}))); 
	} ());
	return nl$1.exports;
}

requireNl();

var sv$1 = {exports: {}};

var sv = sv$1.exports;

var hasRequiredSv;

function requireSv () {
	if (hasRequiredSv) return sv$1.exports;
	hasRequiredSv = 1;
	(function (module, exports) {
(function (global, factory) {
		   typeof commonjsRequire === 'function' ? factory(requireMoment()) :
		   factory(global.moment);
		}(sv, (function (moment) {
		    //! moment.js locale configuration

		    var sv = moment.defineLocale('sv', {
		        months: 'januari_februari_mars_april_maj_juni_juli_augusti_september_oktober_november_december'.split(
		            '_'
		        ),
		        monthsShort: 'jan_feb_mar_apr_maj_jun_jul_aug_sep_okt_nov_dec'.split('_'),
		        weekdays: 'söndag_måndag_tisdag_onsdag_torsdag_fredag_lördag'.split('_'),
		        weekdaysShort: 'sön_mån_tis_ons_tor_fre_lör'.split('_'),
		        weekdaysMin: 'sö_må_ti_on_to_fr_lö'.split('_'),
		        longDateFormat: {
		            LT: 'HH:mm',
		            LTS: 'HH:mm:ss',
		            L: 'YYYY-MM-DD',
		            LL: 'D MMMM YYYY',
		            LLL: 'D MMMM YYYY [kl.] HH:mm',
		            LLLL: 'dddd D MMMM YYYY [kl.] HH:mm',
		            lll: 'D MMM YYYY HH:mm',
		            llll: 'ddd D MMM YYYY HH:mm',
		        },
		        calendar: {
		            sameDay: '[Idag] LT',
		            nextDay: '[Imorgon] LT',
		            lastDay: '[Igår] LT',
		            nextWeek: '[På] dddd LT',
		            lastWeek: '[I] dddd[s] LT',
		            sameElse: 'L',
		        },
		        relativeTime: {
		            future: 'om %s',
		            past: 'för %s sedan',
		            s: 'några sekunder',
		            ss: '%d sekunder',
		            m: 'en minut',
		            mm: '%d minuter',
		            h: 'en timme',
		            hh: '%d timmar',
		            d: 'en dag',
		            dd: '%d dagar',
		            M: 'en månad',
		            MM: '%d månader',
		            y: 'ett år',
		            yy: '%d år',
		        },
		        dayOfMonthOrdinalParse: /\d{1,2}(\:e|\:a)/,
		        ordinal: function (number) {
		            var b = number % 10,
		                output =
		                    ~~((number % 100) / 10) === 1
		                        ? ':e'
		                        : b === 1
		                          ? ':a'
		                          : b === 2
		                            ? ':a'
		                            : b === 3
		                              ? ':e'
		                              : ':e';
		            return number + output;
		        },
		        week: {
		            dow: 1, // Monday is the first day of the week.
		            doy: 4, // The week that contains Jan 4th is the first week of the year.
		        },
		    });

		    return sv;

		}))); 
	} ());
	return sv$1.exports;
}

requireSv();
