@naturalcycles/js-lib 14.231.0 → 14.233.0

package/dist/datetime/localTime.d.ts

@@ -23,34 +23,19 @@ interface TimeComponents {
     minute: number;
     second: number;
 }
-/**
- * @experimental
- */
 export declare class LocalTime {
-    private $date;
-    private constructor();
-    /**
-     * Parses input String into LocalDate.
-     * Input can already be a LocalDate - it is returned as-is in that case.
-     */
-    static of(d: LocalTimeInput): LocalTime;
+    $date: Date;
+    constructor($date: Date);
     /**
-     * Create LocalTime from unixTimestamp in milliseconds (not in seconds).
+     * Returns [cloned] LocalTime that is based on the same unixtimestamp, but in UTC timezone.
+     * Opposite of `.local()` method.
      */
-    static ofMillis(millis: UnixTimestampMillisNumber): LocalTime;
+    utc(): LocalTime;
     /**
-     * Returns null if invalid
+     * Returns [cloned] LocalTime that is based on the same unixtimestamp, but in local timezone.
+     * Opposite of `.utc()` method.
      */
-    static parseOrNull(d: LocalTimeInput | undefined | null): LocalTime | null;
-    static parseToDate(d: LocalTimeInput): Date;
-    static parseToUnixTimestamp(d: LocalTimeInput): UnixTimestampNumber;
-    static isValid(d: LocalTimeInput | undefined | null): boolean;
-    static now(): LocalTime;
-    static fromComponents(c: {
-        year: number;
-        month: number;
-    } & Partial<LocalTimeComponents>): LocalTime;
-    static fromDateUTC(d: Date): LocalTime;
+    local(): LocalTime;
     get(unit: LocalTimeUnit): number;
     set(unit: LocalTimeUnit, v: number, mutate?: boolean): LocalTime;
     year(): number;
@@ -84,11 +69,6 @@ export declare class LocalTime {
      * E.g 31 for January.
      */
     daysInMonth(): number;
-    static sort(items: LocalTime[], mutate?: boolean, dir?: SortDirection): LocalTime[];
-    static earliestOrUndefined(items: LocalTimeInput[]): LocalTime | undefined;
-    static earliest(items: LocalTimeInput[]): LocalTime;
-    static latestOrUndefined(items: LocalTimeInput[]): LocalTime | undefined;
-    static latest(items: LocalTimeInput[]): LocalTime;
     isSame(d: LocalTimeInput): boolean;
     isBefore(d: LocalTimeInput, inclusive?: boolean): boolean;
     isSameOrBefore(d: LocalTimeInput): boolean;
@@ -166,24 +146,48 @@ export declare class LocalTime {
     toMonthId(): MonthId;
     format(fmt: Intl.DateTimeFormat | LocalTimeFormatter): string;
 }
-/**
- * Shortcut wrapper around `LocalTime.of`
- */
-export declare function localTime(d: LocalTimeInput): LocalTime;
-/**
- * Shortcut wrapper around `LocalTime.now`
- */
-export declare function localTimeNow(): LocalTime;
-/**
- * Creates a LocalTime from the input, unless it's falsy - then returns undefined.
- *
- * `localTime` function will instead return LocalTime of `now` for falsy input.
- */
-export declare function localTimeOrUndefined(d?: LocalTimeInput | null): LocalTime | undefined;
-/**
- * Creates a LocalTime from the input, unless it's falsy - then returns LocalTime.now
- */
-export declare function localTimeOrNow(d?: LocalTimeInput | null): LocalTime;
+declare class LocalTimeFactory {
+    /**
+     * Parses input String into LocalDate.
+     * Input can already be a LocalDate - it is returned as-is in that case.
+     */
+    of(d: LocalTimeInput): LocalTime;
+    /**
+     * Create LocalTime from unixTimestamp in milliseconds (not in seconds).
+     */
+    ofMillis(millis: UnixTimestampMillisNumber): LocalTime;
+    /**
+     * Returns null if invalid
+     */
+    parseOrNull(d: LocalTimeInput | undefined | null): LocalTime | null;
+    parseToDate(d: LocalTimeInput): Date;
+    parseToUnixTimestamp(d: LocalTimeInput): UnixTimestampNumber;
+    isValid(d: LocalTimeInput | undefined | null): boolean;
+    now(): LocalTime;
+    /**
+     * Creates a LocalTime from the input, unless it's falsy - then returns undefined.
+     *
+     * `localTime` function will instead return LocalTime of `now` for falsy input.
+     */
+    orUndefined(d?: LocalTimeInput | null): LocalTime | undefined;
+    /**
+     * Creates a LocalTime from the input, unless it's falsy - then returns LocalTime.now
+     */
+    orNow(d?: LocalTimeInput | null): LocalTime;
+    fromComponents(c: {
+        year: number;
+        month: number;
+    } & Partial<LocalTimeComponents>): LocalTime;
+    sort(items: LocalTime[], dir?: SortDirection, mutate?: boolean): LocalTime[];
+    minOrUndefined(items: LocalTimeInput[]): LocalTime | undefined;
+    min(items: LocalTimeInput[]): LocalTime;
+    maxOrUndefined(items: LocalTimeInput[]): LocalTime | undefined;
+    max(items: LocalTimeInput[]): LocalTime;
+}
+interface LocalTimeFn extends LocalTimeFactory {
+    (d: LocalTimeInput): LocalTime;
+}
+export declare const localTime: LocalTimeFn;
 /**
  Convenience function to return current Unix timestamp in seconds.
  Like Date.now(), but in seconds.

package/dist/datetime/localTime.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getUTCOffsetHours = exports.getUTCOffsetMinutes = exports.nowUnix = exports.localTimeOrNow = exports.localTimeOrUndefined = exports.localTimeNow = exports.localTime = exports.LocalTime = exports.ISODayOfWeek = void 0;
+exports.getUTCOffsetHours = exports.getUTCOffsetMinutes = exports.nowUnix = exports.localTime = exports.LocalTime = exports.ISODayOfWeek = void 0;
 const assert_1 = require("../error/assert");
 const time_util_1 = require("../time/time.util");
 const localDate_1 = require("./localDate");
@@ -20,100 +20,23 @@ const SECONDS_IN_DAY = 86400;
 // const MILLISECONDS_IN_DAY = 86400000
 // const MILLISECONDS_IN_MINUTE = 60000
 const VALID_DAYS_OF_WEEK = new Set([1, 2, 3, 4, 5, 6, 7]);
-/**
- * @experimental
- */
 class LocalTime {
     constructor($date) {
         this.$date = $date;
     }
     /**
-     * Parses input String into LocalDate.
-     * Input can already be a LocalDate - it is returned as-is in that case.
+     * Returns [cloned] LocalTime that is based on the same unixtimestamp, but in UTC timezone.
+     * Opposite of `.local()` method.
      */
-    static of(d) {
-        const t = this.parseOrNull(d);
-        (0, assert_1._assert)(t !== null, `Cannot parse "${d}" into LocalTime`, {
-            input: d,
-        });
-        return t;
+    utc() {
+        return new LocalTime(new Date(this.$date.toISOString()));
     }
     /**
-     * Create LocalTime from unixTimestamp in milliseconds (not in seconds).
-     */
-    static ofMillis(millis) {
-        return LocalTime.of(new Date(millis));
-    }
-    /**
-     * Returns null if invalid
+     * Returns [cloned] LocalTime that is based on the same unixtimestamp, but in local timezone.
+     * Opposite of `.utc()` method.
      */
-    static parseOrNull(d) {
-        if (!d)
-            return null;
-        if (d instanceof LocalTime)
-            return d;
-        let date;
-        if (d instanceof Date) {
-            date = d;
-        }
-        else if (typeof d === 'number') {
-            date = new Date(d * 1000);
-        }
-        else if (typeof d !== 'string') {
-            // unexpected type, e.g Function or something
-            return null;
-        }
-        else {
-            // Slicing removes the "timezone component", and makes the date "local"
-            // e.g 2022-04-06T23:15:00+09:00
-            // becomes 2022-04-06T23:15:00
-            date = new Date(d.slice(0, 19));
-            // We used to slice to remove the timezone information, now we don't
-            // date = new Date(d)
-        }
-        // validation
-        if (isNaN(date.getDate())) {
-            // throw new TypeError(`Cannot parse "${d}" into LocalTime`)
-            return null;
-        }
-        // if (utc) {
-        //   date.setMinutes(date.getMinutes() + date.getTimezoneOffset())
-        // }
-        return new LocalTime(date);
-    }
-    static parseToDate(d) {
-        if (d instanceof LocalTime)
-            return d.$date;
-        if (d instanceof Date)
-            return d;
-        const date = typeof d === 'number' ? new Date(d * 1000) : new Date(d);
-        (0, assert_1._assert)(!isNaN(date.getDate()), `Cannot parse "${d}" to Date`, {
-            input: d,
-        });
-        return date;
-    }
-    static parseToUnixTimestamp(d) {
-        if (typeof d === 'number')
-            return d;
-        if (d instanceof LocalTime)
-            return d.unix();
-        const date = d instanceof Date ? d : new Date(d);
-        (0, assert_1._assert)(!isNaN(date.getDate()), `Cannot parse "${d}" to UnixTimestamp`, {
-            input: d,
-        });
-        return date.valueOf() / 1000;
-    }
-    static isValid(d) {
-        return this.parseOrNull(d) !== null;
-    }
-    static now() {
-        return new LocalTime(new Date());
-    }
-    static fromComponents(c) {
-        return new LocalTime(new Date(c.year, c.month - 1, c.day || 1, c.hour || 0, c.minute || 0, c.second || 0));
-    }
-    static fromDateUTC(d) {
-        return new LocalTime(new Date(d.toISOString()));
+    local() {
+        return new LocalTime(new Date(this.$date.getTime()));
     }
     get(unit) {
         if (unit === 'year') {
@@ -215,7 +138,7 @@ class LocalTime {
         }
         if (unit === 'year' || unit === 'month') {
             const d = addMonths(this.$date, unit === 'month' ? num : num * 12, mutate);
-            return mutate ? this : LocalTime.of(d);
+            return mutate ? this : exports.localTime.of(d);
         }
         return this.set(unit, this.get(unit) + num, mutate);
     }
@@ -226,16 +149,16 @@ class LocalTime {
         return Math.abs(this.diff(other, unit));
     }
     diff(other, unit) {
-        const date2 = LocalTime.parseToDate(other);
+        const date2 = exports.localTime.parseToDate(other);
         const secDiff = (this.$date.valueOf() - date2.valueOf()) / 1000;
         if (!secDiff)
             return 0;
         let r;
         if (unit === 'year') {
-            r = differenceInMonths(this.getDate(), date2) / 12;
+            r = differenceInMonths(this.$date, date2) / 12;
         }
         else if (unit === 'month') {
-            r = differenceInMonths(this.getDate(), date2);
+            r = differenceInMonths(this.$date, date2);
         }
         else if (unit === 'day') {
             r = secDiff / SECONDS_IN_DAY;
@@ -302,7 +225,7 @@ class LocalTime {
                     }
                     else {
                         // year or month
-                        const lastDay = localDate_1.LocalDate.getMonthLength(d.getFullYear(), d.getMonth() + 1);
+                        const lastDay = localDate_1.localDate.getMonthLength(d.getFullYear(), d.getMonth() + 1);
                         d.setDate(lastDay);
                     }
                 }
@@ -315,35 +238,7 @@ class LocalTime {
      * E.g 31 for January.
      */
     daysInMonth() {
-        return localDate_1.LocalDate.getMonthLength(this.$date.getFullYear(), this.$date.getMonth() + 1);
-    }
-    static sort(items, mutate = false, dir = 'asc') {
-        const mod = dir === 'desc' ? -1 : 1;
-        return (mutate ? items : [...items]).sort((a, b) => {
-            const v1 = a.$date.valueOf();
-            const v2 = b.$date.valueOf();
-            if (v1 === v2)
-                return 0;
-            return (v1 < v2 ? -1 : 1) * mod;
-        });
-    }
-    static earliestOrUndefined(items) {
-        return items.length ? LocalTime.earliest(items) : undefined;
-    }
-    static earliest(items) {
-        (0, assert_1._assert)(items.length, 'LocalTime.earliest called on empty array');
-        return items
-            .map(i => LocalTime.of(i))
-            .reduce((min, item) => (min.isSameOrBefore(item) ? min : item));
-    }
-    static latestOrUndefined(items) {
-        return items.length ? LocalTime.latest(items) : undefined;
-    }
-    static latest(items) {
-        (0, assert_1._assert)(items.length, 'LocalTime.latest called on empty array');
-        return items
-            .map(i => LocalTime.of(i))
-            .reduce((max, item) => (max.isSameOrAfter(item) ? max : item));
+        return localDate_1.localDate.getMonthLength(this.$date.getFullYear(), this.$date.getMonth() + 1);
     }
     isSame(d) {
         return this.cmp(d) === 0;
@@ -382,13 +277,13 @@ class LocalTime {
      * Third argument allows to override "now".
      */
     isOlderThan(n, unit, now) {
-        return this.isBefore(LocalTime.of(now ?? new Date()).plus(-n, unit));
+        return this.isBefore(exports.localTime.of(now ?? new Date()).plus(-n, unit));
     }
     /**
      * Checks if this localTime is same or older (<=) than "now" by X units.
      */
     isSameOrOlderThan(n, unit, now) {
-        return this.isSameOrBefore(LocalTime.of(now ?? new Date()).plus(-n, unit));
+        return this.isSameOrBefore(exports.localTime.of(now ?? new Date()).plus(-n, unit));
     }
     /**
      * Checks if this localTime is younger (>) than "now" by X units.
@@ -400,13 +295,13 @@ class LocalTime {
      * Third argument allows to override "now".
      */
     isYoungerThan(n, unit, now) {
-        return this.isAfter(LocalTime.of(now ?? new Date()).plus(-n, unit));
+        return this.isAfter(exports.localTime.of(now ?? new Date()).plus(-n, unit));
     }
     /**
      * Checks if this localTime is same or younger (>=) than "now" by X units.
      */
     isSameOrYoungerThan(n, unit, now) {
-        return this.isSameOrAfter(LocalTime.of(now ?? new Date()).plus(-n, unit));
+        return this.isSameOrAfter(exports.localTime.of(now ?? new Date()).plus(-n, unit));
     }
     /**
      * Returns 1 if this > d
@@ -415,19 +310,15 @@ class LocalTime {
      */
     cmp(d) {
         const t1 = this.$date.valueOf();
-        const t2 = LocalTime.parseToDate(d).valueOf();
+        const t2 = exports.localTime.parseToDate(d).valueOf();
         if (t1 === t2)
             return 0;
         return t1 < t2 ? -1 : 1;
     }
     components() {
         return {
-            year: this.$date.getFullYear(),
-            month: this.$date.getMonth() + 1,
-            day: this.$date.getDate(),
-            hour: this.$date.getHours(),
-            minute: this.$date.getMinutes(),
-            second: this.$date.getSeconds(),
+            ...this.dateComponents(),
+            ...this.timeComponents(),
         };
     }
     dateComponents() {
@@ -445,7 +336,7 @@ class LocalTime {
         };
     }
     fromNow(now = new Date()) {
-        const msDiff = LocalTime.parseToDate(now).valueOf() - this.$date.valueOf();
+        const msDiff = exports.localTime.parseToDate(now).valueOf() - this.$date.valueOf();
         if (msDiff === 0)
             return 'now';
         if (msDiff >= 0) {
@@ -469,7 +360,7 @@ class LocalTime {
         return Math.floor(this.$date.valueOf() / 1000);
     }
     toLocalDate() {
-        return localDate_1.LocalDate.fromDate(this.$date);
+        return localDate_1.localDate.fromDate(this.$date);
     }
     /**
      * Returns e.g: `1984-06-21 17:56:21`
@@ -550,68 +441,132 @@ class LocalTime {
     }
 }
 exports.LocalTime = LocalTime;
-/**
- * Shortcut wrapper around `LocalTime.of`
- */
-function localTime(d) {
-    return LocalTime.of(d);
-}
-exports.localTime = localTime;
-/**
- * Shortcut wrapper around `LocalTime.now`
- */
-function localTimeNow() {
-    return LocalTime.now();
-}
-exports.localTimeNow = localTimeNow;
-/**
- * Creates a LocalTime from the input, unless it's falsy - then returns undefined.
- *
- * `localTime` function will instead return LocalTime of `now` for falsy input.
- */
-function localTimeOrUndefined(d) {
-    return d ? LocalTime.of(d) : undefined;
-}
-exports.localTimeOrUndefined = localTimeOrUndefined;
-/**
- * Creates a LocalTime from the input, unless it's falsy - then returns LocalTime.now
- */
-function localTimeOrNow(d) {
-    return d ? LocalTime.of(d) : LocalTime.now();
-}
-exports.localTimeOrNow = localTimeOrNow;
-/**
- Convenience function to return current Unix timestamp in seconds.
- Like Date.now(), but in seconds.
- */
-function nowUnix() {
-    return Math.floor(Date.now() / 1000);
-}
-exports.nowUnix = nowUnix;
-/**
- * UTC offset is the opposite of "timezone offset" - it's the number of minutes to add
- * to the local time to get UTC time.
- *
- * E.g utcOffset for CEST is -120,
- * which means that you need to add -120 minutes to the local time to get UTC time.
- *
- * Instead of -0 it returns 0, for the peace of mind and less weird test/snapshot differences.
- */
-function getUTCOffsetMinutes() {
-    return -new Date().getTimezoneOffset() || 0;
-}
-exports.getUTCOffsetMinutes = getUTCOffsetMinutes;
-/**
- * Same as getUTCOffsetMinutes, but rounded to hours.
- *
- * E.g for CEST it is -2.
- *
- * Instead of -0 it returns 0, for the peace of mind and less weird test/snapshot differences.
- */
-function getUTCOffsetHours() {
-    return Math.round(getUTCOffsetMinutes() / 60);
+class LocalTimeFactory {
+    /**
+     * Parses input String into LocalDate.
+     * Input can already be a LocalDate - it is returned as-is in that case.
+     */
+    of(d) {
+        const t = this.parseOrNull(d);
+        (0, assert_1._assert)(t !== null, `Cannot parse "${d}" into LocalTime`, {
+            input: d,
+        });
+        return t;
+    }
+    /**
+     * Create LocalTime from unixTimestamp in milliseconds (not in seconds).
+     */
+    ofMillis(millis) {
+        return this.of(new Date(millis));
+    }
+    /**
+     * Returns null if invalid
+     */
+    parseOrNull(d) {
+        if (!d)
+            return null;
+        if (d instanceof LocalTime)
+            return d;
+        let date;
+        if (d instanceof Date) {
+            date = d;
+        }
+        else if (typeof d === 'number') {
+            date = new Date(d * 1000);
+        }
+        else if (typeof d !== 'string') {
+            // unexpected type, e.g Function or something
+            return null;
+        }
+        else {
+            // Slicing removes the "timezone component", and makes the date "local"
+            // e.g 2022-04-06T23:15:00+09:00
+            // becomes 2022-04-06T23:15:00
+            date = new Date(d.slice(0, 19));
+            // We used to slice to remove the timezone information, now we don't
+            // date = new Date(d)
+        }
+        // validation
+        if (isNaN(date.getDate())) {
+            // throw new TypeError(`Cannot parse "${d}" into LocalTime`)
+            return null;
+        }
+        return new LocalTime(date);
+    }
+    parseToDate(d) {
+        if (d instanceof LocalTime)
+            return d.$date;
+        if (d instanceof Date)
+            return d;
+        const date = typeof d === 'number' ? new Date(d * 1000) : new Date(d);
+        (0, assert_1._assert)(!isNaN(date.getDate()), `Cannot parse "${d}" to Date`, {
+            input: d,
+        });
+        return date;
+    }
+    parseToUnixTimestamp(d) {
+        if (typeof d === 'number')
+            return d;
+        if (d instanceof LocalTime)
+            return d.unix();
+        const date = d instanceof Date ? d : new Date(d);
+        (0, assert_1._assert)(!isNaN(date.getDate()), `Cannot parse "${d}" to UnixTimestamp`, {
+            input: d,
+        });
+        return date.valueOf() / 1000;
+    }
+    isValid(d) {
+        return this.parseOrNull(d) !== null;
+    }
+    now() {
+        return new LocalTime(new Date());
+    }
+    /**
+     * Creates a LocalTime from the input, unless it's falsy - then returns undefined.
+     *
+     * `localTime` function will instead return LocalTime of `now` for falsy input.
+     */
+    orUndefined(d) {
+        return d ? this.of(d) : undefined;
+    }
+    /**
+     * Creates a LocalTime from the input, unless it's falsy - then returns LocalTime.now
+     */
+    orNow(d) {
+        return d ? this.of(d) : this.now();
+    }
+    fromComponents(c) {
+        return new LocalTime(new Date(c.year, c.month - 1, c.day || 1, c.hour || 0, c.minute || 0, c.second || 0));
+    }
+    sort(items, dir = 'asc', mutate = false) {
+        const mod = dir === 'desc' ? -1 : 1;
+        return (mutate ? items : [...items]).sort((a, b) => {
+            const v1 = a.$date.valueOf();
+            const v2 = b.$date.valueOf();
+            if (v1 === v2)
+                return 0;
+            return (v1 < v2 ? -1 : 1) * mod;
+        });
+    }
+    minOrUndefined(items) {
+        return items.length ? this.min(items) : undefined;
+    }
+    min(items) {
+        (0, assert_1._assert)(items.length, 'localTime.min called on empty array');
+        return items
+            .map(i => this.of(i))
+            .reduce((min, item) => (min.$date.valueOf() <= item.$date.valueOf() ? min : item));
+    }
+    maxOrUndefined(items) {
+        return items.length ? this.max(items) : undefined;
+    }
+    max(items) {
+        (0, assert_1._assert)(items.length, 'localTime.max called on empty array');
+        return items
+            .map(i => this.of(i))
+            .reduce((max, item) => (max.$date.valueOf() >= item.$date.valueOf() ? max : item));
+    }
 }
-exports.getUTCOffsetHours = getUTCOffsetHours;
 // based on: https://github.com/date-fns/date-fns/blob/master/src/getISOWeek/index.ts
 function getWeek(date) {
     const diff = startOfWeek(date).getTime() - startOfWeekYear(date).getTime();
@@ -685,7 +640,7 @@ function addMonths(d, num, mutate = false) {
         year--;
         month += 12;
     }
-    const monthLen = localDate_1.LocalDate.getMonthLength(year, month);
+    const monthLen = localDate_1.localDate.getMonthLength(year, month);
     if (day > monthLen)
         day = monthLen;
     d.setFullYear(year, month - 1, day);
@@ -700,3 +655,40 @@ function differenceInMonths(a, b) {
     const anchor2 = addMonths(a, wholeMonthDiff + sign).getTime();
     return -(wholeMonthDiff + ((b.getTime() - anchor) / (anchor2 - anchor)) * sign);
 }
+const localTimeFactory = new LocalTimeFactory();
+exports.localTime = localTimeFactory.of.bind(localTimeFactory);
+// The line below is the blackest of black magic I have ever written in 2024.
+// And probably 2023 as well.
+Object.setPrototypeOf(exports.localTime, localTimeFactory);
+/**
+ Convenience function to return current Unix timestamp in seconds.
+ Like Date.now(), but in seconds.
+ */
+function nowUnix() {
+    return Math.floor(Date.now() / 1000);
+}
+exports.nowUnix = nowUnix;
+/**
+ * UTC offset is the opposite of "timezone offset" - it's the number of minutes to add
+ * to the local time to get UTC time.
+ *
+ * E.g utcOffset for CEST is -120,
+ * which means that you need to add -120 minutes to the local time to get UTC time.
+ *
+ * Instead of -0 it returns 0, for the peace of mind and less weird test/snapshot differences.
+ */
+function getUTCOffsetMinutes() {
+    return -new Date().getTimezoneOffset() || 0;
+}
+exports.getUTCOffsetMinutes = getUTCOffsetMinutes;
+/**
+ * Same as getUTCOffsetMinutes, but rounded to hours.
+ *
+ * E.g for CEST it is -2.
+ *
+ * Instead of -0 it returns 0, for the peace of mind and less weird test/snapshot differences.
+ */
+function getUTCOffsetHours() {
+    return Math.round(getUTCOffsetMinutes() / 60);
+}
+exports.getUTCOffsetHours = getUTCOffsetHours;

package/dist/datetime/timeInterval.d.ts

@@ -1,6 +1,5 @@
 import type { UnixTimestampNumber, Inclusiveness } from '../types';
-import type { LocalTimeInput } from './localTime';
-import { LocalTime } from './localTime';
+import { LocalTimeInput, LocalTime } from './localTime';
 export type TimeIntervalConfig = TimeInterval | TimeIntervalString;
 export type TimeIntervalString = string;
 /**

package/dist/datetime/timeInterval.js

@@ -14,7 +14,7 @@ class TimeInterval {
         this.$end = $end;
     }
     static of(start, end) {
-        return new TimeInterval(localTime_1.LocalTime.parseToUnixTimestamp(start), localTime_1.LocalTime.parseToUnixTimestamp(end));
+        return new TimeInterval(localTime_1.localTime.parseToUnixTimestamp(start), localTime_1.localTime.parseToUnixTimestamp(end));
     }
     get start() {
         return this.$start;
@@ -23,10 +23,10 @@ class TimeInterval {
         return this.$end;
     }
     get startTime() {
-        return localTime_1.LocalTime.of(this.$start);
+        return (0, localTime_1.localTime)(this.$start);
     }
     get endTime() {
-        return localTime_1.LocalTime.of(this.$end);
+        return (0, localTime_1.localTime)(this.$end);
     }
     /**
      * Parses string like `1649267185/1649267187` into a TimeInterval.
@@ -58,7 +58,7 @@ class TimeInterval {
         return this.cmp(d) >= 0;
     }
     includes(d, incl = '[)') {
-        d = localTime_1.LocalTime.parseToUnixTimestamp(d);
+        d = localTime_1.localTime.parseToUnixTimestamp(d);
         // eslint-disable-next-line @typescript-eslint/prefer-string-starts-ends-with
         if (d < this.$start || (d === this.$start && incl[0] === '('))
             return false;

package/dist/env/buildInfo.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateBuildInfoDev = void 0;
 const localTime_1 = require("../datetime/localTime");
 function generateBuildInfoDev() {
-    const now = (0, localTime_1.localTimeNow)();
+    const now = localTime_1.localTime.now();
     const ts = now.unix();
     const rev = 'devRev';
     const branchName = 'devBranch';