@duplojs/utils 1.2.17 → 1.2.19

package/dist/clean/primitive/base.d.ts

@@ -0,0 +1,36 @@
+import { type Kind, type WrappedValue } from "../../common";
+import * as DDataParser from "../../dataParser";
+import * as DEither from "../../either";
+export type EligiblePrimitive = string | number | boolean | bigint;
+export interface Primitive<GenericValue extends EligiblePrimitive> extends WrappedValue<GenericValue> {
+}
+export declare const primitiveHandlerKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsClean/primitive-handler", unknown>>;
+export interface PrimitiveHandler<GenericValue extends EligiblePrimitive = EligiblePrimitive> extends Kind<typeof primitiveHandlerKind.definition> {
+    readonly dataParser: DDataParser.Contract<GenericValue>;
+    create<GenericData extends GenericValue>(data: GenericData): (DEither.EitherRight<"createNewType", Primitive<GenericData>> | DEither.EitherLeft<"createNewTypeError", DDataParser.DataParserError>);
+    createOrThrow<GenericData extends GenericValue>(data: GenericData): Primitive<GenericData>;
+    createWithUnknown<GenericData extends unknown>(data: GenericData): (DEither.EitherRight<"createNewType", Primitive<GenericValue>> | DEither.EitherLeft<"createNewTypeError", DDataParser.DataParserError>);
+    createWithUnknownOrThrow<GenericData extends unknown>(data: GenericData): Primitive<GenericValue>;
+    is<GenericInput extends WrappedValue>(input: GenericInput): input is Extract<GenericInput, Primitive<GenericValue>>;
+}
+declare const CreatePrimitiveError_base: new (params: {
+    "@DuplojsUtilsError/create-primitive-error"?: unknown;
+}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & Kind<import("../../common").KindDefinition<"create-primitive-error", unknown>, unknown> & Kind<import("../../common").KindDefinition<"@DuplojsUtilsError/create-primitive-error", unknown>, unknown>;
+export declare class CreatePrimitiveError extends CreatePrimitiveError_base {
+    data: unknown;
+    dataParserError: DDataParser.DataParserError;
+    constructor(data: unknown, dataParserError: DDataParser.DataParserError);
+}
+export declare const String: PrimitiveHandler<string>;
+export type String = ReturnType<typeof String["createWithUnknownOrThrow"]>;
+export declare const Number: PrimitiveHandler<number>;
+export type Number = ReturnType<typeof Number["createWithUnknownOrThrow"]>;
+export declare const BigInt: PrimitiveHandler<bigint>;
+export type BigInt = ReturnType<typeof BigInt["createWithUnknownOrThrow"]>;
+export declare const Boolean: PrimitiveHandler<boolean>;
+export type Boolean = ReturnType<typeof Boolean["createWithUnknownOrThrow"]>;
+export declare const Date: PrimitiveHandler<`date${number}-` | `date${number}+`>;
+export type Date = ReturnType<typeof Date["createWithUnknownOrThrow"]>;
+export type Primitives = (String | Number | BigInt | Boolean | Date);
+export type PrimitiveHandlers = (typeof String | typeof Number | typeof BigInt | typeof Boolean | typeof Date);
+export {};

package/dist/clean/primitive/base.mjs

@@ -0,0 +1,64 @@
+import { createCleanKind } from '../kind.mjs';
+import { kindHeritage } from '../../common/kind.mjs';
+import { string } from '../../dataParser/parsers/string/index.mjs';
+import { number } from '../../dataParser/parsers/number/index.mjs';
+import { bigint } from '../../dataParser/parsers/bigint/index.mjs';
+import { boolean } from '../../dataParser/parsers/boolean.mjs';
+import { date } from '../../dataParser/parsers/date.mjs';
+import { createErrorKind } from '../../common/errorKindNamespace.mjs';
+import { unwrap } from '../../common/unwrap.mjs';
+import { isRight } from '../../either/right/is.mjs';
+import { isLeft } from '../../either/left/is.mjs';
+import { left } from '../../either/left/create.mjs';
+import { right } from '../../either/right/create.mjs';
+import { wrapValue } from '../../common/wrapValue.mjs';
+
+const primitiveHandlerKind = createCleanKind("primitive-handler");
+class CreatePrimitiveError extends kindHeritage("create-primitive-error", createErrorKind("create-primitive-error"), Error) {
+    data;
+    dataParserError;
+    constructor(data, dataParserError) {
+        super({}, ["Error when create primitive."]);
+        this.data = data;
+        this.dataParserError = dataParserError;
+    }
+}
+function createPrimitive(dataParser) {
+    function create(data) {
+        const result = dataParser.parse(data);
+        if (isLeft(result)) {
+            return left("createPrimitiveError", unwrap(result));
+        }
+        else {
+            return right("createPrimitive", wrapValue(unwrap(result)));
+        }
+    }
+    function createOrThrow(data) {
+        const result = create(data);
+        if (isLeft(result)) {
+            throw new CreatePrimitiveError(data, unwrap(result));
+        }
+        else {
+            return unwrap(result);
+        }
+    }
+    function is(input) {
+        const result = dataParser.parse(unwrap(input));
+        return isRight(result);
+    }
+    return primitiveHandlerKind.setTo({
+        dataParser,
+        create,
+        createOrThrow,
+        createWithUnknown: create,
+        createWithUnknownOrThrow: createOrThrow,
+        is,
+    });
+}
+const String = createPrimitive(string());
+const Number = createPrimitive(number());
+const BigInt = createPrimitive(bigint());
+const Boolean = createPrimitive(boolean());
+const Date = createPrimitive(date());
+
+export { BigInt, Boolean, CreatePrimitiveError, Date, Number, String, primitiveHandlerKind };

package/dist/clean/primitive/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./base";
+export * from "./operations";

package/dist/clean/primitive/operations/date/dateGreaterThan.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var greaterThan = require('../../../../date/operators/greaterThan.cjs');
+var unwrap = require('../../../../common/unwrap.cjs');
+
+function dateGreaterThan(...args) {
+    if (args.length === 1) {
+        const [threshold] = args;
+        return (primitive) => dateGreaterThan(primitive, threshold);
+    }
+    const [primitive, threshold] = args;
+    return greaterThan.greaterThan(unwrap.unwrap(primitive), unwrap.unwrap(threshold));
+}
+
+exports.dateGreaterThan = dateGreaterThan;

package/dist/clean/primitive/operations/date/dateGreaterThan.d.ts

@@ -0,0 +1,4 @@
+import { type Date } from "../../base";
+import { type TheDate } from "../../../../date";
+export declare function dateGreaterThan(threshold: Date | TheDate): (primitive: Date) => boolean;
+export declare function dateGreaterThan(primitive: Date, threshold: Date | TheDate): boolean;

package/dist/clean/primitive/operations/date/dateGreaterThan.mjs

@@ -0,0 +1,13 @@
+import { greaterThan } from '../../../../date/operators/greaterThan.mjs';
+import { unwrap } from '../../../../common/unwrap.mjs';
+
+function dateGreaterThan(...args) {
+    if (args.length === 1) {
+        const [threshold] = args;
+        return (primitive) => dateGreaterThan(primitive, threshold);
+    }
+    const [primitive, threshold] = args;
+    return greaterThan(unwrap(primitive), unwrap(threshold));
+}
+
+export { dateGreaterThan };

package/dist/clean/primitive/operations/date/dateLessThan.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var lessThan = require('../../../../date/operators/lessThan.cjs');
+var unwrap = require('../../../../common/unwrap.cjs');
+
+function dateLessThan(...args) {
+    if (args.length === 1) {
+        const [threshold] = args;
+        return (primitive) => dateLessThan(primitive, threshold);
+    }
+    const [primitive, threshold] = args;
+    return lessThan.lessThan(unwrap.unwrap(primitive), unwrap.unwrap(threshold));
+}
+
+exports.dateLessThan = dateLessThan;

package/dist/clean/primitive/operations/date/dateLessThan.d.ts

@@ -0,0 +1,4 @@
+import { type Date } from "../../base";
+import { type TheDate } from "../../../../date";
+export declare function dateLessThan(threshold: Date | TheDate): (primitive: Date) => boolean;
+export declare function dateLessThan(primitive: Date, threshold: Date | TheDate): boolean;

package/dist/clean/primitive/operations/date/dateLessThan.mjs

@@ -0,0 +1,13 @@
+import { lessThan } from '../../../../date/operators/lessThan.mjs';
+import { unwrap } from '../../../../common/unwrap.mjs';
+
+function dateLessThan(...args) {
+    if (args.length === 1) {
+        const [threshold] = args;
+        return (primitive) => dateLessThan(primitive, threshold);
+    }
+    const [primitive, threshold] = args;
+    return lessThan(unwrap(primitive), unwrap(threshold));
+}
+
+export { dateLessThan };

package/dist/clean/primitive/operations/date/dateMax.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var max = require('../../../../date/max.cjs');
+var wrapValue = require('../../../../common/wrapValue.cjs');
+var unwrap = require('../../../../common/unwrap.cjs');
+
+function dateMax(...input) {
+    if (input.length === 1) {
+        const [first] = input;
+        return (...rest) => (dateMax(...[first, ...rest]));
+    }
+    return wrapValue.wrapValue(max.max(input.map(unwrap.unwrap)));
+}
+
+exports.dateMax = dateMax;

package/dist/clean/primitive/operations/date/dateMax.d.ts

@@ -0,0 +1,5 @@
+import { type TheDate } from "../../../../date";
+import { type Date } from "../../base";
+import { type AnyTuple } from "../../../../common";
+export declare function dateMax(first: Date | TheDate): (...rest: (Date | TheDate)[]) => Date;
+export declare function dateMax(...input: AnyTuple<Date | TheDate>): Date;

package/dist/clean/primitive/operations/date/dateMax.mjs

@@ -0,0 +1,13 @@
+import { max } from '../../../../date/max.mjs';
+import { wrapValue } from '../../../../common/wrapValue.mjs';
+import { unwrap } from '../../../../common/unwrap.mjs';
+
+function dateMax(...input) {
+    if (input.length === 1) {
+        const [first] = input;
+        return (...rest) => (dateMax(...[first, ...rest]));
+    }
+    return wrapValue(max(input.map(unwrap)));
+}
+
+export { dateMax };

package/dist/clean/primitive/operations/date/dateMin.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var min = require('../../../../date/min.cjs');
+var wrapValue = require('../../../../common/wrapValue.cjs');
+var unwrap = require('../../../../common/unwrap.cjs');
+
+function dateMin(...input) {
+    if (input.length === 1) {
+        const [first] = input;
+        return (...rest) => (dateMin(...[first, ...rest]));
+    }
+    return wrapValue.wrapValue(min.min(input.map(unwrap.unwrap)));
+}
+
+exports.dateMin = dateMin;

package/dist/clean/primitive/operations/date/dateMin.d.ts

@@ -0,0 +1,5 @@
+import { type TheDate } from "../../../../date";
+import { type Date } from "../../base";
+import { type AnyTuple } from "../../../../common";
+export declare function dateMin(first: Date | TheDate): (...rest: (Date | TheDate)[]) => Date;
+export declare function dateMin(...input: AnyTuple<Date | TheDate>): Date;

package/dist/clean/primitive/operations/date/dateMin.mjs

@@ -0,0 +1,13 @@
+import { min } from '../../../../date/min.mjs';
+import { wrapValue } from '../../../../common/wrapValue.mjs';
+import { unwrap } from '../../../../common/unwrap.mjs';
+
+function dateMin(...input) {
+    if (input.length === 1) {
+        const [first] = input;
+        return (...rest) => (dateMin(...[first, ...rest]));
+    }
+    return wrapValue(min(input.map(unwrap)));
+}
+
+export { dateMin };

package/dist/clean/primitive/operations/date/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./dateGreaterThan";
+export * from "./dateLessThan";
+export * from "./dateMin";
+export * from "./dateMax";
+export * from "./dateGreaterThan";
+export * from "./dateLessThan";
+export * from "./dateMax";
+export * from "./dateMin";

package/dist/clean/primitive/operations/equal.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+var unwrap = require('../../../common/unwrap.cjs');
+
+function equal(...args) {
+    if (args.length === 1) {
+        const [value] = args;
+        return (input) => equal(input, value);
+    }
+    const [input, value] = args;
+    return unwrap.unwrap(input) === unwrap.unwrap(value);
+}
+
+exports.equal = equal;

package/dist/clean/primitive/operations/equal.d.ts

@@ -0,0 +1,4 @@
+import { type ToLargeEnsemble, type Unwrap } from "../../../common";
+import { type Primitive, type Primitives, type Date } from "../base";
+export declare function equal<GenericInput extends Primitives, GenericValue extends (GenericInput extends Date ? (Date | Unwrap<Date>) : (Primitive<ToLargeEnsemble<Unwrap<GenericInput>>> | ToLargeEnsemble<Unwrap<GenericInput>>))>(value: GenericValue): (input: GenericInput) => input is GenericInput & Primitive<Unwrap<GenericValue>>;
+export declare function equal<GenericInput extends Primitives, GenericValue extends (GenericInput extends Date ? (Date | Unwrap<Date>) : (Primitive<ToLargeEnsemble<Unwrap<GenericInput>>> | ToLargeEnsemble<Unwrap<GenericInput>>))>(input: GenericInput, value: GenericValue): input is GenericInput & Primitive<Unwrap<GenericValue>>;

package/dist/clean/primitive/operations/equal.mjs

@@ -0,0 +1,12 @@
+import { unwrap } from '../../../common/unwrap.mjs';
+
+function equal(...args) {
+    if (args.length === 1) {
+        const [value] = args;
+        return (input) => equal(input, value);
+    }
+    const [input, value] = args;
+    return unwrap(input) === unwrap(value);
+}
+
+export { equal };

package/dist/clean/primitive/operations/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./equal";
+export * from "./number";
+export * from "./string";
+export * from "./date";
+export * from "./sort";

package/dist/clean/primitive/operations/number/add.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var wrapValue = require('../../../../common/wrapValue.cjs');
+var unwrap = require('../../../../common/unwrap.cjs');
+
+function add(...args) {
+    if (args.length === 1) {
+        const [operand] = args;
+        return (value) => add(value, operand);
+    }
+    const [value, operand] = args;
+    return wrapValue.wrapValue(unwrap.unwrap(value) + unwrap.unwrap(operand));
+}
+
+exports.add = add;

package/dist/clean/primitive/operations/number/add.d.ts

@@ -0,0 +1,3 @@
+import { type Number } from "../../base";
+export declare function add(operand: Number | number): (value: Number) => Number;
+export declare function add(value: Number, operand: Number | number): Number;

package/dist/clean/primitive/operations/number/add.mjs

@@ -0,0 +1,13 @@
+import { wrapValue } from '../../../../common/wrapValue.mjs';
+import { unwrap } from '../../../../common/unwrap.mjs';
+
+function add(...args) {
+    if (args.length === 1) {
+        const [operand] = args;
+        return (value) => add(value, operand);
+    }
+    const [value, operand] = args;
+    return wrapValue(unwrap(value) + unwrap(operand));
+}
+
+export { add };

package/dist/clean/primitive/operations/number/divide.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var wrapValue = require('../../../../common/wrapValue.cjs');
+var unwrap = require('../../../../common/unwrap.cjs');
+
+function divide(...args) {
+    if (args.length === 1) {
+        const [divisor] = args;
+        return (value) => divide(value, divisor);
+    }
+    const [value, divisor] = args;
+    return wrapValue.wrapValue(unwrap.unwrap(value) / unwrap.unwrap(divisor));
+}
+
+exports.divide = divide;

package/dist/clean/primitive/operations/number/divide.d.ts

@@ -0,0 +1,3 @@
+import { type Number } from "../../base";
+export declare function divide(divisor: Number | number): (value: Number) => Number;
+export declare function divide(value: Number, divisor: Number | number): Number;

package/dist/clean/primitive/operations/number/divide.mjs

@@ -0,0 +1,13 @@
+import { wrapValue } from '../../../../common/wrapValue.mjs';
+import { unwrap } from '../../../../common/unwrap.mjs';
+
+function divide(...args) {
+    if (args.length === 1) {
+        const [divisor] = args;
+        return (value) => divide(value, divisor);
+    }
+    const [value, divisor] = args;
+    return wrapValue(unwrap(value) / unwrap(divisor));
+}
+
+export { divide };

package/dist/clean/primitive/operations/number/greaterThan.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+var unwrap = require('../../../../common/unwrap.cjs');
+
+function greaterThan(...args) {
+    if (args.length === 1) {
+        const [threshold] = args;
+        return (primitive) => greaterThan(primitive, threshold);
+    }
+    const [primitive, threshold] = args;
+    return unwrap.unwrap(primitive) > unwrap.unwrap(threshold);
+}
+
+exports.greaterThan = greaterThan;

package/dist/clean/primitive/operations/number/greaterThan.d.ts

@@ -0,0 +1,3 @@
+import { type Number } from "../../base";
+export declare function greaterThan(threshold: Number | number): (value: Number) => boolean;
+export declare function greaterThan(primitive: Number, threshold: Number | number): boolean;

package/dist/clean/primitive/operations/number/greaterThan.mjs

@@ -0,0 +1,12 @@
+import { unwrap } from '../../../../common/unwrap.mjs';
+
+function greaterThan(...args) {
+    if (args.length === 1) {
+        const [threshold] = args;
+        return (primitive) => greaterThan(primitive, threshold);
+    }
+    const [primitive, threshold] = args;
+    return unwrap(primitive) > unwrap(threshold);
+}
+
+export { greaterThan };

package/dist/clean/primitive/operations/number/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./add";
+export * from "./divide";
+export * from "./greaterThan";
+export * from "./lessThan";
+export * from "./max";
+export * from "./min";
+export * from "./multiply";
+export * from "./subtract";

package/dist/clean/primitive/operations/number/lessThan.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+var unwrap = require('../../../../common/unwrap.cjs');
+
+function lessThan(...args) {
+    if (args.length === 1) {
+        const [threshold] = args;
+        return (primitive) => lessThan(primitive, threshold);
+    }
+    const [primitive, threshold] = args;
+    return unwrap.unwrap(primitive) < unwrap.unwrap(threshold);
+}
+
+exports.lessThan = lessThan;

package/dist/clean/primitive/operations/number/lessThan.d.ts

@@ -0,0 +1,3 @@
+import { type Number } from "../../base";
+export declare function lessThan(threshold: Number | number): (value: Number) => boolean;
+export declare function lessThan(primitive: Number, threshold: Number | number): boolean;

package/dist/clean/primitive/operations/number/lessThan.mjs

@@ -0,0 +1,12 @@
+import { unwrap } from '../../../../common/unwrap.mjs';
+
+function lessThan(...args) {
+    if (args.length === 1) {
+        const [threshold] = args;
+        return (primitive) => lessThan(primitive, threshold);
+    }
+    const [primitive, threshold] = args;
+    return unwrap(primitive) < unwrap(threshold);
+}
+
+export { lessThan };

package/dist/clean/primitive/operations/number/max.cjs

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

package/dist/clean/primitive/operations/number/max.d.ts

@@ -0,0 +1,3 @@
+import { type AnyTuple } from "../../../../common";
+import { type Number } from "../../base";
+export declare function max(input: AnyTuple<Number | number>): Number;

package/dist/clean/primitive/operations/number/max.mjs

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

package/dist/clean/primitive/operations/number/min.cjs

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

package/dist/clean/primitive/operations/number/min.d.ts

@@ -0,0 +1,3 @@
+import { type AnyTuple } from "../../../../common";
+import { type Number } from "../../base";
+export declare function min(input: AnyTuple<Number | number>): Number;

package/dist/clean/primitive/operations/number/min.mjs

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

package/dist/clean/primitive/operations/number/multiply.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var wrapValue = require('../../../../common/wrapValue.cjs');
+var unwrap = require('../../../../common/unwrap.cjs');
+
+function multiply(...args) {
+    if (args.length === 1) {
+        const [multiplier] = args;
+        return (value) => multiply(value, multiplier);
+    }
+    const [value, multiplier] = args;
+    return wrapValue.wrapValue(unwrap.unwrap(value) * unwrap.unwrap(multiplier));
+}
+
+exports.multiply = multiply;

package/dist/clean/primitive/operations/number/multiply.d.ts

@@ -0,0 +1,3 @@
+import { type Number } from "../../base";
+export declare function multiply(multiplier: Number | number): (value: Number) => Number;
+export declare function multiply(value: Number, multiplier: Number | number): Number;

package/dist/clean/primitive/operations/number/multiply.mjs

@@ -0,0 +1,13 @@
+import { wrapValue } from '../../../../common/wrapValue.mjs';
+import { unwrap } from '../../../../common/unwrap.mjs';
+
+function multiply(...args) {
+    if (args.length === 1) {
+        const [multiplier] = args;
+        return (value) => multiply(value, multiplier);
+    }
+    const [value, multiplier] = args;
+    return wrapValue(unwrap(value) * unwrap(multiplier));
+}
+
+export { multiply };

package/dist/clean/primitive/operations/number/subtract.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var wrapValue = require('../../../../common/wrapValue.cjs');
+var unwrap = require('../../../../common/unwrap.cjs');
+
+function subtract(...args) {
+    if (args.length === 1) {
+        const [subtrahend] = args;
+        return (value) => subtract(value, subtrahend);
+    }
+    const [value, subtrahend] = args;
+    return wrapValue.wrapValue(unwrap.unwrap(value) - unwrap.unwrap(subtrahend));
+}
+
+exports.subtract = subtract;

package/dist/clean/primitive/operations/number/subtract.d.ts

@@ -0,0 +1,3 @@
+import { type Number } from "../../base";
+export declare function subtract(subtrahend: Number | number): (value: Number) => Number;
+export declare function subtract(value: Number, subtrahend: Number | number): Number;

package/dist/clean/primitive/operations/number/subtract.mjs

@@ -0,0 +1,13 @@
+import { wrapValue } from '../../../../common/wrapValue.mjs';
+import { unwrap } from '../../../../common/unwrap.mjs';
+
+function subtract(...args) {
+    if (args.length === 1) {
+        const [subtrahend] = args;
+        return (value) => subtract(value, subtrahend);
+    }
+    const [value, subtrahend] = args;
+    return wrapValue(unwrap(value) - unwrap(subtrahend));
+}
+
+export { subtract };

package/dist/clean/primitive/operations/sort.cjs

@@ -0,0 +1,35 @@
+'use strict';
+
+var unwrap = require('../../../common/unwrap.cjs');
+var sort$1 = require('../../../number/sort.cjs');
+var wrapValue = require('../../../common/wrapValue.cjs');
+var is = require('../../../date/is.cjs');
+var sort$2 = require('../../../date/sort.cjs');
+var sort$3 = require('../../../string/sort.cjs');
+
+function sort(...args) {
+    if (args.length === 1) {
+        const [type] = args;
+        return ((input) => sort(input, type));
+    }
+    const [input, type] = args;
+    const rawArray = input.map(unwrap.unwrap);
+    const first = rawArray.at(0);
+    if (!first) {
+        return [];
+    }
+    if (typeof first === "number") {
+        return sort$1.sort(rawArray, type)
+            .map(wrapValue.wrapValue);
+    }
+    else if (is.is(first)) {
+        return sort$2.sort(rawArray, type)
+            .map(wrapValue.wrapValue);
+    }
+    else {
+        return sort$3.sort(rawArray, type)
+            .map(wrapValue.wrapValue);
+    }
+}
+
+exports.sort = sort;

package/dist/clean/primitive/operations/sort.d.ts

@@ -0,0 +1,9 @@
+import { type Date, type Number, type String } from "../base";
+import { type SortType } from "../../../common";
+import * as DDate from "../../../date";
+export declare function sort(type: SortType): (input: readonly (Date | DDate.TheDate)[]) => Date[];
+export declare function sort(input: readonly (Date | DDate.TheDate)[], type: SortType): Date[];
+export declare function sort(type: SortType): (input: readonly (Number | number)[]) => Number[];
+export declare function sort(input: readonly (Number | number)[], type: SortType): Number[];
+export declare function sort(type: SortType): (input: readonly (String | string)[]) => String[];
+export declare function sort(input: readonly (String | string)[], type: SortType): String[];