mirror-badiDate/dist/badiDate.mjs

/**
 * @license BadiDate v3.0.2
 * (c) 2018 Jan Greis
 * licensed under MIT
 */

import { DateTime, Duration } from 'luxon';

const month = {
    1: 'Bahá',
    2: 'Jalál',
    3: 'Jamál',
    4: '‘Aẓamat',
    5: 'Núr',
    6: 'Raḥmat',
    7: 'Kalimát',
    8: 'Kamál',
    9: 'Asmá’',
    10: '‘Izzat',
    11: 'Ma_sh_íyyat',
    12: '‘Ilm',
    13: 'Qudrat',
    14: 'Qawl',
    15: 'Masá’il',
    16: '_Sh_araf',
    17: 'Sulṭán',
    18: 'Mulk',
    19: '‘Alá’',
    20: 'Ayyám-i-Há',
};
const monthL = {
    1: 'Splendour',
    2: 'Glory',
    3: 'Beauty',
    4: 'Grandeur',
    5: 'Light',
    6: 'Mercy',
    7: 'Words',
    8: 'Perfection',
    9: 'Names',
    10: 'Might',
    11: 'Will',
    12: 'Knowledge',
    13: 'Power',
    14: 'Speech',
    15: 'Questions',
    16: 'Honour',
    17: 'Sovereignty',
    18: 'Dominion',
    19: 'Loftiness',
    20: 'Ayyám-i-Há',
};
const holyDay = {
    1: 'Naw-Rúz',
    2: 'First day of Riḍván',
    3: 'Ninth day of Riḍván',
    4: 'Twelfth day of Riḍván',
    5: 'Declaration of the Báb',
    6: 'Ascension of Bahá’u’lláh',
    7: 'Martyrdom of the Báb',
    8: 'Birth of the Báb',
    9: 'Birth of Bahá’u’lláh',
    10: 'Day of the Covenant',
    11: 'Ascension of ‘Abdu’l-Bahá',
};
// CAREFUL: Numbering corresponds to Badí' week, i.e. 1 is Jalál (-> Saturday)
const weekday = {
    1: 'Jalál',
    2: 'Jamál',
    3: 'Kamál',
    4: 'Fiḍál',
    5: '‘Idál',
    6: 'Istijlál',
    7: 'Istiqlál',
};
const weekdayAbbr3 = {
    1: 'Jal',
    2: 'Jam',
    3: 'Kam',
    4: 'Fiḍ',
    5: '‘Idá',
    6: 'Isj',
    7: 'Isq',
};
const weekdayAbbr2 = {
    1: 'Jl',
    2: 'Jm',
    3: 'Ka',
    4: 'Fi',
    5: '‘Id',
    6: 'Ij',
    7: 'Iq',
};
const weekdayL = {
    1: 'Glory',
    2: 'Beauty',
    3: 'Perfection',
    4: 'Grace',
    5: 'Justice',
    6: 'Majesty',
    7: 'Independence',
};
const yearInVahid = {
    1: 'Alif',
    2: 'Bá’',
    3: 'Ab',
    4: 'Dál',
    5: 'Báb',
    6: 'Váv',
    7: 'Abad',
    8: 'Jád',
    9: 'Bahá',
    10: 'Ḥubb',
    11: 'Bahháj',
    12: 'Javáb',
    13: 'Aḥad',
    14: 'Vahháb',
    15: 'Vidád',
    16: 'Badí‘',
    17: 'Bahí',
    18: 'Abhá',
    19: 'Váḥid',
};
const vahid = 'Váḥid';
const kulliShay = 'Kull-i-_Sh_ay’';
const BE = 'B.E.';
const badiCalendar = 'Badí‘ Calendar';
const unicodeCharForZero = '0';
const defaultFormat = 'd MM+ y BE';

