@duplojs/utils 1.2.18 → 1.3.19

package/dist/dataParser/parsers/object/required.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+var index = require('./index.cjs');
+var optional = require('../optional.cjs');
+var identifier = require('../../identifier.cjs');
+var pipe = require('../../../common/pipe.cjs');
+var map = require('../../../array/map.cjs');
+var when = require('../../../either/right/when.cjs');
+var when$1 = require('../../../either/left/when.cjs');
+var forward = require('../../../common/forward.cjs');
+var entry = require('../../../object/entry.cjs');
+var entries = require('../../../object/entries.cjs');
+var fromEntries = require('../../../object/fromEntries.cjs');
+
+function required(dataParser, definition) {
+    const newShape = pipe.pipe(dataParser.definition.shape, entries.entries, map.map(([key, dataParser]) => pipe.pipe(identifier.identifier(dataParser, optional.optionalKind), when.whenIsRight((dataParser) => dataParser.definition.inner), when$1.whenIsLeft(forward.forward), (dataParser) => entry.entry(key, dataParser))), fromEntries.fromEntries);
+    return index.object(newShape, definition);
+}
+
+exports.required = required;

package/dist/dataParser/parsers/object/required.d.ts

@@ -0,0 +1,10 @@
+import { type MergeDefinition } from "../../../dataParser/types";
+import { type DataParserObjectShape, type DataParserDefinitionObject, type DataParserObject } from ".";
+import { type NeverCoalescing, type SimplifyTopLevel } from "../../../common";
+import { type DataParserOptional } from "../optional";
+export type RequireDataParserObject<GenericShape extends DataParserObjectShape> = SimplifyTopLevel<{
+    [Prop in keyof GenericShape]: GenericShape[Prop] extends DataParserOptional<any> ? GenericShape[Prop]["definition"]["inner"] : GenericShape[Prop];
+}>;
+export declare function required<GenericDataParserObject extends DataParserObject, const GenericDefinition extends Partial<Omit<DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(dataParser: GenericDataParserObject, definition?: GenericDefinition): DataParserObject<MergeDefinition<DataParserDefinitionObject, NeverCoalescing<GenericDefinition, {}> & {
+    readonly shape: RequireDataParserObject<GenericDataParserObject["definition"]["shape"]>;
+}>>;

package/dist/dataParser/parsers/object/required.mjs

@@ -0,0 +1,18 @@
+import { object } from './index.mjs';
+import { optionalKind } from '../optional.mjs';
+import { identifier } from '../../identifier.mjs';
+import { pipe } from '../../../common/pipe.mjs';
+import { map } from '../../../array/map.mjs';
+import { whenIsRight } from '../../../either/right/when.mjs';
+import { whenIsLeft } from '../../../either/left/when.mjs';
+import { forward } from '../../../common/forward.mjs';
+import { entry } from '../../../object/entry.mjs';
+import { entries } from '../../../object/entries.mjs';
+import { fromEntries } from '../../../object/fromEntries.mjs';
+
+function required(dataParser, definition) {
+    const newShape = pipe(dataParser.definition.shape, entries, map(([key, dataParser]) => pipe(identifier(dataParser, optionalKind), whenIsRight((dataParser) => dataParser.definition.inner), whenIsLeft(forward), (dataParser) => entry(key, dataParser))), fromEntries);
+    return object(newShape, definition);
+}
+
+export { required };

package/dist/dataParser/parsers/record/index.cjs

@@ -45,7 +45,7 @@ function record(key, value, definition) {
                     output[resultKey] = resultValue;
                 }
             }
-            error.popErrorPath(error$1);
+            void (currentIndexPath !== error$1.currentPath.length && error.popErrorPath(error$1));
             if (output === base.SymbolDataParserError) {
                 return output;
             }
@@ -83,7 +83,7 @@ function record(key, value, definition) {
                     output[resultKey] = resultValue;
                 }
             }
