@duplojs/lang 0.0.0

package/dist/chrono/createDateOrThrow.mjs

@@ -0,0 +1,21 @@
+import { parentClass } from "../kind/parentClass.mjs";
+import { createKind } from "./kind.mjs";
+import { isLeft } from "../either/left/is.mjs";
+import { unwrapRight } from "../either/right/unwrap.mjs";
+import { createDate } from "./createDate.mjs";
+//#region scripts/chrono/createDateOrThrow.ts
+var CreateTheDateError = class extends parentClass(createKind("create-the-date-error"), Error) {
+	input;
+	constructor(input) {
+		const value = typeof input === "object" && "value" in input ? JSON.stringify(input) : input.toString();
+		super(`Invalid date input: ${value}`);
+		this.input = input;
+	}
+};
+function createDateOrThrow(input) {
+	const result = createDate(input);
+	if (isLeft(result)) throw new CreateTheDateError(input);
+	return unwrapRight(result);
+}
+//#endregion
+export { CreateTheDateError, createDateOrThrow };

package/dist/chrono/createTime.cjs

@@ -0,0 +1,45 @@
+const require_constants = require("./constants.cjs");
+const require_theTime = require("./theTime.cjs");
+const require_create = require("../either/left/create.cjs");
+const require_create$1 = require("../either/right/create.cjs");
+const require_isSafeTimeValue = require("./isSafeTimeValue.cjs");
+//#region scripts/chrono/createTime.ts
+const unitMapper = {
+	week: require_constants.millisecondInOneWeek,
+	day: require_constants.millisecondsInOneDay,
+	hour: require_constants.millisecondInOneHour,
+	minute: require_constants.millisecondInOneMinute,
+	second: require_constants.millisecondsInOneSecond,
+	millisecond: 1
+};
+function createTime(input, unit) {
+	if (input instanceof require_theTime.TheTime) return input;
+	if (typeof input === "number") {
+		if (unit) return require_theTime.TheTime.new(input * unitMapper[unit]);
+		return createFromTimeValue(input * unitMapper[unit ?? "millisecond"]);
+	}
+	if (typeof input === "string") {
+		const serializeTheTimeMatch = input.match(require_constants.serializeTheTimeRegex);
+		if (!serializeTheTimeMatch) return require_create.left("time-created-error", null);
+		const { value, sign } = serializeTheTimeMatch.groups;
+		return createFromTimeValue(Number(sign === "-" ? `-${value}` : value));
+	}
+	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(require_constants.isoTimeRegex);
+		if (theTimeMatch) {
+			const { sign = "+", hour, minute, second = 0, millisecond = 0 } = theTimeMatch.groups;
+			fromValue = Number(hour) * require_constants.millisecondInOneHour + Number(minute) * require_constants.millisecondInOneMinute + Number(second) * require_constants.millisecondsInOneSecond + Number(millisecond);
+			fromValue = sign === "-" ? -fromValue : fromValue;
+		}
+	}
+	return createFromTimeValue(fromValue + week * require_constants.millisecondInOneWeek + day * require_constants.millisecondsInOneDay + hour * require_constants.millisecondInOneHour + minute * require_constants.millisecondInOneMinute + second * require_constants.millisecondsInOneSecond + millisecond);
+}
+function createFromTimeValue(timeValue) {
+	if (!require_isSafeTimeValue.isSafeTimeValue(timeValue)) return require_create.left("time-created-error", null);
+	return require_create$1.right("time-created", require_theTime.TheTime.new(timeValue));
+}
+//#endregion
+exports.createTime = createTime;

package/dist/chrono/createTime.d.ts

