@duplojs/lang 0.0.0 → 0.0.1-beta.10

package/dist/array/at/default.d.ts

@@ -1,4 +1,4 @@
 import { IsIndexCovered, IsIndexOutOfRange } from '../constraints';
-export type At<GenericArray extends readonly unknown[], GenericIndex extends number> = IsIndexOutOfRange<GenericArray, GenericIndex> extends true ? undefined : IsIndexCovered<GenericArray, GenericIndex> extends true ? GenericArray[number] : GenericArray[number] | undefined;
+export type At<GenericArray extends readonly unknown[], GenericIndex extends number> = GenericArray extends unknown ? IsIndexOutOfRange<GenericArray, GenericIndex> extends true ? undefined : IsIndexCovered<GenericArray, GenericIndex> extends true ? GenericArray[number] : GenericArray[number] | undefined : never;
 export declare function at<GenericArray extends readonly unknown[], GenericIndex extends number>(index: GenericIndex): (array: GenericArray) => At<GenericArray, GenericIndex>;
 export declare function at<GenericArray extends readonly unknown[], GenericIndex extends number>(array: GenericArray, index: GenericIndex): At<GenericArray, GenericIndex>;

package/dist/array/chunk.d.ts

@@ -1,2 +1,3 @@
-export declare function chunk<GenericArray extends readonly unknown[]>(size: number): (array: GenericArray) => GenericArray[number][][];
-export declare function chunk<GenericArray extends readonly unknown[]>(array: GenericArray, size: number): GenericArray[number][][];
+import { MaxElements, MinElements } from './constraints';
+export declare function chunk<GenericArray extends readonly unknown[], GenericSize extends number>(size: GenericSize): (array: GenericArray) => readonly (readonly GenericArray[number][] & MinElements<1> & (number extends GenericSize ? unknown : MaxElements<GenericSize>))[];
+export declare function chunk<GenericArray extends readonly unknown[], GenericSize extends number>(array: GenericArray, size: GenericSize): readonly (readonly GenericArray[number][] & MinElements<1> & (number extends GenericSize ? unknown : MaxElements<GenericSize>))[];

package/dist/array/concat.d.ts

@@ -1,5 +1,5 @@
 import { ReapplyCompatiblesConstraints } from './constraints';
-type ConcatOutput<GenericArray extends readonly unknown[], GenericElements extends readonly unknown[], GenericElementsRest extends readonly unknown[][] = []> = ReapplyCompatiblesConstraints<GenericArray, readonly (GenericArray[number] | GenericElements[number] | GenericElementsRest[number][number])[], "minElements">;
+type ConcatOutput<GenericArray extends readonly unknown[], GenericElements extends readonly unknown[], GenericElementsRest extends readonly unknown[][] = []> = GenericArray extends unknown ? ReapplyCompatiblesConstraints<GenericArray, readonly (GenericArray[number] | GenericElements[number] | GenericElementsRest[number][number])[], "minElements"> : never;
 export declare function concat<GenericArray extends readonly unknown[], GenericElements extends readonly unknown[]>(elements: GenericElements): (array: GenericArray) => ConcatOutput<GenericArray, GenericElements>;
 export declare function concat<GenericArray extends readonly unknown[], GenericElements extends readonly unknown[], GenericElementsRest extends readonly unknown[][]>(array: GenericArray, elements: GenericElements, ...elementsRest: GenericElementsRest): ConcatOutput<GenericArray, GenericElements, GenericElementsRest>;
 export {};

package/dist/array/copyWithin.d.ts

@@ -1,5 +1,5 @@
 import { ReapplyCompatiblesConstraints } from './constraints';
-type CopyWithinOutput<GenericArray extends readonly unknown[]> = ReapplyCompatiblesConstraints<GenericArray, readonly GenericArray[number][]>;
+type CopyWithinOutput<GenericArray extends readonly unknown[]> = GenericArray extends unknown ? ReapplyCompatiblesConstraints<GenericArray, readonly GenericArray[number][]> : never;
 export declare function copyWithin<GenericArray extends readonly unknown[]>(target: number, start: number, end?: number): (array: GenericArray) => CopyWithinOutput<GenericArray>;
 export declare function copyWithin<GenericArray extends readonly unknown[]>(array: GenericArray, target: number, start: number, end?: number): CopyWithinOutput<GenericArray>;
 export {};

package/dist/array/fill/all.d.ts

@@ -1,5 +1,5 @@
 import { ReapplyCompatiblesConstraints } from '../constraints';
-type FillAllOutput<GenericArray extends readonly unknown[], GenericElement extends unknown> = ReapplyCompatiblesConstraints<GenericArray, readonly GenericElement[]>;
+type FillAllOutput<GenericArray extends readonly unknown[], GenericElement extends unknown> = GenericArray extends unknown ? ReapplyCompatiblesConstraints<GenericArray, readonly GenericElement[]> : never;
 export declare function fillAll<GenericElement extends unknown>(element: GenericElement): <GenericArray extends readonly unknown[]>(array: GenericArray) => FillAllOutput<GenericArray, GenericElement>;
 export declare function fillAll<GenericElement extends unknown, GenericArray extends readonly unknown[]>(array: GenericArray, element: GenericElement): FillAllOutput<GenericArray, GenericElement>;
 export {};

package/dist/array/fill/default.d.ts

@@ -1,5 +1,5 @@
 import { ReapplyCompatiblesConstraints } from '../constraints';
