@duplojs/lang 0.0.0

package/dist/array/some.mjs

@@ -0,0 +1,14 @@
+//#region scripts/array/some.ts
+function some(...args) {
+	if (args.length === 1) {
+		const [predicate] = args;
+		return (array) => some(array, predicate);
+	}
+	const [array, predicate] = args;
+	return array.some((element, index) => predicate(element, {
+		index,
+		self: array
+	}));
+}
+//#endregion
+export { some };

package/dist/array/sort.cjs

@@ -0,0 +1,11 @@
+//#region scripts/array/sort.ts
+function sort(...args) {
+	if (args.length === 1) {
+		const [compareFunction] = args;
+		return (array) => sort(array, compareFunction);
+	}
+	const [array, compareFunction] = args;
+	return array.slice().sort(compareFunction);
+}
+//#endregion
+exports.sort = sort;

package/dist/array/sort.d.ts

@@ -0,0 +1,5 @@
+import { ReapplyCompatiblesConstraints } from './constraints';
+type SortOutput<GenericArray extends readonly unknown[], GenericElement extends GenericArray[number]> = ReapplyCompatiblesConstraints<GenericArray, readonly GenericElement[]>;
+export declare function sort<GenericArray extends readonly unknown[], GenericElement extends GenericArray[number] = GenericArray[number]>(compareFunction: (first: GenericElement, second: GenericElement) => number): (array: GenericArray) => SortOutput<GenericArray, GenericElement>;
+export declare function sort<GenericArray extends readonly unknown[], GenericElement extends GenericArray[number] = GenericArray[number]>(array: GenericArray, compareFunction: (first: GenericElement, second: GenericElement) => number): SortOutput<GenericArray, GenericElement>;
+export {};

package/dist/array/sort.mjs

@@ -0,0 +1,11 @@
+//#region scripts/array/sort.ts
+function sort(...args) {
+	if (args.length === 1) {
+		const [compareFunction] = args;
+		return (array) => sort(array, compareFunction);
+	}
+	const [array, compareFunction] = args;
+	return array.slice().sort(compareFunction);
+}
+//#endregion
+export { sort };

package/dist/array/splice/delete.cjs

@@ -0,0 +1,13 @@
+//#region scripts/array/splice/delete.ts
+function spliceDelete(...args) {
+	if (args.length === 2) {
+		const [indexTo, deleteCount] = args;
+		return (array) => spliceDelete(array, indexTo, deleteCount);
+	}
+	const [array, indexTo, deleteCount] = args;
+	const result = array.slice();
+	result.splice(indexTo, deleteCount);
+	return result;
+}
+//#endregion
+exports.spliceDelete = spliceDelete;

package/dist/array/splice/delete.d.ts

@@ -0,0 +1,5 @@
+import { ReapplyCompatiblesConstraints } from '../constraints';
+type SpliceDeleteOutput<GenericArray extends readonly unknown[]> = ReapplyCompatiblesConstraints<GenericArray, readonly GenericArray[number][], "maxElements">;
+export declare function spliceDelete(indexTo: number, deleteCount: number): <GenericArray extends readonly unknown[]>(array: GenericArray) => SpliceDeleteOutput<GenericArray>;
+export declare function spliceDelete<GenericArray extends readonly unknown[]>(array: GenericArray, indexTo: number, deleteCount: number): SpliceDeleteOutput<GenericArray>;
+export {};

package/dist/array/splice/delete.mjs

@@ -0,0 +1,13 @@
+//#region scripts/array/splice/delete.ts
+function spliceDelete(...args) {
+	if (args.length === 2) {
+		const [indexTo, deleteCount] = args;
+		return (array) => spliceDelete(array, indexTo, deleteCount);
+	}
+	const [array, indexTo, deleteCount] = args;
+	const result = array.slice();
+	result.splice(indexTo, deleteCount);
+	return result;
+}
+//#endregion
+export { spliceDelete };

package/dist/array/splice/index.d.ts

@@ -0,0 +1,3 @@
+export * from './delete';
+export * from './insert';
+export * from './replace';

package/dist/array/splice/insert.cjs