-            error.popErrorPath(error$1);
+            void (currentIndexPath !== error$1.currentPath.length && error.popErrorPath(error$1));
             if (output === base.SymbolDataParserError) {
                 return output;
             }

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

@@ -44,7 +44,7 @@ function record(key, value, definition) {
                     output[resultKey] = resultValue;
                 }
             }
-            popErrorPath(error);
+            void (currentIndexPath !== error.currentPath.length && popErrorPath(error));
             if (output === SymbolDataParserError) {
                 return output;
             }
@@ -82,7 +82,7 @@ function record(key, value, definition) {
                     output[resultKey] = resultValue;
                 }
             }
-            popErrorPath(error);
+            void (currentIndexPath !== error.currentPath.length && popErrorPath(error));
             if (output === SymbolDataParserError) {
                 return output;
             }

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

@@ -21,7 +21,7 @@ export interface DataParserRecover<GenericDefinition extends DataParserDefinitio
         ...DataParserRecoverCheckers<Output<this>>[]
     ], GenericChecker>): DataParserRecover<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
 }
-export declare function recover<GenericDataParser extends DataParser, GenericRecoveredValue extends unknown, const GenericDefinition extends Partial<Omit<DataParserDefinitionRecover, "inner" | "recoveredValue">> = never>(inner: GenericDataParser, recoveredValue: GenericRecoveredValue, definition?: GenericDefinition): DataParserRecover<MergeDefinition<DataParserDefinitionRecover, NeverCoalescing<GenericDefinition, {}> & {
+export declare function recover<GenericDataParser extends DataParser, GenericRecoveredValue extends Output<GenericDataParser>, const GenericDefinition extends Partial<Omit<DataParserDefinitionRecover, "inner" | "recoveredValue">> = never>(inner: GenericDataParser, recoveredValue: GenericRecoveredValue, definition?: GenericDefinition): DataParserRecover<MergeDefinition<DataParserDefinitionRecover, NeverCoalescing<GenericDefinition, {}> & {
     inner: GenericDataParser;
     recoveredValue: GenericRecoveredValue;
 }>>;

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

@@ -8,7 +8,7 @@ export declare const dataParserCheckerRefineKind: import("../../common").KindHan
 type _DataParserCheckerRefine<GenericDefinition extends DataParserCheckerDefinitionRefine> = (Kind<typeof dataParserCheckerRefineKind.definition> & DataParserChecker<GenericDefinition, string>);
 export interface DataParserCheckerRefine<GenericDefinition extends DataParserCheckerDefinitionRefine = DataParserCheckerDefinitionRefine> extends _DataParserCheckerRefine<GenericDefinition> {
 }
-export declare function checkerRefine<GenericInput extends unknown, const GenericDefinition extends Partial<Omit<DataParserCheckerDefinitionRefine, "theFunction">> = never>(theFunction: (input: GenericInput) => boolean, definition?: GenericDefinition): DataParserCheckerRefine<AssignObjects<NeverCoalescing<GenericDefinition, {}>, {
+export declare function checkerRefine<GenericInput extends unknown, const GenericDefinition extends Partial<Omit<DataParserCheckerDefinitionRefine, "theFunction">> = never>(theFunction: (input: GenericInput) => boolean, definition?: GenericDefinition): DataParserCheckerRefine<AssignObjects<NeverCoalescing<GenericDefinition, DataParserCheckerDefinitionRefine>, {
     theFunction(input: GenericInput): boolean;
 }>>;
 export type CheckerRefineImplementation<GenericInput extends unknown> = DataParserCheckerRefine<AssignObjects<DataParserCheckerDefinitionRefine, {

package/dist/dataParser/parsers/tuple.cjs

@@ -43,7 +43,7 @@ function tuple(shape, definition) {
                     }
                 }
             }
-            error.popErrorPath(error$1);
+            void (self.definition.shape.length && error.popErrorPath(error$1));
             return output;
         },
         async: async (data, error$1, self) => {
@@ -74,7 +74,7 @@ function tuple(shape, definition) {
                     }
                 }
             }
