@midseelee/date-fns-buddhist-adapter 1.0.0

package/.claude/settings.local.json

@@ -0,0 +1,9 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(npm publish:*)"
+    ],
+    "deny": [],
+    "ask": []
+  }
+}

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2023 Ascendcorp
+Copyright (c) 2025 midseelee (fork modifications)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,49 @@
+# @midseelee/date-fns-buddhist-adapter
+
+> Forked from [ascendcorp/date-fns-buddhist-adapter](https://github.com/ascendcorp/date-fns-buddhist-adapter)
+
+date-fns adapter with Buddhist years functionality compatible with [MUI-X](https://github.com/mui/mui-x) date-picker.
+
+## Installation
+
+```shell
+npm install @midseelee/date-fns-buddhist-adapter
+# or
+pnpm add @midseelee/date-fns-buddhist-adapter
+# or
+bun add @midseelee/date-fns-buddhist-adapter
+```
+
+## Usage
+
+```typescript
+import AdapterDateFns from '@midseelee/date-fns-buddhist-adapter'
+import { LocalizationProvider } from '@mui/x-date-pickers'
+import { DatePicker } from '@mui/x-date-pickers/DatePicker'
+import { thTH } from 'date-fns/locale/th-TH'
+
+function App() {
+  return (
+    <LocalizationProvider dateAdapter={AdapterDateFns} adapterLocale={thTH}>
+      <DatePicker />
+    </LocalizationProvider>
+  )
+}
+```
+
+## Credits
+
+This package is forked from [ascendcorp/date-fns-buddhist-adapter](https://github.com/ascendcorp/date-fns-buddhist-adapter)
+
+### Special Thanks
+
+1. [Ascendcorp](https://github.com/ascendcorp) - Original implementation
+2. [mui-x](https://github.com/mui/mui-x) - MUI X Date Pickers
+3. [date-fns-be](https://github.com/tarzui/date-fns-be) - Buddhist Era utilities
+
+## License
+
+MIT License
+
+- Copyright (c) 2023 Ascendcorp (original)
+- Copyright (c) 2025 midseelee (fork modifications)

package/dist/index.d.ts

@@ -0,0 +1,86 @@
+import { enUS as defaultLocale } from 'date-fns/locale/en-US';
+import type { AdapterFormats, AdapterOptions, AdapterUnits, FieldFormatTokenMap, MuiPickersAdapter } from './models';
+type DateFnsLocale = typeof defaultLocale;
+export default class AdapterDateFns implements MuiPickersAdapter<Date, DateFnsLocale> {
+    isMUIAdapter: boolean;
+    isTimezoneCompatible: boolean;
+    lib: string;
+    locale?: DateFnsLocale;
+    formats: AdapterFormats;
+    formatTokenMap: FieldFormatTokenMap;
+    escapedCharacters: {
+        start: string;
+        end: string;
+    };
+    constructor({ locale, formats }?: AdapterOptions<DateFnsLocale, never>);
+    is12HourCycleInCurrentLocale: () => boolean;
+    expandFormat: (format: string) => string;
+    getFormatHelperText: (format: string) => string;
+    parseISO: (isoString: string) => Date;
+    toISO: (value: Date) => string;
+    getCurrentLocaleCode: () => string;
+    addSeconds: (value: Date, count: number) => Date;
+    addMinutes: (value: Date, count: number) => Date;
+    addHours: (value: Date, count: number) => Date;
+    addDays: (value: Date, count: number) => Date;
+    addWeeks: (value: Date, count: number) => Date;
+    addMonths: (value: Date, count: number) => Date;
+    addYears: (value: Date, amount: number) => Date;
+    isValid: (value: any) => boolean;
+    getDiff: (value: Date, comparing: Date | string, unit?: AdapterUnits) => number;
+    isAfter: (value: Date, comparing: Date) => boolean;
+    isBefore: (value: Date, comparing: Date) => boolean;
+    startOfDay: (value: Date) => Date;
+    endOfDay: (value: Date) => Date;
+    getHours: (value: Date) => number;
+    setHours: (value: Date, count: number) => Date;
+    setMinutes: (value: Date, count: number) => Date;
+    getSeconds: (value: Date) => number;
+    setSeconds: (value: Date, count: number) => Date;
+    setMilliseconds: (value: Date, milliseconds: number) => Date;
+    getMilliseconds: (value: Date) => number;
+    isSameDay: (value: Date, comparing: Date) => boolean;
+    isSameMonth: (value: Date, comparing: Date) => boolean;
+    isSameYear: (value: Date, comparing: Date) => boolean;
+    isSameHour: (value: Date, comparing: Date) => boolean;
+    startOfMonth: (value: Date) => Date;
+    endOfMonth: (value: Date) => Date;
+    startOfWeek: (value: Date) => Date;
+    endOfWeek: (value: Date) => Date;
+    startOfYear: (value: Date) => Date;
+    endOfYear: (value: Date) => Date;
+    getYear: (value: Date) => number;
+    setYear: (value: Date, count: number) => Date;
+    date: (value?: any) => Date | null;
+    dateWithTimezone: (value: string | null | undefined) => Date | null;
+    getTimezone: () => string;
+    setTimezone: (value: Date) => Date;
+    toJsDate: (value: Date) => Date;
+    parse: (value: string, formatString: string) => Date | null;
+    format: (date: Date, formatKey: keyof AdapterFormats) => string;
+    formatByString: (date: Date, formatString: string) => string;
+    isEqual: (date: any, comparing: any) => boolean;
+    isNull: (date: Date) => date is never;
+    isAfterDay: (date: Date, value: Date) => boolean;
+    isBeforeDay: (date: Date, value: Date) => boolean;
+    isBeforeYear: (date: Date, value: Date) => boolean;
+    isAfterYear: (date: Date, value: Date) => boolean;
+    isWithinRange: (date: Date, [start, end]: [Date, Date]) => boolean;
+    formatNumber: (numberToFormat: string) => string;
+    getMinutes: (date: Date) => number;
+    getDate: (value: Date) => number;
+    getMonth: (date: Date) => number;
+    getDaysInMonth: (date: Date) => number;
+    setMonth: (date: Date, count: number) => Date;
+    setDate: (value: Date, date: number) => Date;
+    getMeridiemText: (ampm: "am" | "pm") => "AM" | "PM";
+    getNextMonth: (date: Date) => Date;
+    getPreviousMonth: (date: Date) => Date;
+    getMonthArray: (date: Date) => Date[];
+    mergeDateAndTime: (date: Date, time: Date) => Date;
+    getWeekdays: () => string[];
+    getWeekArray: (date: Date) => Date[][];
+    getWeekNumber: (value: Date) => number;
+    getYearRange: (start: Date, end: Date) => Date[];
+}
+export {};

package/dist/index.js

@@ -0,0 +1,465 @@
+import { addDays, addHours, addMinutes, addMonths, addSeconds, addWeeks, addYears, differenceInDays, differenceInHours, differenceInMilliseconds, differenceInMinutes, differenceInMonths, differenceInQuarters, differenceInSeconds, differenceInWeeks, differenceInYears, eachDayOfInterval, endOfDay, endOfMonth, endOfWeek, endOfYear, format, formatISO, getDate, getDay, getDaysInMonth, getHours, getMilliseconds, getSeconds, getWeek, getYear, isAfter, isBefore, isEqual, isSameDay, isSameHour, isSameMonth, isSameYear, isValid, isWithinInterval, parse as dateFnsParse, parseISO, setDate, setHours, setMilliseconds, setMinutes, setMonth, setSeconds, setYear, startOfDay, startOfMonth, startOfWeek, startOfYear, } from 'date-fns';
+import { enUS as defaultLocale } from 'date-fns/locale/en-US';
+const formatTokenMap = {
+    // Year
+    y: { sectionType: 'year', contentType: 'digit', maxLength: 4 },
+    yy: 'year',
+    yyy: { sectionType: 'year', contentType: 'digit', maxLength: 4 },
+    yyyy: { sectionType: 'year', contentType: 'digit', maxLength: 4 },
+    // Month
+    M: { sectionType: 'month', contentType: 'digit', maxLength: 2 },
+    MM: 'month',
+    MMMM: { sectionType: 'month', contentType: 'letter' },
+    MMM: { sectionType: 'month', contentType: 'letter' },
+    L: { sectionType: 'month', contentType: 'digit', maxLength: 2 },
+    LL: 'month',
+    LLL: { sectionType: 'month', contentType: 'letter' },
+    LLLL: { sectionType: 'month', contentType: 'letter' },
+    // Day of the month
+    d: { sectionType: 'day', contentType: 'digit', maxLength: 2 },
+    dd: 'day',
+    do: { sectionType: 'day', contentType: 'digit-with-letter' },
+    // Day of the week
+    E: { sectionType: 'weekDay', contentType: 'letter' },
+    EE: { sectionType: 'weekDay', contentType: 'letter' },
+    EEE: { sectionType: 'weekDay', contentType: 'letter' },
+    EEEE: { sectionType: 'weekDay', contentType: 'letter' },
+    EEEEE: { sectionType: 'weekDay', contentType: 'letter' },
+    i: { sectionType: 'weekDay', contentType: 'digit', maxLength: 1 },
+    ii: 'weekDay',
+    iii: { sectionType: 'weekDay', contentType: 'letter' },
+    iiii: { sectionType: 'weekDay', contentType: 'letter' },
+    e: { sectionType: 'weekDay', contentType: 'digit', maxLength: 1 },
+    ee: 'weekDay',
+    eee: { sectionType: 'weekDay', contentType: 'letter' },
+    eeee: { sectionType: 'weekDay', contentType: 'letter' },
+    eeeee: { sectionType: 'weekDay', contentType: 'letter' },
+    eeeeee: { sectionType: 'weekDay', contentType: 'letter' },
+    c: { sectionType: 'weekDay', contentType: 'digit', maxLength: 1 },
+    cc: 'weekDay',
+    ccc: { sectionType: 'weekDay', contentType: 'letter' },
+    cccc: { sectionType: 'weekDay', contentType: 'letter' },
+    ccccc: { sectionType: 'weekDay', contentType: 'letter' },
+    cccccc: { sectionType: 'weekDay', contentType: 'letter' },
+    // Meridiem
+    a: 'meridiem',
+    aa: 'meridiem',
+    aaa: 'meridiem',
+    // Hours
+    H: { sectionType: 'hours', contentType: 'digit', maxLength: 2 },
+    HH: 'hours',
+    h: { sectionType: 'hours', contentType: 'digit', maxLength: 2 },
+    hh: 'hours',
+    // Minutes
+    m: { sectionType: 'minutes', contentType: 'digit', maxLength: 2 },
+    mm: 'minutes',
+    // Seconds
+    s: { sectionType: 'seconds', contentType: 'digit', maxLength: 2 },
+    ss: 'seconds',
+};
+const defaultFormats = {
+    dayOfMonth: 'd',
+    fullDate: 'PP',
+    fullDateWithWeekday: 'PPPP',
+    fullDateTime: 'PP p',
+    fullDateTime12h: 'PP hh:mm aaa',
+    fullDateTime24h: 'PP HH:mm',
+    fullTime: 'p',
+    fullTime12h: 'hh:mm aaa',
+    fullTime24h: 'HH:mm',
+    hours12h: 'hh',
+    hours24h: 'HH',
+    keyboardDate: 'P',
+    keyboardDateTime: 'P p',
+    keyboardDateTime12h: 'P hh:mm aaa',
+    keyboardDateTime24h: 'P HH:mm',
+    minutes: 'mm',
+    month: 'LLLL',
+    monthAndDate: 'MMMM d',
+    monthAndYear: 'LLLL yyyy',
+    monthShort: 'MMM',
+    weekday: 'EEEE',
+    weekdayShort: 'EEE',
+    normalDate: 'd MMMM',
+    normalDateWithWeekday: 'EEE, MMM d',
+    seconds: 'ss',
+    shortDate: 'MMM d',
+    year: 'yyyy',
+};
+export default class AdapterDateFns {
+    isMUIAdapter = true;
+    isTimezoneCompatible = false;
+    lib = 'date-fns-buddhist';
+    locale;
+    formats;
+    formatTokenMap = formatTokenMap;
+    escapedCharacters = { start: "'", end: "'" };
+    constructor({ locale, formats } = {}) {
+        this.locale = locale;
+        this.formats = { ...defaultFormats, ...formats, meridiem: '' };
+    }
+    // Note: date-fns input types are more lenient than this adapter, so we need to expose our more
+    // strict signature and delegate to the more lenient signature. Otherwise, we have downstream type errors upon usage.
+    is12HourCycleInCurrentLocale = () => {
+        if (this.locale) {
+            return /a/.test(this.locale.formatLong.time({ width: 'short' }));
+        }
+        // By default date-fns is using en-US locale with am/pm enabled
+        return true;
+    };
+    expandFormat = (format) => {
+        const longFormatRegexp = /P+p+|P+|p+|''|'(''|[^'])+('|$)|./g;
+        // @see https://github.com/date-fns/date-fns/blob/master/src/format/index.js#L31
+        return format
+            .match(longFormatRegexp)
+            .map((token) => {
+            const firstCharacter = token[0];
+            if (firstCharacter === 'p' || firstCharacter === 'P') {
+                const locale = this.locale || defaultLocale;
+                // Use the locale's format function to expand format strings
+                return this.formatByString(new Date(), token);
+            }
+            return token;
+        })
+            .join('');
+    };
+    getFormatHelperText = (format) => {
+        // @see https://github.com/date-fns/date-fns/blob/master/src/format/index.js#L31
+        const longFormatRegexp = /P+p+|P+|p+|''|'(''|[^'])+('|$)|./g;
+        return format
+            .match(longFormatRegexp)
+            .map((token) => {
+            const firstCharacter = token[0];
+            if (firstCharacter === 'p' || firstCharacter === 'P') {
+                // Use the format function to expand format strings
+                return this.formatByString(new Date(), token);
+            }
+            return token;
+        })
+            .join('')
+            .replace(/(aaa|aa|a)/g, '(a|p)m')
+            .toLocaleLowerCase();
+    };
+    parseISO = (isoString) => {
+        return parseISO(isoString);
+    };
+    toISO = (value) => {
+        return formatISO(value, { format: 'extended' });
+    };
+    getCurrentLocaleCode = () => {
+        return this.locale?.code || 'th-Th';
+    };
+    addSeconds = (value, count) => {
+        return addSeconds(value, count);
+    };
+    addMinutes = (value, count) => {
+        return addMinutes(value, count);
+    };
+    addHours = (value, count) => {
+        return addHours(value, count);
+    };
+    addDays = (value, count) => {
+        return addDays(value, count);
+    };
+    addWeeks = (value, count) => {
+        return addWeeks(value, count);
+    };
+    addMonths = (value, count) => {
+        return addMonths(value, count);
+    };
+    addYears = (value, amount) => {
+        return addYears(value, amount);
+    };
+    isValid = (value) => {
+        return isValid(this.date(value));
+    };
+    getDiff = (value, comparing, unit) => {
+        switch (unit) {
+            case 'years':
+                return differenceInYears(value, this.date(comparing));
+            case 'quarters':
+                return differenceInQuarters(value, this.date(comparing));
+            case 'months':
+                return differenceInMonths(value, this.date(comparing));
+            case 'weeks':
+                return differenceInWeeks(value, this.date(comparing));
+            case 'days':
+                return differenceInDays(value, this.date(comparing));
+            case 'hours':
+                return differenceInHours(value, this.date(comparing));
+            case 'minutes':
+                return differenceInMinutes(value, this.date(comparing));
+            case 'seconds':
+                return differenceInSeconds(value, this.date(comparing));
+            default: {
+                return differenceInMilliseconds(value, this.date(comparing));
+            }
+        }
+    };
+    isAfter = (value, comparing) => {
+        return isAfter(value, comparing);
+    };
+    isBefore = (value, comparing) => {
+        return isBefore(value, comparing);
+    };
+    startOfDay = (value) => {
+        return startOfDay(value);
+    };
+    endOfDay = (value) => {
+        return endOfDay(value);
+    };
+    getHours = (value) => {
+        return getHours(value);
+    };
+    setHours = (value, count) => {
+        return setHours(value, count);
+    };
+    setMinutes = (value, count) => {
+        return setMinutes(value, count);
+    };
+    getSeconds = (value) => {
+        return getSeconds(value);
+    };
+    setSeconds = (value, count) => {
+        return setSeconds(value, count);
+    };
+    setMilliseconds = (value, milliseconds) => {
+        return setMilliseconds(value, milliseconds);
+    };
+    getMilliseconds = (value) => {
+        return getMilliseconds(value);
+    };
+    isSameDay = (value, comparing) => {
+        return isSameDay(value, comparing);
+    };
+    isSameMonth = (value, comparing) => {
+        return isSameMonth(value, comparing);
+    };
+    isSameYear = (value, comparing) => {
+        return isSameYear(value, comparing);
+    };
+    isSameHour = (value, comparing) => {
+        return isSameHour(value, comparing);
+    };
+    startOfMonth = (value) => {
+        return startOfMonth(value);
+    };
+    endOfMonth = (value) => {
+        return endOfMonth(value);
+    };
+    startOfWeek = (value) => {
+        return startOfWeek(value, { locale: this.locale });
+    };
+    endOfWeek = (value) => {
+        return endOfWeek(value, { locale: this.locale });
+    };
+    startOfYear = (value) => {
+        return startOfYear(value);
+    };
+    endOfYear = (value) => {
+        return endOfYear(value);
+    };
+    getYear = (value) => {
+        return getYear(value);
+    };
+    setYear = (value, count) => {
+        return setYear(value, count);
+    };
+    date = (value) => {
+        //
+        if (typeof value === 'undefined') {
+            return new Date();
+        }
+        if (value === null) {
+            return null;
+        }
+        return new Date(value);
+    };
+    dateWithTimezone = (value) => {
+        return this.date(value);
+    };
+    getTimezone = () => {
+        return 'default';
+    };
+    setTimezone = (value) => {
+        return value;
+    };
+    toJsDate = (value) => {
+        return value;
+    };
+    parse = (value, formatString) => {
+        if (value === '') {
+            return null;
+        }
+        if ((formatString === 'dd/MM/yyyy' || formatString === 'P') &&
+            value.length === 10) {
+            const year = parseInt(value.substring(6, 10));
+            if (year > 543) {
+                const newYear = year - 543;
+                const res = value.replace(`${year}`, `${newYear}`);
+                return dateFnsParse(res, formatString, new Date(), {
+                    locale: this.locale,
+                });
+            }
+            else {
+                return dateFnsParse(value, formatString, new Date(), {
+                    locale: this.locale,
+                });
+            }
+        }
+        if (formatString === 'MM/yyyy' && value.length === 7) {
+            const year = parseInt(value.substring(3, 7));
+            if (year > 543) {
+                const newYear = year - 543;
+                const res = value.replace(`${year}`, `${newYear}`);
+                return dateFnsParse(res, formatString, new Date(), {
+                    locale: this.locale,
+                });
+            }
+            else {
+                return dateFnsParse(value, formatString, new Date(), {
+                    locale: this.locale,
+                });
+            }
+        }
+        if (formatString === 'yyyy' && value.length === 4) {
+            const year = parseInt(value);
+            if (year > 543) {
+                const newYear = year - 543;
+                const res = value.replace(`${year}`, `${newYear}`);
+                return dateFnsParse(res, formatString, new Date(), {
+                    locale: this.locale,
+                });
+            }
+            else {
+                return dateFnsParse(value, formatString, new Date(), {
+                    locale: this.locale,
+                });
+            }
+        }
+        if (formatString === 'MM' && value.length === 2) {
+            return dateFnsParse(value, formatString, new Date(), {
+                locale: this.locale,
+            });
+        }
+        return null;
+        // return dateFnsParse(value, formatString, new Date(), { locale: this.locale });
+    };
+    format = (date, formatKey) => {
+        return this.formatByString(date, this.formats[formatKey]);
+    };
+    formatByString = (date, formatString) => {
+        const christianYear = `${getYear(date)}`;
+        const buddhishYear = (parseInt(christianYear) + 543).toString();
+        const result = format(date, formatString, { locale: this.locale });
+        return result.replace(christianYear, buddhishYear);
+    };
+    isEqual = (date, comparing) => {
+        if (date === null && comparing === null) {
+            return true;
+        }
+        return isEqual(date, comparing);
+    };
+    isNull = (date) => {
+        return date === null;
+    };
+    isAfterDay = (date, value) => {
+        return isAfter(date, endOfDay(value));
+    };
+    isBeforeDay = (date, value) => {
+        return isBefore(date, startOfDay(value));
+    };
+    isBeforeYear = (date, value) => {
+        return isBefore(date, startOfYear(value));
+    };
+    isAfterYear = (date, value) => {
+        return isAfter(date, endOfYear(value));
+    };
+    isWithinRange = (date, [start, end]) => {
+        return isWithinInterval(date, { start, end });
+    };
+    formatNumber = (numberToFormat) => {
+        return numberToFormat;
+    };
+    getMinutes = (date) => {
+        return date.getMinutes();
+    };
+    getDate = (value) => {
+        return getDate(value);
+    };
+    getMonth = (date) => {
+        return date.getMonth();
+    };
+    getDaysInMonth = (date) => {
+        return getDaysInMonth(date);
+    };
+    setMonth = (date, count) => {
+        return setMonth(date, count);
+    };
+    setDate = (value, date) => {
+        return setDate(value, date);
+    };
+    getMeridiemText = (ampm) => {
+        return ampm === 'am' ? 'AM' : 'PM';
+    };
+    getNextMonth = (date) => {
+        return addMonths(date, 1);
+    };
+    getPreviousMonth = (date) => {
+        return addMonths(date, -1);
+    };
+    getMonthArray = (date) => {
+        const firstMonth = startOfYear(date);
+        const monthArray = [firstMonth];
+        while (monthArray.length < 12) {
+            const prevMonth = monthArray[monthArray.length - 1];
+            monthArray.push(this.getNextMonth(prevMonth));
+        }
+        return monthArray;
+    };
+    mergeDateAndTime = (date, time) => {
+        return this.setSeconds(this.setMinutes(this.setHours(date, this.getHours(time)), this.getMinutes(time)), this.getSeconds(time));
+    };
+    getWeekdays = () => {
+        const now = new Date();
+        return eachDayOfInterval({
+            start: startOfWeek(now, { locale: this.locale }),
+            end: endOfWeek(now, { locale: this.locale }),
+        }).map((day) => this.formatByString(day, 'EEEEEE'));
+    };
+    getWeekArray = (date) => {
+        const start = startOfWeek(startOfMonth(date), { locale: this.locale });
+        const end = endOfWeek(endOfMonth(date), { locale: this.locale });
+        let count = 0;
+        let current = start;
+        const nestedWeeks = [];
+        let lastDay = null;
+        while (isBefore(current, end)) {
+            const weekNumber = Math.floor(count / 7);
+            nestedWeeks[weekNumber] = nestedWeeks[weekNumber] || [];
+            const day = getDay(current);
+            if (lastDay !== day) {
+                lastDay = day;
+                nestedWeeks[weekNumber].push(current);
+                count += 1;
+            }
+            current = addDays(current, 1);
+        }
+        return nestedWeeks;
+    };
+    getWeekNumber = (value) => {
+        return getWeek(value, { locale: this.locale });
+    };
+    getYearRange = (start, end) => {
+        const startDate = startOfYear(start);
+        const endDate = endOfYear(end);
+        const years = [];
+        let current = startDate;
+        while (isBefore(current, endDate)) {
+            years.push(current);
+            current = addYears(current, 1);
+        }
+        return years;
+    };
+}
+//# sourceMappingURL=index.js.map