@@ -0,0 +1,13 @@
+//#region scripts/array/splice/insert.ts
+function spliceInsert(...args) {
+	if (args.length === 2) {
+		const [indexFrom, elements] = args;
+		return (array) => spliceInsert(array, indexFrom, elements);
+	}
+	const [array, indexFrom, elements] = args;
+	const result = array.slice();
+	result.splice(indexFrom, 0, ...elements);
+	return result;
+}
+//#endregion
+exports.spliceInsert = spliceInsert;

package/dist/array/splice/insert.d.ts

@@ -0,0 +1,5 @@
+import { ReapplyCompatiblesConstraints } from '../constraints';
+type SpliceInsertOutput<GenericArray extends readonly unknown[], GenericElements extends readonly unknown[]> = ReapplyCompatiblesConstraints<GenericArray, readonly (GenericArray[number] | GenericElements[number])[], "minElements">;
+export declare function spliceInsert<GenericElements extends readonly unknown[]>(indexFrom: number, elements: GenericElements): <GenericArray extends readonly unknown[]>(array: GenericArray) => SpliceInsertOutput<GenericArray, GenericElements>;
+export declare function spliceInsert<GenericArray extends readonly unknown[], GenericElements extends readonly unknown[]>(array: GenericArray, indexFrom: number, elements: GenericElements): SpliceInsertOutput<GenericArray, GenericElements>;
+export {};

package/dist/array/splice/insert.mjs

@@ -0,0 +1,13 @@
+//#region scripts/array/splice/insert.ts
+function spliceInsert(...args) {
+	if (args.length === 2) {
+		const [indexFrom, elements] = args;
+		return (array) => spliceInsert(array, indexFrom, elements);
+	}
+	const [array, indexFrom, elements] = args;
+	const result = array.slice();
+	result.splice(indexFrom, 0, ...elements);
+	return result;
+}
+//#endregion
+export { spliceInsert };

package/dist/array/splice/replace.cjs

@@ -0,0 +1,13 @@
+//#region scripts/array/splice/replace.ts
+function spliceReplace(...args) {
+	if (args.length === 2) {
+		const [indexFrom, elements] = args;
+		return (array) => spliceReplace(array, indexFrom, elements);
+	}
+	const [array, indexFrom, elements] = args;
+	const result = array.slice();
+	result.splice(indexFrom, elements.length, ...elements);
+	return result;
+}
+//#endregion
+exports.spliceReplace = spliceReplace;

package/dist/array/splice/replace.d.ts

@@ -0,0 +1,2 @@
+export declare function spliceReplace<GenericElements extends readonly unknown[]>(indexFrom: number, elements: GenericElements): <GenericArray extends readonly unknown[]>(array: GenericArray) => (GenericArray[number] | GenericElements[number])[];
+export declare function spliceReplace<GenericArray extends readonly unknown[], GenericElements extends readonly unknown[]>(array: GenericArray, indexFrom: number, elements: GenericElements): (GenericArray[number] | GenericElements[number])[];

package/dist/array/splice/replace.mjs

@@ -0,0 +1,13 @@
+//#region scripts/array/splice/replace.ts
+function spliceReplace(...args) {
+	if (args.length === 2) {
+		const [indexFrom, elements] = args;
+		return (array) => spliceReplace(array, indexFrom, elements);
+	}
+	const [array, indexFrom, elements] = args;
+	const result = array.slice();
+	result.splice(indexFrom, elements.length, ...elements);
+	return result;
+}
+//#endregion
+export { spliceReplace };

package/dist/array/types/index.d.ts

@@ -0,0 +1 @@
+export type * from './unwrap';

package/dist/array/types/unwrap.d.ts

@@ -0,0 +1 @@
+export type Unwrap<GenericValue extends unknown> = GenericValue extends readonly (infer InferredElement)[] ? InferredElement : GenericValue;

package/dist/array/unshift.cjs

@@ -0,0 +1,11 @@
+//#region scripts/array/unshift.ts
+function unshift(...args) {
+	if (args.length === 1) {
+		const [value] = args;
+		return (array) => unshift(array, value);
+	}
+	const [array, ...values] = args;
+	return [...values, ...array];
+}
+//#endregion
+exports.unshift = unshift;

package/dist/array/unshift.d.ts

