@duplojs/utils 1.4.57 → 1.4.59

package/dist/date/createTime.d.ts

@@ -1,8 +1,9 @@
 import { type IsEqual, type And } from "../common";
 import { type maxTimeValue, type minTimeValue } from "./constants";
-import { type TheTime, type SpoolingTime } from "./types";
+import { type SerializedTheTime, type SpoolingTime } from "./types";
 import * as DEither from "../either";
 import { type IsGreater, type IsLess } from "../number";
+import { TheTime } from "./theTime";
 export type MayBeTime = DEither.Right<"time-created", TheTime> | DEither.Left<"time-created-error", null>;
 type Units = "week" | "day" | "hour" | "minute" | "second" | "millisecond";
 declare const SymbolForbiddenTime: unique symbol;
@@ -40,42 +41,42 @@ type ForbiddenTime<GenericInput extends number, GenericUnit extends Units> = IsE
     [SymbolForbiddenTime]: "Support that the weeks between -14892855 and 14892855.";
 } : GenericInput));
 /**
- * Creates a TheTime from a time value, unit, or spooling time input.
+ * Creates a `TheTime` (normalized duration) from numeric or structured inputs.
  * 
- * Signature: `createTime(input, unit?)` → returns a value
+ * Signature: `createTime(input, unit?)` → `TheTime | Either<"time-created", TheTime>`
  * 
- * The input value is not mutated.
+ * The return type depends on the overload:
+ * - Literal `number + unit` overload returns `TheTime` directly.
+ * - Runtime inputs (`number`, `SerializedTheTime`, `SpoolingTime`, `TheTime`) can return `Either`.
  * 
  * ```ts
- * const timeFromUnit = D.createTime(90, "minute");
- * // timeFromUnit: "time5400000+"
+ * const direct = D.createTime(90, "minute");
+ * // direct: TheTime
  * 
- * const mayBeTime = D.createTime({
- * 	hour: 1,
- * 	minute: 15,
- * });
- * // Either<"time-created", TheTime>
+ * const mayBeFromSerialized = D.createTime("time5400000+");
+ * // mayBeFromSerialized: Either<"time-created", TheTime>
  * 
- * const mayBeIso = D.createTime({
+ * const mayBeFromSpooling = D.createTime({
  * 	value: "+01:30:00",
+ * 	minute: 15,
  * });
- * // Either<"time-created", TheTime>
+ * // mayBeFromSpooling: Either<"time-created", TheTime>
  * 
- * const piped = pipe(
+ * pipe(
  * 	120,
  * 	D.createTime,
- * );
- * // piped: Either<"time-created", TheTime>
+ * ); // Either<"time-created", TheTime>
  * ```
  * 
  * @remarks
- * - Returns an Either tagged "time-created" or "time-created-error" for unsafe inputs.
+ * - `TheTime` represents a duration, not a calendar date.
  * 
  * @see https://utils.duplojs.dev/en/v1/api/date/createTime
+ * @see https://utils.duplojs.dev/en/v1/api/date/createTimeOrThrow
  * 
  * @namespace D
  * 
  */
 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 declare function createTime<GenericInput extends number | TheTime | SpoolingTime | SerializedTheTime>(input: GenericInput): MayBeTime;
 export {};

package/dist/date/createTime.mjs

@@ -1,7 +1,6 @@
-import { isoTimeRegex, millisecondsInOneSecond, millisecondInOneMinute, millisecondInOneHour, millisecondsInOneDay, millisecondInOneWeek } from './constants.mjs';
-import { createTheTime } from './createTheTime.mjs';
+import { millisecondsInOneSecond, millisecondInOneMinute, millisecondInOneHour, millisecondsInOneDay, millisecondInOneWeek, serializeTheTimeRegex, isoTimeRegex } from './constants.mjs';
 import { isSafeTimeValue } from './isSafeTimeValue.mjs';
-import { isTime } from './isTime.mjs';
+import { TheTime } from './theTime.mjs';
 import { left } from '../either/left/create.mjs';
 import { right } from '../either/right/create.mjs';
 