-            error.popErrorPath(error$1);
+            void (self.definition.shape.length && error.popErrorPath(error$1));
             return output;
         },
     });

package/dist/dataParser/parsers/tuple.mjs

@@ -41,7 +41,7 @@ function tuple(shape, definition) {
                     }
                 }
             }
-            popErrorPath(error);
+            void (self.definition.shape.length && popErrorPath(error));
             return output;
         },
         async: async (data, error, self) => {
@@ -72,7 +72,7 @@ function tuple(shape, definition) {
                     }
                 }
             }
-            popErrorPath(error);
+            void (self.definition.shape.length && popErrorPath(error));
             return output;
         },
     });

package/dist/date/index.cjs

@@ -14,6 +14,10 @@ var each = require('./each.cjs');
 var createOrThrow = require('./createOrThrow.cjs');
 var round = require('./round.cjs');
 var isSafeTimestamp = require('./isSafeTimestamp.cjs');
+var min = require('./min.cjs');
+var max = require('./max.cjs');
+var sort = require('./sort.cjs');
+var is = require('./is.cjs');
 var timezone = require('./types/timezone.cjs');
 var getDayOfMonth = require('./getters/getDayOfMonth.cjs');
 var getDayOfWeek = require('./getters/getDayOfWeek.cjs');
@@ -82,6 +86,10 @@ exports.CreateTheDateError = createOrThrow.CreateTheDateError;
 exports.createOrThrow = createOrThrow.createOrThrow;
 exports.round = round.round;
 exports.isSafeTimestamp = isSafeTimestamp.isSafeTimestamp;
+exports.min = min.min;
+exports.max = max.max;
+exports.sort = sort.sort;
+exports.is = is.is;
 exports.timezone = timezone.timezone;
 exports.getDayOfMonth = getDayOfMonth.getDayOfMonth;
 exports.getDayOfWeek = getDayOfWeek.getDayOfWeek;

package/dist/date/index.d.ts

@@ -16,3 +16,7 @@ export * from "./each";
 export * from "./createOrThrow";
 export * from "./round";
 export * from "./isSafeTimestamp";
+export * from "./min";
+export * from "./max";
+export * from "./sort";
+export * from "./is";

package/dist/date/index.mjs

@@ -12,6 +12,10 @@ export { each } from './each.mjs';
 export { CreateTheDateError, createOrThrow } from './createOrThrow.mjs';
 export { round } from './round.mjs';
 export { isSafeTimestamp } from './isSafeTimestamp.mjs';
+export { min } from './min.mjs';
+export { max } from './max.mjs';
+export { sort } from './sort.mjs';
+export { is } from './is.mjs';
 export { timezone } from './types/timezone.mjs';
 export { getDayOfMonth } from './getters/getDayOfMonth.mjs';
 export { getDayOfWeek } from './getters/getDayOfWeek.mjs';

package/dist/date/is.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+var constants = require('./constants.cjs');
+
+function is(input) {
+    return constants.theDateRegex.test(input);
+}
+
+exports.is = is;

package/dist/date/is.d.ts

@@ -0,0 +1,2 @@
+import { type TheDate } from "./types";
+export declare function is(input: string): input is TheDate;

package/dist/date/is.mjs

@@ -0,0 +1,7 @@
+import { theDateRegex } from './constants.mjs';
+
+function is(input) {
+    return theDateRegex.test(input);
+}
+
+export { is };

package/dist/date/max.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+var createOrThrow = require('./createOrThrow.cjs');
+var toTimestamp = require('./toTimestamp.cjs');
+
+function max(input) {
+    return createOrThrow.createOrThrow(Math.max(...input.map(toTimestamp.toTimestamp)));
+}
+
+exports.max = max;

package/dist/date/max.d.ts

@@ -0,0 +1,3 @@
+import { type AnyTuple } from "../common";
+import { type TheDate } from "./types";
+export declare function max<GenericInput extends AnyTuple<TheDate>>(input: GenericInput): `date${number}-` | `date${number}+`;