@@ -0,0 +1,5 @@
+import { ReapplyCompatiblesConstraints } from './constraints';
+type UnshiftOutput<GenericArray extends readonly unknown[], GenericValue extends unknown, GenericValuesRest extends readonly unknown[] = []> = ReapplyCompatiblesConstraints<GenericArray, readonly (GenericValue | GenericValuesRest[number] | GenericArray[number])[], "minElements">;
+export declare function unshift<GenericArray extends readonly unknown[], GenericValue extends unknown>(value: GenericValue): (array: GenericArray) => UnshiftOutput<GenericArray, GenericValue>;
+export declare function unshift<GenericArray extends readonly unknown[], GenericValue extends unknown, GenericValuesRest extends readonly unknown[]>(array: GenericArray, value: GenericValue, ...valuesRest: GenericValuesRest): UnshiftOutput<GenericArray, GenericValue, GenericValuesRest>;
+export {};

package/dist/array/unshift.mjs

@@ -0,0 +1,11 @@
+//#region scripts/array/unshift.ts
+function unshift(...args) {
+	if (args.length === 1) {
+		const [value] = args;
+		return (array) => unshift(array, value);
+	}
+	const [array, ...values] = args;
+	return [...values, ...array];
+}
+//#endregion
+export { unshift };

package/dist/chrono/applyTimezone.cjs

@@ -0,0 +1,15 @@
+const require_theDate = require("./theDate.cjs");
+const require_toTimestamp = require("./toTimestamp.cjs");
+const require_getTimezoneOffset = require("./getTimezoneOffset.cjs");
+//#region scripts/chrono/applyTimezone.ts
+function applyTimezone(...args) {
+	if (args.length === 1) {
+		const [timeZone] = args;
+		return (date) => applyTimezone(date, timeZone);
+	}
+	const [date, timeZone] = args;
+	const timestamp = require_toTimestamp.toTimestamp(date);
+	return require_theDate.TheDate.new(timestamp - require_getTimezoneOffset.getTimezoneOffset(date, timeZone));
+}
+//#endregion
+exports.applyTimezone = applyTimezone;

package/dist/chrono/applyTimezone.d.ts

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

package/dist/chrono/applyTimezone.mjs

@@ -0,0 +1,15 @@
+import { TheDate } from "./theDate.mjs";
+import { toTimestamp } from "./toTimestamp.mjs";
+import { getTimezoneOffset } from "./getTimezoneOffset.mjs";
+//#region scripts/chrono/applyTimezone.ts
+function applyTimezone(...args) {
+	if (args.length === 1) {
+		const [timeZone] = args;
+		return (date) => applyTimezone(date, timeZone);
+	}
+	const [date, timeZone] = args;
+	const timestamp = toTimestamp(date);
+	return TheDate.new(timestamp - getTimezoneOffset(date, timeZone));
+}
+//#endregion
+export { applyTimezone };

package/dist/chrono/closestTo.cjs

@@ -0,0 +1,27 @@
+const require_theDate = require("./theDate.cjs");
+const require_toTimestamp = require("./toTimestamp.cjs");
+//#region scripts/chrono/closestTo.ts
+function closestTo(...args) {
+	if (typeof args[0] === "string" || args[0] instanceof require_theDate.TheDate) {
+		const [targetDate, params] = args;
+		return (dates) => closestTo(dates, targetDate, params);
+	}
+	const [dates, targetDate, params] = args;
+	const { tieBreaker } = params ?? {};
+	const targetTimestamp = require_toTimestamp.toTimestamp(targetDate);
+	let closest = void 0;
+	let smallestDiff = Number.POSITIVE_INFINITY;
+	for (const date of dates) {
+		const dateTimestamp = require_toTimestamp.toTimestamp(date);
+		if (tieBreaker === "favorPast" && dateTimestamp > targetTimestamp) continue;
+		if (tieBreaker === "favorFuture" && dateTimestamp < targetTimestamp) continue;
+		const distance = Math.abs(dateTimestamp - targetTimestamp);
+		if (distance < smallestDiff) {
+			smallestDiff = distance;
+			closest = date instanceof require_theDate.TheDate ? date : require_theDate.TheDate.new(dateTimestamp);
+		}
+	}
+	return closest;
+}
+//#endregion
+exports.closestTo = closestTo;

package/dist/chrono/closestTo.d.ts