var en = /*#__PURE__*/Object.freeze({
    __proto__: null,
    month: month,
    monthL: monthL,
    holyDay: holyDay,
    weekday: weekday,
    weekdayAbbr3: weekdayAbbr3,
    weekdayAbbr2: weekdayAbbr2,
    weekdayL: weekdayL,
    yearInVahid: yearInVahid,
    vahid: vahid,
    kulliShay: kulliShay,
    BE: BE,
    badiCalendar: badiCalendar,
    unicodeCharForZero: unicodeCharForZero,
    defaultFormat: defaultFormat
});

/* eslint-disable dot-notation, line-comment-position, camelcase, sort-imports */
const badiLocale = { en, default: en };
const setDefaultLanguage = (language) => {
    if (badiLocale[language] === undefined) {
        // eslint-disable-next-line no-console
        console.log('Chosen language does not exist. Setting has not been changed.');
    }
    else {
        badiLocale['default'] = badiLocale[language];
    }
};
let underlineFormat = 'css';
const setUnderlineFormat = (format) => {
    if (['css', 'u', 'diacritic', 'none'].includes(format)) {
        underlineFormat = format;
    }
    else {
        // eslint-disable-next-line no-console
        console.log('Invalid underline format. Choose one of ["css", "u", "diacritic", "none"]. ' +
            'Setting has not been changed.');
    }
};

