@duplojs/utils 1.3.29 → 1.3.31

package/dist/clean/entity.d.ts

@@ -40,7 +40,7 @@ export interface EntityHandler<GenericName extends string = string, GenericPrope
     readonly name: GenericName;
     readonly propertiesDefinition: GenericPropertiesDefinition;
     readonly mapDataParser: DDataParser.Contract<EntityProperties<GenericPropertiesDefinition>, EntityRawProperties<GenericPropertiesDefinition>>;
-    "new"<GenericProperties extends EntityProperties<GenericPropertiesDefinition>>(properties: GenericProperties): Entity<GenericName> & GenericProperties;
+    "new"<const GenericProperties extends EntityProperties<GenericPropertiesDefinition>>(properties: GenericProperties): Entity<GenericName> & GenericProperties;
     map(rawProperties: EntityRawProperties<GenericPropertiesDefinition>): (DEither.EitherRight<"createEntity", Entity<GenericName> & EntityProperties<GenericPropertiesDefinition>> | DEither.EitherLeft<"createEntityError", DDataParser.DataParserError>);
     mapOrThrow(rawProperties: EntityRawProperties<GenericPropertiesDefinition>): Entity<GenericName> & EntityProperties<GenericPropertiesDefinition>;
     is<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, Entity<GenericName>>;
@@ -70,6 +70,6 @@ export interface PropertiesDefinitionParams {
         inArray: NeverCoalescing<GenericAdvancedArrayPropertyDefinition, true>;
     };
 }
-export declare function createEntity<GenericName extends string, const GenericPropertiesDefinition extends EntityPropertiesDefinition>(name: GenericName, getPropertiesDefinition: (params: PropertiesDefinitionParams) => GenericPropertiesDefinition): EntityHandler<GenericName, GenericPropertiesDefinition>;
+export declare function createEntity<GenericName extends string, const GenericPropertiesDefinition extends EntityPropertiesDefinition>(name: GenericName, getPropertiesDefinition: (params: PropertiesDefinitionParams) => GenericPropertiesDefinition & DObject.ForbiddenKey<GenericPropertiesDefinition, "_entityName" | "_flags">): EntityHandler<GenericName, GenericPropertiesDefinition>;
 export type GetEntity<GenericEntityHandler extends EntityHandler<string, any>> = Extract<ReturnType<GenericEntityHandler["new"]>, any>;
 export {};

package/dist/clean/flag.cjs

@@ -19,6 +19,10 @@ function createFlag(name) {
         getValue(entity) {
             return flagKind.getValue(entity)[name];
         },
+        has(entity) {
+            return flagKind.has(entity)
+                && name in flagKind.getValue(entity);
+        },
     });
 }
 

package/dist/clean/flag.d.ts

@@ -6,6 +6,7 @@ export interface FlagHandler<GenericEntity extends Entity = Entity, GenericName
     readonly name: GenericName;
     append<GenericInputEntity extends GenericEntity, GenericInputValue extends GenericValue>(entity: GenericInputEntity, ...args: IsEqual<GenericValue, never> extends true ? [] : [GenericInputValue]): (GenericInputEntity & Flag<GenericName, GenericInputValue>);
     getValue<GenericInputEntity extends GenericEntity & Flag<GenericName, GenericValue>>(entity: GenericInputEntity): GetKindValue<typeof flagKind, GenericInputEntity>[GenericName];
+    has<GenericInputEntity extends GenericEntity>(entity: GenericInputEntity): Extract<GenericInputEntity, Flag<GenericName, any>>;
 }
 export interface Flag<GenericName extends string = string, GenericValue extends unknown = never> extends Kind<typeof flagKind.definition, Record<GenericName, GenericValue>> {
 }

package/dist/clean/flag.mjs

@@ -17,6 +17,10 @@ function createFlag(name) {
         getValue(entity) {
             return flagKind.getValue(entity)[name];
         },
+        has(entity) {
+            return flagKind.has(entity)
+                && name in flagKind.getValue(entity);
+        },
     });
 }
 

