@duplojs/utils 1.3.29 → 1.3.30

package/dist/date/createTheTime.d.ts

@@ -0,0 +1,2 @@
+import { type TheTime } from "./types";
+export declare function createTheTime(timestamp: number): TheTime;

package/dist/date/createTheTime.mjs

@@ -0,0 +1,8 @@
+import { makeSafeTimeValue } from './makeSafeTimeValue.mjs';
+
+function createTheTime(timestamp) {
+    const safeTimestamp = makeSafeTimeValue(timestamp);
+    return `time${Math.abs(safeTimestamp)}${safeTimestamp < 0 ? "-" : "+"}`;
+}
+
+export { createTheTime };

package/dist/date/createTime.cjs

@@ -0,0 +1,61 @@
+'use strict';
+
+var constants = require('./constants.cjs');
+var createTheTime = require('./createTheTime.cjs');
+var isSafeTimeValue = require('./isSafeTimeValue.cjs');
+var isTime = require('./isTime.cjs');
+var create = require('../either/left/create.cjs');
+var create$1 = require('../either/right/create.cjs');
+
+const unitsMapper = {
+    week: constants.millisecondInOneWeek,
+    day: constants.millisecondsInOneDay,
+    hour: constants.millisecondInOneHour,
+    minute: constants.millisecondInOneMinute,
+    second: constants.millisecondsInOneSecond,
+    millisecond: 1,
+};
+function createTime(input, unit) {
+    if (typeof input === "number" && unit) {
+        return createTheTime.createTheTime(input * unitsMapper[unit]);
+    }
+    if (typeof input === "number") {
+        return createFromTimeValue(input * unitsMapper[unit ?? "millisecond"]);
+    }
+    if (typeof input === "string" && isTime.isTime(input)) {
+        return input;
+    }
+    const { value = 0, week = 0, day = 0, hour = 0, minute = 0, second = 0, millisecond = 0, } = input;
+    let fromValue = 0;
+    if (typeof value === "number") {
+        fromValue = value;
+    }
+    else {
+        const theTimeMatch = value.match(constants.isoTimeRegex);
+        if (theTimeMatch) {
+            const { sign = "+", hour, minute, second = 0, millisecond = 0, } = theTimeMatch.groups;
+            fromValue = (Number(hour) * constants.millisecondInOneHour)
+                + (Number(minute) * constants.millisecondInOneMinute)
+                + (Number(second) * constants.millisecondsInOneSecond)
+                + Number(millisecond);
+            fromValue = sign === "-"
+                ? -fromValue
+                : fromValue;
+        }
+    }
+    return createFromTimeValue(fromValue
+        + (week * constants.millisecondInOneWeek)
+        + (day * constants.millisecondsInOneDay)
+        + (hour * constants.millisecondInOneHour)
+        + (minute * constants.millisecondInOneMinute)
+        + (second * constants.millisecondsInOneSecond)
+        + millisecond);
+}
+function createFromTimeValue(input) {
+    if (!isSafeTimeValue.isSafeTimeValue(input)) {
+        return create.left("time-created-error", null);
+    }
+    return create$1.right("time-created", createTheTime.createTheTime(input));
+}
+
+exports.createTime = createTime;

package/dist/date/createTime.d.ts

