@duplojs/lang 0.0.1-beta.1 → 0.0.1-beta.3

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/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/common/constraint/index.d.ts

@@ -1,2 +1,3 @@
 export * from './cast';
+export * from './remove';
 export * from './types';

package/dist/common/constraint/remove.cjs

@@ -0,0 +1,6 @@
+//#region scripts/common/constraint/remove.ts
+function removeConstraint(value) {
+	return value;
+}
+//#endregion
+exports.removeConstraint = removeConstraint;

package/dist/common/constraint/remove.d.ts

@@ -0,0 +1,2 @@
+import { RemoveConstraint } from './types';
+export declare function removeConstraint<GenericValue extends unknown>(value: GenericValue): GenericValue extends unknown ? RemoveConstraint<GenericValue> : never;

package/dist/common/constraint/remove.mjs

@@ -0,0 +1,6 @@
+//#region scripts/common/constraint/remove.ts
+function removeConstraint(value) {
+	return value;
+}
+//#endregion
+export { removeConstraint };

package/dist/common/index.cjs

@@ -13,6 +13,7 @@ const require_builder = require("./builder.cjs");
 const require_callThen = require("./callThen.cjs");
 const require_clone = require("./clone.cjs");
 const require_index = require("./constraint/cast/index.cjs");
+const require_remove = require("./constraint/remove.cjs");
 const require_detachObjectMethod = require("./detachObjectMethod.cjs");
 const require_enum = require("./enum.cjs");
 const require_equal = require("./equal.cjs");
@@ -104,6 +105,7 @@ var common_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	promiseAll: () => require_promiseAll.promiseAll,
 	promiseObject: () => require_promiseObject.promiseObject,
 	queueKind: () => require_queue.queueKind,
+	removeConstraint: () => require_remove.removeConstraint,
 	shameOnYou: () => require_index.shameOnYou,
 	simpleClone: () => require_simpleClone.simpleClone,
 	stringToBytes: () => require_stringToBytes.stringToBytes,
@@ -177,6 +179,7 @@ exports.preparePipe = require_preparePipe.preparePipe;
 exports.promiseAll = require_promiseAll.promiseAll;
 exports.promiseObject = require_promiseObject.promiseObject;
 exports.queueKind = require_queue.queueKind;
+exports.removeConstraint = require_remove.removeConstraint;
 exports.shameOnYou = require_index.shameOnYou;
 exports.simpleClone = require_simpleClone.simpleClone;
 exports.stringToBytes = require_stringToBytes.stringToBytes;

package/dist/common/index.mjs

@@ -13,6 +13,7 @@ import { MissingBuilderMethodsError, builderKind, createBuilder } from "./builde
 import { callThen } from "./callThen.mjs";
 import { clone } from "./clone.mjs";
 import { cast, shameOnYou } from "./constraint/cast/index.mjs";
+import { removeConstraint } from "./constraint/remove.mjs";
 import { detachObjectMethod } from "./detachObjectMethod.mjs";
 import { createEnum } from "./enum.mjs";
 import { equal } from "./equal.mjs";
