@duplojs/utils 1.4.57 → 1.4.59

package/dist/date/applyTimezone.cjs

@@ -1,17 +1,17 @@
 'use strict';
 
-var createOrThrow = require('./createOrThrow.cjs');
 var getTimezoneOffset = require('./getTimezoneOffset.cjs');
 var toTimestamp = require('./toTimestamp.cjs');
+var theDate = require('./theDate.cjs');
 
 function applyTimezone(...args) {
     if (args.length === 1) {
         const [timeZone] = args;
         return (theDate) => applyTimezone(theDate, timeZone);
     }
-    const [theDate, timeZone] = args;
-    const timestamp = toTimestamp.toTimestamp(theDate);
-    return createOrThrow.createOrThrow(timestamp - getTimezoneOffset.getTimezoneOffset(theDate, timeZone));
+    const [theDate$1, timeZone] = args;
+    const timestamp = toTimestamp.toTimestamp(theDate$1);
+    return theDate.TheDate.new(timestamp - getTimezoneOffset.getTimezoneOffset(theDate$1, timeZone));
 }
 
 exports.applyTimezone = applyTimezone;

package/dist/date/applyTimezone.d.ts

@@ -1,33 +1,35 @@
-import { type Timezone } from "./timezone";
-import { type TheDate } from "./types";
+import type { Timezone } from "./timezone";
+import { TheDate } from "./theDate";
+import type { SerializedTheDate } from "./types";
 /**
- * Applies a timezone to a date.
+ * Applies a timezone offset to a date and returns the shifted `TheDate`.
  * 
  * **Supported call styles:**
- * - Classic: `applyTimezone(timeZone)` → returns a value
- * - Curried: `applyTimezone(theDate, timeZone)` → returns a function waiting for the input
+ * - Classic: `applyTimezone(input, timeZone)` → `TheDate`
+ * - Curried: `applyTimezone(timeZone)` → `(input) => TheDate`
  * 
- * The input value is not mutated.
+ * `input` accepts `TheDate` or `SerializedTheDate`.
  * 
  * ```ts
- * const theDate = D.createOrThrow(1704067200000);
- * const shiftedDate = D.applyTimezone(theDate, "America/New_York");
- * // shiftedDate: "date1704085200000+"
+ * const input = D.create("2024-01-01", {
+ * 	hour: "00",
+ * });
  * 
- * pipe(
- * 	theDate,
- * 	D.applyTimezone("America/New_York"),
- * ); // shiftedDate: "date1704085200000+"
+ * const shifted = D.applyTimezone(input, "America/New_York");
+ * // shifted: TheDate
  * 
+ * pipe(
+ * 	input,
+ * 	D.applyTimezone("Europe/Paris"),
  * ```
  * 
  * @remarks
- * - Applies the timezone offset to shift the date.
+ * - This is a timestamp shift based on the target timezone offset.
  * 
  * @see https://utils.duplojs.dev/en/v1/api/date/applyTimezone
  * 
  * @namespace D
  * 
  */
-export declare function applyTimezone(timeZone: Timezone): (theDate: TheDate) => TheDate;
-export declare function applyTimezone(theDate: TheDate, timeZone: Timezone): TheDate;
+export declare function applyTimezone(timeZone: Timezone): (input: TheDate | SerializedTheDate) => TheDate;
+export declare function applyTimezone(input: TheDate | SerializedTheDate, timeZone: Timezone): TheDate;

package/dist/date/applyTimezone.mjs

@@ -1,6 +1,6 @@
-import { createOrThrow } from './createOrThrow.mjs';
 import { getTimezoneOffset } from './getTimezoneOffset.mjs';
 import { toTimestamp } from './toTimestamp.mjs';