@@ -0,0 +1,7 @@
+import { TheDate } from './theDate';
+import { SerializedTheDate } from './types';
+export interface ClosestToParams {
+    tieBreaker?: "favorPast" | "favorFuture";
+}
+export declare function closestTo(targetDate: TheDate | SerializedTheDate, params?: ClosestToParams): (dates: Iterable<TheDate | SerializedTheDate>) => TheDate | undefined;
+export declare function closestTo(dates: Iterable<TheDate | SerializedTheDate>, targetDate: TheDate | SerializedTheDate, params?: ClosestToParams): TheDate | undefined;

package/dist/chrono/closestTo.mjs

@@ -0,0 +1,27 @@
+import { TheDate } from "./theDate.mjs";
+import { toTimestamp } from "./toTimestamp.mjs";
+//#region scripts/chrono/closestTo.ts
+function closestTo(...args) {
+	if (typeof args[0] === "string" || args[0] instanceof TheDate) {
+		const [targetDate, params] = args;
+		return (dates) => closestTo(dates, targetDate, params);
+	}
+	const [dates, targetDate, params] = args;
+	const { tieBreaker } = params ?? {};
+	const targetTimestamp = toTimestamp(targetDate);
+	let closest = void 0;
+	let smallestDiff = Number.POSITIVE_INFINITY;
+	for (const date of dates) {
+		const dateTimestamp = toTimestamp(date);
+		if (tieBreaker === "favorPast" && dateTimestamp > targetTimestamp) continue;
+		if (tieBreaker === "favorFuture" && dateTimestamp < targetTimestamp) continue;
+		const distance = Math.abs(dateTimestamp - targetTimestamp);
+		if (distance < smallestDiff) {
+			smallestDiff = distance;
+			closest = date instanceof TheDate ? date : TheDate.new(dateTimestamp);
+		}
+	}
+	return closest;
+}
+//#endregion
+export { closestTo };

package/dist/chrono/computeTime.cjs

@@ -0,0 +1,21 @@
+const require_constants = require("./constants.cjs");
+const require_toTimeValue = require("./toTimeValue.cjs");
+//#region scripts/chrono/computeTime.ts
+const unitMapper = {
+	week: 1 / require_constants.millisecondInOneWeek,
+	day: 1 / require_constants.millisecondsInOneDay,
+	hour: 1 / require_constants.millisecondInOneHour,
+	minute: 1 / require_constants.millisecondInOneMinute,
+	second: 1 / require_constants.millisecondsInOneSecond,
+	millisecond: 1
+};
+function computeTime(...args) {
+	if (args.length === 1) {
+		const [unit] = args;
+		return (time) => computeTime(time, unit);
+	}
+	const [time, unit] = args;
+	return require_toTimeValue.toTimeValue(time) * unitMapper[unit];
+}
+//#endregion
+exports.computeTime = computeTime;

package/dist/chrono/computeTime.d.ts

@@ -0,0 +1,5 @@
+import { TheTime } from './theTime';
+import { SerializedTheTime } from './types';
+export type ComputeTimeUnit = "week" | "day" | "hour" | "minute" | "second" | "millisecond";
+export declare function computeTime<GenericTime extends TheTime | SerializedTheTime>(unit: ComputeTimeUnit): (time: GenericTime) => number;
+export declare function computeTime(time: TheTime | SerializedTheTime, unit: ComputeTimeUnit): number;

package/dist/chrono/computeTime.mjs

@@ -0,0 +1,21 @@
+import { millisecondInOneHour, millisecondInOneMinute, millisecondInOneWeek, millisecondsInOneDay, millisecondsInOneSecond } from "./constants.mjs";
+import { toTimeValue } from "./toTimeValue.mjs";
+//#region scripts/chrono/computeTime.ts
+const unitMapper = {
+	week: 1 / millisecondInOneWeek,
+	day: 1 / millisecondsInOneDay,
+	hour: 1 / millisecondInOneHour,
+	minute: 1 / millisecondInOneMinute,
+	second: 1 / millisecondsInOneSecond,
+	millisecond: 1
+};
+function computeTime(...args) {
+	if (args.length === 1) {
+		const [unit] = args;
+		return (time) => computeTime(time, unit);
+	}
+	const [time, unit] = args;
+	return toTimeValue(time) * unitMapper[unit];
+}
+//#endregion
+export { computeTime };

package/dist/chrono/constants.cjs