@@ -0,0 +1,30 @@
+import { TheTime } from './theTime';
+import { maxTimeValue, minTimeValue } from './constants';
+import { SerializedTheTime, SpoolingTime } from './types';
+import type * as DNumber from '../number';
+import type * as DCommon from '../common';
+import * as DEither from '../either';
+export type MayBeTime = DEither.Right<"time-created", TheTime> | DEither.Left<"time-created-error", null>;
+type ChronoCreateTimeUnit = "week" | "day" | "hour" | "minute" | "second" | "millisecond";
+type ForbiddenTime<GenericInput extends number, GenericUnit extends ChronoCreateTimeUnit> = DCommon.IsEqual<GenericInput, number> extends true ? DCommon.ComputedTypeError<"Expect only literal value."> : ((DCommon.IsEqual<GenericUnit, "millisecond"> extends true ? DCommon.And<[
+    DNumber.IsGreaterOrEqual<GenericInput, typeof minTimeValue>,
+    DNumber.IsLessOrEqual<GenericInput, typeof maxTimeValue>
+]> extends true ? GenericInput : DCommon.ComputedTypeError<"Support that the milliseconds between -9007199254740991 and 9007199254740991."> : GenericInput) & (DCommon.IsEqual<GenericUnit, "second"> extends true ? DCommon.And<[
+    DNumber.IsGreaterOrEqual<GenericInput, -9007199254740>,
+    DNumber.IsLessOrEqual<GenericInput, 9007199254740>
+]> extends true ? GenericInput : DCommon.ComputedTypeError<"Support that the seconds between -9007199254740 and 9007199254740."> : GenericInput) & (DCommon.IsEqual<GenericUnit, "minute"> extends true ? DCommon.And<[
+    DNumber.IsGreaterOrEqual<GenericInput, -150119987579>,
+    DNumber.IsLessOrEqual<GenericInput, 150119987579>
+]> extends true ? GenericInput : DCommon.ComputedTypeError<"Support that the minutes between -150119987579 and 150119987579."> : GenericInput) & (DCommon.IsEqual<GenericUnit, "hour"> extends true ? DCommon.And<[
+    DNumber.IsGreaterOrEqual<GenericInput, -2501999792>,
+    DNumber.IsLessOrEqual<GenericInput, 2501999792>
+]> extends true ? GenericInput : DCommon.ComputedTypeError<"Support that the hours between -2501999792 and 2501999792."> : GenericInput) & (DCommon.IsEqual<GenericUnit, "day"> extends true ? DCommon.And<[
+    DNumber.IsGreaterOrEqual<GenericInput, -104249991>,
+    DNumber.IsLessOrEqual<GenericInput, 104249991>
+]> extends true ? GenericInput : DCommon.ComputedTypeError<"Support that the days between -104249991 and 104249991."> : GenericInput) & (DCommon.IsEqual<GenericUnit, "week"> extends true ? DCommon.And<[
+    DNumber.IsGreaterOrEqual<GenericInput, -14892855>,
+    DNumber.IsLessOrEqual<GenericInput, 14892855>
+]> extends true ? GenericInput : DCommon.ComputedTypeError<"Support that the weeks between -14892855 and 14892855."> : GenericInput));
+export declare function createTime<GenericInput extends number, GenericUnit extends ChronoCreateTimeUnit = "millisecond">(input: GenericInput & ForbiddenTime<GenericInput, GenericUnit>, unit: GenericUnit): TheTime;
+export declare function createTime<GenericInput extends number | TheTime | SpoolingTime | SerializedTheTime>(input: GenericInput): MayBeTime;
+export {};

package/dist/chrono/createTime.mjs

