@naturalcycles/js-lib 14.243.1 → 14.245.0

package/dist/datetime/localDate.js

@@ -1,75 +1,82 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.localDate = exports.LocalDate = void 0;
-exports.todayString = todayString;
 const assert_1 = require("../error/assert");
 const is_util_1 = require("../is.util");
 const iterable2_1 = require("../iter/iterable2");
 const localTime_1 = require("./localTime");
 const MDAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
-const DATE_REGEX = /^(\d\d\d\d)-(\d\d)-(\d\d)/;
+/**
+ * Regex is open-ended (no $ at the end) to support e.g Date+Time string to be parsed (time part will be dropped)
+ */
+const DATE_REGEX_LOOSE = /^(\d\d\d\d)-(\d\d)-(\d\d)/;
+/**
+ * Strict version.
+ */
+const DATE_REGEX_STRICT = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
+const COMPACT_DATE_REGEX = /^(\d\d\d\d)(\d\d)(\d\d)$/;
 /**
  * LocalDate represents a date without time.
  * It is timezone-independent.
  */
 class LocalDate {
-    constructor($year, $month, $day) {
-        this.$year = $year;
-        this.$month = $month;
-        this.$day = $day;
+    constructor(year, month, day) {
+        this.year = year;
+        this.month = month;
+        this.day = day;
     }
     get(unit) {
-        return unit === 'year' ? this.$year : unit === 'month' ? this.$month : this.$day;
+        return unit === 'year' ? this.year : unit === 'month' ? this.month : this.day;
     }
     set(unit, v, mutate = false) {
         const t = mutate ? this : this.clone();
         if (unit === 'year') {
-            t.$year = v;
+            t.year = v;
         }
         else if (unit === 'month') {
-            t.$month = v;
+            t.month = v;
         }
         else {
-            t.$day = v;
+            t.day = v;
         }
         return t;
     }
-    year(v) {
-        return v === undefined ? this.$year : this.set('year', v);
+    setYear(v) {
+        return this.set('year', v);
     }
-    month(v) {
-        return v === undefined ? this.$month : this.set('month', v);
+    setMonth(v) {
+        return this.set('month', v);
     }
-    day(v) {
-        return v === undefined ? this.$day : this.set('day', v);
+    setDay(v) {
+        return this.set('day', v);
     }
-    dayOfWeek() {
+    get dayOfWeek() {
         return (this.toDate().getDay() || 7);
     }
     isSame(d) {
-        d = exports.localDate.of(d);
-        return this.$day === d.$day && this.$month === d.$month && this.$year === d.$year;
+        d = exports.localDate.fromInput(d);
+        return this.day === d.day && this.month === d.month && this.year === d.year;
     }
     isBefore(d, inclusive = false) {
-        const r = this.cmp(d);
+        const r = this.compare(d);
         return r === -1 || (r === 0 && inclusive);
     }
     isSameOrBefore(d) {
-        return this.cmp(d) <= 0;
+        return this.compare(d) <= 0;
     }
     isAfter(d, inclusive = false) {
-        const r = this.cmp(d);
+        const r = this.compare(d);
         return r === 1 || (r === 0 && inclusive);
     }
     isSameOrAfter(d) {
-        return this.cmp(d) >= 0;
+        return this.compare(d) >= 0;
     }
     isBetween(min, max, incl = '[)') {
-        let r = this.cmp(min);
+        let r = this.compare(min);
         // eslint-disable-next-line @typescript-eslint/prefer-string-starts-ends-with
         if (r < 0 || (r === 0 && incl[0] === '('))
             return false;
-        r = this.cmp(max);
+        r = this.compare(max);
         if (r > 0 || (r === 0 && incl[1] === ')'))
             return false;
         return true;
@@ -84,13 +91,13 @@ class LocalDate {
      * Third argument allows to override "today".
      */
     isOlderThan(n, unit, today) {
-        return this.isBefore(exports.localDate.of(today || new Date()).plus(-n, unit));
+        return this.isBefore(exports.localDate.fromInput(today || new Date()).plus(-n, unit));
     }
     /**
      * Checks if this localDate is same or older (<=) than "today" by X units.
      */
     isSameOrOlderThan(n, unit, today) {
-        return this.isSameOrBefore(exports.localDate.of(today || new Date()).plus(-n, unit));
+        return this.isSameOrBefore(exports.localDate.fromInput(today || new Date()).plus(-n, unit));
     }
     /**
      * Checks if this localDate is younger (>) than "today" by X units.
@@ -102,13 +109,13 @@ class LocalDate {
      * Third argument allows to override "today".
      */
     isYoungerThan(n, unit, today) {
-        return this.isAfter(exports.localDate.of(today || new Date()).plus(-n, unit));
+        return this.isAfter(exports.localDate.fromInput(today || new Date()).plus(-n, unit));
     }
     /**
      * Checks if this localDate is same or younger (>=) than "today" by X units.
      */
     isSameOrYoungerThan(n, unit, today) {
-        return this.isSameOrAfter(exports.localDate.of(today || new Date()).plus(-n, unit));
+        return this.isSameOrAfter(exports.localDate.fromInput(today || new Date()).plus(-n, unit));
     }
     getAgeInYears(today) {
         return this.getAgeIn('year', today);
@@ -120,26 +127,26 @@ class LocalDate {
         return this.getAgeIn('day', today);
     }
     getAgeIn(unit, today) {
-        return exports.localDate.of(today || new Date()).diff(this, unit);
+        return exports.localDate.fromInput(today || new Date()).diff(this, unit);
     }
     /**
      * Returns 1 if this > d
      * returns 0 if they are equal
      * returns -1 if this < d
      */
-    cmp(d) {
-        d = exports.localDate.of(d);
-        if (this.$year < d.$year)
+    compare(d) {
+        d = exports.localDate.fromInput(d);
+        if (this.year < d.year)
             return -1;
-        if (this.$year > d.$year)
+        if (this.year > d.year)
             return 1;
-        if (this.$month < d.$month)
+        if (this.month < d.month)
             return -1;
-        if (this.$month > d.$month)
+        if (this.month > d.month)
             return 1;
-        if (this.$day < d.$day)
+        if (this.day < d.day)
             return -1;
-        if (this.$day > d.$day)
+        if (this.day > d.day)
             return 1;
         return 0;
     }
@@ -155,48 +162,48 @@ class LocalDate {
      * a.diff(b) means "a minus b"
      */
     diff(d, unit) {
-        d = exports.localDate.of(d);
-        const sign = this.cmp(d);
+        d = exports.localDate.fromInput(d);
+        const sign = this.compare(d);
         if (!sign)
             return 0;
         // Put items in descending order: "big minus small"
         const [big, small] = sign === 1 ? [this, d] : [d, this];
         if (unit === 'year') {
-            let years = big.$year - small.$year;
-            if (big.$month < small.$month ||
-                (big.$month === small.$month &&
-                    big.$day < small.$day &&
-                    !(big.$day === exports.localDate.getMonthLength(big.$year, big.$month) &&
-                        small.$day === exports.localDate.getMonthLength(small.$year, small.$month)))) {
+            let years = big.year - small.year;
+            if (big.month < small.month ||
+                (big.month === small.month &&
+                    big.day < small.day &&
+                    !(big.day === exports.localDate.getMonthLength(big.year, big.month) &&
+                        small.day === exports.localDate.getMonthLength(small.year, small.month)))) {
                 years--;
             }
             return years * sign || 0;
         }
         if (unit === 'month') {
-            let months = (big.$year - small.$year) * 12 + (big.$month - small.$month);
-            if (big.$day < small.$day) {
-                const bigMonthLen = exports.localDate.getMonthLength(big.$year, big.$month);
-                if (big.$day !== bigMonthLen || small.$day < bigMonthLen) {
+            let months = (big.year - small.year) * 12 + (big.month - small.month);
+            if (big.day < small.day) {
+                const bigMonthLen = exports.localDate.getMonthLength(big.year, big.month);
+                if (big.day !== bigMonthLen || small.day < bigMonthLen) {
                     months--;
                 }
             }
             return months * sign || 0;
         }
         // unit is 'day' or 'week'
-        let days = big.$day - small.$day;
+        let days = big.day - small.day;
         // If small date is after 1st of March - next year's "leapness" should be used
-        const offsetYear = small.$month >= 3 ? 1 : 0;
-        for (let year = small.$year; year < big.$year; year++) {
+        const offsetYear = small.month >= 3 ? 1 : 0;
+        for (let year = small.year; year < big.year; year++) {
             days += exports.localDate.getYearLength(year + offsetYear);
         }
-        if (small.$month < big.$month) {
-            for (let month = small.$month; month < big.$month; month++) {
-                days += exports.localDate.getMonthLength(big.$year, month);
+        if (small.month < big.month) {
+            for (let month = small.month; month < big.month; month++) {
+                days += exports.localDate.getMonthLength(big.year, month);
             }
         }
-        else if (big.$month < small.$month) {
-            for (let month = big.$month; month < small.$month; month++) {
-                days -= exports.localDate.getMonthLength(big.$year, month);
+        else if (big.month < small.month) {
+            for (let month = big.month; month < small.month; month++) {
+                days -= exports.localDate.getMonthLength(big.year, month);
             }
         }
         if (unit === 'week') {
@@ -229,68 +236,68 @@ class LocalDate {
         return this.plus(-num, 'year');
     }
     plus(num, unit, mutate = false) {
-        let { $day, $month, $year } = this;
+        let { day, month, year } = this;
         if (unit === 'week') {
             num *= 7;
             unit = 'day';
         }
         if (unit === 'day') {
-            $day += num;
+            day += num;
         }
         else if (unit === 'month') {
-            $month += num;
+            month += num;
         }
         else if (unit === 'year') {
-            $year += num;
+            year += num;
         }
         // check month overflow
-        while ($month > 12) {
-            $year += 1;
-            $month -= 12;
+        while (month > 12) {
+            year += 1;
+            month -= 12;
         }
-        while ($month < 1) {
-            $year -= 1;
-            $month += 12;
+        while (month < 1) {
+            year -= 1;
+            month += 12;
         }
         // check day overflow
         // Applies not only for 'day' unit, but also e.g 2022-05-31 plus 1 month should be 2022-06-30 (not 31!)
-        if ($day < 1) {
-            while ($day < 1) {
-                $month -= 1;
-                if ($month < 1) {
-                    $year -= 1;
-                    $month += 12;
+        if (day < 1) {
+            while (day < 1) {
+                month -= 1;
+                if (month < 1) {
+                    year -= 1;
+                    month += 12;
                 }
-                $day += exports.localDate.getMonthLength($year, $month);
+                day += exports.localDate.getMonthLength(year, month);
             }
         }
         else {
-            let monLen = exports.localDate.getMonthLength($year, $month);
+            let monLen = exports.localDate.getMonthLength(year, month);
             if (unit !== 'day') {
-                if ($day > monLen) {
+                if (day > monLen) {
                     // Case of 2022-05-31 plus 1 month should be 2022-06-30, not 31
-                    $day = monLen;
+                    day = monLen;
                 }
             }
             else {
-                while ($day > monLen) {
-                    $day -= monLen;
-                    $month += 1;
-                    if ($month > 12) {
-                        $year += 1;
-                        $month -= 12;
+                while (day > monLen) {
+                    day -= monLen;
+                    month += 1;
+                    if (month > 12) {
+                        year += 1;
+                        month -= 12;
                     }
-                    monLen = exports.localDate.getMonthLength($year, $month);
+                    monLen = exports.localDate.getMonthLength(year, month);
                 }
             }
         }
         if (mutate) {
-            this.$year = $year;
-            this.$month = $month;
-            this.$day = $day;
+            this.year = year;
+            this.month = month;
+            this.day = day;
             return this;
         }
-        return new LocalDate($year, $month, $day);
+        return new LocalDate(year, month, day);
     }
     minus(num, unit, mutate = false) {
         return this.plus(-num, unit, mutate);
@@ -299,27 +306,28 @@ class LocalDate {
         if (unit === 'day')
             return this;
         if (unit === 'month')
-            return new LocalDate(this.$year, this.$month, 1);
+            return new LocalDate(this.year, this.month, 1);
         // year
-        return new LocalDate(this.$year, 1, 1);
+        return new LocalDate(this.year, 1, 1);
     }
     endOf(unit) {
         if (unit === 'day')
             return this;
-        if (unit === 'month')
-            return new LocalDate(this.$year, this.$month, exports.localDate.getMonthLength(this.$year, this.$month));
+        if (unit === 'month') {
+            return new LocalDate(this.year, this.month, exports.localDate.getMonthLength(this.year, this.month));
+        }
         // year
-        return new LocalDate(this.$year, 12, 31);
+        return new LocalDate(this.year, 12, 31);
     }
     /**
      * Returns how many days are in the current month.
      * E.g 31 for January.
      */
-    daysInMonth() {
-        return exports.localDate.getMonthLength(this.$year, this.$month);
+    get daysInMonth() {
+        return exports.localDate.getMonthLength(this.year, this.month);
     }
     clone() {
-        return new LocalDate(this.$year, this.$month, this.$day);
+        return new LocalDate(this.year, this.month, this.day);
     }
     /**
      * Converts LocalDate into instance of Date.
@@ -328,7 +336,7 @@ class LocalDate {
      * Timezone will match local timezone.
      */
     toDate() {
-        return new Date(this.$year, this.$month - 1, this.$day);
+        return new Date(this.year, this.month - 1, this.day);
     }
     /**
      * Converts LocalDate to Date in UTC timezone.
@@ -339,9 +347,9 @@ class LocalDate {
     }
     toDateObject() {
         return {
-            year: this.$year,
-            month: this.$month,
-            day: this.$day,
+            year: this.year,
+            month: this.month,
+            day: this.day,
         };
     }
     /**
@@ -349,16 +357,16 @@ class LocalDate {
      * LocalTime's Date will be in local timezone.
      */
     toLocalTime() {
-        return localTime_1.localTime.of(this.toDate());
+        return localTime_1.localTime.fromDate(this.toDate());
     }
     /**
      * Returns e.g: `1984-06-21`
      */
     toISODate() {
         return [
-            String(this.$year).padStart(4, '0'),
-            String(this.$month).padStart(2, '0'),
-            String(this.$day).padStart(2, '0'),
+            String(this.year).padStart(4, '0'),
+            String(this.month).padStart(2, '0'),
+            String(this.day).padStart(2, '0'),
         ].join('-');
     }
     /**
@@ -383,9 +391,9 @@ class LocalDate {
      */
     toStringCompact() {
         return [
-            String(this.$year).padStart(4, '0'),
-            String(this.$month).padStart(2, '0'),
-            String(this.$day).padStart(2, '0'),
+            String(this.year).padStart(4, '0'),
+            String(this.month).padStart(2, '0'),
+            String(this.day).padStart(2, '0'),
         ].join('');
     }
     /**
@@ -397,13 +405,13 @@ class LocalDate {
     /**
      * Returns unix timestamp of 00:00:00 of that date (in UTC, because unix timestamp always reflects UTC).
      */
-    unix() {
+    get unix() {
         return Math.floor(this.toDate().valueOf() / 1000);
     }
     /**
      * Same as .unix(), but in milliseconds.
      */
-    unixMillis() {
+    get unixMillis() {
         return this.toDate().valueOf();
     }
     toJSON() {
@@ -419,10 +427,36 @@ class LocalDate {
 exports.LocalDate = LocalDate;
 class LocalDateFactory {
     /**
-     * Create LocalDate from year, month and day components.
+     * Creates a LocalDate from the input, unless it's falsy - then returns undefined.
+     *
+     * Similar to `localDate.orToday`, but that will instead return Today on falsy input.
      */
-    create(year, month, day) {
-        return new LocalDate(year, month, day);
+    orUndefined(d) {
+        return d ? this.fromInput(d) : undefined;
+    }
+    /**
+     * Creates a LocalDate from the input, unless it's falsy - then returns localDate.today.
+     */
+    orToday(d) {
+        return d ? this.fromInput(d) : this.today();
+    }
+    /**
+     * Creates LocalDate that represents `today` (in local timezone).
+     */
+    today() {
+        return this.fromDate(new Date());
+    }
+    /**
+     * Creates LocalDate that represents `today` in UTC.
+     */
+    todayInUTC() {
+        return this.fromDateInUTC(new Date());
+    }
+    /**
+     Convenience function to return current today's IsoDateString representation, e.g `2024-06-21`
+     */
+    todayString() {
+        return this.fromDate(new Date()).toISODate();
     }
     /**
      * Create LocalDate from LocalDateInput.
@@ -433,67 +467,112 @@ class LocalDateFactory {
      *
      * Will throw if it fails to parse/construct LocalDate.
      */
-    of(d) {
-        const t = this.parseOrNull(d);
-        (0, assert_1._assert)(t !== null, `Cannot parse "${d}" into LocalDate`, {
-            input: d,
-        });
-        return t;
+    fromInput(input) {
+        if (input instanceof LocalDate)
+            return input;
+        if (input instanceof Date) {
+            return this.fromDate(input);
+        }
+        // It means it's a string
+        return this.fromIsoDateString(input);
+    }
+    /**
+     * Returns true if input is valid to create LocalDate.
+     */
+    isValid(input) {
+        if (!input)
+            return false;
+        if (input instanceof LocalDate)
+            return true;
+        if (input instanceof Date)
+            return !isNaN(input.getDate());
+        return this.isValidString(input);
+    }
+    /**
+     * Returns true if isoString is a valid iso8601 string like `yyyy-mm-dd`.
+     */
+    isValidString(isoString) {
+        return !!this.parseToLocalDateOrUndefined(DATE_REGEX_STRICT, isoString);
     }
     /**
-     * Tries to construct LocalDate from LocalDateInput, returns null otherwise.
-     * Does not throw (returns null instead).
+     * Tries to convert/parse the input into LocalDate.
+     * Uses LOOSE parsing.
+     * If invalid - doesn't throw, but returns undefined instead.
      */
-    parseOrNull(d) {
-        if (!d)
-            return null;
-        if (d instanceof LocalDate)
-            return d;
-        if (d instanceof Date) {
-            return this.fromDate(d);
+    try(input) {
+        if (!input)
+            return;
+        if (input instanceof LocalDate)
+            return input;
+        if (input instanceof Date) {
+            if (isNaN(input.getDate()))
+                return;
+            return new LocalDate(input.getFullYear(), input.getMonth() + 1, input.getDate());
         }
-        const m = typeof d === 'string' && DATE_REGEX.exec(d);
+        return this.parseToLocalDateOrUndefined(DATE_REGEX_LOOSE, input);
+    }
+    /**
+     * Performs STRICT parsing.
+     * Only allows IsoDateString input, nothing else.
+     */
+    fromIsoDateString(s) {
+        return this.parseToLocalDate(DATE_REGEX_STRICT, s);
+    }
+    /**
+     * Parses "compact iso8601 format", e.g `19840621` into LocalDate.
+     * Throws if it fails to do so.
+     */
+    fromCompactString(s) {
+        return this.parseToLocalDate(COMPACT_DATE_REGEX, s);
+    }
+    /**
+     * Performs LOOSE parsing.
+     * Tries to coerce imprefect/incorrect string input into IsoDateString.
+     * Use with caution.
+     * Allows to input IsoDateTimeString, will drop the Time part of it.
+     */
+    parse(s) {
+        return this.parseToLocalDate(DATE_REGEX_LOOSE, String(s));
+    }
+    /**
+     * Throws if it fails to parse the input string via Regex and YMD validation.
+     */
+    parseToLocalDate(regex, s) {
+        const ld = this.parseToLocalDateOrUndefined(regex, s);
+        (0, assert_1._assert)(ld, `Cannot parse "${s}" into LocalDate`);
+        return ld;
+    }
+    /**
+     * Tries to parse the input string, returns undefined if input is invalid.
+     */
+    parseToLocalDateOrUndefined(regex, s) {
+        if (!s || typeof s !== 'string')
+            return;
+        const m = regex.exec(s);
         if (!m)
-            return null;
+            return;
         const year = Number(m[1]);
         const month = Number(m[2]);
         const day = Number(m[3]);
-        if (!year ||
-            !month ||
-            month < 1 ||
-            month > 12 ||
-            !day ||
-            day < 1 ||
-            day > this.getMonthLength(year, month)) {
-            return null;
-        }
+        if (!this.isDateObjectValid({ year, month, day }))
+            return;
         return new LocalDate(year, month, day);
     }
     /**
-     * Parses "compact iso8601 format", e.g `19840621` into LocalDate.
-     * Throws if it fails to do so.
+     * Throws on invalid value.
      */
-    parseCompact(d) {
-        const [year, month, day] = [d.slice(0, 4), d.slice(4, 2), d.slice(6, 2)].map(Number);
-        (0, assert_1._assert)(day && month && year, `Cannot parse "${d}" into LocalDate`);
-        return new LocalDate(year, month, day);
-    }
-    getYearLength(year) {
-        return this.isLeapYear(year) ? 366 : 365;
-    }
-    getMonthLength(year, month) {
-        if (month === 2)
-            return this.isLeapYear(year) ? 29 : 28;
-        return MDAYS[month];
+    validateDateObject(o) {
+        (0, assert_1._assert)(this.isDateObjectValid(o), `Cannot construct LocalDate from: ${o.year}-${o.month}-${o.day}`);
     }
-    isLeapYear(year) {
-        return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+    isDateObjectValid({ year, month, day }) {
+        return (!!year && month >= 1 && month <= 12 && day >= 1 && day <= this.getMonthLength(year, month));
     }
     /**
      * Constructs LocalDate from Date.
      * Takes Date as-is, in its timezone - local or UTC.
      */
     fromDate(d) {
+        (0, assert_1._assert)(!isNaN(d.getDate()), `localDate.fromDate is called on Date object that is invalid`);
         return new LocalDate(d.getFullYear(), d.getMonth() + 1, d.getDate());
     }
     /**
@@ -501,32 +580,19 @@ class LocalDateFactory {
      * Takes Date's year/month/day components in UTC, using getUTCFullYear, getUTCMonth, getUTCDate.
      */
     fromDateInUTC(d) {
+        (0, assert_1._assert)(!isNaN(d.getDate()), `localDate.fromDateInUTC is called on Date object that is invalid`);
         return new LocalDate(d.getUTCFullYear(), d.getUTCMonth() + 1, d.getUTCDate());
     }
-    /**
-     * Returns true if isoString is a valid iso8601 string like `yyyy-mm-dd`.
-     */
-    isValid(isoString) {
-        return this.parseOrNull(isoString) !== null;
-    }
-    /**
-     * Creates LocalDate that represents `today` (in local timezone).
-     */
-    today() {
-        return this.fromDate(new Date());
-    }
-    /**
-     * Creates LocalDate that represents `today` in UTC.
-     */
-    todayInUTC() {
-        return this.fromDateInUTC(new Date());
+    fromDateObject(o) {
+        this.validateDateObject(o);
+        return new LocalDate(o.year, o.month, o.day);
     }
     /**
      * Sorts an array of LocalDates in `dir` order (ascending by default).
      */
     sort(items, dir = 'asc', mutate = false) {
         const mod = dir === 'desc' ? -1 : 1;
-        return (mutate ? items : [...items]).sort((a, b) => a.cmp(b) * mod);
+        return (mutate ? items : [...items]).sort((a, b) => a.compare(b) * mod);
     }
     /**
      * Returns the earliest (min) LocalDate from the array, or undefined if the array is empty.
@@ -542,7 +608,7 @@ class LocalDateFactory {
         const items2 = items.filter(is_util_1._isTruthy);
         (0, assert_1._assert)(items2.length, 'localDate.min called on empty array');
         return items2
-            .map(i => this.of(i))
+            .map(i => this.fromInput(i))
             .reduce((min, item) => (min.isSameOrBefore(item) ? min : item));
     }
     /**
@@ -558,7 +624,9 @@ class LocalDateFactory {
     max(items) {
         const items2 = items.filter(is_util_1._isTruthy);
         (0, assert_1._assert)(items2.length, 'localDate.max called on empty array');
-        return items2.map(i => this.of(i)).reduce((max, item) => (max.isSameOrAfter(item) ? max : item));
+        return items2
+            .map(i => this.fromInput(i))
+            .reduce((max, item) => (max.isSameOrAfter(item) ? max : item));
     }
     /**
      * Returns the range (array) of LocalDates between min and max.
@@ -576,8 +644,8 @@ class LocalDateFactory {
             step *= 7;
             stepUnit = 'day';
         }
-        const $min = this.of(min).startOf(stepUnit);
-        const $max = this.of(max).startOf(stepUnit);
+        const $min = this.fromInput(min).startOf(stepUnit);
+        const $max = this.fromInput(max).startOf(stepUnit);
         let value = $min;
         // eslint-disable-next-line @typescript-eslint/prefer-string-starts-ends-with
         if (value.isAfter($min, incl[0] === '[')) {
@@ -598,32 +666,20 @@ class LocalDateFactory {
             },
         });
     }
-    /**
-     * Creates a LocalDate from the input, unless it's falsy - then returns undefined.
-     *
-     * Similar to `localDate.orToday`, but that will instead return Today on falsy input.
-     */
-    orUndefined(d) {
-        return d ? this.of(d) : undefined;
+    getYearLength(year) {
+        return this.isLeapYear(year) ? 366 : 365;
     }
-    /**
-     * Creates a LocalDate from the input, unless it's falsy - then returns localDate.today.
-     */
-    orToday(d) {
-        return d ? this.of(d) : this.today();
+    getMonthLength(year, month) {
+        if (month === 2)
+            return this.isLeapYear(year) ? 29 : 28;
+        return MDAYS[month];
+    }
+    isLeapYear(year) {
+        return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
     }
 }
 const localDateFactory = new LocalDateFactory();
-// export const localDate = Object.assign((d: LocalDateInput) => {
-//   return localDateFactory.of(d)
-// }, localDateFactory) as LocalDateFn
-exports.localDate = localDateFactory.of.bind(localDateFactory);
+exports.localDate = localDateFactory.fromInput.bind(localDateFactory);
 // The line below is the blackest of black magic I have ever written in 2024.
 // And probably 2023 as well.
 Object.setPrototypeOf(exports.localDate, localDateFactory);
-/**
- Convenience function to return current today's IsoDateString representation, e.g `2024-06-21`
- */
-function todayString() {
-    return exports.localDate.fromDate(new Date()).toISODate();
-}