@@ -0,0 +1,28 @@
+//#region scripts/chrono/constants.ts
+const minTimestamp = -864e13;
+const maxTimestamp = 864e13;
+const minTimeValue = -9007199254740991;
+const maxTimeValue = 9007199254740991;
+const millisecondInOneWeek = 6048e5;
+const millisecondsInOneDay = 864e5;
+const millisecondInOneHour = 36e5;
+const millisecondInOneMinute = 6e4;
+const millisecondsInOneSecond = 1e3;
+const serializeTheDateRegex = /^date-?(?<value>\d{1,16})(?<sign>[+-])$/;
+const isoDateRegex = /^(?<year>-?[0-9]{4})-(?<month>[0-9]{2})-(?<date>[0-9]{2})(?:T(?<hour>[0-9]{2}):(?<minute>[0-9]{2}):(?<second>[0-9]{2})(?:\.(?<millisecond>[0-9]{3}))?Z?)?$/;
+const serializeTheTimeRegex = /^time-?(?<value>\d{1,16})(?<sign>[+-])$/;
+const isoTimeRegex = /^(?<sign>[+-])?(?<hour>[0-9]{2}):(?<minute>[0-9]{2})(?::(?<second>[0-9]{2})(?:\.(?<millisecond>[0-9]{3}))?Z?)?$/;
+//#endregion
+exports.isoDateRegex = isoDateRegex;
+exports.isoTimeRegex = isoTimeRegex;
+exports.maxTimeValue = maxTimeValue;
+exports.maxTimestamp = maxTimestamp;
+exports.millisecondInOneHour = millisecondInOneHour;
+exports.millisecondInOneMinute = millisecondInOneMinute;
+exports.millisecondInOneWeek = millisecondInOneWeek;
+exports.millisecondsInOneDay = millisecondsInOneDay;
+exports.millisecondsInOneSecond = millisecondsInOneSecond;
+exports.minTimeValue = minTimeValue;
+exports.minTimestamp = minTimestamp;
+exports.serializeTheDateRegex = serializeTheDateRegex;
+exports.serializeTheTimeRegex = serializeTheTimeRegex;

package/dist/chrono/constants.d.ts

@@ -0,0 +1,18 @@
+export declare const minTimestamp = -8640000000000000;
+export declare const maxTimestamp = 8640000000000000;
+export declare const minTimeValue = -9007199254740991;
+export declare const maxTimeValue = 9007199254740991;
+export declare const millisecondInOneWeek = 604800000;
+export declare const millisecondsInOneDay = 86400000;
+export declare const millisecondInOneHour = 3600000;
+export declare const millisecondInOneMinute = 60000;
+export declare const millisecondsInOneSecond = 1000;
+export declare const daysInOneWeek = 7;
+export declare const monthsInOneYear = 12;
+export declare const minutesInOneHour = 60;
+export declare const secondsInOneMinute = 60;
+export declare const hoursInOneDay = 24;
+export declare const serializeTheDateRegex: RegExp;
+export declare const isoDateRegex: RegExp;
+export declare const serializeTheTimeRegex: RegExp;
+export declare const isoTimeRegex: RegExp;

package/dist/chrono/constants.mjs

@@ -0,0 +1,16 @@
+//#region scripts/chrono/constants.ts
+const minTimestamp = -864e13;
+const maxTimestamp = 864e13;
+const minTimeValue = -9007199254740991;
+const maxTimeValue = 9007199254740991;
+const millisecondInOneWeek = 6048e5;
+const millisecondsInOneDay = 864e5;
+const millisecondInOneHour = 36e5;
+const millisecondInOneMinute = 6e4;
+const millisecondsInOneSecond = 1e3;
+const serializeTheDateRegex = /^date-?(?<value>\d{1,16})(?<sign>[+-])$/;
+const isoDateRegex = /^(?<year>-?[0-9]{4})-(?<month>[0-9]{2})-(?<date>[0-9]{2})(?:T(?<hour>[0-9]{2}):(?<minute>[0-9]{2}):(?<second>[0-9]{2})(?:\.(?<millisecond>[0-9]{3}))?Z?)?$/;
+const serializeTheTimeRegex = /^time-?(?<value>\d{1,16})(?<sign>[+-])$/;
+const isoTimeRegex = /^(?<sign>[+-])?(?<hour>[0-9]{2}):(?<minute>[0-9]{2})(?::(?<second>[0-9]{2})(?:\.(?<millisecond>[0-9]{3}))?Z?)?$/;
+//#endregion
+export { isoDateRegex, isoTimeRegex, maxTimeValue, maxTimestamp, millisecondInOneHour, millisecondInOneMinute, millisecondInOneWeek, millisecondsInOneDay, millisecondsInOneSecond, minTimeValue, minTimestamp, serializeTheDateRegex, serializeTheTimeRegex };