const formatTokens = [
    ['DDL', 'DD+', 'MML', 'MM+', 'WWL', 'yyv', 'KiS'],
    ['dd', 'DD', 'mm', 'MM', 'ww', 'WW', 'yv', 'YV', 'vv', 'kk', 'yy', 'BE', 'BC', 'Va'],
    ['d', 'D', 'm', 'M', 'W', 'v', 'k', 'y']
];
// eslint-disable-next-line complexity
const formatBadiDate = (badiDate, formatString, language) => {
    if (!badiDate.isValid) {
        return 'Not a valid Badí‘ date';
    }
    if (typeof language === 'string' && badiLocale[language] === undefined && language.includes('-')) {
        language = language.split('-')[0];
    }
    if (language === undefined || badiLocale[language] === undefined) {
        language = 'default';
    }
    formatString = formatString !== null && formatString !== void 0 ? formatString : formatItemFallback(language, 'defaultFormat');
    let formattedDate = '';
    const length = formatString.length;
    for (let i = 0; i < length; i++) {
        // Text wrapped in {} is output as-is. A '{' without a matching '}'
        // results in invalid input
        if (formatString[i] === '{' && i < length - 1) {
            for (let j = i + 1; j <= length; j++) {
                if (j === length) {
                    return 'Invalid formatting string.';
                }
                if (formatString[j] === '}') {
                    i = j;
                    break;
                }
                formattedDate += formatString[j];
            }
        }
        else {
            const next1 = formatString[i];
            const next2 = next1 + formatString[i + 1];
            const next3 = next2 + formatString[i + 2];
            if (formatTokens[0].includes(next3)) {
                formattedDate += getFormatItem(badiDate, next3, language);
                i += 2;
            }
            else if (formatTokens[1].includes(next2)) {
                formattedDate += getFormatItem(badiDate, next2, language);
                i += 1;
            }
            else if (formatTokens[2].includes(next1)) {
                formattedDate += getFormatItem(badiDate, next1, language);
            }
            else {
                formattedDate += next1;
            }
        }
    }
    return formattedDate;
};
// eslint-disable-next-line complexity
const getFormatItem = (badiDate, token, language) => {
    switch (token) {
        // Single character tokens
        case 'd':
            return digitRewrite(badiDate.day, language);
        case 'D':
            return postProcessLocaleItem(formatItemFallback(language, 'month', badiDate.day), 3);
        case 'm':
            return digitRewrite(badiDate.month, language);
        case 'M':
            return postProcessLocaleItem(formatItemFallback(language, 'month', badiDate.month), 3);
        case 'W':
            return formatItemFallback(language, 'weekdayAbbr3', (badiDate.gregorianDate.weekday + 1) % 7 + 1);
        case 'y':
            return digitRewrite(badiDate.year, language);
        case 'v':
            return digitRewrite((Math.floor((badiDate.year - 1) / 19) % 19) + 1, language);
        case 'k':
            return digitRewrite(Math.floor((badiDate.year - 1) / 361) + 1, language);
        // Two character tokens
        case 'dd':
            return digitRewrite((`0${String(badiDate.day)}`).slice(-2), language);
        case 'DD':
            return postProcessLocaleItem(formatItemFallback(language, 'month', badiDate.day));
        case 'mm':
            return digitRewrite((`0${String(badiDate.month)}`).slice(-2), language);
        case 'MM':
            return postProcessLocaleItem(formatItemFallback(language, 'month', badiDate.month));
        case 'ww':
            return formatItemFallback(language, 'weekdayAbbr2', (badiDate.gregorianDate.weekday + 1) % 7 + 1);
        case 'WW':
            return formatItemFallback(language, 'weekday', (badiDate.gregorianDate.weekday + 1) % 7 + 1);
        case 'yy':
            return digitRewrite((`00${String(badiDate.year)}`).slice(-3), language);
        case 'yv':
            return digitRewrite((badiDate.year - 1) % 19 + 1, language);
        case 'YV':
            return formatItemFallback(language, 'yearInVahid', (badiDate.year - 1) % 19 + 1);
        case 'vv':
            return digitRewrite((`0${String((Math.floor((badiDate.year - 1) / 19) + 2) % 19 - 1)}`).slice(-2), language);
        case 'kk':
            return digitRewrite((`0${String(Math.floor((badiDate.year - 1) / 361) + 1)}`).slice(-2), language);
        case 'Va':
            return formatItemFallback(language, 'vahid');
        case 'BE':
            return formatItemFallback(language, 'BE');
        case 'BC':
            return formatItemFallback(language, 'badiCalendar');
        // Three character tokens
        case 'DDL':
            return formatItemFallback(language, 'monthL', badiDate.day);
        case 'DD+': {
            const day = postProcessLocaleItem(formatItemFallback(language, 'month', badiDate.day));
            const dayL = formatItemFallback(language, 'monthL', badiDate.day);
            if (day === dayL) {
                return day;
            }
            if (badiLocale[language] === badiLocale.fa) {
                return `<span dir="rtl">${day} (${dayL})</span>`;
            }
            return `${day} (${dayL})`;
        }
        case 'MML':
            return formatItemFallback(language, 'monthL', badiDate.month);
        case 'MM+': {
            const month = postProcessLocaleItem(formatItemFallback(language, 'month', badiDate.month));
            const monthL = formatItemFallback(language, 'monthL', badiDate.month);
            if (month === monthL) {
                return month;
            }
            if (badiLocale[language] === badiLocale.fa) {
                return `<span dir="rtl">${month} (${monthL})</span>`;
            }
            return `${month} (${monthL})`;
        }
        case 'WWL':
            return formatItemFallback(language, 'weekdayL', (badiDate.gregorianDate.weekday + 1) % 7 + 1);
        case 'yyv':
            return digitRewrite((`0${String((badiDate.year - 1) % 19 + 1)}`).slice(-2), language);
        case 'KiS':
            return postProcessLocaleItem(formatItemFallback(language, 'kulliShay'));
        // istanbul ignore next
        default:
            return '';
    }
};
const postProcessLocaleItem = (item, crop) => {
    if (crop && crop < item.length) {
        let char = 0;
        let counter = 0;
        while (counter < crop) {
            if (!'_’‘'.includes(item[char])) {
                counter++;
            }
            char++;
        }
        if ('_’‘'.includes(item[char])) {
            char++;
        }
        item = item.slice(0, char);
        if (item.split('_').length % 2 === 0) {
            item += '_';
        }
    }
    const stringComponents = item.split('_');
    for (let i = 1; i < stringComponents.length; i += 2) {
        stringComponents[i] = underlineString(stringComponents[i]);
    }
    return stringComponents.join('');
};
const underlineString = (str) => {
    switch (underlineFormat) {
        case 'css':
            return `<span style="text-decoration:underline">${str}</span>`;
        case 'diacritic':
            return str.split('').map(char => `${char}\u0332`).join('');
        case 'u':
            return `<u>${str}</u>`;
        case 'none':
            return str;
        // istanbul ignore next
        default:
            throw new TypeError('Unexpected underlineFormat');
    }
};
const digitRewrite = (number, language) => {
    number = String(number);
    const unicodeOffset = formatItemFallback(language, 'unicodeCharForZero').charCodeAt(0) - '0'.charCodeAt(0);
    if (unicodeOffset === 0) {
        return number;
    }
    const codePoints = [...number].map(num => num.charCodeAt(0) + unicodeOffset);
    return String.fromCharCode(...codePoints);
};
const formatItemFallback = (language, category, index) => {
    var _a;
    if (index === undefined) {
        while (badiLocale[language][category] === undefined) {
            language = languageFallback(language);
        }
        return badiLocale[language][category];
    }
    while (((_a = badiLocale[language][category]) === null || _a === void 0 ? void 0 : _a[index]) === undefined) {
        language = languageFallback(language);
    }
    return badiLocale[language][category][index];
};
const languageFallback = (languageCode) => {
    if (languageCode.includes('-')) {
        return languageCode.split('-')[0];
        // eslint-disable-next-line no-negated-condition
    }
    else if (languageCode !== 'default') {
        return 'default';
    }
    return 'en';
};