@@ -0,0 +1,45 @@
+import { isoTimeRegex, millisecondInOneHour, millisecondInOneMinute, millisecondInOneWeek, millisecondsInOneDay, millisecondsInOneSecond, serializeTheTimeRegex } from "./constants.mjs";
+import { TheTime } from "./theTime.mjs";
+import { left } from "../either/left/create.mjs";
+import { right } from "../either/right/create.mjs";
+import { isSafeTimeValue } from "./isSafeTimeValue.mjs";
+//#region scripts/chrono/createTime.ts
+const unitMapper = {
+	week: millisecondInOneWeek,
+	day: millisecondsInOneDay,
+	hour: millisecondInOneHour,
+	minute: millisecondInOneMinute,
+	second: millisecondsInOneSecond,
+	millisecond: 1
+};
+function createTime(input, unit) {
+	if (input instanceof TheTime) return input;
+	if (typeof input === "number") {
+		if (unit) return TheTime.new(input * unitMapper[unit]);
+		return createFromTimeValue(input * unitMapper[unit ?? "millisecond"]);
+	}
+	if (typeof input === "string") {
+		const serializeTheTimeMatch = input.match(serializeTheTimeRegex);
+		if (!serializeTheTimeMatch) return left("time-created-error", null);
+		const { value, sign } = serializeTheTimeMatch.groups;
+		return createFromTimeValue(Number(sign === "-" ? `-${value}` : value));
+	}
+	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(timeValue) {
+	if (!isSafeTimeValue(timeValue)) return left("time-created-error", null);
+	return right("time-created", TheTime.new(timeValue));
+}
+//#endregion
+export { createTime };

package/dist/chrono/createTimeOrThrow.cjs

@@ -0,0 +1,22 @@
+const require_parentClass = require("../kind/parentClass.cjs");
+const require_kind = require("./kind.cjs");
+const require_is = require("../either/left/is.cjs");
+const require_unwrap = require("../either/right/unwrap.cjs");
+const require_createTime = require("./createTime.cjs");
+//#region scripts/chrono/createTimeOrThrow.ts
+var CreateTheTimeError = class extends require_parentClass.parentClass(require_kind.createKind("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 = require_createTime.createTime(input);
+	if (require_is.isLeft(result)) throw new CreateTheTimeError(input);
+	return require_unwrap.unwrapRight(result);
+}
+//#endregion
+exports.CreateTheTimeError = CreateTheTimeError;
+exports.createTimeOrThrow = createTimeOrThrow;

package/dist/chrono/createTimeOrThrow.d.ts

@@ -0,0 +1,10 @@
+import { SerializedTheTime, SpoolingTime } from './types';
+import { TheTime } from './theTime';
+import * as DKind from '../kind';
+declare const CreateTheTimeError_base: DKind.KindClass<DKind.Handler<DKind.Definition<"@DuplojsLangChrono/create-the-time-error", unknown>>, ErrorConstructor>;
+export declare class CreateTheTimeError extends CreateTheTimeError_base {
+    input: TheTime | number | SpoolingTime | SerializedTheTime;
+    constructor(input: TheTime | number | SpoolingTime | SerializedTheTime);
+}
+export declare function createTimeOrThrow(input: number | TheTime | SpoolingTime | SerializedTheTime): TheTime;
+export {};

package/dist/chrono/createTimeOrThrow.mjs

@@ -0,0 +1,21 @@
+import { parentClass } from "../kind/parentClass.mjs";
+import { createKind } from "./kind.mjs";
+import { isLeft } from "../either/left/is.mjs";
+import { unwrapRight } from "../either/right/unwrap.mjs";
+import { createTime } from "./createTime.mjs";
+//#region scripts/chrono/createTimeOrThrow.ts
+var CreateTheTimeError = class extends parentClass(createKind("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 unwrapRight(result);
+}
+//#endregion
+export { CreateTheTimeError, createTimeOrThrow };

package/dist/chrono/eachDate.cjs

@@ -0,0 +1,36 @@
+const require_constants = require("./constants.cjs");
+const require_theDate = require("./theDate.cjs");
+const require_loop = require("../generator/loop.cjs");
+const require_toTimestamp = require("./toTimestamp.cjs");
+//#region scripts/chrono/eachDate.ts
+const stepMapper = {
+	millisecond: (timestamp, direction) => timestamp + direction,
+	second: (timestamp, direction) => timestamp + direction * require_constants.millisecondsInOneSecond,
+	minute: (timestamp, direction) => timestamp + direction * require_constants.millisecondInOneMinute,
+	hour: (timestamp, direction) => timestamp + direction * require_constants.millisecondInOneHour,
+	day: (timestamp, direction) => timestamp + direction * require_constants.millisecondsInOneDay,
+	month: (timestamp, direction) => {
+		const date = new Date(timestamp);
+		date.setUTCMonth(date.getUTCMonth() + direction);
+		return date.getTime();
+	},
+	year: (timestamp, direction) => {
+		const date = new Date(timestamp);
+		date.setUTCFullYear(date.getUTCFullYear() + direction);
+		return date.getTime();
+	}
+};
+function eachDate(range, unit = "day") {
+	const startTimestamp = require_toTimestamp.toTimestamp(range.start);
+	const endTimestamp = require_toTimestamp.toTimestamp(range.end);
+	const direction = startTimestamp <= endTimestamp ? 1 : -1;
+	const advanceTimestamp = stepMapper[unit];
+	return require_loop.loop(({ exit, next, previousOutput }) => {
+		if (!previousOutput) return range.start instanceof require_theDate.TheDate ? next(range.start) : next(require_theDate.TheDate.new(require_toTimestamp.toTimestamp(range.start)));
+		const currentTimestamp = advanceTimestamp(require_toTimestamp.toTimestamp(previousOutput), direction);
+		if (!(direction === 1 ? currentTimestamp < endTimestamp : currentTimestamp > endTimestamp)) return exit(currentTimestamp === endTimestamp ? require_theDate.TheDate.new(currentTimestamp) : void 0);
+		return next(require_theDate.TheDate.new(currentTimestamp));
+	});
+}
+//#endregion
+exports.eachDate = eachDate;

package/dist/chrono/eachDate.d.ts

@@ -0,0 +1,6 @@
+import { TheDate } from './theDate';
+import { Unit, SerializedTheDate } from './types';
+export declare function eachDate(range: {
+    start: TheDate | SerializedTheDate;
+    end: TheDate | SerializedTheDate;
+}, unit?: Unit): Generator<TheDate, unknown, unknown>;

package/dist/chrono/eachDate.mjs

@@ -0,0 +1,36 @@
+import { millisecondInOneHour, millisecondInOneMinute, millisecondsInOneDay, millisecondsInOneSecond } from "./constants.mjs";
+import { TheDate } from "./theDate.mjs";
+import { loop } from "../generator/loop.mjs";
+import { toTimestamp } from "./toTimestamp.mjs";
+//#region scripts/chrono/eachDate.ts
+const stepMapper = {
+	millisecond: (timestamp, direction) => timestamp + direction,
+	second: (timestamp, direction) => timestamp + direction * millisecondsInOneSecond,
+	minute: (timestamp, direction) => timestamp + direction * millisecondInOneMinute,
+	hour: (timestamp, direction) => timestamp + direction * millisecondInOneHour,
+	day: (timestamp, direction) => timestamp + direction * millisecondsInOneDay,
+	month: (timestamp, direction) => {
+		const date = new Date(timestamp);
+		date.setUTCMonth(date.getUTCMonth() + direction);
+		return date.getTime();
+	},
+	year: (timestamp, direction) => {
+		const date = new Date(timestamp);
+		date.setUTCFullYear(date.getUTCFullYear() + direction);
+		return date.getTime();
+	}
+};
+function eachDate(range, unit = "day") {
+	const startTimestamp = toTimestamp(range.start);
+	const endTimestamp = toTimestamp(range.end);
+	const direction = startTimestamp <= endTimestamp ? 1 : -1;
+	const advanceTimestamp = stepMapper[unit];
+	return loop(({ exit, next, previousOutput }) => {
+		if (!previousOutput) return range.start instanceof TheDate ? next(range.start) : next(TheDate.new(toTimestamp(range.start)));
+		const currentTimestamp = advanceTimestamp(toTimestamp(previousOutput), direction);
+		if (!(direction === 1 ? currentTimestamp < endTimestamp : currentTimestamp > endTimestamp)) return exit(currentTimestamp === endTimestamp ? TheDate.new(currentTimestamp) : void 0);
+		return next(TheDate.new(currentTimestamp));
+	});
+}
+//#endregion
+export { eachDate };

package/dist/chrono/formatDate.cjs

@@ -0,0 +1,36 @@
+const require_toNative = require("./toNative.cjs");
+//#region scripts/chrono/formatDate.ts
+const formatStringRegex = /YYYY|YY|MM|DD|HH|mm|ss|SSS|ZZ/g;
+function formatDate(...args) {
+	if (args.length === 2) {
+		const [formatString, timezone] = args;
+		return (date) => formatDate(date, formatString, timezone);
+	}
+	const [date, formatString, timezone] = args;
+	const nativeDate = require_toNative.toNative(date);
+	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(nativeDate).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: nativeDate.getMilliseconds().toString(),
+		ZZ: timezone
+	};
+	return formatString.replace(formatStringRegex, (token) => tokens[token]);
+}
+//#endregion
+exports.formatDate = formatDate;

package/dist/chrono/formatDate.d.ts

@@ -0,0 +1,5 @@
+import { TheDate } from './theDate';
+import { Timezone } from './timezone';
+import { SerializedTheDate } from './types';
+export declare function formatDate<GenericDate extends TheDate | SerializedTheDate, GenericFormat extends string, GenericTimezone extends Timezone>(formatString: GenericFormat, timezone: GenericTimezone): (date: GenericDate) => string;
+export declare function formatDate<GenericDate extends TheDate | SerializedTheDate, GenericFormat extends string, GenericTimezone extends Timezone>(date: GenericDate, formatString: GenericFormat, timezone: GenericTimezone): string;

package/dist/chrono/formatDate.mjs

@@ -0,0 +1,36 @@
+import { toNative } from "./toNative.mjs";
+//#region scripts/chrono/formatDate.ts
+const formatStringRegex = /YYYY|YY|MM|DD|HH|mm|ss|SSS|ZZ/g;
+function formatDate(...args) {
+	if (args.length === 2) {
+		const [formatString, timezone] = args;
+		return (date) => formatDate(date, formatString, timezone);
+	}
+	const [date, formatString, timezone] = args;
+	const nativeDate = toNative(date);
+	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(nativeDate).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: nativeDate.getMilliseconds().toString(),
+		ZZ: timezone
+	};
+	return formatString.replace(formatStringRegex, (token) => tokens[token]);
+}
+//#endregion
+export { formatDate };

package/dist/chrono/formatTime.cjs

@@ -0,0 +1,36 @@
+const require_constants = require("./constants.cjs");
+const require_toTimeValue = require("./toTimeValue.cjs");
+//#region scripts/chrono/formatTime.ts
+const formatStringRegex = /WW|DD|HH|mm|ss|SSS/g;
+function formatTime(...args) {
+	if (args.length === 1) {
+		const [formatString] = args;
+		return (time) => formatTime(time, formatString);
+	}
+	const [time, formatString] = args;
+	const timeValue = require_toTimeValue.toTimeValue(time);
+	const isNegative = timeValue < 0;
+	let remaining = Math.abs(timeValue);
+	const weeks = Math.floor(remaining / require_constants.millisecondInOneWeek);
+	remaining -= weeks * require_constants.millisecondInOneWeek;
+	const days = Math.floor(remaining / require_constants.millisecondsInOneDay);
+	remaining -= days * require_constants.millisecondsInOneDay;
+	const hours = Math.floor(remaining / require_constants.millisecondInOneHour);
+	remaining -= hours * require_constants.millisecondInOneHour;
+	const minutes = Math.floor(remaining / require_constants.millisecondInOneMinute);
+	remaining -= minutes * require_constants.millisecondInOneMinute;
+	const seconds = Math.floor(remaining / require_constants.millisecondsInOneSecond);
+	remaining -= seconds * require_constants.millisecondsInOneSecond;
+	const tokens = {
+		WW: weeks.toString().padStart(2, "0"),
+		DD: days.toString().padStart(2, "0"),
+		HH: hours.toString().padStart(2, "0"),
+		mm: minutes.toString().padStart(2, "0"),
+		ss: seconds.toString().padStart(2, "0"),
+		SSS: remaining.toString().padStart(3, "0")
+	};
+	const formatted = formatString.replace(formatStringRegex, (token) => tokens[token]);
+	return isNegative ? `-${formatted}` : formatted;
+}
+//#endregion
+exports.formatTime = formatTime;

package/dist/chrono/formatTime.d.ts

@@ -0,0 +1,4 @@
+import { TheTime } from './theTime';
+import { SerializedTheTime } from './types';
+export declare function formatTime<GenericTime extends TheTime | SerializedTheTime, GenericFormat extends string>(formatString: GenericFormat): (time: GenericTime) => string;
+export declare function formatTime<GenericTime extends TheTime | SerializedTheTime, GenericFormat extends string>(time: GenericTime, formatString: GenericFormat): string;

package/dist/chrono/formatTime.mjs

@@ -0,0 +1,36 @@
+import { millisecondInOneHour, millisecondInOneMinute, millisecondInOneWeek, millisecondsInOneDay, millisecondsInOneSecond } from "./constants.mjs";
+import { toTimeValue } from "./toTimeValue.mjs";
+//#region scripts/chrono/formatTime.ts
+const formatStringRegex = /WW|DD|HH|mm|ss|SSS/g;
+function formatTime(...args) {
+	if (args.length === 1) {
+		const [formatString] = args;
+		return (time) => formatTime(time, formatString);
+	}
+	const [time, formatString] = args;
+	const timeValue = toTimeValue(time);
+	const isNegative = timeValue < 0;
+	let remaining = Math.abs(timeValue);
+	const weeks = Math.floor(remaining / millisecondInOneWeek);
+	remaining -= weeks * millisecondInOneWeek;
+	const days = Math.floor(remaining / millisecondsInOneDay);
+	remaining -= days * millisecondsInOneDay;
+	const hours = Math.floor(remaining / millisecondInOneHour);
+	remaining -= hours * millisecondInOneHour;
+	const minutes = Math.floor(remaining / millisecondInOneMinute);
+	remaining -= minutes * millisecondInOneMinute;
+	const seconds = Math.floor(remaining / millisecondsInOneSecond);
+	remaining -= seconds * millisecondsInOneSecond;
+	const tokens = {
+		WW: weeks.toString().padStart(2, "0"),
+		DD: days.toString().padStart(2, "0"),
+		HH: hours.toString().padStart(2, "0"),
+		mm: minutes.toString().padStart(2, "0"),
+		ss: seconds.toString().padStart(2, "0"),
+		SSS: remaining.toString().padStart(3, "0")
+	};
+	const formatted = formatString.replace(formatStringRegex, (token) => tokens[token]);
+	return isNegative ? `-${formatted}` : formatted;
+}
+//#endregion
+export { formatTime };

package/dist/chrono/getDifference.cjs

@@ -0,0 +1,16 @@
+const require_makeSafeTimeValue = require("./makeSafeTimeValue.cjs");
+const require_theTime = require("./theTime.cjs");
+const require_toTimestamp = require("./toTimestamp.cjs");
+//#region scripts/chrono/getDifference.ts
+function getDifference(...args) {
+	if (args.length === 1) {
+		const [referenceDate] = args;
+		return (date) => getDifference(date, referenceDate);
+	}
+	const [date, referenceDate] = args;
+	const dateTimestamp = require_toTimestamp.toTimestamp(date);
+	const referenceTimestamp = require_toTimestamp.toTimestamp(referenceDate);
+	return require_theTime.TheTime.new(require_makeSafeTimeValue.makeSafeTimeValue(dateTimestamp - referenceTimestamp));
+}
+//#endregion
+exports.getDifference = getDifference;

package/dist/chrono/getDifference.d.ts

@@ -0,0 +1,5 @@
+import { TheDate } from './theDate';
+import { TheTime } from './theTime';
+import { SerializedTheDate } from './types';
+export declare function getDifference(referenceDate: TheDate | SerializedTheDate): (date: TheDate | SerializedTheDate) => TheTime;
+export declare function getDifference(date: TheDate | SerializedTheDate, referenceDate: TheDate | SerializedTheDate): TheTime;

package/dist/chrono/getDifference.mjs

@@ -0,0 +1,16 @@
+import { makeSafeTimeValue } from "./makeSafeTimeValue.mjs";
+import { TheTime } from "./theTime.mjs";
+import { toTimestamp } from "./toTimestamp.mjs";
+//#region scripts/chrono/getDifference.ts
+function getDifference(...args) {
+	if (args.length === 1) {
+		const [referenceDate] = args;
+		return (date) => getDifference(date, referenceDate);
+	}
+	const [date, referenceDate] = args;
+	const dateTimestamp = toTimestamp(date);
+	const referenceTimestamp = toTimestamp(referenceDate);
+	return TheTime.new(makeSafeTimeValue(dateTimestamp - referenceTimestamp));
+}
+//#endregion
+export { getDifference };

package/dist/chrono/getTimezoneOffset.cjs

@@ -0,0 +1,25 @@
+const require_theDate = require("./theDate.cjs");
+const require_toNative = require("./toNative.cjs");
+//#region scripts/chrono/getTimezoneOffset.ts
+function getTimezoneOffset(...args) {
+	if (args.length === 1) {
+		const [timeZone] = args;
+		return (date) => getTimezoneOffset(date, timeZone);
+	}
+	const [date, timeZone] = args;
+	const nativeDate = date instanceof require_theDate.TheDate ? date : require_toNative.toNative(date);
+	const formatter = 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(formatter.formatToParts(nativeDate).map((part) => [part.type, part.value]));
+	return Date.UTC(Number(parts.year), Number(parts.month) - 1, Number(parts.day), Number(parts.hour), Number(parts.minute), Number(parts.second)) - nativeDate.getTime();
+}
+//#endregion
+exports.getTimezoneOffset = getTimezoneOffset;

package/dist/chrono/getTimezoneOffset.d.ts

@@ -0,0 +1,5 @@
+import { Timezone } from './timezone';
+import { TheDate } from './theDate';
+import { SerializedTheDate } from './types';
+export declare function getTimezoneOffset(timeZone: Timezone): (date: TheDate | SerializedTheDate) => number;
+export declare function getTimezoneOffset(date: TheDate | SerializedTheDate, timeZone: Timezone): number;

package/dist/chrono/getTimezoneOffset.mjs

@@ -0,0 +1,25 @@
+import { TheDate } from "./theDate.mjs";
+import { toNative } from "./toNative.mjs";
+//#region scripts/chrono/getTimezoneOffset.ts
+function getTimezoneOffset(...args) {
+	if (args.length === 1) {
+		const [timeZone] = args;
+		return (date) => getTimezoneOffset(date, timeZone);
+	}
+	const [date, timeZone] = args;
+	const nativeDate = date instanceof TheDate ? date : toNative(date);
+	const formatter = 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(formatter.formatToParts(nativeDate).map((part) => [part.type, part.value]));
+	return Date.UTC(Number(parts.year), Number(parts.month) - 1, Number(parts.day), Number(parts.hour), Number(parts.minute), Number(parts.second)) - nativeDate.getTime();
+}
+//#endregion
+export { getTimezoneOffset };

package/dist/chrono/getters/getDayOfMonth.cjs

@@ -0,0 +1,13 @@
+const require_toNative = require("../toNative.cjs");
+//#region scripts/chrono/getters/getDayOfMonth.ts
+function getDayOfMonth(date, timezone = "UTC") {
+	const nativeDate = require_toNative.toNative(date);
+	if (timezone === "UTC") return nativeDate.getUTCDate();
+	const formatter = new Intl.DateTimeFormat("en-US", {
+		timeZone: timezone,
+		day: "numeric"
+	});
+	return Number(formatter.format(nativeDate));
+}
+//#endregion
+exports.getDayOfMonth = getDayOfMonth;

package/dist/chrono/getters/getDayOfMonth.d.ts

@@ -0,0 +1,4 @@
+import { SerializedTheDate } from '../types';
+import { TheDate } from '../theDate';
+import { Timezone } from '../timezone';
+export declare function getDayOfMonth<GenericDate extends TheDate | SerializedTheDate>(date: GenericDate, timezone?: Timezone): number;

package/dist/chrono/getters/getDayOfMonth.mjs

@@ -0,0 +1,13 @@
+import { toNative } from "../toNative.mjs";
+//#region scripts/chrono/getters/getDayOfMonth.ts
+function getDayOfMonth(date, timezone = "UTC") {
+	const nativeDate = toNative(date);
+	if (timezone === "UTC") return nativeDate.getUTCDate();
+	const formatter = new Intl.DateTimeFormat("en-US", {
+		timeZone: timezone,
+		day: "numeric"
+	});
+	return Number(formatter.format(nativeDate));
+}
+//#endregion
+export { getDayOfMonth };

package/dist/chrono/getters/getDayOfWeek.cjs

@@ -0,0 +1,22 @@
+const require_toNative = require("../toNative.cjs");
+//#region scripts/chrono/getters/getDayOfWeek.ts
+const weekdayMapper = {
+	Sunday: 0,
+	Monday: 1,
+	Tuesday: 2,
+	Wednesday: 3,
+	Thursday: 4,
+	Friday: 5,
+	Saturday: 6
+};
+function getDayOfWeek(date, timezone = "UTC") {
+	const nativeDate = require_toNative.toNative(date);
+	if (timezone === "UTC") return nativeDate.getUTCDay();
+	const weekday = new Intl.DateTimeFormat("en-US", {
+		timeZone: timezone,
+		weekday: "long"
+	}).format(nativeDate);
+	return weekdayMapper[weekday];
+}
+//#endregion
+exports.getDayOfWeek = getDayOfWeek;

package/dist/chrono/getters/getDayOfWeek.d.ts

@@ -0,0 +1,4 @@
+import { SerializedTheDate } from '../types';
+import { TheDate } from '../theDate';
+import { Timezone } from '../timezone';
+export declare function getDayOfWeek<GenericDate extends TheDate | SerializedTheDate>(date: GenericDate, timezone?: Timezone): number;

package/dist/chrono/getters/getDayOfWeek.mjs

@@ -0,0 +1,22 @@
+import { toNative } from "../toNative.mjs";
+//#region scripts/chrono/getters/getDayOfWeek.ts
+const weekdayMapper = {
+	Sunday: 0,
+	Monday: 1,
+	Tuesday: 2,
+	Wednesday: 3,
+	Thursday: 4,
+	Friday: 5,
+	Saturday: 6
+};
+function getDayOfWeek(date, timezone = "UTC") {
+	const nativeDate = toNative(date);
+	if (timezone === "UTC") return nativeDate.getUTCDay();
+	const weekday = new Intl.DateTimeFormat("en-US", {
+		timeZone: timezone,
+		weekday: "long"
+	}).format(nativeDate);
+	return weekdayMapper[weekday];
+}
+//#endregion
+export { getDayOfWeek };