package/dist/chrono/createDate.cjs

@@ -0,0 +1,68 @@
+const require_constants = require("./constants.cjs");
+const require_theDate = require("./theDate.cjs");
+const require_isDate = require("./isDate.cjs");
+const require_create = require("../either/left/create.cjs");
+const require_is = require("../either/left/is.cjs");
+const require_when = require("../either/left/when.cjs");
+const require_create$1 = require("../either/right/create.cjs");
+const require_unwrap = require("../either/right/unwrap.cjs");
+const require_safeCallback = require("../either/safeCallback.cjs");
+const require_isSafeTimestamp = require("./isSafeTimestamp.cjs");
+const require_toNative = require("./toNative.cjs");
+const require_applyTimezone = require("./applyTimezone.cjs");
+//#region scripts/chrono/createDate.ts
+const safeDateRegex = /^(?<year>-?[0-9]+)-(?<monthWithDay>[0-1][0-9]-[0-3][0-9])$/;
+function createDate(input, params) {
+	if (typeof input === "number") return createFromTimestamp(input);
+	if (input instanceof Date) return createFromTimestamp(input.getTime());
+	const serializeTheDateMatch = typeof input === "string" && input.match(require_constants.serializeTheDateRegex);
+	if (serializeTheDateMatch) {
+		const { value, sign } = serializeTheDateMatch.groups;
+		return createFromTimestamp(Number(sign === "-" ? `-${value}` : value));
+	}
+	const safeDateMatch = typeof input === "string" && input.match(safeDateRegex);
+	if (safeDateMatch) {
+		const { year, monthWithDay } = safeDateMatch.groups;
+		const date = /* @__PURE__ */ new Date(`0004-${monthWithDay}T${params?.hour ?? "00"}:${params?.minute ?? "00"}:${params?.second ?? "00"}.${params?.millisecond ?? "000"}Z`);
+		date.setUTCFullYear(Number(year));
+		return require_theDate.TheDate.new(date.getTime());
+	}
+	if (typeof input === "object") {
+		let inputValueResult = void 0;
+		const serializeTheDateMatch = typeof input.value === "string" && input.value.match(require_constants.serializeTheDateRegex);
+		if (serializeTheDateMatch) {
+			const { value, sign } = serializeTheDateMatch.groups;
+			inputValueResult = createFromTimestamp(Number(sign === "-" ? `-${value}` : value));
+		} else if (require_isDate.isDate(input.value)) inputValueResult = require_create$1.right("date-created", input.value);
+		else if (input.value instanceof Date) inputValueResult = createFromTimestamp(input.value.getTime());
+		else if (typeof input.value === "number") inputValueResult = createFromTimestamp(input.value);
+		else {
+			const isoDateMatch = input.value.match(require_constants.isoDateRegex);
+			if (isoDateMatch) {
+				const { year, month, date, hour, minute, second, millisecond } = isoDateMatch.groups;
+				inputValueResult = createFromTimestamp(Date.UTC(Number(year), Number(month) - 1, Number(date), typeof hour === "string" ? Number(hour) : 0, typeof minute === "string" ? Number(minute) : 0, typeof second === "string" ? Number(second) : 0, typeof millisecond === "string" ? Number(millisecond) : 0));
+			}
+		}
+		if (!inputValueResult || require_is.isLeft(inputValueResult)) return inputValueResult || require_create.left("date-created-error", null);
+		const date = require_toNative.toNative(require_unwrap.unwrapRight(inputValueResult));
+		input.year && date.setUTCFullYear(input.year);
+		input.month && date.setMonth(input.month);
+		input.day && date.setDate(input.day);
+		input.hour && date.setHours(input.hour);
+		input.minute && date.setMinutes(input.minute);
+		input.second && date.setSeconds(input.second);
+		input.millisecond && date.setMilliseconds(input.millisecond);
+		const result = createFromTimestamp(date.getTime());
+		if (require_is.isLeft(result)) return result;
+		const timezone = input.timezone;
+		if (!timezone) return result;
+		return require_when.whenIsLeft(require_safeCallback.safeCallback(() => require_create$1.right("date-created", require_applyTimezone.applyTimezone(require_unwrap.unwrapRight(result), timezone))), () => require_create.left("date-created-error", null));
+	}
+	return require_create.left("date-created-error", null);
+}
+function createFromTimestamp(timestamp) {
+	if (!require_isSafeTimestamp.isSafeTimestamp(timestamp)) return require_create.left("date-created-error", null);
+	return require_create$1.right("date-created", require_theDate.TheDate.new(timestamp));
+}
+//#endregion
+exports.createDate = createDate;