package/dist/date/max.mjs

@@ -0,0 +1,8 @@
+import { createOrThrow } from './createOrThrow.mjs';
+import { toTimestamp } from './toTimestamp.mjs';
+
+function max(input) {
+    return createOrThrow(Math.max(...input.map(toTimestamp)));
+}
+
+export { max };

package/dist/date/min.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+var createOrThrow = require('./createOrThrow.cjs');
+var toTimestamp = require('./toTimestamp.cjs');
+
+function min(input) {
+    return createOrThrow.createOrThrow(Math.min(...input.map(toTimestamp.toTimestamp)));
+}
+
+exports.min = min;

package/dist/date/min.d.ts

@@ -0,0 +1,3 @@
+import { type AnyTuple } from "../common";
+import { type TheDate } from "./types";
+export declare function min<GenericInput extends AnyTuple<TheDate>>(input: GenericInput): `date${number}-` | `date${number}+`;

package/dist/date/min.mjs

@@ -0,0 +1,8 @@
+import { createOrThrow } from './createOrThrow.mjs';
+import { toTimestamp } from './toTimestamp.mjs';
+
+function min(input) {
+    return createOrThrow(Math.min(...input.map(toTimestamp)));
+}
+
+export { min };

package/dist/date/sort.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+var createOrThrow = require('./createOrThrow.cjs');
+var toTimestamp = require('./toTimestamp.cjs');
+
+function sort(...args) {
+    if (args.length === 1) {
+        const [type] = args;
+        return (array) => sort(array, type);
+    }
+    const [array, type] = args;
+    return array
+        .map(toTimestamp.toTimestamp)
+        .sort(type === "DSC"
+        ? (first, second) => second - first
+        : (first, second) => first - second)
+        .map(createOrThrow.createOrThrow);
+}
+
+exports.sort = sort;

package/dist/date/sort.d.ts

@@ -0,0 +1,4 @@
+import { type SortType } from "../common";
+import { type TheDate } from "./types";
+export declare function sort<GenericArray extends readonly TheDate[]>(type: SortType): (array: GenericArray) => TheDate[];
+export declare function sort<GenericArray extends readonly TheDate[]>(array: GenericArray, type: SortType): TheDate[];

package/dist/date/sort.mjs

@@ -0,0 +1,18 @@
+import { createOrThrow } from './createOrThrow.mjs';
+import { toTimestamp } from './toTimestamp.mjs';
+
+function sort(...args) {
+    if (args.length === 1) {
+        const [type] = args;
+        return (array) => sort(array, type);
+    }
+    const [array, type] = args;
+    return array
+        .map(toTimestamp)
+        .sort(type === "DSC"
+        ? (first, second) => second - first
+        : (first, second) => first - second)
+        .map(createOrThrow);
+}
+
+export { sort };

package/dist/generator/reduce.cjs

@@ -3,7 +3,7 @@
 var kind = require('../common/kind.cjs');
 var wrapValue = require('../common/wrapValue.cjs');
 var unwrap = require('../common/unwrap.cjs');