@@ -0,0 +1,44 @@
+import { type IsEqual, type And } from "../common";
+import { type maxTimeValue, type minTimeValue } from "./constants";
+import { type TheTime, type SpoolingTime } from "./types";
+import * as DEither from "../either";
+import { type IsGreater, type IsLess } from "../number";
+export type MayBeTime = DEither.EitherRight<"time-created", TheTime> | DEither.EitherLeft<"time-created-error", null>;
+type Units = "week" | "day" | "hour" | "minute" | "second" | "millisecond";
+declare const SymbolForbiddenTime: unique symbol;
+type ForbiddenTime<GenericInput extends number, GenericUnit extends Units> = IsEqual<GenericInput, number> extends true ? {
+    [SymbolForbiddenTime]: "Expect only literal value.";
+} : ((IsEqual<GenericUnit, "millisecond"> extends true ? And<[
+    IsGreater<GenericInput, typeof minTimeValue>,
+    IsLess<GenericInput, typeof maxTimeValue>
+]> extends true ? GenericInput : {
+    [SymbolForbiddenTime]: "Support that the milliseconds between -9007199254740991 and 9007199254740991.";
+} : GenericInput) & (IsEqual<GenericUnit, "second"> extends true ? And<[
+    IsGreater<GenericInput, -9007199254740>,
+    IsLess<GenericInput, 9007199254740>
+]> extends true ? GenericInput : {
+    [SymbolForbiddenTime]: "Support that the seconds between -9007199254740 and 9007199254740.";
+} : GenericInput) & (IsEqual<GenericUnit, "minute"> extends true ? And<[
+    IsGreater<GenericInput, -150119987579>,
+    IsLess<GenericInput, 150119987579>
+]> extends true ? GenericInput : {
+    [SymbolForbiddenTime]: "Support that the minutes between -150119987579 and 150119987579.";
+} : GenericInput) & (IsEqual<GenericUnit, "hour"> extends true ? And<[
+    IsGreater<GenericInput, -2501999792>,
+    IsLess<GenericInput, 2501999792>
+]> extends true ? GenericInput : {
+    [SymbolForbiddenTime]: "Support that the hours between -2501999792 and 2501999792.";
+} : GenericInput) & (IsEqual<GenericUnit, "day"> extends true ? And<[
+    IsGreater<GenericInput, -104249991>,
+    IsLess<GenericInput, 104249991>
+]> extends true ? GenericInput : {
+    [SymbolForbiddenTime]: "Support that the days between -104249991 and 104249991.";
+} : GenericInput) & (IsEqual<GenericUnit, "week"> extends true ? And<[
+    IsGreater<GenericInput, -14892855>,
+    IsLess<GenericInput, 14892855>
+]> extends true ? GenericInput : {
+    [SymbolForbiddenTime]: "Support that the weeks between -14892855 and 14892855.";
+} : GenericInput));
+export declare function createTime<GenericInput extends number, GenericUnit extends Units = "millisecond">(input: GenericInput & ForbiddenTime<GenericInput, GenericUnit>, unit: GenericUnit): TheTime;
+export declare function createTime<GenericInput extends number | TheTime | SpoolingTime>(input: GenericInput): MayBeTime;
+export {};

package/dist/date/createTime.mjs

@@ -0,0 +1,59 @@
+import { isoTimeRegex, millisecondsInOneSecond, millisecondInOneMinute, millisecondInOneHour, millisecondsInOneDay, millisecondInOneWeek } from './constants.mjs';
+import { createTheTime } from './createTheTime.mjs';
+import { isSafeTimeValue } from './isSafeTimeValue.mjs';
+import { isTime } from './isTime.mjs';
+import { left } from '../either/left/create.mjs';
+import { right } from '../either/right/create.mjs';
+
+const unitsMapper = {
+    week: millisecondInOneWeek,
+    day: millisecondsInOneDay,
+    hour: millisecondInOneHour,
+    minute: millisecondInOneMinute,
+    second: millisecondsInOneSecond,
+    millisecond: 1,
+};
+function createTime(input, unit) {
+    if (typeof input === "number" && unit) {
+        return createTheTime(input * unitsMapper[unit]);
+    }
+    if (typeof input === "number") {
+        return createFromTimeValue(input * unitsMapper[unit ?? "millisecond"]);
+    }
+    if (typeof input === "string" && isTime(input)) {
+        return input;
+    }
+    const { value = 0, week = 0, day = 0, hour = 0, minute = 0, second = 0, millisecond = 0, } = input;
+    let fromValue = 0;
+    if (typeof value === "number") {
+        fromValue = value;
+    }
+    else {
+        const theTimeMatch = value.match(isoTimeRegex);
+        if (theTimeMatch) {
+            const { sign = "+", hour, minute, second = 0, millisecond = 0, } = theTimeMatch.groups;
+            fromValue = (Number(hour) * millisecondInOneHour)
+                + (Number(minute) * millisecondInOneMinute)
+                + (Number(second) * millisecondsInOneSecond)
+                + Number(millisecond);
+            fromValue = sign === "-"
+                ? -fromValue
+                : fromValue;
+        }
+    }
+    return createFromTimeValue(fromValue
+        + (week * millisecondInOneWeek)
+        + (day * millisecondsInOneDay)
+        + (hour * millisecondInOneHour)
+        + (minute * millisecondInOneMinute)
+        + (second * millisecondsInOneSecond)
+        + millisecond);
+}
+function createFromTimeValue(input) {
+    if (!isSafeTimeValue(input)) {
+        return left("time-created-error", null);
+    }
+    return right("time-created", createTheTime(input));
+}
+
+export { createTime };