package/dist/clean/index.cjs

@@ -6,6 +6,7 @@ var entity = require('./entity.cjs');
 var repository = require('./repository.cjs');
 var useCase = require('./useCase.cjs');
 var flag = require('./flag.cjs');
+var unwrapEntity = require('./unwrapEntity.cjs');
 var base = require('./constraint/base.cjs');
 var number = require('./constraint/defaultConstraint/number.cjs');
 var string = require('./constraint/defaultConstraint/string.cjs');
@@ -26,9 +27,15 @@ var lengthLessThan = require('./primitive/operations/string/lengthLessThan.cjs')
 var concat = require('./primitive/operations/string/concat.cjs');
 var dateGreaterThan = require('./primitive/operations/date/dateGreaterThan.cjs');
 var dateLessThan = require('./primitive/operations/date/dateLessThan.cjs');
+var dateAddTime = require('./primitive/operations/date/dateAddTime.cjs');
+var dateSubtractTime = require('./primitive/operations/date/dateSubtractTime.cjs');
 var dateMin = require('./primitive/operations/date/dateMin.cjs');
 var dateMax = require('./primitive/operations/date/dateMax.cjs');
 var sort = require('./primitive/operations/sort.cjs');
+var timeGreaterThan = require('./primitive/operations/time/timeGreaterThan.cjs');
+var timeLessThan = require('./primitive/operations/time/timeLessThan.cjs');
+var timeMin = require('./primitive/operations/time/timeMin.cjs');
+var timeMax = require('./primitive/operations/time/timeMax.cjs');
 
 
 
@@ -47,6 +54,7 @@ exports.useCaseHandlerKind = useCase.useCaseHandlerKind;
 exports.useCaseInstances = useCase.useCaseInstances;
 exports.createFlag = flag.createFlag;
 exports.flagKind = flag.flagKind;
+exports.unwrapEntity = unwrapEntity.unwrapEntity;
 exports.CreateConstrainedTypeError = base.CreateConstrainedTypeError;
 exports.constrainedTypeKind = base.constrainedTypeKind;
 exports.constraintHandlerKind = base.constraintHandlerKind;
@@ -62,6 +70,7 @@ exports.CreatePrimitiveError = base$1.CreatePrimitiveError;
 exports.Date = base$1.Date;
 exports.Number = base$1.Number;
 exports.String = base$1.String;
+exports.Time = base$1.Time;
 exports.primitiveHandlerKind = base$1.primitiveHandlerKind;
 exports.equal = equal.equal;
 exports.add = add.add;
@@ -79,6 +88,12 @@ exports.lengthLessThan = lengthLessThan.lengthLessThan;
 exports.concat = concat.concat;
 exports.dateGreaterThan = dateGreaterThan.dateGreaterThan;
 exports.dateLessThan = dateLessThan.dateLessThan;
+exports.dateAddTime = dateAddTime.dateAddTime;
+exports.dateSubtractTime = dateSubtractTime.dateSubtractTime;
 exports.dateMin = dateMin.dateMin;
 exports.dateMax = dateMax.dateMax;
 exports.sort = sort.sort;
+exports.timeGreaterThan = timeGreaterThan.timeGreaterThan;
+exports.timeLessThan = timeLessThan.timeLessThan;
+exports.timeMin = timeMin.timeMin;
+exports.timeMax = timeMax.timeMax;

package/dist/clean/index.d.ts

@@ -7,3 +7,4 @@ export * from "./primitive";
 export * from "./repository";
 export * from "./useCase";
 export * from "./flag";
+export * from "./unwrapEntity";

package/dist/clean/index.mjs

@@ -4,10 +4,11 @@ export { CreateEntityError, createEntity, entityKind } from './entity.mjs';
 export { createRepository, repositoryHandlerKind } from './repository.mjs';
 export { createUseCase, useCaseHandlerKind, useCaseInstances } from './useCase.mjs';
 export { createFlag, flagKind } from './flag.mjs';