-type FillOutput<GenericArray extends readonly unknown[], GenericValue extends unknown> = ReapplyCompatiblesConstraints<GenericArray, readonly (GenericArray[number] | GenericValue)[]>;
-export declare function fill<GenericArray extends readonly unknown[], GenericValue extends unknown>(value: GenericValue, start: number, end: number): (array: GenericArray) => FillOutput<GenericArray, GenericValue>;
-export declare function fill<GenericArray extends readonly unknown[], GenericValue extends unknown>(array: GenericArray, value: GenericValue, start: number, end: number): FillOutput<GenericArray, GenericValue>;
+type FillOutput<GenericArray extends readonly unknown[], GenericValue extends unknown> = GenericArray extends unknown ? ReapplyCompatiblesConstraints<GenericArray, readonly (GenericArray[number] | GenericValue)[]> : never;
+export declare function fill<GenericArray extends readonly unknown[], const GenericValue extends unknown>(value: GenericValue, start: number, end: number): (array: GenericArray) => FillOutput<GenericArray, GenericValue>;
+export declare function fill<GenericArray extends readonly unknown[], const GenericValue extends unknown>(array: GenericArray, value: GenericValue, start: number, end: number): FillOutput<GenericArray, GenericValue>;
 export {};

package/dist/array/filter.d.ts

@@ -3,7 +3,7 @@ export interface FilterPredicateFunctionParams<GenericArray extends readonly unk
     index: number;
     self: GenericArray;
 }
-type FilterOutput<GenericArray extends readonly unknown[], GenericElement extends GenericArray[number] = GenericArray[number]> = ReapplyCompatiblesConstraints<GenericArray, readonly GenericElement[], "maxElements">;
+type FilterOutput<GenericArray extends readonly unknown[], GenericElement extends GenericArray[number] = GenericArray[number]> = GenericArray extends unknown ? ReapplyCompatiblesConstraints<GenericArray, readonly GenericElement[], "maxElements"> : never;
 export declare function filter<GenericArray extends readonly unknown[], GenericElement extends GenericArray[number]>(predicate: (element: GenericArray[number], params: FilterPredicateFunctionParams<GenericArray>) => element is GenericElement): (array: GenericArray) => FilterOutput<GenericArray, GenericElement>;
 export declare function filter<GenericArray extends readonly unknown[], GenericElement extends GenericArray[number]>(array: GenericArray, predicate: (element: GenericArray[number], params: FilterPredicateFunctionParams<GenericArray>) => element is GenericElement): FilterOutput<GenericArray, GenericElement>;
 export declare function filter<GenericArray extends readonly unknown[]>(predicate: (element: GenericArray[number], params: FilterPredicateFunctionParams<GenericArray>) => boolean): (array: GenericArray) => FilterOutput<GenericArray>;

package/dist/array/findAndReplace.d.ts

@@ -4,7 +4,7 @@ export interface FindAndReplacePredicateFunctionParams<GenericArray extends read
     index: number;
     self: GenericArray;
 }
-type FindAndReplaceOutput<GenericArray extends readonly unknown[], GenericValue extends DCommon.AnyValue> = (ReapplyCompatiblesConstraints<GenericArray, readonly (GenericArray[number] | GenericValue)[]> | undefined);
+type FindAndReplaceOutput<GenericArray extends readonly unknown[], GenericValue extends DCommon.AnyValue> = GenericArray extends unknown ? (ReapplyCompatiblesConstraints<GenericArray, readonly (GenericArray[number] | GenericValue)[]> | undefined) : never;
 export declare function findAndReplace<GenericArray extends readonly unknown[], GenericValue extends DCommon.AnyValue>(predicate: (element: GenericArray[number], params: FindAndReplacePredicateFunctionParams<GenericArray>) => boolean, value: GenericValue): (array: GenericArray) => Extract<FindAndReplaceOutput<GenericArray, GenericValue>, any>;
 export declare function findAndReplace<GenericArray extends readonly unknown[], GenericValue extends DCommon.AnyValue>(array: GenericArray, predicate: (element: GenericArray[number], params: FindAndReplacePredicateFunctionParams<GenericArray>) => boolean, value: GenericValue): Extract<FindAndReplaceOutput<GenericArray, GenericValue>, any>;
 export {};

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

@@ -3,7 +3,7 @@ export interface FindAndSpliceDeletePredicateFunctionParams<GenericArray extends
     index: number;
     self: GenericArray;
 }
-type FindAndSpliceDeleteOutput<GenericArray extends readonly unknown[]> = Extract<ReapplyCompatiblesConstraints<GenericArray, readonly GenericArray[number][], "maxElements"> | undefined, any>;
+type FindAndSpliceDeleteOutput<GenericArray extends readonly unknown[]> = GenericArray extends unknown ? Extract<ReapplyCompatiblesConstraints<GenericArray, readonly GenericArray[number][], "maxElements"> | undefined, any> : never;
 export declare function findAndSpliceDelete<GenericArray extends readonly unknown[]>(predicate: (element: GenericArray[number], params: FindAndSpliceDeletePredicateFunctionParams<GenericArray>) => boolean, deleteCount: number): (array: GenericArray) => Extract<FindAndSpliceDeleteOutput<GenericArray>, any>;
 export declare function findAndSpliceDelete<GenericArray extends readonly unknown[]>(array: GenericArray, predicate: (element: GenericArray[number], params: FindAndSpliceDeletePredicateFunctionParams<GenericArray>) => boolean, deleteCount: number): Extract<FindAndSpliceDeleteOutput<GenericArray>, any>;
 export {};

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

@@ -3,7 +3,7 @@ export interface FindAndSpliceInsertPredicateFunctionParams<GenericArray extends
     index: number;
     self: GenericArray;
 }