package/dist/date/createTimeOrThrow.cjs

@@ -0,0 +1,28 @@
+'use strict';
+
+var createTime = require('./createTime.cjs');
+var kind = require('../common/kind.cjs');
+var is = require('../either/left/is.cjs');
+var unwrap = require('../common/unwrap.cjs');
+var errorKindNamespace = require('../common/errorKindNamespace.cjs');
+
+class CreateTheTimeError extends kind.kindHeritage("create-the-time-error", errorKindNamespace.createErrorKind("create-the-time-error"), Error) {
+    input;
+    constructor(input) {
+        const value = typeof input === "object"
+            ? JSON.stringify(input)
+            : input.toString();
+        super({}, [`Invalid date input: ${value}`]);
+        this.input = input;
+    }
+}
+function createTimeOrThrow(input) {
+    const result = createTime.createTime(input);
+    if (is.isLeft(result)) {
+        throw new CreateTheTimeError(input);
+    }
+    return unwrap.unwrap(result);
+}
+
+exports.CreateTheTimeError = CreateTheTimeError;
+exports.createTimeOrThrow = createTimeOrThrow;

package/dist/date/createTimeOrThrow.d.ts

@@ -0,0 +1,10 @@
+import type { SpoolingTime, TheTime } from "./types";
+declare const CreateTheTimeError_base: new (params: {
+    "@DuplojsUtilsError/create-the-time-error"?: unknown;
+}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("../common").Kind<import("../common").KindDefinition<"create-the-time-error", unknown>, unknown> & import("../common").Kind<import("../common").KindDefinition<"@DuplojsUtilsError/create-the-time-error", unknown>, unknown>;
+export declare class CreateTheTimeError extends CreateTheTimeError_base {
+    input: TheTime | number | SpoolingTime;
+    constructor(input: TheTime | number | SpoolingTime);
+}
+export declare function createTimeOrThrow(input: number | TheTime | SpoolingTime): TheTime;
+export {};

package/dist/date/createTimeOrThrow.mjs

@@ -0,0 +1,25 @@
+import { createTime } from './createTime.mjs';
+import { kindHeritage } from '../common/kind.mjs';
+import { isLeft } from '../either/left/is.mjs';
+import { unwrap } from '../common/unwrap.mjs';
+import { createErrorKind } from '../common/errorKindNamespace.mjs';
+
+class CreateTheTimeError extends kindHeritage("create-the-time-error", createErrorKind("create-the-time-error"), Error) {
+    input;
+    constructor(input) {
+        const value = typeof input === "object"
+            ? JSON.stringify(input)
+            : input.toString();
+        super({}, [`Invalid date input: ${value}`]);
+        this.input = input;
+    }
+}
+function createTimeOrThrow(input) {
+    const result = createTime(input);
+    if (isLeft(result)) {
+        throw new CreateTheTimeError(input);
+    }
+    return unwrap(result);
+}
+
+export { CreateTheTimeError, createTimeOrThrow };

package/dist/date/format.cjs

@@ -0,0 +1,37 @@
+'use strict';
+
+var toNative = require('./toNative.cjs');
+
+function format(...args) {
+    if (args.length === 2) {
+        const [formatString, timezone] = args;
+        return (input) => format(input, formatString, timezone);
+    }
+    const [input, formatString, timezone] = args;
+    const date = toNative.toNative(input);
+    const formatter = new Intl.DateTimeFormat("en-US", {
+        timeZone: timezone,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+        hour12: false,
+    });
+    const parts = Object.fromEntries(formatter.formatToParts(date).map((part) => [part.type, part.value]));
+    const tokens = {
+        YYYY: parts.year,
+        YY: parts.year.slice(-2),
+        MM: parts.month,
+        DD: parts.day,
+        HH: parts.hour,
+        mm: parts.minute,
+        ss: parts.second,
+        SSS: date.getMilliseconds().toString(),
+        ZZ: timezone,
+    };
+    return formatString.replace(/YYYY|YY|MM|DD|HH|mm|ss|SSS|ZZ/g, (token) => tokens[token]);
+}
+
+exports.format = format;

package/dist/date/format.d.ts

@@ -0,0 +1,4 @@
+import type { TheDate } from "./types";
+import type { Timezone } from "./timezone";
+export declare function format<GenericInput extends TheDate, GenericFormat extends string, GenericTimezone extends Timezone>(formatString: GenericFormat, timezone: GenericTimezone): (input: GenericInput) => string;
+export declare function format<GenericInput extends TheDate, GenericFormat extends string, GenericTimezone extends Timezone>(input: GenericInput, formatString: GenericFormat, timezone: GenericTimezone): string;

package/dist/date/format.mjs

@@ -0,0 +1,35 @@
+import { toNative } from './toNative.mjs';
+
+function format(...args) {
+    if (args.length === 2) {
+        const [formatString, timezone] = args;
+        return (input) => format(input, formatString, timezone);
+    }
+    const [input, formatString, timezone] = args;
+    const date = toNative(input);
+    const formatter = new Intl.DateTimeFormat("en-US", {
+        timeZone: timezone,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+        hour12: false,
+    });
+    const parts = Object.fromEntries(formatter.formatToParts(date).map((part) => [part.type, part.value]));
+    const tokens = {
+        YYYY: parts.year,
+        YY: parts.year.slice(-2),
+        MM: parts.month,
+        DD: parts.day,
+        HH: parts.hour,
+        mm: parts.minute,
+        ss: parts.second,
+        SSS: date.getMilliseconds().toString(),
+        ZZ: timezone,
+    };
+    return formatString.replace(/YYYY|YY|MM|DD|HH|mm|ss|SSS|ZZ/g, (token) => tokens[token]);
+}
+
+export { format };

package/dist/date/getTimezoneOffset.cjs

@@ -0,0 +1,27 @@
+'use strict';
+
+var toNative = require('./toNative.cjs');
+
+function getTimezoneOffset(...args) {
+    if (args.length === 1) {
+        const [timeZone] = args;
+        return (theDate) => getTimezoneOffset(theDate, timeZone);
+    }
+    const [theDate, timeZone] = args;
+    const date = toNative.toNative(theDate);
+    const fmt = new Intl.DateTimeFormat("en-US", {
+        timeZone,
+        hour12: false,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+    });
+    const parts = Object.fromEntries(fmt.formatToParts(date).map((part) => [part.type, part.value]));
+    const tzDateAsUTC = Date.UTC(Number(parts.year), Number(parts.month) - 1, Number(parts.day), Number(parts.hour), Number(parts.minute), Number(parts.second));
+    return tzDateAsUTC - date.getTime();
+}
+
+exports.getTimezoneOffset = getTimezoneOffset;

package/dist/date/getTimezoneOffset.d.ts

@@ -0,0 +1,4 @@
+import { type Timezone } from "./timezone";
+import { type TheDate } from "./types";
+export declare function getTimezoneOffset(timeZone: Timezone): (theDate: TheDate) => number;
+export declare function getTimezoneOffset(theDate: TheDate, timeZone: Timezone): number;

package/dist/date/getTimezoneOffset.mjs

@@ -0,0 +1,25 @@
+import { toNative } from './toNative.mjs';
+
+function getTimezoneOffset(...args) {
+    if (args.length === 1) {
+        const [timeZone] = args;
+        return (theDate) => getTimezoneOffset(theDate, timeZone);
+    }
+    const [theDate, timeZone] = args;
+    const date = toNative(theDate);
+    const fmt = new Intl.DateTimeFormat("en-US", {
+        timeZone,
+        hour12: false,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+    });
+    const parts = Object.fromEntries(fmt.formatToParts(date).map((part) => [part.type, part.value]));
+    const tzDateAsUTC = Date.UTC(Number(parts.year), Number(parts.month) - 1, Number(parts.day), Number(parts.hour), Number(parts.minute), Number(parts.second));
+    return tzDateAsUTC - date.getTime();
+}
+
+export { getTimezoneOffset };

package/dist/date/getters/getDayOfYear.cjs

@@ -1,5 +1,6 @@
 'use strict';
 
+var constants = require('../constants.cjs');
 var toNative = require('../toNative.cjs');
 
 function getDayOfYear(input, timezone = "UTC") {
@@ -27,7 +28,7 @@ function getDayOfYear(input, timezone = "UTC") {
     const yearStart = Date.UTC(year, 0, 1);
     const currentDate = Date.UTC(year, month, day);
     const millisecondsDiff = currentDate - yearStart;
-    const dayOfYear = Math.floor(millisecondsDiff / 86400000) + 1;
+    const dayOfYear = Math.floor(millisecondsDiff / constants.millisecondsInOneDay) + 1;
     return dayOfYear;
 }
 

package/dist/date/getters/getDayOfYear.mjs

@@ -1,3 +1,4 @@
+import { millisecondsInOneDay } from '../constants.mjs';
 import { toNative } from '../toNative.mjs';
 
 function getDayOfYear(input, timezone = "UTC") {
@@ -25,7 +26,7 @@ function getDayOfYear(input, timezone = "UTC") {
     const yearStart = Date.UTC(year, 0, 1);
     const currentDate = Date.UTC(year, month, day);
     const millisecondsDiff = currentDate - yearStart;
-    const dayOfYear = Math.floor(millisecondsDiff / 86400000) + 1;
+    const dayOfYear = Math.floor(millisecondsDiff / millisecondsInOneDay) + 1;
     return dayOfYear;
 }
 

package/dist/date/index.cjs

@@ -8,17 +8,31 @@ var yesterday = require('./yesterday.cjs');
 var tomorrow = require('./tomorrow.cjs');
 var toNative = require('./toNative.cjs');
 var toTimestamp = require('./toTimestamp.cjs');
+var toTimeValue = require('./toTimeValue.cjs');
 var toISOString = require('./toISOString.cjs');
 var closestTo = require('./closestTo.cjs');
 var each = require('./each.cjs');
 var createOrThrow = require('./createOrThrow.cjs');
 var round = require('./round.cjs');
 var isSafeTimestamp = require('./isSafeTimestamp.cjs');
+var isSafeTimeValue = require('./isSafeTimeValue.cjs');
 var min = require('./min.cjs');
+var minTime = require('./minTime.cjs');
 var max = require('./max.cjs');
+var maxTime = require('./maxTime.cjs');
 var sort = require('./sort.cjs');
+var sortTimes = require('./sortTimes.cjs');
 var is = require('./is.cjs');
-var timezone = require('./types/timezone.cjs');
+var isTime = require('./isTime.cjs');
+var timezone = require('./timezone.cjs');
+var getTimezoneOffset = require('./getTimezoneOffset.cjs');
+var applyTimezone = require('./applyTimezone.cjs');
+var format = require('./format.cjs');
+var makeSafeTimestamp = require('./makeSafeTimestamp.cjs');
+var createTheDate = require('./createTheDate.cjs');
+var createTheTime = require('./createTheTime.cjs');
+var createTime = require('./createTime.cjs');
+var createTimeOrThrow = require('./createTimeOrThrow.cjs');
 var getDayOfMonth = require('./getters/getDayOfMonth.cjs');
 var getDayOfWeek = require('./getters/getDayOfWeek.cjs');
 var getFirstDayOfWeek = require('./getters/getFirstDayOfWeek.cjs');
@@ -39,6 +53,7 @@ var addMilliseconds = require('./operators/addMilliseconds.cjs');
 var addMinutes = require('./operators/addMinutes.cjs');
 var addMonths = require('./operators/addMonths.cjs');
 var addSeconds = require('./operators/addSeconds.cjs');
+var addTime = require('./operators/addTime.cjs');
 var addWeeks = require('./operators/addWeeks.cjs');
 var addYears = require('./operators/addYears.cjs');
 var subtractDays = require('./operators/subtractDays.cjs');
@@ -47,38 +62,50 @@ var subtractMilliseconds = require('./operators/subtractMilliseconds.cjs');
 var subtractMinutes = require('./operators/subtractMinutes.cjs');
 var subtractMonths = require('./operators/subtractMonths.cjs');
 var subtractSeconds = require('./operators/subtractSeconds.cjs');
+var subtractTime = require('./operators/subtractTime.cjs');
 var subtractWeeks = require('./operators/subtractWeeks.cjs');
 var subtractYears = require('./operators/subtractYears.cjs');
 var between = require('./operators/between.cjs');
 var betweenThan = require('./operators/betweenThan.cjs');
+var betweenThanTime = require('./operators/betweenThanTime.cjs');
+var betweenTime = require('./operators/betweenTime.cjs');
 var greater = require('./operators/greater.cjs');
 var greaterThan = require('./operators/greaterThan.cjs');
+var greaterThanTime = require('./operators/greaterThanTime.cjs');
+var greaterTime = require('./operators/greaterTime.cjs');
 var less = require('./operators/less.cjs');
 var lessThan = require('./operators/lessThan.cjs');
+var lessThanTime = require('./operators/lessThanTime.cjs');
+var lessTime = require('./operators/lessTime.cjs');
 
 
 
 exports.daysInOneWeek = constants.daysInOneWeek;
 exports.hoursInOneDay = constants.hoursInOneDay;
+exports.isoDateRegex = constants.isoDateRegex;
+exports.isoTimeRegex = constants.isoTimeRegex;
+exports.maxTimeValue = constants.maxTimeValue;
 exports.maxTimestamp = constants.maxTimestamp;
 exports.millisecondInOneHour = constants.millisecondInOneHour;
 exports.millisecondInOneMinute = constants.millisecondInOneMinute;
 exports.millisecondInOneWeek = constants.millisecondInOneWeek;
 exports.millisecondsInOneDay = constants.millisecondsInOneDay;
 exports.millisecondsInOneSecond = constants.millisecondsInOneSecond;
+exports.minTimeValue = constants.minTimeValue;
 exports.minTimestamp = constants.minTimestamp;
 exports.minutesInOneHour = constants.minutesInOneHour;
 exports.monthsInOneYear = constants.monthsInOneYear;
 exports.secondsInOneMinute = constants.secondsInOneMinute;
 exports.theDateRegex = constants.theDateRegex;
+exports.theTimeRegex = constants.theTimeRegex;
 exports.create = create.create;
 exports.now = now.now;
 exports.today = today.today;
 exports.yesterday = yesterday.yesterday;
 exports.tomorrow = tomorrow.tomorrow;
 exports.toNative = toNative.toNative;
-exports.InvalidTheDateError = toTimestamp.InvalidTheDateError;
 exports.toTimestamp = toTimestamp.toTimestamp;
+exports.toTimeValue = toTimeValue.toTimeValue;
 exports.toISOString = toISOString.toISOString;
 exports.closestTo = closestTo.closestTo;
 exports.each = each.each;
@@ -86,11 +113,25 @@ exports.CreateTheDateError = createOrThrow.CreateTheDateError;
 exports.createOrThrow = createOrThrow.createOrThrow;
 exports.round = round.round;
 exports.isSafeTimestamp = isSafeTimestamp.isSafeTimestamp;
+exports.isSafeTimeValue = isSafeTimeValue.isSafeTimeValue;
 exports.min = min.min;
+exports.minTime = minTime.minTime;
 exports.max = max.max;
+exports.maxTime = maxTime.maxTime;
 exports.sort = sort.sort;
+exports.sortTimes = sortTimes.sortTimes;
 exports.is = is.is;
+exports.isTime = isTime.isTime;
 exports.timezone = timezone.timezone;
+exports.getTimezoneOffset = getTimezoneOffset.getTimezoneOffset;
+exports.applyTimezone = applyTimezone.applyTimezone;
+exports.format = format.format;
+exports.makeSafeTimestamp = makeSafeTimestamp.makeSafeTimestamp;
+exports.createTheDate = createTheDate.createTheDate;
+exports.createTheTime = createTheTime.createTheTime;
+exports.createTime = createTime.createTime;
+exports.CreateTheTimeError = createTimeOrThrow.CreateTheTimeError;
+exports.createTimeOrThrow = createTimeOrThrow.createTimeOrThrow;
 exports.getDayOfMonth = getDayOfMonth.getDayOfMonth;
 exports.getDayOfWeek = getDayOfWeek.getDayOfWeek;
 exports.getFirstDayOfWeek = getFirstDayOfWeek.getFirstDayOfWeek;
@@ -111,6 +152,7 @@ exports.addMilliseconds = addMilliseconds.addMilliseconds;
 exports.addMinutes = addMinutes.addMinutes;
 exports.addMonths = addMonths.addMonths;
 exports.addSeconds = addSeconds.addSeconds;
+exports.addTime = addTime.addTime;
 exports.addWeeks = addWeeks.addWeeks;
 exports.addYears = addYears.addYears;
 exports.subtractDays = subtractDays.subtractDays;
@@ -119,11 +161,18 @@ exports.subtractMilliseconds = subtractMilliseconds.subtractMilliseconds;
 exports.subtractMinutes = subtractMinutes.subtractMinutes;
 exports.subtractMonths = subtractMonths.subtractMonths;
 exports.subtractSeconds = subtractSeconds.subtractSeconds;
+exports.subtractTime = subtractTime.subtractTime;
 exports.subtractWeeks = subtractWeeks.subtractWeeks;
 exports.subtractYears = subtractYears.subtractYears;
 exports.between = between.between;
 exports.betweenThan = betweenThan.betweenThan;
+exports.betweenThanTime = betweenThanTime.betweenThanTime;
+exports.betweenTime = betweenTime.betweenTime;
 exports.greater = greater.greater;
 exports.greaterThan = greaterThan.greaterThan;
+exports.greaterThanTime = greaterThanTime.greaterThanTime;
+exports.greaterTime = greaterTime.greaterTime;
 exports.less = less.less;
 exports.lessThan = lessThan.lessThan;
+exports.lessThanTime = lessThanTime.lessThanTime;
+exports.lessTime = lessTime.lessTime;

package/dist/date/index.d.ts

@@ -7,6 +7,7 @@ export * from "./yesterday";
 export * from "./tomorrow";
 export * from "./toNative";
 export * from "./toTimestamp";
+export * from "./toTimeValue";
 export * from "./getters";
 export * from "./toISOString";
 export * from "./operators";
@@ -16,7 +17,21 @@ export * from "./each";
 export * from "./createOrThrow";
 export * from "./round";
 export * from "./isSafeTimestamp";
+export * from "./isSafeTimeValue";
 export * from "./min";
+export * from "./minTime";
 export * from "./max";
+export * from "./maxTime";
 export * from "./sort";
+export * from "./sortTimes";
 export * from "./is";
+export * from "./isTime";
+export * from "./timezone";
+export * from "./getTimezoneOffset";
+export * from "./applyTimezone";
+export * from "./format";
+export * from "./makeSafeTimestamp";
+export * from "./createTheDate";
+export * from "./createTheTime";
+export * from "./createTime";
+export * from "./createTimeOrThrow";