@duplojs/utils 1.4.32 → 1.4.34

package/dist/dataParser/parsers/time/index.mjs

@@ -11,6 +11,9 @@ import { isTime } from '../../../date/isTime.mjs';
 import { createOverride } from '../../../common/override.mjs';
 
 const timeKind = createDataParserKind("time");
+/**
+ * {@include dataParser/classic/time/index.md}
+ */
 function time(definition) {
     const self = dataParserInit(timeKind, {
         errorMessage: definition?.errorMessage,

package/dist/dataParser/parsers/transform.cjs

@@ -6,6 +6,9 @@ var kind = require('../kind.cjs');
 var override = require('../../common/override.cjs');
 
 const transformKind = kind.createDataParserKind("transform");
+/**
+ * {@include dataParser/classic/transform/index.md}
+ */
 function transform(inner, theFunction, definition) {
     const self = base.dataParserInit(transformKind, {
         errorMessage: definition?.errorMessage,

package/dist/dataParser/parsers/transform.d.ts

@@ -21,11 +21,36 @@ export interface DataParserTransform<GenericDefinition extends DataParserDefinit
         DataParserTransformCheckers<Output<this>>,
         ...DataParserTransformCheckers<Output<this>>[]
     ], GenericChecker>): DataParserTransform<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    construct<const GenericDefinition extends DataParserDefinitionTransform>(definition: GenericDefinition): DataParserTransform<MergeDefinition<DataParserDefinitionTransform, GenericDefinition>>;
 }
+/**
+ * Creates a data parser that transforms the output of another parser.
+ * 
+ * **Supported call styles:**
+ * - Classic: `DP.transform(inner, theFunction, definition?)` -> returns a transform parser
+ * - Curried: not available
+ * 
+ * Runs the inner parser and applies a transformation function to its output.
+ * 
+ * ```ts
+ * const parser = DP.transform(DP.string(), (value) => value.length);
+ * const result = parser.parse("Duplo");
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: number
+ * }
+ * 
+ * const toUpper = DP.transform(
+ * 	DP.string(),
+ * 	S.toUpperCase,
+ * );
+ * const upperResult = toUpper.parse("duplo");
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/transform
+ * 
+ * @namespace DP
+ * 
+ */
 export declare function transform<GenericDataParser extends DataParser, GenericOutput extends unknown, const GenericDefinition extends Partial<Omit<DataParserDefinitionTransform, "inner" | "theFunction">> = never>(inner: GenericDataParser, theFunction: (input: Output<GenericDataParser>, error: DataParserError) => GenericOutput, definition?: GenericDefinition): DataParserTransform<MergeDefinition<DataParserDefinitionTransform, NeverCoalescing<GenericDefinition, {}> & {
     inner: GenericDataParser;
     theFunction(input: Output<GenericDataParser>): GenericOutput;

package/dist/dataParser/parsers/transform.mjs

@@ -4,6 +4,9 @@ import { createDataParserKind } from '../kind.mjs';
 import { createOverride } from '../../common/override.mjs';
 
 const transformKind = createDataParserKind("transform");
+/**
+ * {@include dataParser/classic/transform/index.md}
+ */
 function transform(inner, theFunction, definition) {
     const self = dataParserInit(transformKind, {
         errorMessage: definition?.errorMessage,

package/dist/dataParser/parsers/tuple.cjs

@@ -6,6 +6,9 @@ var kind = require('../kind.cjs');
 var override = require('../../common/override.cjs');
 
 const tupleKind = kind.createDataParserKind("tuple");
+/**
+ * {@include dataParser/classic/tuple/index.md}
+ */
 function tuple(shape, definition) {
     const self = base.dataParserInit(tupleKind, {
         errorMessage: definition?.errorMessage,

package/dist/dataParser/parsers/tuple.d.ts

@@ -36,11 +36,33 @@ export interface DataParserTuple<GenericDefinition extends DataParserDefinitionT
         DataParserTupleCheckers<Output<this>>,
         ...DataParserTupleCheckers<Output<this>>[]
     ], GenericChecker>): DataParserTuple<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    construct<const GenericDefinition extends DataParserDefinitionTuple>(definition: GenericDefinition): DataParserTuple<MergeDefinition<DataParserDefinitionTuple, GenericDefinition>>;
 }
+/**
+ * Creates a data parser for tuples with a fixed shape.
+ * 
+ * **Supported call styles:**
+ * - Classic: `DP.tuple(shape, definition?)` -> returns a tuple parser
+ * - Curried: not available
+ * 
+ * Validates array inputs against the provided tuple shape, with an optional rest parser.
+ * 
+ * ```ts
+ * const parser = DP.tuple([DP.string(), DP.number()]);
+ * const result = parser.parse(["id", 42]);
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: [string, number]
+ * }
+ * 
+ * const withRest = DP.tuple([DP.string()], { rest: DP.number() });
+ * const restResult = withRest.parse(["a", 1, 2, 3]);
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/tuple
+ * 
+ * @namespace DP
+ * 
+ */
 export declare function tuple<GenericShape extends TupleShape, const GenericDefinition extends Partial<Omit<DataParserDefinitionTuple, "shape">> = never>(shape: GenericShape, definition?: GenericDefinition): DataParserTuple<MergeDefinition<DataParserDefinitionTuple, NeverCoalescing<GenericDefinition, {}> & {
     shape: GenericShape;
 }>>;

package/dist/dataParser/parsers/tuple.mjs

@@ -4,6 +4,9 @@ import { createDataParserKind } from '../kind.mjs';
 import { createOverride } from '../../common/override.mjs';
 
 const tupleKind = createDataParserKind("tuple");
+/**
+ * {@include dataParser/classic/tuple/index.md}
+ */
 function tuple(shape, definition) {
     const self = dataParserInit(tupleKind, {
         errorMessage: definition?.errorMessage,

package/dist/dataParser/parsers/union.cjs

@@ -6,6 +6,9 @@ var kind = require('../kind.cjs');
 var override = require('../../common/override.cjs');
 
 const unionKind = kind.createDataParserKind("union");
+/**
+ * {@include dataParser/classic/union/index.md}
+ */
 function union(options, definition) {
     const self = base.dataParserInit(unionKind, {
         errorMessage: definition?.errorMessage,

package/dist/dataParser/parsers/union.d.ts

@@ -20,11 +20,38 @@ export interface DataParserUnion<GenericDefinition extends DataParserDefinitionU
         DataParserUnionCheckers<Output<this>>,
         ...DataParserUnionCheckers<Output<this>>[]
     ], GenericChecker>): DataParserUnion<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    construct<const GenericDefinition extends DataParserDefinitionUnion>(definition: GenericDefinition): DataParserUnion<MergeDefinition<DataParserDefinitionUnion, GenericDefinition>>;
 }
+/**
+ * Creates a data parser that accepts one of multiple parsers.
+ * 
+ * **Supported call styles:**
+ * - Classic: `DP.union(options, definition?)` -> returns a union parser
+ * - Curried: not available
+ * 
+ * Tries each option in order until one succeeds, then returns its output.
+ * 
+ * ```ts
+ * const parser = DP.union([DP.string(), DP.number()]);
+ * const result = parser.parse("hello");
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: string | number
+ * }
+ * 
+ * const literals = DP.union([DP.literal("on"), DP.literal("off")]);
+ * const literalResult = literals.parse("off");
+ * 
+ * const withCheckers = DP.union(
+ * 	[DP.string(), DP.coerce.number()],
+ * 	{ checkers: [DP.checkerRefine((value) => value !== "forbidden")] },
+ * );
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/union
+ * 
+ * @namespace DP
+ * 
+ */
 export declare function union<GenericOptions extends UnionOptions, const GenericDefinition extends Partial<Omit<DataParserDefinitionUnion, "options">> = never>(options: GenericOptions, definition?: GenericDefinition): DataParserUnion<MergeDefinition<DataParserDefinitionUnion, NeverCoalescing<GenericDefinition, {}> & {
     options: GenericOptions;
 }>>;

package/dist/dataParser/parsers/union.mjs

@@ -4,6 +4,9 @@ import { createDataParserKind } from '../kind.mjs';
 import { createOverride } from '../../common/override.mjs';
 
 const unionKind = createDataParserKind("union");
+/**
+ * {@include dataParser/classic/union/index.md}
+ */
 function union(options, definition) {
     const self = dataParserInit(unionKind, {
         errorMessage: definition?.errorMessage,

package/dist/dataParser/parsers/unknown.cjs

@@ -5,6 +5,9 @@ var kind = require('../kind.cjs');
 var override = require('../../common/override.cjs');
 
 const unknownKind = kind.createDataParserKind("unknown");
+/**
+ * {@include dataParser/classic/unknown/index.md}
+ */
 function unknown(definition) {
     const self = base.dataParserInit(unknownKind, {
         errorMessage: definition?.errorMessage,

package/dist/dataParser/parsers/unknown.d.ts

@@ -18,11 +18,37 @@ export interface DataParserUnknown<GenericDefinition extends DataParserDefinitio
         DataParserUnknownCheckers,
         ...DataParserUnknownCheckers[]
     ], GenericChecker>): DataParserUnknown<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    construct<const GenericDefinition extends DataParserDefinitionUnknown>(definition: GenericDefinition): DataParserUnknown<MergeDefinition<DataParserDefinitionUnknown, GenericDefinition>>;
 }
+/**
+ * Creates a data parser that accepts any value.
+ * 
+ * **Supported call styles:**
+ * - Classic: `DP.unknown(definition?)` -> returns an unknown parser
+ * - Curried: not available
+ * 
+ * Always succeeds, unless additional checkers reject the value.
+ * 
+ * ```ts
+ * const parser = DP.unknown();
+ * const result = parser.parse({ any: "value" });
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: unknown
+ * }
+ * 
+ * const nonEmptyString = DP.unknown({
+ * 	checkers: [DP.checkerRefine((value) => typeof value === "string" && value.length > 0)],
+ * });
+ * 
+ * const numbersOnly = DP.unknown()
+ * 	.addChecker(DP.checkerRefine((value) => typeof value === "number"));
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/unknown
+ * 
+ * @namespace DP
+ * 
+ */
 export declare function unknown<const GenericDefinition extends Partial<DataParserDefinitionUnknown> = never>(definition?: GenericDefinition): DataParserUnknown<MergeDefinition<DataParserDefinitionUnknown, NeverCoalescing<GenericDefinition, {}>>>;
 export declare namespace unknown {
     var overrideHandler: import("../../common").OverrideHandler<DataParserUnknown<DataParserDefinitionUnknown>>;

package/dist/dataParser/parsers/unknown.mjs

@@ -3,6 +3,9 @@ import { createDataParserKind } from '../kind.mjs';
 import { createOverride } from '../../common/override.mjs';
 
 const unknownKind = createDataParserKind("unknown");
+/**
+ * {@include dataParser/classic/unknown/index.md}
+ */
 function unknown(definition) {
     const self = dataParserInit(unknownKind, {
         errorMessage: definition?.errorMessage,

package/dist/dataParser/types/addCheckersToDefinition.d.ts

@@ -1,5 +1,5 @@
-import { type AnyTuple, type SimplifyTopLevel } from "../../common";
+import { type SimplifyTopLevel } from "../../common";
 import { type DataParserChecker, type DataParserDefinition } from "../base";
 export type AddCheckersToDefinition<GenericDefinition extends DataParserDefinition, GenericChecker extends readonly [DataParserChecker, ...DataParserChecker[]]> = SimplifyTopLevel<Omit<GenericDefinition, "checkers"> & {
-    readonly checkers: GenericDefinition["checkers"] extends AnyTuple ? readonly [...GenericDefinition["checkers"], ...GenericChecker] : GenericChecker;
+    readonly checkers: readonly [...GenericDefinition["checkers"], ...GenericChecker];
 }>;

package/dist/date/applyTimezone.d.ts

@@ -1,4 +1,33 @@
 import { type Timezone } from "./timezone";
 import { type TheDate } from "./types";
+/**
+ * Applies a timezone to a date.
+ * 
+ * **Supported call styles:**
+ * - Classic: `applyTimezone(timeZone)` → returns a value
+ * - Curried: `applyTimezone(theDate, timeZone)` → returns a function waiting for the input
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * const theDate = D.createOrThrow(1704067200000);
+ * const shiftedDate = D.applyTimezone(theDate, "America/New_York");
+ * // shiftedDate: "date1704085200000+"
+ * 
+ * pipe(
+ * 	theDate,
+ * 	D.applyTimezone("America/New_York"),
+ * ); // shiftedDate: "date1704085200000+"
+ * 
+ * ```
+ * 
+ * @remarks
+ * - Applies the timezone offset to shift the date.
+ * 
+ * @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;

package/dist/date/closestTo.d.ts

@@ -2,6 +2,41 @@ import type { TheDate } from "./types";
 interface ClosestToParams {
     tieBreaker?: "favorPast" | "favorFuture";
 }
+/**
+ * Finds the closest date to a target.
+ * 
+ * **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.
+ * 
+ * ```ts
+ * const inputs = [
+ * 	D.create("2024-06-01"),
+ * 	D.create("2024-06-10"),
+ * 	D.create("2024-06-20"),
+ * ] as const;
+ * 
+ * const target = D.create("2024-06-15");
+ * const result = D.closestTo(inputs, target);
+ * // result: "date1717996800000+" (10 June 2024)
+ * 
+ * pipe(
+ * 	inputs,
+ * 	D.closestTo(target),
+ * ); // result: "date1717996800000+" (10 June 2024)
+ * 
+ * ```
+ * 
+ * @remarks
+ * - `tieBreaker` can be "favorPast" or "favorFuture" to resolve equidistant dates.
+ * 
+ * @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 {};

package/dist/date/create.d.ts

@@ -21,6 +21,58 @@ interface SafeDateParams {
     second?: Second;
     millisecond?: Millisecond;
 }
+/**
+ * Creates a TheDate from various inputs.
+ * 
+ * Signature: `create(input)` → returns a value
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * // Either<"date-created", TheDate>
+ * const mayBeDateFromNativeDate = D.create(
+ * 	new Date("2024-06-20T12:00:00Z"),
+ * );
+ * 
+ * // 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+"
+ * 
+ * ```
+ * 
+ * @remarks
+ * - Returns an Either tagged "date-created" or "date-created-error" for invalid inputs.
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/date/create
+ * 
+ * @namespace D
+ * 
+ */
 export declare function create<GenericInput extends TheDate | Date | number>(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;

package/dist/date/createOrThrow.d.ts

@@ -6,6 +6,41 @@ export declare class CreateTheDateError extends CreateTheDateError_base {
     input: string | Date | number | SpoolingDate;
     constructor(input: string | Date | number | SpoolingDate);
 }
+/**
+ * Creates a TheDate or throws on invalid input.
+ * 
+ * Signature: `createOrThrow(input)` → returns a value
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * const input = 1_700_000_000_000;
+ * const result = D.createOrThrow(input);
+ * // result: "date1700000000000+"
+ * 
+ * const input2 = result;
+ * const result2 = D.createOrThrow(input2);
+ * // result2: "date1700000000000+"
+ * 
+ * const input3 = new Date("2024-06-20T12:00:00Z");
+ * const result3 = D.createOrThrow(input3);
+ * // result3: "date1718884800000+"
+ * 
+ * pipe(
+ * 	input,
+ * 	(value) => D.createOrThrow(value),
+ * ); // result: "date1700000000000+"
+ * 
+ * ```
+ * 
+ * @remarks
+ * - Throws when the input cannot be converted to TheDate.
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/date/createOrThrow
+ * 
+ * @namespace D
+ * 
+ */
 export declare function createOrThrow<GenericInput extends TheDate | Date | number>(input: GenericInput): TheDate;
 export declare function createOrThrow<GenericInput extends SpoolingDate>(input: GenericInput): TheDate;
 export {};

package/dist/date/createTheDate.cjs

@@ -2,6 +2,9 @@
 
 var makeSafeTimestamp = require('./makeSafeTimestamp.cjs');
 
+/**
+ * {@include date/createTheDate/index.md}
+ */
 function createTheDate(timestamp) {
     const safeTimestamp = makeSafeTimestamp.makeSafeTimestamp(timestamp);
     return `date${Math.abs(safeTimestamp)}${safeTimestamp < 0 ? "-" : "+"}`;

package/dist/date/createTheDate.d.ts

@@ -1,2 +1,28 @@
 import { type TheDate } from "./types";
+/**
+ * Creates a TheDate from a timestamp in milliseconds.
+ * 
+ * Signature: `createTheDate(input)` → returns a value
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * const result = D.createTheDate(1_700_000_000_000);
+ * // result: "date1700000000000+"
+ * 
+ * const result2 = D.createTheDate(-1_700_000_000_000);
+ * // result2: "date1700000000000-"
+ * 
+ * const result3 = D.createTheDate(8_640_000_000_000_500);
+ * // result3: "date8640000000000000+"
+ * ```
+ * 
+ * @remarks
+ * - The input is rounded and clamped to the supported timestamp range.
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/date/createTheDate
+ * 
+ * @namespace D
+ * 
+ */
 export declare function createTheDate(timestamp: number): TheDate;

package/dist/date/createTheDate.mjs

@@ -1,5 +1,8 @@
 import { makeSafeTimestamp } from './makeSafeTimestamp.mjs';
 
+/**
+ * {@include date/createTheDate/index.md}
+ */
 function createTheDate(timestamp) {
     const safeTimestamp = makeSafeTimestamp(timestamp);
     return `date${Math.abs(safeTimestamp)}${safeTimestamp < 0 ? "-" : "+"}`;

package/dist/date/createTheTime.cjs

@@ -2,6 +2,9 @@
 
 var makeSafeTimeValue = require('./makeSafeTimeValue.cjs');
 
+/**
+ * {@include date/createTheTime/index.md}
+ */
 function createTheTime(timestamp) {
     const safeTimestamp = makeSafeTimeValue.makeSafeTimeValue(timestamp);
     return `time${Math.abs(safeTimestamp)}${safeTimestamp < 0 ? "-" : "+"}`;

package/dist/date/createTheTime.d.ts

@@ -1,2 +1,25 @@
 import { type TheTime } from "./types";
+/**
+ * Creates a TheTime from a time value in milliseconds.
+ * 
+ * Signature: `createTheTime(input)` → returns a value
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * const result = D.createTheTime(90_000);
+ * // result: "time90000+"
+ * 
+ * const result2 = D.createTheTime(-90_000);
+ * // result2: "time90000-"
+ * ```
+ * 
+ * @remarks
+ * - The input is rounded and clamped to the supported time range.
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/date/createTheTime
+ * 
+ * @namespace D
+ * 
+ */
 export declare function createTheTime(timestamp: number): TheTime;

package/dist/date/createTheTime.mjs

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

package/dist/date/createTime.d.ts

@@ -39,6 +39,43 @@ type ForbiddenTime<GenericInput extends number, GenericUnit extends Units> = IsE
 ]> extends true ? GenericInput : {
     [SymbolForbiddenTime]: "Support that the weeks between -14892855 and 14892855.";
 } : GenericInput));
+/**
+ * Creates a TheTime from a time value, unit, or spooling time input.
+ * 
+ * Signature: `createTime(input, unit?)` → returns a value
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * const timeFromUnit = D.createTime(90, "minute");
+ * // timeFromUnit: "time5400000+"
+ * 
+ * const mayBeTime = D.createTime({
+ * 	hour: 1,
+ * 	minute: 15,
+ * });
+ * // Either<"time-created", TheTime>
+ * 
+ * const mayBeIso = D.createTime({
+ * 	value: "+01:30:00",
+ * });
+ * // Either<"time-created", TheTime>
+ * 
+ * const piped = pipe(
+ * 	120,
+ * 	D.createTime,
+ * );
+ * // piped: Either<"time-created", TheTime>
+ * ```
+ * 
+ * @remarks
+ * - Returns an Either tagged "time-created" or "time-created-error" for unsafe inputs.
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/date/createTime
+ * 
+ * @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 {};

package/dist/date/createTimeOrThrow.cjs

@@ -16,6 +16,9 @@ class CreateTheTimeError extends kind.kindHeritage("create-the-time-error", erro
         this.input = input;
     }
 }
+/**
+ * {@include date/createTimeOrThrow/index.md}
+ */
 function createTimeOrThrow(input) {
     const result = createTime.createTime(input);
     if (is.isLeft(result)) {

package/dist/date/createTimeOrThrow.d.ts

@@ -6,5 +6,40 @@ export declare class CreateTheTimeError extends CreateTheTimeError_base {
     input: TheTime | number | SpoolingTime;
     constructor(input: TheTime | number | SpoolingTime);
 }
+/**
+ * Creates a TheTime or throws on invalid input.
+ * 
+ * Signature: `createTimeOrThrow(input)` → returns a value
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * const input = 90_000;
+ * const result = D.createTimeOrThrow(input);
+ * // result: "time90000+"
+ * 
+ * const input2 = "time3600000+";
+ * const result2 = D.createTimeOrThrow(input2);
+ * // result2: "time3600000+"
+ * 
+ * const input3 = {
+ * 	hour: 1,
+ * 	minute: 30,
+ * };
+ * const result3 = D.createTimeOrThrow(input3);
+ * // result3: "time5400000+"
+ * 
+ * pipe(
+ * 	input,
+ * ```
+ * 
+ * @remarks
+ * - Throws when the input cannot be converted to TheTime.
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/date/createTimeOrThrow
+ * 
+ * @namespace D
+ * 
+ */
 export declare function createTimeOrThrow(input: number | TheTime | SpoolingTime): TheTime;
 export {};

package/dist/date/createTimeOrThrow.mjs

@@ -14,6 +14,9 @@ class CreateTheTimeError extends kindHeritage("create-the-time-error", createErr
         this.input = input;
     }
 }
+/**
+ * {@include date/createTimeOrThrow/index.md}
+ */
 function createTimeOrThrow(input) {
     const result = createTime(input);
     if (isLeft(result)) {

package/dist/date/each.cjs

@@ -22,6 +22,9 @@ const stepMapper = {
         return date.getTime();
     },
 };
+/**
+ * {@include date/each/index.md}
+ */
 function each(range, unit = "day") {
     const startTimestamp = toTimestamp.toTimestamp(range.start);
     const endTimestamp = toTimestamp.toTimestamp(range.end);