-var override = require('../object/override.cjs');
+var reduce$1 = require('../array/reduce.cjs');
 
 const generatorReduceFromKind = kind.createKind("generator-reduce-from");
 function reduceFrom(value) {
@@ -22,11 +22,7 @@ function reduce(...args) {
             element,
             index,
             lastValue,
-            nextWithObject: ((object1, object2) => ({
-                "-next": override.override(object1, object2),
-            })),
-            exit: (output) => ({ "-exit": output }),
-            next: (output) => ({ "-next": output }),
+            ...reduce$1.reduceTools,
         });
         if ("-exit" in result) {
             return result["-exit"];

package/dist/generator/reduce.d.ts

@@ -15,6 +15,7 @@ export interface GeneratorReduceFunctionParams<GenericElement extends unknown =
     nextWithObject: GenericOutput extends object ? (object1: GenericOutput, object2: Partial<GenericOutput>) => GeneratorReduceNext<GenericOutput> : undefined;
     next(output: GenericOutput): GeneratorReduceNext<GenericOutput>;
     exit<GenericExitValue extends unknown>(output: GenericExitValue): GeneratorReduceExit<GenericExitValue>;
+    nextPush: GenericOutput extends readonly any[] ? (array: GenericOutput, ...values: GenericOutput) => GeneratorReduceExit<GenericOutput> : undefined;
 }
 declare const generatorReduceFromKind: import("../common").KindHandler<import("../common").KindDefinition<"generator-reduce-from", unknown>>;
 export interface GeneratorReduceFromResult<GenericValue extends unknown = unknown> extends Kind<typeof generatorReduceFromKind.definition>, WrappedValue<GenericValue> {

package/dist/generator/reduce.mjs

@@ -1,7 +1,7 @@
 import { createKind } from '../common/kind.mjs';
 import { wrapValue } from '../common/wrapValue.mjs';
 import { unwrap } from '../common/unwrap.mjs';
-import { override } from '../object/override.mjs';
+import { reduceTools } from '../array/reduce.mjs';
 
 const generatorReduceFromKind = createKind("generator-reduce-from");
 function reduceFrom(value) {
@@ -20,11 +20,7 @@ function reduce(...args) {
             element,
             index,
             lastValue,
-            nextWithObject: ((object1, object2) => ({
-                "-next": override(object1, object2),
-            })),
-            exit: (output) => ({ "-exit": output }),
-            next: (output) => ({ "-next": output }),
+            ...reduceTools,
         });
         if ("-exit" in result) {
             return result["-exit"];

package/dist/index.cjs

@@ -11,6 +11,7 @@ var index$7 = require('./dataParser/index.cjs');
 var index$8 = require('./dataParser/parsers/coerce/index.cjs');
 var index$9 = require('./dataParser/extended/index.cjs');
 var index$a = require('./date/index.cjs');
+var index$b = require('./clean/index.cjs');
 var addWrappedProperties = require('./common/addWrappedProperties.cjs');
 var asyncPipe = require('./common/asyncPipe.cjs');
 var clone = require('./common/clone.cjs');
@@ -40,7 +41,6 @@ var forward = require('./common/forward.cjs');
 var when = require('./common/when.cjs');
 var whenNot = require('./common/whenNot.cjs');
 var equal = require('./common/equal.cjs');
-var not = require('./common/not.cjs');
 var isType = require('./common/isType.cjs');
 var and = require('./common/and.cjs');
 var or = require('./common/or.cjs');
@@ -79,6 +79,8 @@ exports.DDataParserExtended = index$9;
 exports.DPE = index$9;
 exports.D = index$a;
 exports.DDate = index$a;
+exports.C = index$b;
+exports.DClean = index$b;
 exports.addWrappedProperties = addWrappedProperties.addWrappedProperties;
 exports.asyncPipe = asyncPipe.asyncPipe;
 exports.clone = clone.clone;
@@ -118,7 +120,6 @@ exports.forward = forward.forward;
 exports.when = when.when;
 exports.whenNot = whenNot.whenNot;
 exports.equal = equal.equal;
-exports.not = not.not;
 exports.isType = isType.isType;
 exports.and = and.and;
 exports.or = or.or;

package/dist/index.d.ts

@@ -21,3 +21,5 @@ export * as DPE from "./dataParser/extended";
 export * as DDataParserExtended from "./dataParser/extended";
 export * as D from "./date";
 export * as DDate from "./date";
+export * as C from "./clean";
+export * as DClean from "./clean";

package/dist/index.mjs

@@ -31,6 +31,9 @@ export { index$9 as DPE };
 import * as index$a from './date/index.mjs';
 export { index$a as D };
 export { index$a as DDate };
+import * as index$b from './clean/index.mjs';
+export { index$b as C };
+export { index$b as DClean };
 export { addWrappedProperties } from './common/addWrappedProperties.mjs';
 export { asyncPipe } from './common/asyncPipe.mjs';
 export { clone } from './common/clone.mjs';
@@ -60,7 +63,6 @@ export { forward } from './common/forward.mjs';
 export { when } from './common/when.mjs';
 export { whenNot } from './common/whenNot.mjs';
 export { equal } from './common/equal.mjs';
-export { not } from './common/not.mjs';
 export { isType } from './common/isType.mjs';
 export { and } from './common/and.mjs';
 export { or } from './common/or.mjs';

package/dist/number/index.cjs

@@ -30,6 +30,7 @@ var toFixed = require('./toFixed.cjs');
 var sqrt = require('./sqrt.cjs');
 var between = require('./between.cjs');
 var betweenThan = require('./betweenThan.cjs');
+var sort = require('./sort.cjs');
 
 
 
@@ -63,3 +64,4 @@ exports.toFixed = toFixed.toFixed;
 exports.sqrt = sqrt.sqrt;
 exports.between = between.between;
 exports.betweenThan = betweenThan.betweenThan;
+exports.sort = sort.sort;

package/dist/number/index.d.ts

@@ -29,3 +29,4 @@ export * from "./sqrt";
 export * from "./types";
 export * from "./between";
 export * from "./betweenThan";
+export * from "./sort";

package/dist/number/index.mjs

@@ -28,3 +28,4 @@ export { toFixed } from './toFixed.mjs';
 export { sqrt } from './sqrt.mjs';
 export { between } from './between.mjs';
 export { betweenThan } from './betweenThan.mjs';
+export { sort } from './sort.mjs';

package/dist/number/max.cjs

@@ -1,12 +1,7 @@
 'use strict';
 
-function max(...args) {
-    if (args.length === 1) {
-        const [comparison] = args;
-        return (value) => max(value, comparison);
-    }
-    const [value, comparison] = args;
-    return Math.max(value, comparison);
+function max(input) {
+    return Math.max(...input);
 }
 
 exports.max = max;

package/dist/number/max.d.ts

@@ -1,2 +1,2 @@
-export declare function max<GenericValue extends number>(comparison: number): (value: GenericValue) => number;
-export declare function max<GenericValue extends number>(value: GenericValue, comparison: number): number;
+import { type AnyTuple } from "../common";
+export declare function max<GenericInput extends AnyTuple<number>>(input: GenericInput): number;

package/dist/number/max.mjs

@@ -1,10 +1,5 @@
-function max(...args) {
-    if (args.length === 1) {
-        const [comparison] = args;
-        return (value) => max(value, comparison);
-    }
-    const [value, comparison] = args;
-    return Math.max(value, comparison);
+function max(input) {
+    return Math.max(...input);
 }
 
 export { max };

package/dist/number/min.cjs

@@ -1,12 +1,7 @@
 'use strict';
 
-function min(...args) {
-    if (args.length === 1) {
-        const [comparison] = args;
-        return (value) => min(value, comparison);
-    }
-    const [value, comparison] = args;
-    return Math.min(value, comparison);
+function min(input) {
+    return Math.min(...input);
 }
 
 exports.min = min;

package/dist/number/min.d.ts

@@ -1,2 +1,2 @@
-export declare function min<GenericValue extends number>(comparison: number): (value: GenericValue) => number;
-export declare function min<GenericValue extends number>(value: GenericValue, comparison: number): number;
+import { type AnyTuple } from "../common";
+export declare function min<GenericInput extends AnyTuple<number>>(input: GenericInput): number;

package/dist/number/min.mjs

@@ -1,10 +1,5 @@
-function min(...args) {
-    if (args.length === 1) {
-        const [comparison] = args;
-        return (value) => min(value, comparison);
-    }
-    const [value, comparison] = args;
-    return Math.min(value, comparison);
+function min(input) {
+    return Math.min(...input);
 }
 
 export { min };

package/dist/number/sort.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+function sort(...args) {
+    if (args.length === 1) {
+        const [type] = args;
+        return (array) => sort(array, type);
+    }
+    const [array, type] = args;
+    return [...array].sort(type === "DSC"
+        ? (first, second) => second - first
+        : (first, second) => first - second);
+}
+
+exports.sort = sort;

package/dist/number/sort.d.ts

@@ -0,0 +1,3 @@
+import { type SortType } from "../common";
+export declare function sort<GenericArray extends readonly number[]>(type: SortType): (array: GenericArray) => number[];
+export declare function sort<GenericArray extends readonly number[]>(array: GenericArray, type: SortType): number[];

package/dist/number/sort.mjs

@@ -0,0 +1,12 @@
+function sort(...args) {
+    if (args.length === 1) {
+        const [type] = args;
+        return (array) => sort(array, type);
+    }
+    const [array, type] = args;
+    return [...array].sort(type === "DSC"
+        ? (first, second) => second - first
+        : (first, second) => first - second);
+}
+
+export { sort };

package/dist/pattern/when.d.ts

@@ -1,6 +1,6 @@
-import { type AnyValue, type BreakGenericLink, type IsEqual } from "../common";
+import { type AnyValue, type BreakGenericLink, type IsEqual, type EscapeVoid } from "../common";
 import { type PatternResult } from "./result";
-export declare function when<GenericInput extends unknown, GenericInputValue extends Exclude<IsEqual<GenericInput, unknown> extends true ? AnyValue : GenericInput, PatternResult>, GenericInputPatternResult extends Extract<GenericInput, PatternResult>, GenericPredicatedInput extends GenericInputValue, GenericOutput extends AnyValue>(predicate: (input: GenericInputValue) => input is GenericPredicatedInput, theFunction: (predicatedInput: GenericPredicatedInput) => GenericOutput): (input: (GenericInput | GenericInputPatternResult | GenericInputValue)) => (GenericInputPatternResult | Exclude<BreakGenericLink<GenericInputValue>, GenericPredicatedInput> | PatternResult<GenericOutput>);
-export declare function when<GenericInput extends unknown, GenericInputValue extends Exclude<IsEqual<GenericInput, unknown> extends true ? AnyValue : GenericInput, PatternResult>, GenericInputPatternResult extends Extract<GenericInput, PatternResult>, GenericOutput extends AnyValue>(predicate: (input: GenericInputValue) => boolean, theFunction: (predicatedInput: GenericInputValue) => GenericOutput): (input: (GenericInput | GenericInputPatternResult | GenericInputValue)) => (GenericInputPatternResult | GenericInputValue | PatternResult<GenericOutput>);
-export declare function when<GenericInput extends unknown, GenericInputValue extends Exclude<IsEqual<GenericInput, unknown> extends true ? AnyValue : GenericInput, PatternResult>, GenericInputPatternResult extends Extract<GenericInput, PatternResult>, GenericPredicatedInput extends GenericInputValue, GenericOutput extends AnyValue>(input: (GenericInput | GenericInputPatternResult | GenericInputValue), predicate: (input: GenericInputValue) => input is GenericPredicatedInput, theFunction: (predicatedInput: GenericPredicatedInput) => GenericOutput): (GenericInputPatternResult | Exclude<GenericInputValue, GenericPredicatedInput> | PatternResult<GenericOutput>);
-export declare function when<GenericInput extends unknown, GenericInputValue extends Exclude<IsEqual<GenericInput, unknown> extends true ? AnyValue : GenericInput, PatternResult>, GenericInputPatternResult extends Extract<GenericInput, PatternResult>, GenericOutput extends AnyValue>(input: (GenericInput | GenericInputPatternResult | GenericInputValue), predicate: (input: GenericInputValue) => boolean, theFunction: (predicatedInput: GenericInputValue) => GenericOutput): (GenericInputPatternResult | GenericInputValue | PatternResult<GenericOutput>);
+export declare function when<GenericInput extends unknown, GenericInputValue extends Exclude<IsEqual<GenericInput, unknown> extends true ? AnyValue : GenericInput, PatternResult>, GenericInputPatternResult extends Extract<GenericInput, PatternResult>, GenericPredicatedInput extends GenericInputValue, GenericOutput extends AnyValue | EscapeVoid>(predicate: (input: GenericInputValue) => input is GenericPredicatedInput, theFunction: (predicatedInput: GenericPredicatedInput) => GenericOutput): (input: (GenericInput | GenericInputPatternResult | GenericInputValue)) => (GenericInputPatternResult | Exclude<BreakGenericLink<GenericInput>, GenericPredicatedInput | PatternResult> | PatternResult<GenericOutput>);
+export declare function when<GenericInput extends unknown, GenericInputValue extends Exclude<IsEqual<GenericInput, unknown> extends true ? AnyValue : GenericInput, PatternResult>, GenericInputPatternResult extends Extract<GenericInput, PatternResult>, GenericOutput extends AnyValue | EscapeVoid>(predicate: (input: GenericInputValue) => boolean, theFunction: (predicatedInput: GenericInputValue) => GenericOutput): (input: (GenericInput | GenericInputPatternResult | GenericInputValue)) => (GenericInputPatternResult | GenericInputValue | PatternResult<GenericOutput>);
+export declare function when<GenericInput extends unknown, GenericInputValue extends Exclude<IsEqual<GenericInput, unknown> extends true ? AnyValue : GenericInput, PatternResult>, GenericInputPatternResult extends Extract<GenericInput, PatternResult>, GenericPredicatedInput extends GenericInputValue, GenericOutput extends AnyValue | EscapeVoid>(input: (GenericInput | GenericInputPatternResult | GenericInputValue), predicate: (input: GenericInputValue) => input is GenericPredicatedInput, theFunction: (predicatedInput: GenericPredicatedInput) => GenericOutput): (GenericInputPatternResult | Exclude<BreakGenericLink<GenericInput>, GenericPredicatedInput | PatternResult> | PatternResult<GenericOutput>);
+export declare function when<GenericInput extends unknown, GenericInputValue extends Exclude<IsEqual<GenericInput, unknown> extends true ? AnyValue : GenericInput, PatternResult>, GenericInputPatternResult extends Extract<GenericInput, PatternResult>, GenericOutput extends AnyValue | EscapeVoid>(input: (GenericInput | GenericInputPatternResult | GenericInputValue), predicate: (input: GenericInputValue) => boolean, theFunction: (predicatedInput: GenericInputValue) => GenericOutput): (GenericInputPatternResult | GenericInputValue | PatternResult<GenericOutput>);

package/dist/string/index.cjs

@@ -27,6 +27,7 @@ var normalize = require('./normalize.cjs');
 var test = require('./test.cjs');
 var isIn = require('./isIn.cjs');
 var length = require('./length.cjs');
+var sort = require('./sort.cjs');
 var _default = require('./at/default.cjs');
 var first = require('./at/first.cjs');
 var last = require('./at/last.cjs');
@@ -63,6 +64,7 @@ exports.normalize = normalize.normalize;
 exports.test = test.test;
 exports.isIn = isIn.isIn;
 exports.length = length.length;
+exports.sort = sort.sort;
 exports.at = _default.at;
 exports.first = first.first;
 exports.last = last.last;

package/dist/string/index.d.ts

@@ -28,3 +28,4 @@ export * from "./normalize";
 export * from "./test";
 export * from "./isIn";
 export * from "./length";
+export * from "./sort";

package/dist/string/index.mjs

@@ -25,6 +25,7 @@ export { normalize } from './normalize.mjs';
 export { test } from './test.mjs';
 export { isIn } from './isIn.mjs';
 export { length } from './length.mjs';
+export { sort } from './sort.mjs';
 export { at } from './at/default.mjs';
 export { first } from './at/first.mjs';
 export { last } from './at/last.mjs';