package/dist/chrono/createDate.d.ts

@@ -0,0 +1,21 @@
+import { TheDate } from './theDate';
+import { Hour, IsLeapYear, IsSafeYear, Millisecond, Minute, Second, MonthWithDay, SpoolingDate, SerializedTheDate } from './types';
+import * as DEither from '../either';
+import type * as DCommon from '../common';
+import type * as DString from '../string';
+export type MayBe = DEither.Right<"date-created", TheDate> | DEither.Left<"date-created-error", null>;
+type SafeDate = `${number}-${MonthWithDay}`;
+type ForbiddenDate<GenericDate extends string> = DCommon.And<[
+    DCommon.IsExtends<GenericDate, SafeDate>,
+    DCommon.Not<DCommon.IsEqual<GenericDate, SafeDate>>
+]> extends true ? ((DString.Includes<GenericDate, "."> extends true ? DCommon.ComputedTypeError<"Year can't be includes a float number."> : GenericDate) & (GenericDate extends `${infer InferredYear extends number}-02-29` ? IsLeapYear<InferredYear> extends true ? GenericDate : DCommon.ComputedTypeError<"Is not a leap year."> : GenericDate) & (GenericDate extends `${infer InferredYear extends number}-${MonthWithDay}` ? IsSafeYear<InferredYear> extends true ? GenericDate : DCommon.ComputedTypeError<"Support that the years between -271820 and 275759."> : GenericDate)) : GenericDate;
+export interface CreateSafeDateParams {
+    hour?: Hour;
+    minute?: Minute;
+    second?: Second;
+    millisecond?: Millisecond;
+}
+export declare function createDate<GenericInput extends TheDate | Date | number | SerializedTheDate>(input: GenericInput): MayBe;
+export declare function createDate<GenericInput extends SpoolingDate>(input: GenericInput): MayBe;
+export declare function createDate<GenericInput extends SafeDate>(input: GenericInput & ForbiddenDate<GenericInput>, params?: CreateSafeDateParams): TheDate;
+export {};

package/dist/chrono/createDate.mjs