-type FindAndSpliceInsertOutput<GenericArray extends readonly unknown[], GenericElements extends readonly unknown[]> = ReapplyCompatiblesConstraints<GenericArray, readonly (GenericArray[number] | GenericElements[number])[], "minElements"> | undefined;
+type FindAndSpliceInsertOutput<GenericArray extends readonly unknown[], GenericElements extends readonly unknown[]> = GenericArray extends unknown ? (ReapplyCompatiblesConstraints<GenericArray, readonly (GenericArray[number] | GenericElements[number])[], "minElements"> | undefined) : never;
 export declare function findAndSpliceInsert<GenericElements extends readonly unknown[]>(predicate: (element: unknown, params: FindAndSpliceInsertPredicateFunctionParams) => boolean, elements: GenericElements): <GenericArray extends readonly unknown[]>(array: GenericArray) => Extract<FindAndSpliceInsertOutput<GenericArray, GenericElements>, any>;
 export declare function findAndSpliceInsert<GenericArray extends readonly unknown[], GenericElements extends readonly unknown[]>(array: GenericArray, predicate: (element: GenericArray[number], params: FindAndSpliceInsertPredicateFunctionParams<GenericArray>) => boolean, elements: GenericElements): Extract<FindAndSpliceInsertOutput<GenericArray, GenericElements>, any>;
 export {};

package/dist/array/index.cjs

@@ -43,7 +43,6 @@ const require_shift = require("./shift.cjs");
 const require_unshift = require("./unshift.cjs");
 const require_insert$2 = require("./insert.cjs");
 const require_reverse = require("./reverse.cjs");
-const require_infer = require("./infer.cjs");
 const require_notIncludes = require("./notIncludes.cjs");
 const require_findLast = require("./findLast.cjs");
 const require_findLastIndex = require("./findLastIndex.cjs");
@@ -82,7 +81,6 @@ var array_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	groupOutput: () => require_group.groupOutput,
 	includes: () => require_includes.includes,
 	indexOf: () => require_indexOf.indexOf,
-	infer: () => require_infer.infer,
 	insert: () => require_insert$2.insert,
 	is: () => require_is.is,
 	isLastIndex: () => require_isLastIndex.isLastIndex,
@@ -149,7 +147,6 @@ exports.group = require_group.group;
 exports.groupOutput = require_group.groupOutput;
 exports.includes = require_includes.includes;
 exports.indexOf = require_indexOf.indexOf;
-exports.infer = require_infer.infer;
 exports.insert = require_insert$2.insert;
 exports.is = require_is.is;
 exports.isLastIndex = require_isLastIndex.isLastIndex;

package/dist/array/index.d.ts

@@ -37,7 +37,6 @@ export * from './shift';
 export * from './unshift';
 export * from './insert';
 export * from './reverse';
-export * from './infer';
 export * from './notIncludes';
 export * from './findLast';
 export * from './findLastIndex';

package/dist/array/index.mjs

@@ -43,7 +43,6 @@ import { shift } from "./shift.mjs";
 import { unshift } from "./unshift.mjs";
 import { insert } from "./insert.mjs";
 import { reverse } from "./reverse.mjs";
-import { infer } from "./infer.mjs";
 import { notIncludes } from "./notIncludes.mjs";
 import { findLast } from "./findLast.mjs";
 import { findLastIndex } from "./findLastIndex.mjs";