@@ -14,14 +13,24 @@ const unitsMapper = {
     millisecond: 1,
 };
 function createTime(input, unit) {
-    if (typeof input === "number" && unit) {
-        return createTheTime(input * unitsMapper[unit]);
+    if (input instanceof TheTime) {
+        return input;
     }
     if (typeof input === "number") {
+        if (unit) {
+            return TheTime.new(input * unitsMapper[unit]);
+        }
         return createFromTimeValue(input * unitsMapper[unit ?? "millisecond"]);
     }
-    if (typeof input === "string" && isTime(input)) {
-        return input;
+    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;
@@ -53,7 +62,7 @@ function createFromTimeValue(input) {
     if (!isSafeTimeValue(input)) {
         return left("time-created-error", null);
     }
-    return right("time-created", createTheTime(input));
+    return right("time-created", TheTime.new(input));
 }
 
 export { createTime };

package/dist/date/createTimeOrThrow.d.ts

@@ -1,45 +1,42 @@
-import type { SpoolingTime, TheTime } from "./types";
+import type { SerializedTheTime, SpoolingTime } from "./types";
+import { type TheTime } from "./theTime";
 declare const CreateTheTimeError_base: new (params: {
     "@DuplojsUtilsError/create-the-time-error"?: unknown;
 }, parentParams: readonly [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);
+    input: TheTime | number | SpoolingTime | SerializedTheTime;
+    constructor(input: TheTime | number | SpoolingTime | SerializedTheTime);
 }
 /**
- * Creates a TheTime or throws on invalid input.
+ * Creates a `TheTime` and throws when input is invalid.
  * 
- * Signature: `createTimeOrThrow(input)` → returns a value
- * 
- * The input value is not mutated.
+ * Signature: `createTimeOrThrow(input)` → `TheTime`
  * 
  * ```ts
- * const input = 90_000;
- * const result = D.createTimeOrThrow(input);
- * // result: "time90000+"
+ * const fromNumber = D.createTimeOrThrow(90_000);
+ * // fromNumber: TheTime
  * 
- * const input2 = "time3600000+";
- * const result2 = D.createTimeOrThrow(input2);
- * // result2: "time3600000+"
+ * const fromSerialized = D.createTimeOrThrow("time3600000+");
+ * // fromSerialized: TheTime
  * 
- * const input3 = {
+ * const fromSpooling = D.createTimeOrThrow({
  * 	hour: 1,
  * 	minute: 30,
- * };
- * const result3 = D.createTimeOrThrow(input3);
- * // result3: "time5400000+"
+ * });
+ * // fromSpooling: TheTime
  * 
  * pipe(
- * 	input,
+ * 	fromNumber,
  * ```
  * 
  * @remarks
- * - Throws when the input cannot be converted to TheTime.
+ * - Throws `CreateTheTimeError` on invalid input.
  * 
  * @see https://utils.duplojs.dev/en/v1/api/date/createTimeOrThrow
+ * @see https://utils.duplojs.dev/en/v1/api/date/createTime
  * 
  * @namespace D
  * 
  */
-export declare function createTimeOrThrow(input: number | TheTime | SpoolingTime): TheTime;
+export declare function createTimeOrThrow(input: number | TheTime | SpoolingTime | SerializedTheTime): TheTime;
 export {};

package/dist/date/each.cjs

@@ -3,7 +3,7 @@
 var loop = require('../generator/loop.cjs');
 var constants = require('./constants.cjs');
 var toTimestamp = require('./toTimestamp.cjs');
-var createOrThrow = require('./createOrThrow.cjs');
+var theDate = require('./theDate.cjs');
 
 const stepMapper = {
     millisecond: (timestamp, direction) => timestamp + direction,
@@ -32,7 +32,9 @@ function each(range, unit = "day") {
     const advanceTimestamp = stepMapper[unit];
     return loop.loop(({ exit, next, previousOutput, }) => {
         if (!previousOutput) {
-            return next(range.start);
+            return range.start instanceof theDate.TheDate
+                ? next(range.start)
+                : next(theDate.TheDate.new(toTimestamp.toTimestamp(range.start)));
         }
         const currentTimestamp = advanceTimestamp(toTimestamp.toTimestamp(previousOutput), direction);
         const isWithinRange = direction === 1
@@ -40,10 +42,10 @@ function each(range, unit = "day") {
             : currentTimestamp > endTimestamp;
         if (!isWithinRange) {
             return exit(currentTimestamp === endTimestamp
-                ? createOrThrow.createOrThrow(currentTimestamp)
+                ? theDate.TheDate.new(currentTimestamp)
                 : undefined);
         }
-        return next(createOrThrow.createOrThrow(currentTimestamp));
+        return next(theDate.TheDate.new(currentTimestamp));
     });
 }
 

package/dist/date/each.d.ts

@@ -1,30 +1,32 @@
-import type { TheDate, Unit } from "./types";
+import { TheDate } from "./theDate";
+import type { Unit, SerializedTheDate } from "./types";
 /**
- * Iterates over a date range.
+ * Creates an iterator over a date range with a chosen unit step.
  * 
- * Signature: `each(range, unit)` → returns a value
- * 
- * The input value is not mutated.
+ * Signature: `each(range, unit?)` → `Iterator<TheDate>`
  * 
  * ```ts
- * const input = {
+ * const range = {
  * 	start: D.create("2024-06-01"),
  * 	end: D.create("2024-06-03"),
  * } as const;
  * 
- * const iterator = D.each(input);
- * const result = A.from(iterator);
- * // result: ["date1717200000000+", "date1717286400000+", "date1717372800000+"]
- * 
- * pipe(
- * 	input,
- * 	D.each,
- * ); // result: ["date1717200000000+", "date1717286400000+", "date1717372800000+"]
- * 
+ * const iterator = D.each(range, "day");
+ * const values = A.from(iterator);
+ * // values: TheDate[]
+ * 
+ * const reverse = A.from(
+ * 	D.each({
+ * 		start: D.create("2024-06-03"),
+ * 		end: D.create("2024-06-01"),
+ * 	}),
+ * );
+ * // reverse: TheDate[]
  * ```
  * 
  * @remarks
- * - Includes the end date when it falls on a step boundary.
+ * - Supports ascending and descending ranges.
+ * - Includes the end value when exactly aligned with step boundaries.
  * 
  * @see https://utils.duplojs.dev/en/v1/api/date/each
  * 
@@ -32,6 +34,6 @@ import type { TheDate, Unit } from "./types";
  * 
  */
 export declare function each(range: {
-    start: TheDate;
-    end: TheDate;
-}, unit?: Unit): Generator<`date${number}-` | `date${number}+`, unknown, unknown>;
+    start: TheDate | SerializedTheDate;
+    end: TheDate | SerializedTheDate;
+}, unit?: Unit): Generator<TheDate, unknown, unknown>;

package/dist/date/each.mjs

@@ -1,7 +1,7 @@
 import { loop } from '../generator/loop.mjs';
 import { millisecondsInOneDay, millisecondInOneHour, millisecondInOneMinute, millisecondsInOneSecond } from './constants.mjs';
 import { toTimestamp } from './toTimestamp.mjs';
-import { createOrThrow } from './createOrThrow.mjs';
+import { TheDate } from './theDate.mjs';
 
 const stepMapper = {
     millisecond: (timestamp, direction) => timestamp + direction,
@@ -30,7 +30,9 @@ function each(range, unit = "day") {
     const advanceTimestamp = stepMapper[unit];
     return loop(({ exit, next, previousOutput, }) => {
         if (!previousOutput) {
-            return next(range.start);
+            return range.start instanceof TheDate
+                ? next(range.start)
+                : next(TheDate.new(toTimestamp(range.start)));
         }
         const currentTimestamp = advanceTimestamp(toTimestamp(previousOutput), direction);
         const isWithinRange = direction === 1
@@ -38,10 +40,10 @@ function each(range, unit = "day") {
             : currentTimestamp > endTimestamp;
         if (!isWithinRange) {
             return exit(currentTimestamp === endTimestamp
-                ? createOrThrow(currentTimestamp)
+                ? TheDate.new(currentTimestamp)
                 : undefined);
         }
-        return next(createOrThrow(currentTimestamp));
+        return next(TheDate.new(currentTimestamp));
     });
 }
 

package/dist/date/format.d.ts

@@ -1,33 +1,35 @@
-import type { TheDate } from "./types";
+import { type TheDate } from "./theDate";
 import type { Timezone } from "./timezone";
+import type { SerializedTheDate } from "./types";
 /**
- * Formats a date.
+ * Formats a date with custom tokens in a target timezone.
  * 
  * **Supported call styles:**
- * - Classic: `format(input, formatString, timezone)` → returns a value
- * - Curried: `format(formatString, timezone)` → returns a function waiting for the input
+ * - Classic: `format(input, formatString, timezone)` → `string`
+ * - Curried: `format(formatString, timezone)` → `(input) => string`
  * 
- * The input value is not mutated.
+ * `input` accepts `TheDate` or `SerializedTheDate`.
  * 
  * ```ts
- * const theDate = D.createOrThrow(1704067200123);
- * const fullFormat = D.format(theDate, "YYYY-MM-DD HH:mm:ss.SSS ZZ", "UTC");
- * // fullFormat: "2024-01-01 00:00:00.123 UTC"
+ * const input = D.create("2024-01-01", {
+ * 	hour: "00",
+ * 	minute: "00",
+ * 	second: "00",
+ * 	millisecond: "123",
+ * });
  * 
- * pipe(
- * 	theDate,
- * 	D.format("YYYY-MM-DD HH:mm:ss.SSS ZZ", "UTC"),
- * ); // fullFormat: "2024-01-01 00:00:00.123 UTC"
+ * const full = D.format(input, "YYYY-MM-DD HH:mm:ss.SSS ZZ", "UTC");
+ * // full: string
  * 
  * ```
  * 
  * @remarks
- * - Supports tokens: YYYY, YY, MM, DD, HH, mm, ss, SSS, ZZ.
+ * - Supported tokens: `YYYY`, `YY`, `MM`, `DD`, `HH`, `mm`, `ss`, `SSS`, `ZZ`.
  * 
  * @see https://utils.duplojs.dev/en/v1/api/date/format
  * 
  * @namespace D
  * 
  */
-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;
+export declare function format<GenericInput extends TheDate | SerializedTheDate, GenericFormat extends string, GenericTimezone extends Timezone>(formatString: GenericFormat, timezone: GenericTimezone): (input: GenericInput) => string;
+export declare function format<GenericInput extends TheDate | SerializedTheDate, GenericFormat extends string, GenericTimezone extends Timezone>(input: GenericInput, formatString: GenericFormat, timezone: GenericTimezone): string;

package/dist/date/formatTime.d.ts

@@ -1,35 +1,36 @@
-import type { TheTime } from "./types";
+import { type TheTime } from "./theTime";
+import type { SerializedTheTime } from "./types";
 /**
- * Formats a time.
+ * Formats a duration value with custom time tokens.
  * 
  * **Supported call styles:**
- * - Classic: `formatTime(input, formatString)` → returns a value
- * - Curried: `formatTime(formatString)` → returns a function waiting for the input
+ * - Classic: `formatTime(input, formatString)` → `string`
+ * - Curried: `formatTime(formatString)` → `(input) => string`
  * 
- * The input value is not mutated.
+ * `input` accepts `TheTime` or `SerializedTheTime`.
  * 
  * ```ts
- * const theTime = D.createTheTime(788_645_006);
- * const fullFormat = D.formatTime(theTime, "WW DD HH:mm:ss.SSS");
- * // fullFormat: "01 02 03:04:05.006"
+ * const input = D.createTime(788_645_006, "millisecond");
+ * const full = D.formatTime(input, "WW DD HH:mm:ss.SSS");
+ * // full: string
  * 
  * pipe(
- * 	theTime,
+ * 	input,
  * 	D.formatTime("HH:mm"),
- * ); // result: "03:04"
+ * ); // string
  * 
- * const negativeTime = D.createTheTime(-5_000);
- * const shortFormat = D.formatTime(negativeTime, "ss.SSS");
- * // shortFormat: "-05.000"
+ * const negative = D.createTime(-5_000, "millisecond");
+ * const short = D.formatTime(negative, "ss.SSS");
+ * // short: string
  * ```
  * 
  * @remarks
- * - Supports tokens: WW, DD, HH, mm, ss, SSS.
+ * - Supported tokens: `WW`, `DD`, `HH`, `mm`, `ss`, `SSS`.
  * 
  * @see https://utils.duplojs.dev/en/v1/api/date/formatTime
  * 
  * @namespace D
  * 
  */
-export declare function formatTime<GenericInput extends TheTime, GenericFormat extends string>(formatString: GenericFormat): (input: GenericInput) => string;
-export declare function formatTime<GenericInput extends TheTime, GenericFormat extends string>(input: GenericInput, formatString: GenericFormat): string;
+export declare function formatTime<GenericInput extends TheTime | SerializedTheTime, GenericFormat extends string>(formatString: GenericFormat): (input: GenericInput) => string;
+export declare function formatTime<GenericInput extends TheTime | SerializedTheTime, GenericFormat extends string>(input: GenericInput, formatString: GenericFormat): string;

package/dist/date/getTimezoneOffset.cjs

@@ -1,14 +1,17 @@
 'use strict';
 
+var theDate = require('./theDate.cjs');
 var toNative = require('./toNative.cjs');
 
 function getTimezoneOffset(...args) {
     if (args.length === 1) {
         const [timeZone] = args;
-        return (theDate) => getTimezoneOffset(theDate, timeZone);
+        return (input) => getTimezoneOffset(input, timeZone);
     }
-    const [theDate, timeZone] = args;
-    const date = toNative.toNative(theDate);
+    const [input, timeZone] = args;
+    const date = input instanceof theDate.TheDate
+        ? input
+        : toNative.toNative(input);
     const fmt = new Intl.DateTimeFormat("en-US", {
         timeZone,
         hour12: false,

package/dist/date/getTimezoneOffset.d.ts

@@ -1,33 +1,32 @@
-import { type Timezone } from "./timezone";
-import { type TheDate } from "./types";
+import type { Timezone } from "./timezone";
+import { TheDate } from "./theDate";
+import type { SerializedTheDate } from "./types";
 /**
- * Returns the timezone offset of a date.
+ * Returns timezone offset in milliseconds for a given date and timezone.
  * 
  * **Supported call styles:**
- * - Classic: `getTimezoneOffset(timeZone)` → returns a value
- * - Curried: `getTimezoneOffset(theDate, timeZone)` → returns a function waiting for the input
+ * - Classic: `getTimezoneOffset(input, timeZone)` → `number`
+ * - Curried: `getTimezoneOffset(timeZone)` → `(input) => number`
  * 
- * The input value is not mutated.
+ * `input` accepts `TheDate` or `SerializedTheDate`.
  * 
  * ```ts
- * const theDate = D.createOrThrow(1704067200000);
- * const offset = D.getTimezoneOffset(theDate, "America/New_York");
- * // offset: -18000000
+ * const input = D.create("2024-01-01", {
+ * 	hour: "00",
+ * });
  * 
- * pipe(
- * 	theDate,
- * 	D.getTimezoneOffset("America/New_York"),
- * ); // offset: -18000000
+ * const offset = D.getTimezoneOffset(input, "America/New_York");
+ * // offset: number
  * 
+ * pipe(
+ * 	input,
+ * 	D.getTimezoneOffset("Europe/Paris"),
  * ```
  * 
- * @remarks
- * - Returns the offset in milliseconds for the given timezone.
- * 
  * @see https://utils.duplojs.dev/en/v1/api/date/getTimezoneOffset
  * 
  * @namespace D
  * 
  */
-export declare function getTimezoneOffset(timeZone: Timezone): (theDate: TheDate) => number;
-export declare function getTimezoneOffset(theDate: TheDate, timeZone: Timezone): number;
+export declare function getTimezoneOffset(timeZone: Timezone): (input: TheDate | SerializedTheDate) => number;
+export declare function getTimezoneOffset(input: TheDate | SerializedTheDate, timeZone: Timezone): number;

package/dist/date/getTimezoneOffset.mjs

@@ -1,12 +1,15 @@
+import { TheDate } from './theDate.mjs';
 import { toNative } from './toNative.mjs';
 
 function getTimezoneOffset(...args) {
     if (args.length === 1) {
         const [timeZone] = args;
-        return (theDate) => getTimezoneOffset(theDate, timeZone);
+        return (input) => getTimezoneOffset(input, timeZone);
     }
-    const [theDate, timeZone] = args;
-    const date = toNative(theDate);
+    const [input, timeZone] = args;
+    const date = input instanceof TheDate
+        ? input
+        : toNative(input);
     const fmt = new Intl.DateTimeFormat("en-US", {
         timeZone,
         hour12: false,

package/dist/date/getters/getDayOfMonth.cjs

@@ -6,15 +6,15 @@ var toNative = require('../toNative.cjs');
  * {@include date/getDayOfMonth/index.md}
  */
 function getDayOfMonth(input, timezone = "UTC") {
-    const nativeDate = toNative.toNative(input);
+    const date = toNative.toNative(input);
     if (timezone === "UTC") {
-        return nativeDate.getUTCDate();
+        return date.getUTCDate();
     }
     const formatter = new Intl.DateTimeFormat("en-US", {
         timeZone: timezone,
         day: "numeric",
     });
-    return Number(formatter.format(nativeDate));
+    return Number(formatter.format(date));
 }
 
 exports.getDayOfMonth = getDayOfMonth;

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

@@ -1,31 +1,37 @@
-import { type TheDate, type Timezone } from "..";
+import type { SerializedTheDate } from "../types";
+import type { TheDate } from "../theDate";
+import type { Timezone } from "../timezone";
 /**
- * Returns the day of month of a date.
+ * Returns the day of month (`1` to `31`) for a date in a target timezone.
  * 
- * Signature: `getDayOfMonth(input, timezone)` → returns a value
+ * Signature: `getDayOfMonth(input, timezone?)` → `number`
  * 
- * If timezone is omitted, UTC is used.
- * 
- * The input value is not mutated.
+ * `input` accepts `TheDate` or `SerializedTheDate`. If `timezone` is omitted, UTC is used.
  * 
  * ```ts
- * const input = D.create("2024-06-01");
- * const result = D.getDayOfMonth(input);
- * // result: 1
+ * const input = D.create("2024-06-01", {
+ * 	hour: "00",
+ * 	minute: "30",
+ * });
+ * const utcDay = D.getDayOfMonth(input);
+ * // utcDay: 1
  * 
- * const result2 = D.getDayOfMonth(input, "America/New_York");
- * // result2: 1
+ * const laDay = D.getDayOfMonth(input, "America/Los_Angeles");
+ * // laDay: 31
  * 
  * pipe(
  * 	input,
- * 	D.getDayOfMonth,
- * ); // result: 1
+ * 	(value) => D.getDayOfMonth(value, "UTC"),
+ * ); // 1
  * 
  * ```
  * 
+ * @remarks
+ * - The same instant can map to a different calendar day depending on timezone.
+ * 
  * @see https://utils.duplojs.dev/en/v1/api/date/getDayOfMonth
  * 
  * @namespace D
  * 
  */
-export declare function getDayOfMonth<GenericInput extends TheDate>(input: GenericInput, timezone?: Timezone): number;
+export declare function getDayOfMonth<GenericInput extends TheDate | SerializedTheDate>(input: GenericInput, timezone?: Timezone): number;

package/dist/date/getters/getDayOfMonth.mjs

@@ -4,15 +4,15 @@ import { toNative } from '../toNative.mjs';
  * {@include date/getDayOfMonth/index.md}
  */
 function getDayOfMonth(input, timezone = "UTC") {
-    const nativeDate = toNative(input);
+    const date = toNative(input);
     if (timezone === "UTC") {
-        return nativeDate.getUTCDate();
+        return date.getUTCDate();
     }
     const formatter = new Intl.DateTimeFormat("en-US", {
         timeZone: timezone,
         day: "numeric",
     });
-    return Number(formatter.format(nativeDate));
+    return Number(formatter.format(date));
 }
 
 export { getDayOfMonth };

package/dist/date/getters/getDayOfWeek.cjs

@@ -15,15 +15,15 @@ const weekdayMapper = {
  * {@include date/getDayOfWeek/index.md}
  */
 function getDayOfWeek(input, timezone = "UTC") {
-    const nativeDate = toNative.toNative(input);
+    const date = toNative.toNative(input);
     if (timezone === "UTC") {
-        return nativeDate.getUTCDay();
+        return date.getUTCDay();
     }
     const formatter = new Intl.DateTimeFormat("en-US", {
         timeZone: timezone,
         weekday: "long",
     });
-    const weekday = formatter.format(nativeDate);
+    const weekday = formatter.format(date);
     return weekdayMapper[weekday];
 }