+export { unwrapEntity } from './unwrapEntity.mjs';
 export { CreateConstrainedTypeError, constrainedTypeKind, constraintHandlerKind, createConstraint } from './constraint/base.mjs';
 export { Int, Negative, Positive } from './constraint/defaultConstraint/number.mjs';
 export { Email, Url } from './constraint/defaultConstraint/string.mjs';
-export { BigInt, Boolean, CreatePrimitiveError, Date, Number, String, primitiveHandlerKind } from './primitive/base.mjs';
+export { BigInt, Boolean, CreatePrimitiveError, Date, Number, String, Time, primitiveHandlerKind } from './primitive/base.mjs';
 export { equal } from './primitive/operations/equal.mjs';
 export { add } from './primitive/operations/number/add.mjs';
 export { divide } from './primitive/operations/number/divide.mjs';
@@ -24,6 +25,12 @@ export { lengthLessThan } from './primitive/operations/string/lengthLessThan.mjs
 export { concat } from './primitive/operations/string/concat.mjs';
 export { dateGreaterThan } from './primitive/operations/date/dateGreaterThan.mjs';
 export { dateLessThan } from './primitive/operations/date/dateLessThan.mjs';
+export { dateAddTime } from './primitive/operations/date/dateAddTime.mjs';
+export { dateSubtractTime } from './primitive/operations/date/dateSubtractTime.mjs';
 export { dateMin } from './primitive/operations/date/dateMin.mjs';
 export { dateMax } from './primitive/operations/date/dateMax.mjs';
 export { sort } from './primitive/operations/sort.mjs';
+export { timeGreaterThan } from './primitive/operations/time/timeGreaterThan.mjs';
+export { timeLessThan } from './primitive/operations/time/timeLessThan.mjs';
+export { timeMin } from './primitive/operations/time/timeMin.mjs';
+export { timeMax } from './primitive/operations/time/timeMax.mjs';

package/dist/clean/newType.d.ts

@@ -1,4 +1,4 @@
-import { type Kind, type WrappedValue, type Unwrap, type NeverCoalescing } from "..";
+import { type Kind, type WrappedValue, type Unwrap, type NeverCoalescing, type DeepReadonly } from "..";
 import { constrainedTypeKind, type ConstraintHandler } from "./constraint";
 import { type Primitive, type EligiblePrimitive } from "./primitive";
 import * as DEither from "../either";
@@ -34,6 +34,6 @@ export declare class CreateNewTypeError extends CreateNewTypeError_base {
 export declare function createNewType<GenericName extends string, GenericDataParser extends DDataParser.DataParser, const GenericConstrainHandler extends (ConstraintHandler<string, EligiblePrimitive, readonly DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, DDataParser.Output<GenericDataParser>>[]> | readonly [
     ConstraintHandler<string, EligiblePrimitive, readonly DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, DDataParser.Output<GenericDataParser>>[]>,
     ...ConstraintHandler<string, EligiblePrimitive, readonly DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, DDataParser.Output<GenericDataParser>>[]>[]
-]) = never>(name: GenericName, dataParser: GenericDataParser & DataParserContainTransform<GenericDataParser>, constraint?: GenericConstrainHandler): NewTypeHandler<GenericName, DDataParser.Output<GenericDataParser>, DArray.ArrayCoalescing<NeverCoalescing<GenericConstrainHandler, readonly []>>>;
+]) = never>(name: GenericName, dataParser: GenericDataParser & DataParserContainTransform<GenericDataParser>, constraint?: GenericConstrainHandler): NewTypeHandler<GenericName, DeepReadonly<DDataParser.Output<GenericDataParser>>, DArray.ArrayCoalescing<NeverCoalescing<GenericConstrainHandler, readonly []>>>;
 export type GetNewType<GenericHandler extends NewTypeHandler<string, unknown, readonly any[]>> = Extract<GenericHandler extends any ? NewType<GenericHandler["name"], DDataParser.Output<GenericHandler["dataParser"]>, GenericHandler["constrains"][number]["name"]> : never, any>;
 export {};