@@ -82,7 +81,6 @@ var array_exports = /* @__PURE__ */ __exportAll({
 	groupOutput: () => groupOutput,
 	includes: () => includes,
 	indexOf: () => indexOf,
-	infer: () => infer,
 	insert: () => insert,
 	is: () => is,
 	isLastIndex: () => isLastIndex,
@@ -116,4 +114,4 @@ var array_exports = /* @__PURE__ */ __exportAll({
 	unshift: () => unshift
 });
 //#endregion
-export { array_exports, at, chunk, coalescing, concat, copyWithin, createKind, every, fill, fillAll, filter, find, findAndReplace, findAndSpliceDelete, findAndSpliceInsert, findAndSpliceReplace, findDuplicates, findIndex, findLast, findLastIndex, first, flat, flatMap, from, group, groupOutput, includes, indexOf, infer, insert, is, isLastIndex, last, lastIndexOf, length, lengthEqual, map, maxElements, minElements, notIncludes, pop, prepend, push, reduce, reduceFrom, reduceKind, reduceRight, reduceTools, reverse, select, selectTools, set, shift, slice, some, sort, spliceDelete, spliceInsert, spliceReplace, unshift };
+export { array_exports, at, chunk, coalescing, concat, copyWithin, createKind, every, fill, fillAll, filter, find, findAndReplace, findAndSpliceDelete, findAndSpliceInsert, findAndSpliceReplace, findDuplicates, findIndex, findLast, findLastIndex, first, flat, flatMap, from, group, groupOutput, includes, indexOf, insert, is, isLastIndex, last, lastIndexOf, length, lengthEqual, map, maxElements, minElements, notIncludes, pop, prepend, push, reduce, reduceFrom, reduceKind, reduceRight, reduceTools, reverse, select, selectTools, set, shift, slice, some, sort, spliceDelete, spliceInsert, spliceReplace, unshift };

package/dist/array/insert.d.ts

@@ -1,5 +1,5 @@
 import { ReapplyCompatiblesConstraints } from './constraints';
-type InsertOutput<GenericArray extends readonly unknown[], GenericValue extends unknown> = ReapplyCompatiblesConstraints<GenericArray, readonly (GenericArray[number] | GenericValue)[], "minElements">;
-export declare function insert<GenericValue extends unknown, GenericArray extends readonly unknown[]>(array: GenericArray): (value: GenericValue) => InsertOutput<GenericArray, GenericValue>;
-export declare function insert<GenericValue extends unknown, GenericArray extends readonly unknown[]>(value: GenericValue, array: GenericArray): InsertOutput<GenericArray, GenericValue>;
+type InsertOutput<GenericArray extends readonly unknown[], GenericValue extends unknown> = GenericArray extends unknown ? ReapplyCompatiblesConstraints<GenericArray, readonly (GenericArray[number] | GenericValue)[], "minElements"> : never;
+export declare function insert<const GenericValue extends unknown, GenericArray extends readonly unknown[]>(array: GenericArray): (value: GenericValue) => InsertOutput<GenericArray, GenericValue>;
+export declare function insert<const GenericValue extends unknown, GenericArray extends readonly unknown[]>(value: GenericValue, array: GenericArray): InsertOutput<GenericArray, GenericValue>;
 export {};

package/dist/array/length.d.ts

@@ -1,5 +1,5 @@
 import type * as DCommon from '../common';
 import type * as DNumber from '../number';
-type LengthOutput<GenericArray extends readonly unknown[]> = DCommon.IsEqual<GenericArray["length"], number> extends true ? number & DNumber.Positive : DNumber.IsGreater<GenericArray["length"], 0> extends true ? GenericArray["length"] & DNumber.StrictPositive : 0 & DNumber.Positive;
+type LengthOutput<GenericArray extends readonly unknown[]> = GenericArray extends unknown ? DCommon.IsEqual<GenericArray["length"], number> extends true ? number & DNumber.Positive : DNumber.IsGreater<GenericArray["length"], 0> extends true ? GenericArray["length"] & DNumber.StrictPositive : 0 & DNumber.Positive : never;
 export declare function length<GenericArray extends readonly unknown[]>(array: GenericArray): LengthOutput<GenericArray>;
 export {};

package/dist/array/lengthEqual.d.ts

@@ -6,7 +6,7 @@ type RequireMinElementsConstraint<GenericArray extends readonly unknown[], Gener
 type RequireMaxElementsConstraint<GenericArray extends readonly unknown[], GenericLength extends number> = ExtractMaxElements<GenericArray, unknown> extends MaxElements<infer InferredMax> ? DNumber.IsGreaterOrEqual<InferredMax, GenericLength> extends true ? unknown : DCommon.ComputedTypeError<`Cannot apply LengthEqual<${GenericLength}> on MaxElements<${InferredMax}>.`> : unknown;
 type RequireApplyLengthEqual<GenericArray extends readonly unknown[], GenericLength extends number> = (DNumber.ForbiddenNegative<GenericLength> & DNumber.RequireSimpleLiteral<GenericLength> & RequireLengthEqualConstraint<GenericArray, GenericLength> & RequireMinElementsConstraint<GenericArray, GenericLength> & RequireMaxElementsConstraint<GenericArray, GenericLength>);
 type RequireApplyLengthEqualBoolean<GenericArray extends readonly unknown[], GenericLength extends number> = DCommon.IsEqual<GenericLength, number> extends true ? unknown : RequireApplyLengthEqual<GenericArray, GenericLength>;
-type LengthEqualOutput<GenericArray extends readonly unknown[], GenericLength extends number> = GenericArray extends unknown ? IsImpossibleToApplyLengthEqual<GenericArray, LengthEqual<GenericLength>> extends true ? never : ComputeLengthEqualCompatibility<GenericArray, LengthEqual<GenericLength>, DCommon.CompatibilityConstraintResult<false, number, number>> extends infer InferredResult ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? GenericArray : GenericArray & LengthEqual<GenericLength> : never : never;
+type LengthEqualOutput<GenericArray extends readonly unknown[], GenericLength extends number> = GenericArray extends unknown ? IsImpossibleToApplyLengthEqual<GenericArray, LengthEqual<GenericLength>> extends true ? never : ComputeLengthEqualCompatibility<GenericArray, LengthEqual<GenericLength>, DCommon.CompatibilityConstraintResult<false, number, number>> extends infer InferredResult ? DCommon.ContainExtends<InferredResult, DCommon.CompatibilityConstraintResult<true>> extends true ? GenericArray : GenericArray & LengthEqual<GenericLength> : never : never;
 export declare function lengthEqual<GenericArray extends readonly unknown[], const GenericLength extends number>(length: GenericLength & RequireApplyLengthEqual<GenericArray, GenericLength>): (array: GenericArray) => array is LengthEqualOutput<GenericArray, GenericLength>;
 export declare function lengthEqual<GenericArray extends readonly unknown[], const GenericLength extends number>(length: GenericLength & RequireApplyLengthEqualBoolean<GenericArray, GenericLength>): (array: GenericArray) => boolean;
 export declare function lengthEqual<GenericArray extends readonly unknown[], const GenericLength extends number>(array: GenericArray, length: GenericLength & RequireApplyLengthEqual<GenericArray, GenericLength>): array is LengthEqualOutput<GenericArray, GenericLength>;

package/dist/array/map.d.ts

@@ -3,7 +3,7 @@ export interface MapTheFunctionParams<GenericInputArray extends readonly unknown
     index: number;
     self: GenericInputArray;
 }
-type MapOutput<GenericArray extends readonly unknown[], GenericOutput extends unknown> = ReapplyCompatiblesConstraints<GenericArray, readonly GenericOutput[]>;
+type MapOutput<GenericArray extends readonly unknown[], GenericOutput extends unknown> = GenericArray extends unknown ? ReapplyCompatiblesConstraints<GenericArray, readonly GenericOutput[]> : never;
 export declare function map<GenericArray extends readonly unknown[], GenericOutput extends unknown>(theFunction: (element: GenericArray[number], params: MapTheFunctionParams<GenericArray>) => GenericOutput): (array: GenericArray) => MapOutput<GenericArray, GenericOutput>;
 export declare function map<GenericArray extends readonly unknown[], GenericOutput extends unknown>(array: GenericArray, theFunction: (element: GenericArray[number], params: MapTheFunctionParams<GenericArray>) => GenericOutput): MapOutput<GenericArray, GenericOutput>;
 export {};

package/dist/array/maxElements.d.ts

@@ -5,7 +5,7 @@ type RequireLengthEqualConstraint<GenericArray extends readonly unknown[], Gener
 type RequireMinElementsConstraint<GenericArray extends readonly unknown[], GenericMax extends number> = ExtractMinElements<GenericArray, unknown> extends MinElements<infer InferredMin> ? DNumber.IsGreaterOrEqual<GenericMax, InferredMin> extends true ? unknown : DCommon.ComputedTypeError<`Cannot apply MaxElements<${GenericMax}> on MinElements<${InferredMin}>.`> : unknown;
 type RequireApplyMaxElements<GenericArray extends readonly unknown[], GenericMax extends number> = (DNumber.ForbiddenNegative<GenericMax> & DNumber.RequireSimpleLiteral<GenericMax> & RequireLengthEqualConstraint<GenericArray, GenericMax> & RequireMinElementsConstraint<GenericArray, GenericMax>);
 type RequireApplyMaxElementsBoolean<GenericArray extends readonly unknown[], GenericMax extends number> = DCommon.IsEqual<GenericMax, number> extends true ? unknown : RequireApplyMaxElements<GenericArray, GenericMax>;
-type MaxElementsOutput<GenericArray extends readonly unknown[], GenericMax extends number> = GenericArray extends unknown ? IsImpossibleToApplyMaxElements<GenericArray, MaxElements<GenericMax>> extends true ? never : ComputeMaxElementsCompatibility<GenericArray, MaxElements<GenericMax>, DCommon.CompatibilityConstraintResult<false, number, number>> extends infer InferredResult ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? GenericArray : GenericArray & MaxElements<GenericMax> : never : never;
+type MaxElementsOutput<GenericArray extends readonly unknown[], GenericMax extends number> = GenericArray extends unknown ? IsImpossibleToApplyMaxElements<GenericArray, MaxElements<GenericMax>> extends true ? never : ComputeMaxElementsCompatibility<GenericArray, MaxElements<GenericMax>, DCommon.CompatibilityConstraintResult<false, number, number>> extends infer InferredResult ? DCommon.ContainExtends<InferredResult, DCommon.CompatibilityConstraintResult<true>> extends true ? GenericArray : GenericArray & MaxElements<GenericMax> : never : never;
 export declare function maxElements<GenericArray extends readonly unknown[], const GenericMax extends number>(max: GenericMax & RequireApplyMaxElements<GenericArray, GenericMax>): (array: GenericArray) => array is MaxElementsOutput<GenericArray, GenericMax>;
 export declare function maxElements<GenericArray extends readonly unknown[], const GenericMax extends number>(max: GenericMax & RequireApplyMaxElementsBoolean<GenericArray, GenericMax>): (array: GenericArray) => boolean;
 export declare function maxElements<GenericArray extends readonly unknown[], const GenericMax extends number>(array: GenericArray, max: GenericMax & RequireApplyMaxElements<GenericArray, GenericMax>): array is MaxElementsOutput<GenericArray, GenericMax>;

package/dist/array/minElements.d.ts

@@ -5,7 +5,7 @@ type RequireLengthEqualConstraint<GenericArray extends readonly unknown[], Gener
 type RequireMaxElementsConstraint<GenericArray extends readonly unknown[], GenericMin extends number> = ExtractMaxElements<GenericArray, unknown> extends MaxElements<infer InferredMax> ? DNumber.IsGreaterOrEqual<InferredMax, GenericMin> extends true ? unknown : DCommon.ComputedTypeError<`Cannot apply MinElements<${GenericMin}> on MaxElements<${InferredMax}>.`> : unknown;
 type RequireApplyMinElements<GenericArray extends readonly unknown[], GenericMin extends number> = (DNumber.ForbiddenNegative<GenericMin> & DNumber.RequireSimpleLiteral<GenericMin> & RequireLengthEqualConstraint<GenericArray, GenericMin> & RequireMaxElementsConstraint<GenericArray, GenericMin>);
 type RequireApplyMinElementsBoolean<GenericArray extends readonly unknown[], GenericMin extends number> = DCommon.IsEqual<GenericMin, number> extends true ? unknown : RequireApplyMinElements<GenericArray, GenericMin>;
-type MinElementsOutput<GenericArray extends readonly unknown[], GenericMin extends number> = GenericArray extends unknown ? IsImpossibleToApplyMinElements<GenericArray, MinElements<GenericMin>> extends true ? never : ComputeMinElementsCompatibility<GenericArray, MinElements<GenericMin>, DCommon.CompatibilityConstraintResult<false, number, number>> extends infer InferredResult ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? GenericArray : GenericArray & MinElements<GenericMin> : never : never;
+type MinElementsOutput<GenericArray extends readonly unknown[], GenericMin extends number> = GenericArray extends unknown ? IsImpossibleToApplyMinElements<GenericArray, MinElements<GenericMin>> extends true ? never : ComputeMinElementsCompatibility<GenericArray, MinElements<GenericMin>, DCommon.CompatibilityConstraintResult<false, number, number>> extends infer InferredResult ? DCommon.ContainExtends<InferredResult, DCommon.CompatibilityConstraintResult<true>> extends true ? GenericArray : GenericArray & MinElements<GenericMin> : never : never;
 export declare function minElements<GenericArray extends readonly unknown[], const GenericMin extends number>(min: GenericMin & RequireApplyMinElements<GenericArray, GenericMin>): (array: GenericArray) => array is MinElementsOutput<GenericArray, GenericMin>;
 export declare function minElements<GenericArray extends readonly unknown[], const GenericMin extends number>(min: GenericMin & RequireApplyMinElementsBoolean<GenericArray, GenericMin>): (array: GenericArray) => boolean;
 export declare function minElements<GenericArray extends readonly unknown[], const GenericMin extends number>(array: GenericArray, min: GenericMin & RequireApplyMinElements<GenericArray, GenericMin>): array is MinElementsOutput<GenericArray, GenericMin>;

package/dist/array/pop.d.ts

@@ -1,4 +1,4 @@
 import { ReapplyCompatiblesConstraints } from './constraints';
-type PopOutput<GenericArray extends readonly unknown[]> = ReapplyCompatiblesConstraints<GenericArray, readonly GenericArray[number][], "maxElements">;
+type PopOutput<GenericArray extends readonly unknown[]> = GenericArray extends unknown ? ReapplyCompatiblesConstraints<GenericArray, readonly GenericArray[number][], "maxElements"> : never;
 export declare function pop<GenericArray extends readonly unknown[]>(array: GenericArray): PopOutput<GenericArray>;
 export {};

package/dist/array/prepend.d.ts

@@ -1,5 +1,5 @@
 import { ReapplyCompatiblesConstraints } from './constraints';
-type PrependOutput<GenericArray extends readonly unknown[], GenericElements extends readonly unknown[], GenericElementsRest extends readonly unknown[][] = []> = ReapplyCompatiblesConstraints<GenericArray, readonly (GenericElements[number] | GenericElementsRest[number][number] | GenericArray[number])[], "minElements">;
+type PrependOutput<GenericArray extends readonly unknown[], GenericElements extends readonly unknown[], GenericElementsRest extends readonly unknown[][] = []> = GenericArray extends unknown ? ReapplyCompatiblesConstraints<GenericArray, readonly (GenericElements[number] | GenericElementsRest[number][number] | GenericArray[number])[], "minElements"> : never;
 export declare function prepend<GenericArray extends readonly unknown[], GenericElements extends readonly unknown[]>(elements: GenericElements): (array: GenericArray) => PrependOutput<GenericArray, GenericElements>;
 export declare function prepend<GenericArray extends readonly unknown[], GenericElements extends readonly unknown[], GenericElementsRest extends readonly unknown[][]>(array: GenericArray, elements: GenericElements, ...elementsRest: GenericElementsRest): PrependOutput<GenericArray, GenericElements, GenericElementsRest>;
 export {};

package/dist/array/push.d.ts

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

package/dist/array/reverse.d.ts

@@ -1,4 +1,4 @@
 import { ReapplyCompatiblesConstraints } from './constraints';
-type ReverseOutput<GenericArray extends readonly unknown[]> = ReapplyCompatiblesConstraints<GenericArray, readonly GenericArray[number][]>;
+type ReverseOutput<GenericArray extends readonly unknown[]> = GenericArray extends unknown ? ReapplyCompatiblesConstraints<GenericArray, readonly GenericArray[number][]> : never;
 export declare function reverse<GenericArray extends readonly unknown[]>(array: GenericArray): ReverseOutput<GenericArray>;
 export {};

package/dist/array/shift.d.ts

@@ -1,4 +1,4 @@
 import { ReapplyCompatiblesConstraints } from './constraints';
-type ShiftOutput<GenericArray extends readonly unknown[]> = ReapplyCompatiblesConstraints<GenericArray, readonly GenericArray[number][], "maxElements">;
+type ShiftOutput<GenericArray extends readonly unknown[]> = GenericArray extends unknown ? ReapplyCompatiblesConstraints<GenericArray, readonly GenericArray[number][], "maxElements"> : never;
 export declare function shift<GenericArray extends readonly unknown[]>(array: GenericArray): ShiftOutput<GenericArray>;
 export {};

package/dist/array/sort.d.ts

@@ -1,5 +1,5 @@
 import { ReapplyCompatiblesConstraints } from './constraints';
-type SortOutput<GenericArray extends readonly unknown[], GenericElement extends GenericArray[number]> = ReapplyCompatiblesConstraints<GenericArray, readonly GenericElement[]>;
+type SortOutput<GenericArray extends readonly unknown[], GenericElement extends GenericArray[number]> = GenericArray extends unknown ? ReapplyCompatiblesConstraints<GenericArray, readonly GenericElement[]> : never;
 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/splice/delete.d.ts

@@ -1,5 +1,5 @@
 import { ReapplyCompatiblesConstraints } from '../constraints';
-type SpliceDeleteOutput<GenericArray extends readonly unknown[]> = ReapplyCompatiblesConstraints<GenericArray, readonly GenericArray[number][], "maxElements">;
+type SpliceDeleteOutput<GenericArray extends readonly unknown[]> = GenericArray extends unknown ? ReapplyCompatiblesConstraints<GenericArray, readonly GenericArray[number][], "maxElements"> : never;
 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/insert.d.ts

@@ -1,5 +1,5 @@
 import { ReapplyCompatiblesConstraints } from '../constraints';
-type SpliceInsertOutput<GenericArray extends readonly unknown[], GenericElements extends readonly unknown[]> = ReapplyCompatiblesConstraints<GenericArray, readonly (GenericArray[number] | GenericElements[number])[], "minElements">;
+type SpliceInsertOutput<GenericArray extends readonly unknown[], GenericElements extends readonly unknown[]> = GenericArray extends unknown ? ReapplyCompatiblesConstraints<GenericArray, readonly (GenericArray[number] | GenericElements[number])[], "minElements"> : never;
 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/unshift.d.ts

@@ -1,5 +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>;
+type UnshiftOutput<GenericArray extends readonly unknown[], GenericValue extends unknown, GenericValuesRest extends readonly unknown[] = []> = GenericArray extends unknown ? ReapplyCompatiblesConstraints<GenericArray, readonly (GenericValue | GenericValuesRest[number] | GenericArray[number])[], "minElements"> : never;
+export declare function unshift<GenericArray extends readonly unknown[], const GenericValue extends unknown>(value: GenericValue): (array: GenericArray) => UnshiftOutput<GenericArray, GenericValue>;
+export declare function unshift<GenericArray extends readonly unknown[], const GenericValue extends unknown, GenericValuesRest extends readonly unknown[]>(array: GenericArray, value: GenericValue, ...valuesRest: GenericValuesRest): UnshiftOutput<GenericArray, GenericValue, GenericValuesRest>;
 export {};

package/dist/chrono/createDate.cjs

@@ -3,8 +3,8 @@ 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_when = require("../either/left/when.cjs");
 const require_unwrap = require("../either/right/unwrap.cjs");
 const require_safeCallback = require("../either/safeCallback.cjs");
 const require_isSafeTimestamp = require("./isSafeTimestamp.cjs");
@@ -28,23 +28,23 @@ function createDate(input, params) {
 		return require_theDate.TheDate.new(date.getTime());
 	}
 	if (typeof input === "object") {
-		let inputValueResult = void 0;
+		let resolvedDate = 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);
+			resolvedDate = createFromTimestamp(Number(sign === "-" ? `-${value}` : value));
+		} else if (require_isDate.isDate(input.value)) resolvedDate = require_create$1.right("date-created", input.value);
+		else if (input.value instanceof Date) resolvedDate = createFromTimestamp(input.value.getTime());
+		else if (typeof input.value === "number") resolvedDate = 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));
+				resolvedDate = 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));
+		if (!resolvedDate || require_is.isLeft(resolvedDate)) return resolvedDate || require_create.left("date-created-error", null);
+		const date = require_toNative.toNative(require_unwrap.unwrapRight(resolvedDate));
 		input.year && date.setUTCFullYear(input.year);
 		input.month && date.setMonth(input.month);
 		input.day && date.setDate(input.day);