@@ -0,0 +1,68 @@
+import { isoDateRegex, serializeTheDateRegex } from "./constants.mjs";
+import { TheDate } from "./theDate.mjs";
+import { isDate } from "./isDate.mjs";
+import { left } from "../either/left/create.mjs";
+import { isLeft } from "../either/left/is.mjs";
+import { whenIsLeft } from "../either/left/when.mjs";
+import { right } from "../either/right/create.mjs";
+import { unwrapRight } from "../either/right/unwrap.mjs";
+import { safeCallback } from "../either/safeCallback.mjs";
+import { isSafeTimestamp } from "./isSafeTimestamp.mjs";
+import { toNative } from "./toNative.mjs";
+import { applyTimezone } from "./applyTimezone.mjs";
+//#region scripts/chrono/createDate.ts
+const safeDateRegex = /^(?<year>-?[0-9]+)-(?<monthWithDay>[0-1][0-9]-[0-3][0-9])$/;
+function createDate(input, params) {
+	if (typeof input === "number") return createFromTimestamp(input);
+	if (input instanceof Date) return createFromTimestamp(input.getTime());
+	const serializeTheDateMatch = typeof input === "string" && input.match(serializeTheDateRegex);
+	if (serializeTheDateMatch) {
+		const { value, sign } = serializeTheDateMatch.groups;
+		return createFromTimestamp(Number(sign === "-" ? `-${value}` : value));
+	}
+	const safeDateMatch = typeof input === "string" && input.match(safeDateRegex);
+	if (safeDateMatch) {
+		const { year, monthWithDay } = safeDateMatch.groups;
+		const date = /* @__PURE__ */ new Date(`0004-${monthWithDay}T${params?.hour ?? "00"}:${params?.minute ?? "00"}:${params?.second ?? "00"}.${params?.millisecond ?? "000"}Z`);
+		date.setUTCFullYear(Number(year));
+		return TheDate.new(date.getTime());
+	}
+	if (typeof input === "object") {
+		let inputValueResult = void 0;
+		const serializeTheDateMatch = typeof input.value === "string" && input.value.match(serializeTheDateRegex);
+		if (serializeTheDateMatch) {
+			const { value, sign } = serializeTheDateMatch.groups;
+			inputValueResult = createFromTimestamp(Number(sign === "-" ? `-${value}` : value));
+		} else if (isDate(input.value)) inputValueResult = right("date-created", input.value);
+		else if (input.value instanceof Date) inputValueResult = createFromTimestamp(input.value.getTime());
+		else if (typeof input.value === "number") inputValueResult = createFromTimestamp(input.value);
+		else {
+			const isoDateMatch = input.value.match(isoDateRegex);
+			if (isoDateMatch) {
+				const { year, month, date, hour, minute, second, millisecond } = isoDateMatch.groups;
+				inputValueResult = createFromTimestamp(Date.UTC(Number(year), Number(month) - 1, Number(date), typeof hour === "string" ? Number(hour) : 0, typeof minute === "string" ? Number(minute) : 0, typeof second === "string" ? Number(second) : 0, typeof millisecond === "string" ? Number(millisecond) : 0));
+			}
+		}
+		if (!inputValueResult || isLeft(inputValueResult)) return inputValueResult || left("date-created-error", null);
+		const date = toNative(unwrapRight(inputValueResult));
+		input.year && date.setUTCFullYear(input.year);
+		input.month && date.setMonth(input.month);
+		input.day && date.setDate(input.day);
+		input.hour && date.setHours(input.hour);
+		input.minute && date.setMinutes(input.minute);
+		input.second && date.setSeconds(input.second);
+		input.millisecond && date.setMilliseconds(input.millisecond);
+		const result = createFromTimestamp(date.getTime());
+		if (isLeft(result)) return result;
+		const timezone = input.timezone;
+		if (!timezone) return result;
+		return whenIsLeft(safeCallback(() => right("date-created", applyTimezone(unwrapRight(result), timezone))), () => left("date-created-error", null));
+	}
+	return left("date-created-error", null);
+}
+function createFromTimestamp(timestamp) {
+	if (!isSafeTimestamp(timestamp)) return left("date-created-error", null);
+	return right("date-created", TheDate.new(timestamp));
+}
+//#endregion
+export { createDate };

package/dist/chrono/createDateOrThrow.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_createDate = require("./createDate.cjs");
+//#region scripts/chrono/createDateOrThrow.ts
+var CreateTheDateError = class extends require_parentClass.parentClass(require_kind.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 = require_createDate.createDate(input);
+	if (require_is.isLeft(result)) throw new CreateTheDateError(input);
+	return require_unwrap.unwrapRight(result);
+}
+//#endregion
+exports.CreateTheDateError = CreateTheDateError;
+exports.createDateOrThrow = createDateOrThrow;

package/dist/chrono/createDateOrThrow.d.ts

@@ -0,0 +1,11 @@
+import { SerializedTheDate, SpoolingDate } from './types';
+import { TheDate } from './theDate';
+import * as DKind from '../kind';
+declare const CreateTheDateError_base: DKind.KindClass<DKind.Handler<DKind.Definition<"@DuplojsLangChrono/create-the-date-error", unknown>>, ErrorConstructor>;
+export declare class CreateTheDateError extends CreateTheDateError_base {
+    input: string | Date | number | SpoolingDate | TheDate;
+    constructor(input: string | Date | number | SpoolingDate | TheDate);
+}
+export declare function createDateOrThrow<GenericInput extends TheDate | Date | number | SerializedTheDate>(input: GenericInput): TheDate;
+export declare function createDateOrThrow<GenericInput extends SpoolingDate>(input: GenericInput): TheDate;
+export {};