package/dist/clean/primitive/base.cjs

@@ -7,6 +7,7 @@ var index$1 = require('../../dataParser/parsers/number/index.cjs');
 var index$2 = require('../../dataParser/parsers/bigint/index.cjs');
 var boolean = require('../../dataParser/parsers/boolean.cjs');
 var date = require('../../dataParser/parsers/date.cjs');
+var index$3 = require('../../dataParser/parsers/time/index.cjs');
 var errorKindNamespace = require('../../common/errorKindNamespace.cjs');
 var unwrap = require('../../common/unwrap.cjs');
 var is = require('../../either/right/is.cjs');
@@ -62,6 +63,7 @@ const Number = createPrimitive(index$1.number());
 const BigInt = createPrimitive(index$2.bigint());
 const Boolean = createPrimitive(boolean.boolean());
 const Date = createPrimitive(date.date());
+const Time = createPrimitive(index$3.time());
 
 exports.BigInt = BigInt;
 exports.Boolean = Boolean;
@@ -69,4 +71,5 @@ exports.CreatePrimitiveError = CreatePrimitiveError;
 exports.Date = Date;
 exports.Number = Number;
 exports.String = String;
+exports.Time = Time;
 exports.primitiveHandlerKind = primitiveHandlerKind;

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

@@ -31,6 +31,8 @@ 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 declare const Time: PrimitiveHandler<`time${number}-` | `time${number}+`>;
+export type Time = ReturnType<typeof Time["createWithUnknownOrThrow"]>;
+export type Primitives = (String | Number | BigInt | Boolean | Date | Time);
+export type PrimitiveHandlers = (typeof String | typeof Number | typeof BigInt | typeof Boolean | typeof Date | typeof Time);
 export {};

package/dist/clean/primitive/base.mjs

@@ -5,6 +5,7 @@ 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 { time } from '../../dataParser/parsers/time/index.mjs';
 import { createErrorKind } from '../../common/errorKindNamespace.mjs';
 import { unwrap } from '../../common/unwrap.mjs';
 import { isRight } from '../../either/right/is.mjs';
@@ -60,5 +61,6 @@ const Number = createPrimitive(number());
 const BigInt = createPrimitive(bigint());
 const Boolean = createPrimitive(boolean());
 const Date = createPrimitive(date());
+const Time = createPrimitive(time());
 
-export { BigInt, Boolean, CreatePrimitiveError, Date, Number, String, primitiveHandlerKind };
+export { BigInt, Boolean, CreatePrimitiveError, Date, Number, String, Time, primitiveHandlerKind };

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

@@ -0,0 +1,16 @@
+'use strict';
+
+var addTime = require('../../../../date/operators/addTime.cjs');
+var wrapValue = require('../../../../common/wrapValue.cjs');
+var unwrap = require('../../../../common/unwrap.cjs');
+
+function dateAddTime(...args) {
+    if (args.length === 1) {
+        const [time] = args;
+        return (primitive) => dateAddTime(primitive, time);
+    }
+    const [primitive, time] = args;
+    return wrapValue.wrapValue(addTime.addTime(unwrap.unwrap(primitive), unwrap.unwrap(time)));
+}
+
+exports.dateAddTime = dateAddTime;

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

@@ -0,0 +1,4 @@
+import { type Date, type Time } from "../../base";
+import { type TheTime } from "../../../../date";
+export declare function dateAddTime(time: Time | TheTime): (primitive: Date) => Date;
+export declare function dateAddTime(primitive: Date, time: Time | TheTime): Date;

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

@@ -0,0 +1,14 @@
+import { addTime } from '../../../../date/operators/addTime.mjs';
+import { wrapValue } from '../../../../common/wrapValue.mjs';
+import { unwrap } from '../../../../common/unwrap.mjs';
+
+function dateAddTime(...args) {
+    if (args.length === 1) {
+        const [time] = args;
+        return (primitive) => dateAddTime(primitive, time);
+    }
+    const [primitive, time] = args;
+    return wrapValue(addTime(unwrap(primitive), unwrap(time)));
+}
+
+export { dateAddTime };

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