const badiYears = [
    'l4da', 'k4ci', 'k5c7', 'l4d6', 'l4ce', 'k4c4', 'k5d4', 'l4cb', 'l4c1', 'k4cj', 'k5c8', 'l4d7', 'l4cf', 'k4c5',
    'k4d5', 'k5ce', 'l4c2', 'k4d2', 'k4ca', 'k5da', 'l4ch', 'k4c6', 'k4d6', 'k5cf', 'l4c4', 'k4d4', 'k4cc', 'k5c1',
    'l4cj', 'k4c8', 'k4d8', 'k5cg', 'l4c5', 'k4d5', 'k4ce', 'k5c3', 'l4d2', 'k4ca', 'k4d9', 'k5ci', 'l4c6', 'k4d6',
    'k4cf', 'k4c4', 'k5d4', 'k4cb', 'k4bj', 'k4cj', 'k5c9', 'k4d8', 'k4cg', 'k4c6', 'k5d6', 'k4cd', 'k4c2', 'k4d2',
    'k5ca', 'k4d9', 'k4ci', 'k4c7', 'k5d7', 'k4cf', 'k4c4', 'k4d4', 'k5cc', 'k4bj', 'k4cj', 'k4c9', 'k5d9', 'k4cg',
    'k4c6', 'k4d5', 'k5cd', 'k4c2', 'k4d1', 'k4ca', 'k4da', 'j5cj', 'k4c7', 'k4d7', 'k4cf', 'j5c4', 'k4d3', 'k4cb',
    'k4c1', 'k5d1', 'l4c9', 'l4d9', 'l4ch', 'k5c6', 'l4d5', 'l4cd', 'l4c2', 'k5d2', 'l4ca', 'l4da', 'l4cj', 'k5c8',
    'l4d7', 'l4cf', 'l4c4', 'k5d4', 'l4cb', 'l4c1', 'l4d1', 'k5c9', 'l4d8', 'l4cg', 'l4c5', 'k4d5', 'k5ce', 'l4c2',
    'l4d2', 'k4cb', 'k5db', 'l4ci', 'l4c7', 'k4d7', 'k5cf', 'l4c4', 'l4d4', 'k4cc', 'k5c2', 'l4d1', 'l4c9', 'k4d9',
    'k5ch', 'l4c5', 'l4d5', 'k4ce', 'k5c3', 'l4d2', 'l4cb', 'k4da', 'k5ci', 'l4c6', 'l4d6', 'k4cf', 'k5c5', 'l4d4',
    'l4cc', 'k4c1', 'k4d1', 'k5c9', 'l4d8', 'k4cg', 'k4c6', 'k5d6', 'l4ce', 'k4c3', 'k4d3', 'k5cb', 'l4da', 'k4ci',
    'k4c7', 'k5d7', 'l4cf', 'k4c5', 'k4d5', 'k5cd', 'l4c1', 'k4cj', 'k4c9', 'k5d9', 'l4cg', 'k4c6', 'k4d6', 'k5ce',
    'l4c3', 'k4d2', 'k4ca', 'k5bj', 'l4ci', 'k4c7', 'k4d7', 'k4cg', 'k5c5', 'k4d4', 'k4cc', 'k4c1', 'k5d1', 'k4c9',
    'k4d9', 'k4ch', 'k5c7', 'l4d6', 'l4ce', 'l4c3', 'l5d3', 'l4ca', 'l4da', 'l4cj', 'l5c8', 'l4d7', 'l4cg', 'l4c5',
    'l5d4', 'l4cb', 'l4c1', 'l4d1', 'l5ca', 'l4d9', 'l4ch', 'l4c6', 'l5d6', 'l4cd', 'l4c2', 'l4d2', 'l4cb', 'k5c1',
    'l4cj', 'l4c8', 'l4d8', 'k5cg', 'l4c4', 'l4d4', 'l4cc', 'k5c2', 'l4d1', 'l4ca', 'l4da', 'k5ci', 'l4c6', 'l4d5',
    'l4ce', 'k5c3', 'l4d2', 'l4cb', 'l4db', 'k5cj', 'l4c8', 'l4d7', 'l4cf', 'k5c5', 'l4d4', 'l4cc', 'l4c2', 'k5d2',
    'l4c9', 'l4d9', 'l4ch', 'k4c6', 'k5d6', 'l4ce', 'l4c3', 'k4d3', 'k5cc', 'l4db', 'l4cj', 'k4c8', 'k5d8', 'l4cf',
    'l4c4', 'k4d5', 'k5cd', 'l4c2', 'l4d2', 'k4ca', 'k5d9', 'l4cg', 'l4c6', 'k4d6', 'k5cf', 'l4c3', 'l4d3', 'k4cb',
    'k5bj', 'l4ci', 'l4c7', 'k4d7', 'k5cg', 'l4c5', 'l4d5', 'k4cd', 'k4c2', 'k5d2', 'l4c9', 'k4d9', 'k4ch', 'k5c7',
    'l4d6', 'k4cf', 'k4c4', 'k5d4', 'l4cb', 'l4bj', 'l4cj', 'l5c8', 'm4d7', 'l4cg', 'l4c5', 'l5d5', 'm4cc', 'l4c1',
    'l4d1', 'l5ca', 'm4d9', 'l4ch', 'l4c7', 'l5d7', 'm4ce', 'l4c3', 'l4d3', 'l5cb', 'm4bi', 'l4ci', 'l4c8', 'l4d8',
    'l5ch', 'l4c5', 'l4d5', 'l4cd', 'l5c2', 'l4d1', 'l4c9', 'l4da', 'l5ci', 'l4c7', 'l4d7', 'l4cf', 'l5c4', 'l4d2',
    'l4cb', 'l4bj', 'l5d1', 'l4c8', 'l4d8', 'l4cg', 'l5c5', 'l4d4', 'l4cc', 'l4c2', 'l5d2', 'l4c9', 'l4da', 'l4ci',
];