+import { TheDate } from './theDate.mjs';
 
 function applyTimezone(...args) {
     if (args.length === 1) {
@@ -9,7 +9,7 @@ function applyTimezone(...args) {
     }
     const [theDate, timeZone] = args;
     const timestamp = toTimestamp(theDate);
-    return createOrThrow(timestamp - getTimezoneOffset(theDate, timeZone));
+    return TheDate.new(timestamp - getTimezoneOffset(theDate, timeZone));
 }
 
 export { applyTimezone };

package/dist/date/closestTo.cjs

@@ -1,9 +1,10 @@
 'use strict';
 
+var theDate = require('./theDate.cjs');
 var toTimestamp = require('./toTimestamp.cjs');
 
 function closestTo(...args) {
-    if (typeof args[0] === "string") {
+    if (typeof args[0] === "string" || args[0] instanceof theDate.TheDate) {
         const [target, params] = args;
         return (input) => closestTo(input, target, params);
     }
@@ -23,7 +24,10 @@ function closestTo(...args) {
         const distance = Math.abs(valueTimestamp - targetTimestamp);
         if (distance < smallestDiff) {
             smallestDiff = distance;
-            closest = value;
+            if (value instanceof theDate.TheDate) {
+                closest = value;
+            }
+            closest = theDate.TheDate.new(valueTimestamp);
         }
     }
     return closest;

package/dist/date/closestTo.d.ts

@@ -1,15 +1,14 @@
-import type { TheDate } from "./types";
+import { TheDate } from "./theDate";
+import type { SerializedTheDate } from "./types";
 interface ClosestToParams {
     tieBreaker?: "favorPast" | "favorFuture";
 }
 /**
- * Finds the closest date to a target.
+ * Finds the closest date from an iterable relative to a target date.
  * 
  * **Supported call styles:**
- * - Classic: `closestTo(input, target, params?)` → returns a value
- * - Curried: `closestTo(target, params?)` → returns a function waiting for the input
- * 
- * The input value is not mutated.
+ * - Classic: `closestTo(input, target, params?)` → `TheDate | undefined`
+ * - Curried: `closestTo(target, params?)` → `(input) => TheDate | undefined`
  * 
  * ```ts
  * const inputs = [
@@ -19,24 +18,25 @@ interface ClosestToParams {
  * ] as const;
  * 
  * const target = D.create("2024-06-15");
- * const result = D.closestTo(inputs, target);
- * // result: "date1717996800000+" (10 June 2024)
+ * const nearest = D.closestTo(inputs, target);
+ * // nearest: TheDate | undefined
  * 
- * pipe(
- * 	inputs,
- * 	D.closestTo(target),
- * ); // result: "date1717996800000+" (10 June 2024)
+ * const nearestPast = D.closestTo(inputs, target, {
+ * 	tieBreaker: "favorPast",
+ * });
+ * // nearestPast: TheDate | undefined
  * 
  * ```
  * 
  * @remarks
- * - `tieBreaker` can be "favorPast" or "favorFuture" to resolve equidistant dates.
+ * - `tieBreaker: "favorPast"` ignores future candidates.
+ * - `tieBreaker: "favorFuture"` ignores past candidates.
  * 
  * @see https://utils.duplojs.dev/en/v1/api/date/closestTo
  * 
  * @namespace D
  * 
  */
-export declare function closestTo<GenericIterable extends Iterable<TheDate>>(target: TheDate, params?: ClosestToParams): (input: GenericIterable) => TheDate | undefined;
-export declare function closestTo<GenericIterable extends Iterable<TheDate>>(input: GenericIterable, target: TheDate, params?: ClosestToParams): TheDate | undefined;
+export declare function closestTo<GenericIterable extends Iterable<TheDate | SerializedTheDate>>(target: TheDate | SerializedTheDate, params?: ClosestToParams): (input: GenericIterable) => TheDate | undefined;
+export declare function closestTo<GenericIterable extends Iterable<TheDate | SerializedTheDate>>(input: GenericIterable, target: TheDate | SerializedTheDate, params?: ClosestToParams): TheDate | undefined;
 export {};

package/dist/date/closestTo.mjs

@@ -1,7 +1,8 @@
+import { TheDate } from './theDate.mjs';
 import { toTimestamp } from './toTimestamp.mjs';
 
 function closestTo(...args) {
-    if (typeof args[0] === "string") {
+    if (typeof args[0] === "string" || args[0] instanceof TheDate) {
         const [target, params] = args;
         return (input) => closestTo(input, target, params);
     }
@@ -21,7 +22,10 @@ function closestTo(...args) {
         const distance = Math.abs(valueTimestamp - targetTimestamp);
         if (distance < smallestDiff) {
             smallestDiff = distance;
-            closest = value;
+            if (value instanceof TheDate) {
+                closest = value;
+            }
+            closest = TheDate.new(valueTimestamp);
         }
     }
     return closest;

package/dist/date/constants.cjs

@@ -14,9 +14,9 @@ const monthsInOneYear = 12;
 const minutesInOneHour = 60;
 const secondsInOneMinute = 60;
 const hoursInOneDay = 24;
-const theDateRegex = /^date-?(?<value>\d{1,16})(?<sign>[+-])$/;
+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 theTimeRegex = /^time-?(?<value>\d{1,16})(?<sign>[+-])$/;
+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?)?$/;
 
 exports.daysInOneWeek = daysInOneWeek;
@@ -35,5 +35,5 @@ exports.minTimestamp = minTimestamp;
 exports.minutesInOneHour = minutesInOneHour;
 exports.monthsInOneYear = monthsInOneYear;
 exports.secondsInOneMinute = secondsInOneMinute;
-exports.theDateRegex = theDateRegex;
-exports.theTimeRegex = theTimeRegex;
+exports.serializeTheDateRegex = serializeTheDateRegex;
+exports.serializeTheTimeRegex = serializeTheTimeRegex;

package/dist/date/constants.d.ts

@@ -12,7 +12,7 @@ export declare const monthsInOneYear = 12;
 export declare const minutesInOneHour = 60;
 export declare const secondsInOneMinute = 60;
 export declare const hoursInOneDay = 24;
-export declare const theDateRegex: RegExp;
+export declare const serializeTheDateRegex: RegExp;
 export declare const isoDateRegex: RegExp;
-export declare const theTimeRegex: RegExp;
+export declare const serializeTheTimeRegex: RegExp;
 export declare const isoTimeRegex: RegExp;

package/dist/date/constants.mjs

@@ -12,9 +12,9 @@ const monthsInOneYear = 12;
 const minutesInOneHour = 60;
 const secondsInOneMinute = 60;
 const hoursInOneDay = 24;
-const theDateRegex = /^date-?(?<value>\d{1,16})(?<sign>[+-])$/;
+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 theTimeRegex = /^time-?(?<value>\d{1,16})(?<sign>[+-])$/;
+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?)?$/;
 
-export { daysInOneWeek, hoursInOneDay, isoDateRegex, isoTimeRegex, maxTimeValue, maxTimestamp, millisecondInOneHour, millisecondInOneMinute, millisecondInOneWeek, millisecondsInOneDay, millisecondsInOneSecond, minTimeValue, minTimestamp, minutesInOneHour, monthsInOneYear, secondsInOneMinute, theDateRegex, theTimeRegex };
+export { daysInOneWeek, hoursInOneDay, isoDateRegex, isoTimeRegex, maxTimeValue, maxTimestamp, millisecondInOneHour, millisecondInOneMinute, millisecondInOneWeek, millisecondsInOneDay, millisecondsInOneSecond, minTimeValue, minTimestamp, minutesInOneHour, monthsInOneYear, secondsInOneMinute, serializeTheDateRegex, serializeTheTimeRegex };

package/dist/date/create.cjs

@@ -5,7 +5,7 @@ var isSafeTimestamp = require('./isSafeTimestamp.cjs');
 var applyTimezone = require('./applyTimezone.cjs');
 var is = require('./is.cjs');
 var toNative = require('./toNative.cjs');
-var createTheDate = require('./createTheDate.cjs');
+var theDate = require('./theDate.cjs');
 var create$1 = require('../either/right/create.cjs');
 var is$1 = require('../either/left/is.cjs');
 var create$2 = require('../either/left/create.cjs');
@@ -21,28 +21,38 @@ function create(input, params) {
     if (input instanceof Date) {
         return createFromTimestamp(input.getTime());
     }
-    if (typeof input === "string" && is.is(input)) {
-        return create$1.right("date-created", input);
+    const serializeTheDateMatch = typeof input === "string" && input.match(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 = new Date(`0000-${monthWithDay}T${params?.hour ?? "00"}:${params?.minute ?? "00"}:${params?.second ?? "00"}.${params?.millisecond ?? "000"}Z`);
         date.setUTCFullYear(Number(year));
-        const timestamp = date.getTime();
-        return `date${Math.abs(timestamp)}${timestamp < 0 ? "-" : "+"}`;
+        return theDate.TheDate.new(date.getTime());
     }
     if (typeof input === "object") {
         let inputValueResult = undefined;
-        if (input.value instanceof Date) {
+        const serializeTheDateMatch = typeof input.value === "string" && input.value.match(constants.serializeTheDateRegex);
+        if (serializeTheDateMatch) {
+            const { value, sign } = serializeTheDateMatch.groups;
+            inputValueResult = createFromTimestamp(Number(sign === "-"
+                ? `-${value}`
+                : value));
+        }
+        else if (is.is(input.value)) {
+            inputValueResult = 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 if (is.is(input.value)) {
-            inputValueResult = create$1.right("date-created", input.value);
-        }
         else {
             const isoDateMatch = input.value.match(constants.isoDateRegex);
             if (isoDateMatch) {
@@ -77,7 +87,7 @@ function createFromTimestamp(input) {
     if (!isSafeTimestamp.isSafeTimestamp(input)) {
         return create$2.left("date-created-error", null);
     }
-    return create$1.right("date-created", createTheDate.createTheDate(input));
+    return create$1.right("date-created", theDate.TheDate.new(input));
 }
 
 exports.create = create;

package/dist/date/create.d.ts

@@ -1,7 +1,9 @@
-import type { Hour, IsLeapYear, IsSafeYear, Millisecond, Minute, Second, TheDate, MonthWithDay, SpoolingDate } from "./types";
+import type { Hour, IsLeapYear, IsSafeYear, Millisecond, Minute, Second, MonthWithDay, SpoolingDate } from "./types";
 import * as DEither from "../either";
 import type * as DString from "../string";
 import { type And, type IsEqual, type Not, type IsExtends } from "../common";
+import { TheDate } from "./theDate";
+import type { SerializedTheDate } from "./types/serializedTheDate";
 export type MayBe = DEither.Right<"date-created", TheDate> | DEither.Left<"date-created-error", null>;
 type SafeDate = `${number}-${MonthWithDay}`;
 declare const SymbolForbiddenDate: unique symbol;
@@ -22,58 +24,42 @@ interface SafeDateParams {
     millisecond?: Millisecond;
 }
 /**
- * Creates a TheDate from various inputs.
+ * Creates a `TheDate` from date-like inputs.
  * 
- * Signature: `create(input)` → returns a value
+ * Signature: `create(input, params?)` → `TheDate | MaybeEither<TheDate>`
  * 
- * The input value is not mutated.
+ * The return type depends on the overload:
+ * - Safe literal date strings (`YYYY-MM-DD`) return `TheDate` directly.
+ * - Runtime inputs (`number`, `Date`, `SerializedTheDate`, `SpoolingDate`, other strings) return `Either`.
  * 
  * ```ts
- * // Either<"date-created", TheDate>
- * const mayBeDateFromNativeDate = D.create(
- * 	new Date("2024-06-20T12:00:00Z"),
- * );
+ * const direct = D.create("2024-02-29", {
+ * 	hour: "10",
+ * 	minute: "30",
+ * });
+ * // direct: TheDate
  * 
- * // Either<"date-created", TheDate>
- * const mayBeDateFromTimestamp = D.create(
- * 	1_700_000_000_000,
- * );
- * 
- * // "date1709183400000+"
- * const dateFromSafeFormat = D.create(
- * 	"2024-02-29",
- * 	{
- * 		hour: "10",
- * 		minute: "30",
- * 	},
- * );
- * 
- * const dateWrongLeapYear = D.create(
- * 	// @ts-expect-error Safe with leap year.
- * 	"2023-02-29",
- * );
- * 
- * const dateWrongRangeYear = D.create(
- * 	// @ts-expect-error Safe against dates that fall outside the supported date range.
- * 	"-596126-12-30",
- * );
- * 
- * pipe(
- * 	"2024-02-29",
- * 	D.create,
- * ); // "date1709183400000+"
+ * const mayBeFromTimestamp = D.create(1_700_000_000_000);
+ * // mayBeFromTimestamp: Either.Right<"date-created", TheDate> | DEither.Left<"date-created-error", null>
  * 
+ * const mayBeFromSpooling = D.create({
+ * 	value: "2024-06-20T12:00:00Z",
+ * 	timezone: "Europe/Paris",
+ * });
+ * // mayBeFromSpooling: Either<"date-created", TheDate>
  * ```
  * 
  * @remarks
- * - Returns an Either tagged "date-created" or "date-created-error" for invalid inputs.
+ * - Use this API when you want a non-throwing creation flow.
+ * - For throwing behavior, use `createOrThrow`.
  * 
  * @see https://utils.duplojs.dev/en/v1/api/date/create
+ * @see https://utils.duplojs.dev/en/v1/api/date/createOrThrow
  * 
  * @namespace D
  * 
  */
-export declare function create<GenericInput extends TheDate | Date | number>(input: GenericInput): MayBe;
+export declare function create<GenericInput extends TheDate | Date | number | SerializedTheDate>(input: GenericInput): MayBe;
 export declare function create<GenericInput extends SpoolingDate>(input: GenericInput): MayBe;
 export declare function create<GenericInput extends SafeDate>(input: GenericInput & ForbiddenDate<GenericInput>, params?: SafeDateParams): TheDate;
 export {};

package/dist/date/create.mjs

@@ -1,9 +1,9 @@
-import { isoDateRegex } from './constants.mjs';
+import { serializeTheDateRegex, isoDateRegex } from './constants.mjs';
 import { isSafeTimestamp } from './isSafeTimestamp.mjs';
 import { applyTimezone } from './applyTimezone.mjs';
 import { is } from './is.mjs';
 import { toNative } from './toNative.mjs';
-import { createTheDate } from './createTheDate.mjs';
+import { TheDate } from './theDate.mjs';
 import { right } from '../either/right/create.mjs';
 import { isLeft } from '../either/left/is.mjs';
 import { left } from '../either/left/create.mjs';
@@ -19,28 +19,38 @@ function create(input, params) {
     if (input instanceof Date) {
         return createFromTimestamp(input.getTime());
     }
-    if (typeof input === "string" && is(input)) {
-        return right("date-created", input);
+    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 = new Date(`0000-${monthWithDay}T${params?.hour ?? "00"}:${params?.minute ?? "00"}:${params?.second ?? "00"}.${params?.millisecond ?? "000"}Z`);
         date.setUTCFullYear(Number(year));
-        const timestamp = date.getTime();
-        return `date${Math.abs(timestamp)}${timestamp < 0 ? "-" : "+"}`;
+        return TheDate.new(date.getTime());
     }
     if (typeof input === "object") {
         let inputValueResult = undefined;
-        if (input.value instanceof Date) {
+        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 (is(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 if (is(input.value)) {
-            inputValueResult = right("date-created", input.value);
-        }
         else {
             const isoDateMatch = input.value.match(isoDateRegex);
             if (isoDateMatch) {
@@ -75,7 +85,7 @@ function createFromTimestamp(input) {
     if (!isSafeTimestamp(input)) {
         return left("date-created-error", null);
     }
-    return right("date-created", createTheDate(input));
+    return right("date-created", TheDate.new(input));
 }
 
 export { create };

package/dist/date/createOrThrow.d.ts

@@ -1,46 +1,44 @@
-import type { TheDate, SpoolingDate } from "./types";
+import type { SerializedTheDate, SpoolingDate } from "./types";
+import type { TheDate } from "./theDate";
 declare const CreateTheDateError_base: new (params: {
     "@DuplojsUtilsError/create-the-date-error"?: unknown;
 }, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("../common").Kind<import("../common").KindDefinition<"create-the-date-error", unknown>, unknown> & import("../common").Kind<import("../common").KindDefinition<"@DuplojsUtilsError/create-the-date-error", unknown>, unknown>;
 export declare class CreateTheDateError extends CreateTheDateError_base {
-    input: string | Date | number | SpoolingDate;
-    constructor(input: string | Date | number | SpoolingDate);
+    input: string | Date | number | SpoolingDate | TheDate;
+    constructor(input: string | Date | number | SpoolingDate | TheDate);
 }
 /**
- * Creates a TheDate or throws on invalid input.
+ * Creates a `TheDate` and throws when input cannot be parsed or normalized.
  * 
- * Signature: `createOrThrow(input)` → returns a value
+ * Signature: `createOrThrow(input)` → `TheDate`
  * 
- * The input value is not mutated.
+ * `input` accepts the same runtime shapes as `create` (`Date`, `number`, `SerializedTheDate`, `SpoolingDate`, strings).
  * 
  * ```ts
- * const input = 1_700_000_000_000;
- * const result = D.createOrThrow(input);
- * // result: "date1700000000000+"
+ * const fromTimestamp = D.createOrThrow(1_700_000_000_000);
+ * // fromTimestamp: TheDate
  * 
- * const input2 = result;
- * const result2 = D.createOrThrow(input2);
- * // result2: "date1700000000000+"
+ * const fromSerialized = D.createOrThrow("date1700000000000+");
+ * // fromSerialized: TheDate
  * 
- * const input3 = new Date("2024-06-20T12:00:00Z");
- * const result3 = D.createOrThrow(input3);
- * // result3: "date1718884800000+"
+ * const fromDate = D.createOrThrow(new Date("2024-06-20T12:00:00Z"));
+ * // fromDate: TheDate
  * 
  * pipe(
- * 	input,
+ * 	fromTimestamp,
  * 	(value) => D.createOrThrow(value),
- * ); // result: "date1700000000000+"
- * 
+ * ); // TheDate
  * ```
  * 
  * @remarks
- * - Throws when the input cannot be converted to TheDate.
+ * - Throws `CreateTheDateError` on invalid input.
  * 
  * @see https://utils.duplojs.dev/en/v1/api/date/createOrThrow
+ * @see https://utils.duplojs.dev/en/v1/api/date/create
  * 
  * @namespace D
  * 
  */
-export declare function createOrThrow<GenericInput extends TheDate | Date | number>(input: GenericInput): TheDate;
+export declare function createOrThrow<GenericInput extends TheDate | Date | number | SerializedTheDate>(input: GenericInput): TheDate;
 export declare function createOrThrow<GenericInput extends SpoolingDate>(input: GenericInput): TheDate;
 export {};

package/dist/date/createTime.cjs

@@ -1,9 +1,8 @@
 'use strict';
 
 var constants = require('./constants.cjs');
-var createTheTime = require('./createTheTime.cjs');
 var isSafeTimeValue = require('./isSafeTimeValue.cjs');
-var isTime = require('./isTime.cjs');
+var theTime = require('./theTime.cjs');
 var create = require('../either/left/create.cjs');
 var create$1 = require('../either/right/create.cjs');
 
@@ -16,14 +15,24 @@ const unitsMapper = {
     millisecond: 1,
 };
 function createTime(input, unit) {
-    if (typeof input === "number" && unit) {
-        return createTheTime.createTheTime(input * unitsMapper[unit]);
+    if (input instanceof theTime.TheTime) {
+        return input;
     }
     if (typeof input === "number") {
+        if (unit) {
+            return theTime.TheTime.new(input * unitsMapper[unit]);
+        }
         return createFromTimeValue(input * unitsMapper[unit ?? "millisecond"]);
     }
-    if (typeof input === "string" && isTime.isTime(input)) {
-        return input;
+    if (typeof input === "string") {
+        const serializeTheTimeMatch = input.match(constants.serializeTheTimeRegex);
+        if (!serializeTheTimeMatch) {
+            return 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;
@@ -55,7 +64,7 @@ function createFromTimeValue(input) {
     if (!isSafeTimeValue.isSafeTimeValue(input)) {
         return create.left("time-created-error", null);
     }
-    return create$1.right("time-created", createTheTime.createTheTime(input));
+    return create$1.right("time-created", theTime.TheTime.new(input));
 }
 
 exports.createTime = createTime;