@@ -4,11 +4,7 @@ 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]));
-    }
+function dateMax(input) {
     return wrapValue.wrapValue(max.max(input.map(unwrap.unwrap)));
 }
 

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

@@ -1,5 +1,4 @@
 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;
+export declare function dateMax(input: AnyTuple<Date | TheDate>): Date;

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

@@ -2,11 +2,7 @@ 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]));
-    }
+function dateMax(input) {
     return wrapValue(max(input.map(unwrap)));
 }
 

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

@@ -4,11 +4,7 @@ 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]));
-    }
+function dateMin(input) {
     return wrapValue.wrapValue(min.min(input.map(unwrap.unwrap)));
 }
 

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

@@ -1,5 +1,4 @@
 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;
+export declare function dateMin(input: AnyTuple<Date | TheDate>): Date;

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

@@ -2,11 +2,7 @@ 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]));
-    }
+function dateMin(input) {
     return wrapValue(min(input.map(unwrap)));
 }
 

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

@@ -0,0 +1,16 @@
+'use strict';
+
+var subtractTime = require('../../../../date/operators/subtractTime.cjs');
+var wrapValue = require('../../../../common/wrapValue.cjs');
+var unwrap = require('../../../../common/unwrap.cjs');
+
+function dateSubtractTime(...args) {
+    if (args.length === 1) {
+        const [time] = args;
+        return (primitive) => dateSubtractTime(primitive, time);
+    }
+    const [primitive, time] = args;
+    return wrapValue.wrapValue(subtractTime.subtractTime(unwrap.unwrap(primitive), unwrap.unwrap(time)));
+}
+
+exports.dateSubtractTime = dateSubtractTime;

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

@@ -0,0 +1,4 @@
+import { type Date, type Time } from "../../base";
+import { type TheTime } from "../../../../date";
+export declare function dateSubtractTime(time: Time | TheTime): (primitive: Date) => Date;
+export declare function dateSubtractTime(primitive: Date, time: Time | TheTime): Date;

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

@@ -0,0 +1,14 @@
+import { subtractTime } from '../../../../date/operators/subtractTime.mjs';
+import { wrapValue } from '../../../../common/wrapValue.mjs';
+import { unwrap } from '../../../../common/unwrap.mjs';
+
+function dateSubtractTime(...args) {
+    if (args.length === 1) {
+        const [time] = args;
+        return (primitive) => dateSubtractTime(primitive, time);
+    }
+    const [primitive, time] = args;
+    return wrapValue(subtractTime(unwrap(primitive), unwrap(time)));
+}
+
+export { dateSubtractTime };

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

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

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

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

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

@@ -3,3 +3,4 @@ export * from "./number";
 export * from "./string";
 export * from "./date";
 export * from "./sort";
+export * from "./time";

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