package/dist/chrono/createDate.d.ts

@@ -3,7 +3,7 @@ import { Hour, IsLeapYear, IsSafeYear, Millisecond, Minute, Second, MonthWithDay
 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>;
+export type MayBeDate = 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>,
@@ -15,7 +15,7 @@ export interface CreateSafeDateParams {
     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 TheDate | Date | number | SerializedTheDate>(input: GenericInput): MayBeDate;
+export declare function createDate<GenericInput extends SpoolingDate>(input: GenericInput): MayBeDate;
 export declare function createDate<GenericInput extends SafeDate>(input: GenericInput & ForbiddenDate<GenericInput>, params?: CreateSafeDateParams): TheDate;
 export {};

package/dist/chrono/createDate.mjs

@@ -3,8 +3,8 @@ 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 { whenIsLeft } from "../either/left/when.mjs";
 import { unwrapRight } from "../either/right/unwrap.mjs";
 import { safeCallback } from "../either/safeCallback.mjs";
 import { isSafeTimestamp } from "./isSafeTimestamp.mjs";
@@ -28,23 +28,23 @@ function createDate(input, params) {
 		return TheDate.new(date.getTime());
 	}
 	if (typeof input === "object") {
-		let inputValueResult = void 0;
+		let resolvedDate = 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);
+			resolvedDate = createFromTimestamp(Number(sign === "-" ? `-${value}` : value));
+		} else if (isDate(input.value)) resolvedDate = right("date-created", input.value);
+		else if (input.value instanceof Date) resolvedDate = createFromTimestamp(input.value.getTime());
+		else if (typeof input.value === "number") resolvedDate = 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));
+				resolvedDate = 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));
+		if (!resolvedDate || isLeft(resolvedDate)) return resolvedDate || left("date-created-error", null);
+		const date = toNative(unwrapRight(resolvedDate));
 		input.year && date.setUTCFullYear(input.year);
 		input.month && date.setMonth(input.month);
 		input.day && date.setDate(input.day);

