@duplojs/utils 1.2.17 → 1.2.19

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

@@ -2,11 +2,11 @@ import { dataParserInit, SymbolDataParserError, dataParserKind } from '../../bas
 import { SymbolDataParserErrorIssue, setErrorPath, popErrorPath } from '../../error.mjs';
 import { createDataParserKind } from '../../kind.mjs';
 import { memo } from '../../../common/memo.mjs';
-import { forward } from '../../../common/forward.mjs';
 import { pipe } from '../../../common/pipe.mjs';
 import { map } from '../../../array/map.mjs';
 import { filter } from '../../../array/filter.mjs';
 import { entries } from '../../../object/entries.mjs';
+import { forward } from '../../../common/forward.mjs';
 import { createOverride } from '../../../common/override.mjs';
 
 const objectKind = createDataParserKind("object");
@@ -41,7 +41,7 @@ function object(shape, definition) {
                     output[entry.key] = result;
                 }
             }
-            popErrorPath(error);
+            void (self.definition.optimizedShape.value.length && popErrorPath(error));
             return output;
         },
         async: async (data, error, self) => {
@@ -63,7 +63,7 @@ function object(shape, definition) {
                     output[entry.key] = result;
                 }
             }
-            popErrorPath(error);
+            void (self.definition.optimizedShape.value.length && popErrorPath(error));
             return output;
         },
     });

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

@@ -0,0 +1,20 @@
+'use strict';
+
+var index = require('./index.cjs');
+var optional = require('../optional.cjs');
+var identifier = require('../../identifier.cjs');
+var forward = require('../../../common/forward.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 entry = require('../../../object/entry.cjs');
+var entries = require('../../../object/entries.cjs');
+var fromEntries = require('../../../object/fromEntries.cjs');
+
+function partial(dataParser, definition) {
+    const newShape = pipe.pipe(dataParser.definition.shape, entries.entries, map.map(([key, dataParser]) => pipe.pipe(identifier.identifier(dataParser, optional.optionalKind), when.whenIsRight(forward.forward), when$1.whenIsLeft(optional.optional), (dataParser) => entry.entry(key, dataParser))), fromEntries.fromEntries);
+    return index.object(newShape, definition);
+}
+
+exports.partial = partial;

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

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

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

@@ -0,0 +1,18 @@
+import { object } from './index.mjs';
+import { optionalKind, optional } from '../optional.mjs';
+import { identifier } from '../../identifier.mjs';
+import { forward } from '../../../common/forward.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 { entry } from '../../../object/entry.mjs';
+import { entries } from '../../../object/entries.mjs';
+import { fromEntries } from '../../../object/fromEntries.mjs';
+
+function partial(dataParser, definition) {
+    const newShape = pipe(dataParser.definition.shape, entries, map(([key, dataParser]) => pipe(identifier(dataParser, optionalKind), whenIsRight(forward), whenIsLeft(optional), (dataParser) => entry(key, dataParser))), fromEntries);
+    return object(newShape, definition);
+}
+
+export { partial };

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/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/chunk.cjs

@@ -0,0 +1,24 @@
+'use strict';
+
+function chunk(...args) {
+    if (args.length === 1) {
+        const [size] = args;
+        return (input) => chunk(input, size);
+    }
+    const [input, size] = args;
+    return (function* () {
+        let buffer = [];
+        for (const element of input) {
+            buffer.push(element);
+            if (buffer.length === size) {
+                yield buffer;
+                buffer = [];
+            }
+        }
+        if (buffer.length > 0) {
+            yield buffer;
+        }
+    })();
+}
+
+exports.chunk = chunk;

package/dist/generator/chunk.d.ts

@@ -0,0 +1,2 @@
+export declare function chunk<const GenericElement extends unknown>(size: number): (input: Iterable<GenericElement>) => Generator<GenericElement[], unknown, unknown>;
+export declare function chunk<const GenericElement extends unknown>(input: Iterable<GenericElement>, size: number): Generator<GenericElement[], unknown, unknown>;

package/dist/generator/chunk.mjs

@@ -0,0 +1,22 @@
+function chunk(...args) {
+    if (args.length === 1) {
+        const [size] = args;
+        return (input) => chunk(input, size);
+    }
+    const [input, size] = args;
+    return (function* () {
+        let buffer = [];
+        for (const element of input) {
+            buffer.push(element);
+            if (buffer.length === size) {
+                yield buffer;
+                buffer = [];
+            }
+        }
+        if (buffer.length > 0) {
+            yield buffer;
+        }
+    })();
+}
+
+export { chunk };

package/dist/generator/index.cjs

@@ -9,6 +9,7 @@ var reduce = require('./reduce.cjs');
 var asyncReduce = require('./asyncReduce.cjs');
 var loop = require('./loop.cjs');
 var asyncLoop = require('./asyncLoop.cjs');
+var chunk = require('./chunk.cjs');
 
 
 
@@ -22,3 +23,4 @@ exports.reduceFrom = reduce.reduceFrom;
 exports.asyncReduce = asyncReduce.asyncReduce;
 exports.loop = loop.loop;
 exports.asyncLoop = asyncLoop.asyncLoop;
+exports.chunk = chunk.chunk;

package/dist/generator/index.d.ts

@@ -7,3 +7,4 @@ export * from "./reduce";
 export * from "./asyncReduce";
 export * from "./loop";
 export * from "./asyncLoop";
+export * from "./chunk";

package/dist/generator/index.mjs

@@ -7,3 +7,4 @@ export { reduce, reduceFrom } from './reduce.mjs';
 export { asyncReduce } from './asyncReduce.mjs';
 export { loop } from './loop.mjs';
 export { asyncLoop } from './asyncLoop.mjs';
+export { chunk } from './chunk.mjs';

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;