@@ -5,6 +5,8 @@ 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 isTime = require('../../../date/isTime.cjs');
+var sortTimes = require('../../../date/sortTimes.cjs');
 var sort$3 = require('../../../string/sort.cjs');
 
 function sort(...args) {
@@ -26,6 +28,10 @@ function sort(...args) {
         return sort$2.sort(rawArray, type)
             .map(wrapValue.wrapValue);
     }
+    else if (isTime.isTime(first)) {
+        return sortTimes.sortTimes(rawArray, type)
+            .map(wrapValue.wrapValue);
+    }
     else {
         return sort$3.sort(rawArray, type)
             .map(wrapValue.wrapValue);

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

@@ -1,9 +1,5 @@
-import { type Date, type Number, type String } from "../base";
-import { type SortType } from "../../../common";
+import { type Date, type Number, type String, type Time } from "../base";
+import { type ToWrappedValue, 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[];
+export declare function sort<GenericInput extends (readonly (Date | DDate.TheDate)[] | readonly (Number | number)[] | readonly (String | string)[] | readonly (Time | DDate.TheTime)[])>(type: SortType): (input: GenericInput) => ToWrappedValue<GenericInput[number]>[];
+export declare function sort<GenericInput extends (readonly (Date | DDate.TheDate)[] | readonly (Number | number)[] | readonly (String | string)[] | readonly (Time | DDate.TheTime)[])>(input: GenericInput, type: SortType): ToWrappedValue<GenericInput[number]>[];

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

@@ -3,6 +3,8 @@ import { sort as sort$1 } from '../../../number/sort.mjs';
 import { wrapValue } from '../../../common/wrapValue.mjs';
 import { is } from '../../../date/is.mjs';
 import { sort as sort$2 } from '../../../date/sort.mjs';
+import { isTime } from '../../../date/isTime.mjs';
+import { sortTimes } from '../../../date/sortTimes.mjs';
 import { sort as sort$3 } from '../../../string/sort.mjs';
 
 function sort(...args) {
@@ -24,6 +26,10 @@ function sort(...args) {
         return sort$2(rawArray, type)
             .map(wrapValue);
     }
+    else if (isTime(first)) {
+        return sortTimes(rawArray, type)
+            .map(wrapValue);
+    }
     else {
         return sort$3(rawArray, type)
             .map(wrapValue);

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

@@ -0,0 +1,4 @@
+export * from "./timeGreaterThan";
+export * from "./timeLessThan";
+export * from "./timeMin";
+export * from "./timeMax";

package/dist/clean/primitive/operations/time/timeGreaterThan.cjs

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

package/dist/clean/primitive/operations/time/timeGreaterThan.d.ts

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

package/dist/clean/primitive/operations/time/timeGreaterThan.mjs

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

package/dist/clean/primitive/operations/time/timeLessThan.cjs

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

package/dist/clean/primitive/operations/time/timeLessThan.d.ts

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

package/dist/clean/primitive/operations/time/timeLessThan.mjs

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

package/dist/clean/primitive/operations/time/timeMax.cjs

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

package/dist/clean/primitive/operations/time/timeMax.d.ts

@@ -0,0 +1,4 @@
+import { type TheTime } from "../../../../date";
+import { type Time } from "../../base";
+import { type AnyTuple } from "../../../../common";
+export declare function timeMax(input: AnyTuple<Time | TheTime>): Time;

package/dist/clean/primitive/operations/time/timeMax.mjs

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

package/dist/clean/primitive/operations/time/timeMin.cjs

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

package/dist/clean/primitive/operations/time/timeMin.d.ts

@@ -0,0 +1,4 @@
+import { type TheTime } from "../../../../date";
+import { type Time } from "../../base";
+import { type AnyTuple } from "../../../../common";
+export declare function timeMin(input: AnyTuple<Time | TheTime>): Time;

package/dist/clean/primitive/operations/time/timeMin.mjs

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

package/dist/clean/unwrapEntity.cjs

@@ -0,0 +1,26 @@
+'use strict';
+
+var entity = require('./entity.cjs');
+var flag = require('./flag.cjs');
+var unwrap = require('../common/unwrap.cjs');
+
+function unwrapEntity(entity$1) {
+    const unwrapEntity = {};
+    for (const prop in entity$1) {
+        if (prop === entity.entityKind.runTimeKey) {
+            unwrapEntity._entityName = entity$1[prop];
+        }
+        else if (prop === flag.flagKind.runTimeKey) {
+            unwrapEntity._flags = entity$1[prop];
+        }
+        else if (entity$1[prop] instanceof Array) {
+            unwrapEntity[prop] = entity$1[prop].map(unwrap.unwrap);
+        }
+        else {
+            unwrapEntity[prop] = unwrap.unwrap(entity$1[prop]);
+        }
+    }
+    return unwrapEntity;
+}
+
+exports.unwrapEntity = unwrapEntity;