package/dist/chrono/createTime.cjs

@@ -1,7 +1,11 @@
 const require_constants = require("./constants.cjs");
 const require_theTime = require("./theTime.cjs");
+const require_isTime = require("./isTime.cjs");
 const require_create = require("../either/left/create.cjs");
+const require_is = require("../either/left/is.cjs");
 const require_create$1 = require("../either/right/create.cjs");
+const require_unwrap = require("../either/right/unwrap.cjs");
+const require_toNative = require("./toNative.cjs");
 const require_isSafeTimeValue = require("./isSafeTimeValue.cjs");
 //#region scripts/chrono/createTime.ts
 const unitMapper = {
@@ -18,24 +22,31 @@ function createTime(input, unit) {
 		if (unit) return require_theTime.TheTime.new(input * unitMapper[unit]);
 		return createFromTimeValue(input * unitMapper[unit ?? "millisecond"]);
 	}
-	if (typeof input === "string") {
-		const serializeTheTimeMatch = input.match(require_constants.serializeTheTimeRegex);
-		if (!serializeTheTimeMatch) return require_create.left("time-created-error", null);
+	const serializeTheTimeMatch = typeof input === "string" && input.match(require_constants.serializeTheTimeRegex);
+	if (serializeTheTimeMatch) {
 		const { value, sign } = serializeTheTimeMatch.groups;
 		return createFromTimeValue(Number(sign === "-" ? `-${value}` : value));
 	}
-	const { value = 0, week = 0, day = 0, hour = 0, minute = 0, second = 0, millisecond = 0 } = input;
-	let fromValue = 0;
-	if (typeof value === "number") fromValue = value;
-	else {
-		const theTimeMatch = value.match(require_constants.isoTimeRegex);
-		if (theTimeMatch) {
-			const { sign = "+", hour, minute, second = 0, millisecond = 0 } = theTimeMatch.groups;
-			fromValue = Number(hour) * require_constants.millisecondInOneHour + Number(minute) * require_constants.millisecondInOneMinute + Number(second) * require_constants.millisecondsInOneSecond + Number(millisecond);
-			fromValue = sign === "-" ? -fromValue : fromValue;
+	if (typeof input === "object") {
+		let resolvedTime = void 0;
+		const serializeTheTimeMatch = typeof input.value === "string" && input.value.match(require_constants.serializeTheTimeRegex);
+		if (serializeTheTimeMatch) {
+			const { value, sign } = serializeTheTimeMatch.groups;
+			resolvedTime = createFromTimeValue(Number(sign === "-" ? `-${value}` : value));
+		} else if (typeof input.value === "number") resolvedTime = createFromTimeValue(input.value);
+		else if (require_isTime.isTime(input.value)) resolvedTime = require_create$1.right("time-created", input.value);
+		else {
+			const theTimeMatch = input.value?.match(require_constants.isoTimeRegex);
+			if (theTimeMatch) {
+				const { sign = "+", hour, minute, second = 0, millisecond = 0 } = theTimeMatch.groups;
+				resolvedTime = createFromTimeValue((Number(hour) * require_constants.millisecondInOneHour + Number(minute) * require_constants.millisecondInOneMinute + Number(second) * require_constants.millisecondsInOneSecond + Number(millisecond)) * (sign === "-" ? -1 : 1));
+			}
 		}
+		if (!resolvedTime || require_is.isLeft(resolvedTime)) return resolvedTime || require_create.left("time-created-error", null);
+		const { week = 0, day = 0, hour = 0, minute = 0, second = 0, millisecond = 0 } = input;
+		return createFromTimeValue(require_toNative.toNative(require_unwrap.unwrapRight(resolvedTime)) + week * require_constants.millisecondInOneWeek + day * require_constants.millisecondsInOneDay + hour * require_constants.millisecondInOneHour + minute * require_constants.millisecondInOneMinute + second * require_constants.millisecondsInOneSecond + millisecond);
 	}
-	return createFromTimeValue(fromValue + week * require_constants.millisecondInOneWeek + day * require_constants.millisecondsInOneDay + hour * require_constants.millisecondInOneHour + minute * require_constants.millisecondInOneMinute + second * require_constants.millisecondsInOneSecond + millisecond);
+	return require_create.left("time-created-error", null);
 }
 function createFromTimeValue(timeValue) {
 	if (!require_isSafeTimeValue.isSafeTimeValue(timeValue)) return require_create.left("time-created-error", null);

package/dist/chrono/createTime.mjs

@@ -1,7 +1,11 @@
 import { isoTimeRegex, millisecondInOneHour, millisecondInOneMinute, millisecondInOneWeek, millisecondsInOneDay, millisecondsInOneSecond, serializeTheTimeRegex } from "./constants.mjs";
 import { TheTime } from "./theTime.mjs";
+import { isTime } from "./isTime.mjs";
 import { left } from "../either/left/create.mjs";
+import { isLeft } from "../either/left/is.mjs";
 import { right } from "../either/right/create.mjs";
+import { unwrapRight } from "../either/right/unwrap.mjs";
+import { toNative } from "./toNative.mjs";
 import { isSafeTimeValue } from "./isSafeTimeValue.mjs";
 //#region scripts/chrono/createTime.ts
 const unitMapper = {
@@ -18,24 +22,31 @@ function createTime(input, unit) {
 		if (unit) return TheTime.new(input * unitMapper[unit]);
 		return createFromTimeValue(input * unitMapper[unit ?? "millisecond"]);
 	}
-	if (typeof input === "string") {
-		const serializeTheTimeMatch = input.match(serializeTheTimeRegex);
-		if (!serializeTheTimeMatch) return left("time-created-error", null);
+	const serializeTheTimeMatch = typeof input === "string" && input.match(serializeTheTimeRegex);
+	if (serializeTheTimeMatch) {
 		const { value, sign } = serializeTheTimeMatch.groups;
 		return createFromTimeValue(Number(sign === "-" ? `-${value}` : value));
 	}
-	const { value = 0, week = 0, day = 0, hour = 0, minute = 0, second = 0, millisecond = 0 } = input;
-	let fromValue = 0;
-	if (typeof value === "number") fromValue = value;
-	else {
-		const theTimeMatch = value.match(isoTimeRegex);
-		if (theTimeMatch) {
-			const { sign = "+", hour, minute, second = 0, millisecond = 0 } = theTimeMatch.groups;
-			fromValue = Number(hour) * millisecondInOneHour + Number(minute) * millisecondInOneMinute + Number(second) * millisecondsInOneSecond + Number(millisecond);
-			fromValue = sign === "-" ? -fromValue : fromValue;
+	if (typeof input === "object") {
+		let resolvedTime = void 0;
+		const serializeTheTimeMatch = typeof input.value === "string" && input.value.match(serializeTheTimeRegex);
+		if (serializeTheTimeMatch) {
+			const { value, sign } = serializeTheTimeMatch.groups;
+			resolvedTime = createFromTimeValue(Number(sign === "-" ? `-${value}` : value));
+		} else if (typeof input.value === "number") resolvedTime = createFromTimeValue(input.value);
+		else if (isTime(input.value)) resolvedTime = right("time-created", input.value);
+		else {
+			const theTimeMatch = input.value?.match(isoTimeRegex);
+			if (theTimeMatch) {
+				const { sign = "+", hour, minute, second = 0, millisecond = 0 } = theTimeMatch.groups;
+				resolvedTime = createFromTimeValue((Number(hour) * millisecondInOneHour + Number(minute) * millisecondInOneMinute + Number(second) * millisecondsInOneSecond + Number(millisecond)) * (sign === "-" ? -1 : 1));
+			}
 		}
+		if (!resolvedTime || isLeft(resolvedTime)) return resolvedTime || left("time-created-error", null);
+		const { week = 0, day = 0, hour = 0, minute = 0, second = 0, millisecond = 0 } = input;
+		return createFromTimeValue(toNative(unwrapRight(resolvedTime)) + week * millisecondInOneWeek + day * millisecondsInOneDay + hour * millisecondInOneHour + minute * millisecondInOneMinute + second * millisecondsInOneSecond + millisecond);
 	}
-	return createFromTimeValue(fromValue + week * millisecondInOneWeek + day * millisecondsInOneDay + hour * millisecondInOneHour + minute * millisecondInOneMinute + second * millisecondsInOneSecond + millisecond);
+	return left("time-created-error", null);
 }
 function createFromTimeValue(timeValue) {
 	if (!isSafeTimeValue(timeValue)) return left("time-created-error", null);