class BadiDate {
    constructor(date) {
        this._holyDay = undefined;
        this._valid = true;
        this._invalidReason = undefined;
        try {
            if (this._isDateObject(date)) {
                this._gregorianDate = DateTime.fromObject({ year: date.getFullYear(), month: date.getMonth() + 1, day: date.getDate(), zone: 'UTC' });
            }
            else if (DateTime.isDateTime(date)) {
                this._gregorianDate = DateTime.fromObject({ year: date.year, month: date.month, day: date.day, zone: 'UTC' });
            }
            else if (this._isYearMonthDay(date) || this._isYearHolyDayNumber(date)) {
                this._setFromBadiDate(date);
            }
            else {
                throw new TypeError('Unrecognized input format');
            }
            if (this._year === undefined) {
                // We haven't set the Badí' date yet
                this._setFromGregorianDate();
            }
            this._setHolyDay();
        }
        catch (err) {
            this._setInvalid(err);
        }
        Object.freeze(this);
    }
    format(formatString, language) {
        return formatBadiDate(this, formatString, language);
    }
    _isDateObject(arg) {
        return Object.prototype.toString.call(arg) === '[object Date]';
    }
    _isYearMonthDay(arg) {
        return typeof arg.year === 'number' && typeof arg.month === 'number' &&
            typeof arg.day === 'number';
    }
    _isYearHolyDayNumber(arg) {
        return typeof arg.year === 'number' && arg.month === undefined &&
            arg.day === undefined && typeof arg.holyDayNumber === 'number';
    }
    _notInValidGregorianDateRange(datetime) {
        const lowerBound = DateTime.fromObject({ year: 1844, month: 3, day: 21, zone: 'UTC' });
        const upperBound = DateTime.fromObject({ year: 2351, month: 3, day: 20, zone: 'UTC' });
        return datetime < lowerBound || datetime > upperBound;
    }
    _setFromGregorianDate() {
        if (this._notInValidGregorianDateRange(this._gregorianDate)) {
            throw new RangeError('Input date outside of valid range (1844-03-21 - 2351-03-20)');
        }
        const gregorianYear = this._gregorianDate.year;
        const oldImplementationCutoff = DateTime.fromObject({ year: 2015, month: 3, day: 21, zone: 'UTC' });
        if (this._gregorianDate < oldImplementationCutoff) {
            const { month, day } = this._gregorianDate;
            if (month < 3 || (month === 3 && day < 21)) {
                this._nawRuz = DateTime.fromObject({ year: gregorianYear - 1, month: 3, day: 21, zone: 'UTC' });
                this._year = gregorianYear - 1844;
            }
            else {
                this._nawRuz = DateTime.fromObject({ year: gregorianYear, month: 3, day: 21, zone: 'UTC' });
                this._year = gregorianYear - 1843;
            }
            this._setOldAyyamiHaLength();
            this._yearTwinBirthdays = [12, 5, 13, 9];
        }
        else {
            this._year = gregorianYear - 1843;
            this._setBadiYearInfo(true);
        }
        this._setBadiMonthAndDay();
    }
    /**
     * Set Badí' month and day from Gregorian date
     */
    _setBadiMonthAndDay() {
        const dayOfBadiYear = this._dayOfYear(this._gregorianDate);
        if (dayOfBadiYear < 343) {
            this._month = Math.floor((dayOfBadiYear - 1) / 19 + 1);
            this._day = (dayOfBadiYear - 1) % 19 + 1;
        }
        else if (dayOfBadiYear < 343 + this._ayyamiHaLength) {
            this._month = 20;
            this._day = dayOfBadiYear - 342;
        }
        else {
            this._month = 19;
            this._day = dayOfBadiYear - (342 + this._ayyamiHaLength);
        }
    }
    _setFromBadiDate(date) {
        this._year = date.year;
        if (this._year < 1 || this._year > 507) {
            throw new RangeError('Input date outside of valid range (1 - 507 B.E.)');
        }
        else if (this._year < 172) {
            this._nawRuz = DateTime.fromObject({ year: 1843 + this._year, month: 3, day: 21, zone: 'UTC' });
            this._setOldAyyamiHaLength();
            this._yearTwinBirthdays = [12, 5, 13, 9];
        }
        else {
            this._setBadiYearInfo();
        }
        if (this._isYearMonthDay(date)) {
            this._month = date.month;
            this._day = date.day;
            if (this._month === 20 && this._day > this._ayyamiHaLength) {
                // If only off by one day, we'll bubble up so that 5th Ayyám-i-Há in a year with only 4 days of
                // Ayyám-i-Há can be salvaged
                if (this._day - this._ayyamiHaLength === 1) {
                    this._month = 19;
                    this._day = 1;
                }
                else {
                    throw new TypeError('Input numbers do not designate a valid date');
                }
            }
            if (this._month < 1 || this._month > 20 || this._day < 1 || this.day > 19) {
                throw new TypeError('Input numbers do not designate a valid date');
            }
        }
        else {
            if (date.holyDayNumber < 1 || date.holyDayNumber > 11) {
                throw new TypeError('Input numbers do not designate a valid Holy Day');
            }
            this._holyDay = date.holyDayNumber;
            [this._month, this._day] = this._holyDayMapping()[this._holyDay];
        }
        this._gregorianDate = this._nawRuz.plus(Duration.fromObject({ days: this._dayOfYear([this._year, this._month, this._day]) - 1 }));
    }
    _setOldAyyamiHaLength() {
        if (DateTime.fromObject({ year: this._nawRuz.year + 1 }).isInLeapYear) {
            this._ayyamiHaLength = 5;
        }
        else {
            this._ayyamiHaLength = 4;
        }
    }
    _setBadiYearInfo(fromGregorianDate = false) {
        let yearData = this._extractBadiYearInfo();
        if (fromGregorianDate && this._gregorianDate < yearData.nawRuz) {
            this._year -= 1;
            yearData = this._extractBadiYearInfo();
        }
        this._nawRuz = yearData.nawRuz;
        this._ayyamiHaLength = yearData.ayyamiHaLength;
        this._yearTwinBirthdays = yearData.twinBirthdays;
    }
    _extractBadiYearInfo() {
        let nawRuz, ayyamiHaLength, twinBirthdays;
        // Check whether data needs to be unpacked or exists in the verbose version
        // istanbul ignore else
        if (badiYears[0] === 'l4da') {
            const components = badiYears[this._year - 172].split('');
            nawRuz = DateTime.fromObject({ year: this._year - 172 + 2015, month: 3, day: parseInt(components[0], 36), zone: 'UTC' });
            ayyamiHaLength = parseInt(components[1], 36);
            const TB1 = [parseInt(components[2], 36), parseInt(components[3], 36)];
            const TB2 = TB1[1] < 19 ? [TB1[0], TB1[1] + 1] : [TB1[0] + 1, 1];
            twinBirthdays = [TB1[0], TB1[1], TB2[0], TB2[1]];
        }
        else {
            ({ nawRuz, ayyamiHaLength, twinBirthdays } = badiYears[this._year]);
            nawRuz = DateTime.fromISO(nawRuz, { zone: 'UTC' });
        }
        return { nawRuz, ayyamiHaLength, twinBirthdays };
    }
    _dayOfYear(date) {
        // Naw-Rúz is day 1
        if (Array.isArray(date)) {
            // We have a Badí' date
            if (date[1] < 19) {
                return 19 * (date[1] - 1) + date[2];
            }
            else if (date[1] === 20) {
                return 342 + date[2];
            }
            // date[1] === 19
            return 342 + this._ayyamiHaLength + date[2];
        }
        return date.diff(this._nawRuz).as('days') + 1;
    }
    _setInvalid(invalidReason) {
        this._gregorianDate = DateTime.invalid('Not a valid Badí‘ date');
        this._year = NaN;
        this._month = NaN;
        this._day = NaN;
        this._ayyamiHaLength = NaN;
        this._nawRuz = DateTime.invalid('Not a valid Badí‘ date');
        this._valid = false;
        this._invalidReason = invalidReason;
    }
    _setHolyDay() {
        const mapping = this._holyDayMapping();
        this._holyDay = parseInt(Object.keys(mapping)
            .find(key => mapping[key][0] === this._month && mapping[key][1] === this._day), 10);
    }
    _holyDayMapping() {
        return {
            [1 /* NawRuz */]: [1, 1],
            [2 /* FirstRidvan */]: [2, 13],
            [3 /* NinthRidvan */]: [3, 2],
            [4 /* TwelfthRidvan */]: [3, 5],
            [5 /* DeclarationOfTheBab */]: [4, this._year < 172 ? 7 : 8],
            [6 /* AscensionOfBahaullah */]: [4, 13],
            [7 /* MartyrdomOfTheBab */]: [6, this._year < 172 ? 16 : 17],
            [8 /* BirthOfTheBab */]: [this._yearTwinBirthdays[0], this._yearTwinBirthdays[1]],
            [9 /* BirthOfBahaullah */]: [this._yearTwinBirthdays[2], this._yearTwinBirthdays[3]],
            [10 /* DayOfTheCovenant */]: [14, 4],
            [11 /* AscensionOfAbdulBaha */]: [14, 6],
        };
    }
    _leapYearsBefore() {
        let leapYearsBefore = Math.floor(Math.min(this.year - 1, 171) / 4);
        if (this.year > 172) {
            // istanbul ignore else
            if (badiYears[0] === 'l4da') {
                leapYearsBefore += badiYears.slice(0, this.year - 172).filter(entry => entry[1] === '5').length;
            }
            else {
                leapYearsBefore += Object.entries(badiYears)
                    .filter(([year, data]) => parseInt(year, 10) < this.year &&
                    data.ayyamiHaLength === 5).length;
            }
        }
        return leapYearsBefore;
    }
    holyDay(language = undefined) {
        if (!this._holyDay) {
            return '';
        }
        if (language === undefined || badiLocale[language] === undefined) {
            language = 'default';
        }
        return formatItemFallback(language, 'holyDay', this._holyDay);
    }
    valueOf() {
        return this._dayOfYear([this.year, this.month, this.day]) + this._leapYearsBefore() + (this.year - 1) * 365;
    }
    equals(other) {
        return this.isValid && other.isValid && this.valueOf() === other.valueOf();
    }
    get isValid() {
        return this._valid;
    }
    get invalidReason() {
        return this._invalidReason;
    }
    get day() {
        return this._day;
    }
    get month() {
        return this._month;
    }
    get year() {
        return this._year;
    }
    // number of the Badí' weekday between 1 (Jalál ~> Saturday) and 7 (Istiqlál ~> Friday).
    get weekday() {
        return (this._gregorianDate.weekday + 1) % 7 + 1;
    }
    get yearInVahid() {
        return (this._year - 1) % 19 + 1;
    }
    get vahid() {
        return (Math.floor((this._year - 1) / 19) % 19) + 1;
    }
    get kullIShay() {
        return Math.floor((this._year - 1) / 361) + 1;
    }
    // Gregorian date on whose sunset the Badí' date ends.
    get gregorianDate() {
        return this._gregorianDate;
    }
    get ayyamiHaLength() {
        return this._ayyamiHaLength;
    }
    get holyDayNumber() {
        return this._holyDay ? this._holyDay : undefined;
    }
    get workSuspended() {
        return this._holyDay ? this.holyDayNumber < 10 : undefined;
    }
    get nextMonth() {
        let { year, month } = this;
        switch (month) {
            case 18:
                month = 20;
                break;
            case 19:
                month = 1;
                year += 1;
                break;
            case 20:
                month = 19;
                break;
            default:
                month += 1;
        }
        return new BadiDate({ year, month, day: 1 });
    }
    get previousMonth() {
        let { year, month } = this;
        switch (month) {
            case 1:
                month = 19;
                year -= 1;
                break;
            case 19:
                month = 20;
                break;
            case 20:
                month = 18;
                break;
            default:
                month -= 1;
        }
        return new BadiDate({ year, month, day: 1 });
    }
    get nextDay() {
        if (this._day === 19 || (this._month === 20 && this._day === this._ayyamiHaLength)) {
            return this.nextMonth;
        }
        return new BadiDate({ year: this._year, month: this._month, day: this._day + 1 });
    }
    get previousDay() {
        if (this._day === 1) {
            const { previousMonth } = this;
            let day = 19;
            if (this._month === 19) {
                day = this._ayyamiHaLength;
            }
            return new BadiDate({
                year: previousMonth.year,
                month: previousMonth.month,
                day,
            });
        }
        return new BadiDate({ year: this._year, month: this._month, day: this._day - 1 });
    }
}
const badiDateSettings = (settings) => {
    if (settings.defaultLanguage) {
        setDefaultLanguage(settings.defaultLanguage);
    }
    if (settings.underlineFormat) {
        setUnderlineFormat(settings.underlineFormat);
    }
};

export { BadiDate, badiDateSettings };