@@ -104,6 +105,7 @@ var common_exports = /* @__PURE__ */ __exportAll({
 	promiseAll: () => promiseAll,
 	promiseObject: () => promiseObject,
 	queueKind: () => queueKind,
+	removeConstraint: () => removeConstraint,
 	shameOnYou: () => shameOnYou,
 	simpleClone: () => simpleClone,
 	stringToBytes: () => stringToBytes,
@@ -121,4 +123,4 @@ var common_exports = /* @__PURE__ */ __exportAll({
 	whenNot: () => whenNot
 });
 //#endregion
-export { AssertsError, InvalidBytesInStringError, InvalidMillisecondInStringError, MissingBuilderMethodsError, TheFormData, and, asserts, asyncInnerPipe, asyncLoop, asyncPipe, bindPrototypeMethods, builderKind, callThen, cast, clone, common_exports, createAsyncRetry, createBuilder, createEnum, createExternalPromise, createFormData, createGlobalStore, createInterpolation, createKind, createQueue, createTransformer, detachObjectMethod, equal, escapeRegExp, falsy, forward, forwardAsserts, forwardLog, innerPipe, instanceOf, isType, justExec, justReturn, loop, memo, memoObject, memoPromise, mimeType, or, pipe, pipeCall, prepareAsyncPipe, preparePipe, promiseAll, promiseObject, queueKind, shameOnYou, simpleClone, stringToBytes, stringToMillisecond, timeout, toCurriedPredicate, toJSON, toNative, toRegExp, transformer, truthy, useAsyncRetry, when, whenElse, whenNot };
+export { AssertsError, InvalidBytesInStringError, InvalidMillisecondInStringError, MissingBuilderMethodsError, TheFormData, and, asserts, asyncInnerPipe, asyncLoop, asyncPipe, bindPrototypeMethods, builderKind, callThen, cast, clone, common_exports, createAsyncRetry, createBuilder, createEnum, createExternalPromise, createFormData, createGlobalStore, createInterpolation, createKind, createQueue, createTransformer, detachObjectMethod, equal, escapeRegExp, falsy, forward, forwardAsserts, forwardLog, innerPipe, instanceOf, isType, justExec, justReturn, loop, memo, memoObject, memoPromise, mimeType, or, pipe, pipeCall, prepareAsyncPipe, preparePipe, promiseAll, promiseObject, queueKind, removeConstraint, shameOnYou, simpleClone, stringToBytes, stringToMillisecond, timeout, toCurriedPredicate, toJSON, toNative, toRegExp, transformer, truthy, useAsyncRetry, when, whenElse, whenNot };

package/dist/common/types/forward.d.ts

@@ -0,0 +1 @@
+export type Forward<GenericValue extends unknown> = GenericValue;

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

@@ -22,6 +22,7 @@ export type * from './fixDeepFunctionInfer';
 export type * from './forbiddenPromise';
 export type * from './forbiddenUnion';
 export type * from './forcePredicate';
+export type * from './forward';
 export type * from './hasSomething';
 export type * from './isEqual';
 export type * from './isNever';
@@ -48,6 +49,7 @@ export type * from './simplifyTopLevel';
 export type * from './simplifyType';
 export type * from './simplifyTypeForce';
 export type * from './sortType';
+export type * from './splitPromise';
 export type * from './toLargeEnsemble';
 export type * from './unionContain';
 export type * from './unionToIntersection';

package/dist/common/types/splitPromise.d.ts

@@ -0,0 +1 @@
+export type SplitPromise<GenericValue extends unknown> = GenericValue extends Promise<infer InferredValue> ? InferredValue extends unknown ? Promise<InferredValue> : never : GenericValue;

package/dist/dataStructure/common/codec.cjs

@@ -6,13 +6,14 @@ const require_resultSymbol = require("./resultSymbol.cjs");
 const codecKind = require_kind.createKind("codec");
 const codecsKind = require_kind.createKind("codecs");
 function createCodec(fundamentalType, predicateEncode, encode, decode) {
-	return {
+	const self = {
 		fundamentalType,
-		predicateEncode,
-		encode: (data, errorHandler) => errorHandler?.().setCurrentContext("encode") ?? require_callThen.callThen(encode(data, errorHandler), (encodedData) => encodedData === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(predicateEncode(encodedData, errorHandler), (result) => errorHandler?.().setCurrentContext("default") ?? (result === false ? require_resultSymbol.ErrorSymbol : encodedData))),
-		decode: (data, errorHandler) => errorHandler?.().setCurrentContext("decode") ?? require_callThen.callThen(predicateEncode(data, errorHandler), (result) => result === false ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(decode(data, errorHandler), (result) => errorHandler?.().setCurrentContext("default") ?? result)),
+		predicateEncode: (data) => predicateEncode(data),
+		encode: (data, errorHandler) => require_callThen.callThen(encode(data, self, errorHandler), (encodedData) => encodedData === require_resultSymbol.ErrorSymbol ? require_resultSymbol.ErrorSymbol : require_callThen.callThen(predicateEncode(encodedData), (result) => result === false ? errorHandler?.().addEncodeIssue(self, encodedData) ?? require_resultSymbol.ErrorSymbol : encodedData)),
+		decode: (data, errorHandler) => require_callThen.callThen(predicateEncode(data), (result) => result === false ? errorHandler?.().addDecodeIssue(self, data) ?? require_resultSymbol.ErrorSymbol : decode(data, self, errorHandler)),
 		[codecKind.runTimeKey]: null
 	};
+	return self;
 }
 function createCodecs(definition) {
 	return {

package/dist/dataStructure/common/codec.d.ts

@@ -1,13 +1,13 @@
 import { FundamentalTypeValue, FundamentalType } from '../fundamentalType';
 import { GetErrorHandler } from './error';
 import { ErrorSymbol } from './resultSymbol';
-import { DObject } from '../../index.ts';
 import type * as DKind from '../../kind';
 import * as DCommon from '../../common';
+import type * as DObject from '../../object';
 export declare const codecKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/codec", unknown>>;
 export interface Codec<GenericFundamentalType extends FundamentalType = FundamentalType, GenericEncodedValue extends unknown = unknown> extends DKind.Kind<typeof codecKind> {
     readonly fundamentalType: GenericFundamentalType;
-    predicateEncode(input: unknown, errorHandler?: GetErrorHandler): input is GenericEncodedValue;
+    predicateEncode(input: unknown): input is GenericEncodedValue;
     encode(data: FundamentalTypeValue<GenericFundamentalType>, errorHandler?: GetErrorHandler): DCommon.MaybePromise<GenericEncodedValue | ErrorSymbol>;
     decode(data: GenericEncodedValue, errorHandler?: GetErrorHandler): DCommon.MaybePromise<FundamentalTypeValue<GenericFundamentalType> | ErrorSymbol>;
 }
@@ -17,7 +17,7 @@ export interface Codecs<GenericCodecMapper extends Record<string, Codec> = Recor
     readonly definition: GenericCodecMapper;
     readonly context: DCommon.Memoized<CodecContext>;
 }
-export declare function createCodec<GenericFundamentalType extends FundamentalType = FundamentalType, GenericEncodedValue extends unknown = unknown>(fundamentalType: GenericFundamentalType, predicateEncode: (input: unknown, errorHandler?: GetErrorHandler) => input is GenericEncodedValue, encode: (data: FundamentalTypeValue<GenericFundamentalType>, errorHandler?: GetErrorHandler) => DCommon.MaybePromise<GenericEncodedValue | ErrorSymbol>, decode: (data: GenericEncodedValue, errorHandler?: GetErrorHandler) => DCommon.MaybePromise<FundamentalTypeValue<GenericFundamentalType> | ErrorSymbol>): Codec<GenericFundamentalType, GenericEncodedValue>;
+export declare function createCodec<GenericFundamentalType extends FundamentalType = FundamentalType, GenericEncodedValue extends unknown = unknown>(fundamentalType: GenericFundamentalType, predicateEncode: (data: unknown) => data is GenericEncodedValue, encode: (data: FundamentalTypeValue<GenericFundamentalType>, self: Codec<GenericFundamentalType, GenericEncodedValue>, errorHandler?: GetErrorHandler) => DCommon.MaybePromise<GenericEncodedValue | ErrorSymbol>, decode: (data: GenericEncodedValue, self: Codec<GenericFundamentalType, GenericEncodedValue>, errorHandler?: GetErrorHandler) => DCommon.MaybePromise<FundamentalTypeValue<GenericFundamentalType> | ErrorSymbol>): Codec<GenericFundamentalType, GenericEncodedValue>;
 type ForbiddenDuplicateFundamentalType<GenericDefinition extends Record<string, Codec>> = {
     [Prop in keyof GenericDefinition]: [GenericDefinition[Prop]];
 }[keyof GenericDefinition] extends infer InferredResult extends [unknown] ? DCommon.IsEqual<DCommon.RemoveDuplicateInUnion<InferredResult>, InferredResult> extends true ? unknown : DCommon.ComputedTypeError<"Several codecs use the same fundamental type."> : never;

package/dist/dataStructure/common/codec.mjs

@@ -6,13 +6,14 @@ import { ErrorSymbol } from "./resultSymbol.mjs";
 const codecKind = createKind("codec");
 const codecsKind = createKind("codecs");
 function createCodec(fundamentalType, predicateEncode, encode, decode) {
-	return {
+	const self = {
 		fundamentalType,
-		predicateEncode,
-		encode: (data, errorHandler) => errorHandler?.().setCurrentContext("encode") ?? callThen(encode(data, errorHandler), (encodedData) => encodedData === ErrorSymbol ? ErrorSymbol : callThen(predicateEncode(encodedData, errorHandler), (result) => errorHandler?.().setCurrentContext("default") ?? (result === false ? ErrorSymbol : encodedData))),
-		decode: (data, errorHandler) => errorHandler?.().setCurrentContext("decode") ?? callThen(predicateEncode(data, errorHandler), (result) => result === false ? ErrorSymbol : callThen(decode(data, errorHandler), (result) => errorHandler?.().setCurrentContext("default") ?? result)),
+		predicateEncode: (data) => predicateEncode(data),
+		encode: (data, errorHandler) => callThen(encode(data, self, errorHandler), (encodedData) => encodedData === ErrorSymbol ? ErrorSymbol : callThen(predicateEncode(encodedData), (result) => result === false ? errorHandler?.().addEncodeIssue(self, encodedData) ?? ErrorSymbol : encodedData)),
+		decode: (data, errorHandler) => callThen(predicateEncode(data), (result) => result === false ? errorHandler?.().addDecodeIssue(self, data) ?? ErrorSymbol : decode(data, self, errorHandler)),
 		[codecKind.runTimeKey]: null
 	};
+	return self;
 }
 function createCodecs(definition) {
 	return {

package/dist/dataStructure/common/error.cjs

@@ -1,10 +1,13 @@
+const require_kind = require("../kind.cjs");
 //#region scripts/dataStructure/common/error.ts
-function createErrorHandler() {
-	let currentStagePath = -1;
+const issueKind = require_kind.createKind("issue");
+const encodeIssueKind = require_kind.createKind("encode-issue");
+const decodeIssueKind = require_kind.createKind("decode-issue");
+function createErrorHandler(defaultPath) {
 	const issues = [];
-	let currentPath = [];
+	const currentPath = defaultPath ? [...defaultPath] : [];
+	let currentStagePath = currentPath.length - 1;
 	let currentStage = void 0;
-	let context = "default";
 	return {
 		currentPath,
 		issues,
@@ -22,32 +25,47 @@ function createErrorHandler() {
 			currentStagePath++;
 			return currentStage;
 		},
-		setCurrentContext: (newContext) => {
-			context = newContext;
+		addIssue: (source, data, subSource) => {
+			issues.push({
+				data,
+				path: currentPath.join("."),
+				getSource: () => source,
+				getSubSource: subSource ? () => subSource : void 0,
+				[issueKind.runTimeKey]: null
+			});
+		},
+		addEncodeIssue: (source, data, message) => {
+			issues.push({
+				data,
+				path: currentPath.join("."),
+				message,
+				getSource: () => source,
+				[encodeIssueKind.runTimeKey]: null
+			});
 		},
-		addIssue: (source, data) => {
+		addDecodeIssue: (source, data, message) => {
 			issues.push({
-				context,
 				data,
 				path: currentPath.join("."),
-				getSource: () => source
+				message,
+				getSource: () => source,
+				[decodeIssueKind.runTimeKey]: null
 			});
 		},
 		createError: () => ({ issues }),
-		importIssues: (errorHandler) => void errorHandler.forEach((value) => void issues.push(...typeof value === "function" ? value().issues : value.issues)),
-		usePath: (path) => {
-			currentPath = [...path];
-			currentStagePath = currentPath.length - 1;
-		}
+		importIssues: (errorHandler) => void errorHandler.forEach((value) => void issues.push(...typeof value === "function" ? value().issues : value.issues))
 	};
 }
-function createGetErrorHandler() {
+function createGetErrorHandler(defaultPath) {
 	let errorHandler = void 0;
 	return () => {
-		if (errorHandler === void 0) errorHandler = createErrorHandler();
+		if (errorHandler === void 0) errorHandler = createErrorHandler(defaultPath);
 		return errorHandler;
 	};
 }
 //#endregion
 exports.createErrorHandler = createErrorHandler;
 exports.createGetErrorHandler = createGetErrorHandler;
+exports.decodeIssueKind = decodeIssueKind;
+exports.encodeIssueKind = encodeIssueKind;
+exports.issueKind = issueKind;

package/dist/dataStructure/common/error.d.ts

@@ -1,30 +1,48 @@
 import { Constraint } from '../constraint';
-import { FundamentalType } from '../fundamentalType';
 import { Structure } from '../structure';
 import { Type } from '../type';
-export interface Issue {
-    readonly context: ("default" | "encode" | "decode");
+import { Codec } from './codec';
+import type * as DCommon from '../../common';
+import type * as DKind from '../../kind';
+export declare const issueKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/issue", unknown>>;
+export interface Issue extends DKind.Kind<typeof issueKind> {
     readonly path: string;
     readonly data: unknown;
-    getSource(): (Type | Structure | FundamentalType | Constraint);
+    getSource(): Structure;
+    getSubSource?(): (Type | Constraint);
 }
+export declare const encodeIssueKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/encode-issue", unknown>>;
+export interface EncodeIssue extends DKind.Kind<typeof encodeIssueKind> {
+    readonly path: string;
+    readonly data: unknown;
+    readonly message?: string;
+    getSource(): Codec;
+}
+export declare const decodeIssueKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/decode-issue", unknown>>;
+export interface DecodeIssue extends DKind.Kind<typeof decodeIssueKind> {
+    readonly path: string;
+    readonly data: unknown;
+    readonly message?: string;
+    getSource(): Codec;
+}
+export type Issues = (Issue | EncodeIssue | DecodeIssue);
 export interface PathStageErrorHandler {
     setCurrentPath(path: string): void;
     close(): void;
 }
 export interface Error {
-    readonly issues: readonly Issue[];
+    readonly issues: readonly Issues[];
 }
 export interface ErrorHandler {
-    readonly issues: readonly Issue[];
+    readonly issues: readonly Issues[];
     readonly currentPath: string[];
-    setCurrentContext(context: Issue["context"]): void;
-    addIssue(source: ReturnType<Issue["getSource"]>, data: unknown): void;
+    addIssue(source: ReturnType<Issue["getSource"]>, data: unknown, subSource?: ReturnType<Extract<Issue["getSubSource"], DCommon.AnyFunction>>): void;
+    addEncodeIssue(source: ReturnType<EncodeIssue["getSource"]>, data: unknown, message?: string): void;
+    addDecodeIssue(source: ReturnType<DecodeIssue["getSource"]>, data: unknown, message?: string): void;
     importIssues(errorHandler: (GetErrorHandler | ErrorHandler)[]): void;
     createPathStage(): PathStageErrorHandler;
     createError(): Error;
-    usePath(path: string[]): void;
 }
-export declare function createErrorHandler(): ErrorHandler;
+export declare function createErrorHandler(defaultPath?: string[]): ErrorHandler;
 export type GetErrorHandler = () => ErrorHandler;
-export declare function createGetErrorHandler(): GetErrorHandler;
+export declare function createGetErrorHandler(defaultPath?: string[]): GetErrorHandler;