@duplojs/utils 1.3.29 → 1.3.31

package/dist/clean/unwrapEntity.d.ts

@@ -0,0 +1,13 @@
+import { type GetKindValue, type SimplifyTopLevel, type Kind, type Unwrap, type DeepReadonly } from "../common";
+import { entityKind, type Entity } from "./entity";
+import { flagKind } from "./flag";
+type UnwrapArrayProperties<GenericValue extends readonly any[]> = GenericValue extends readonly [infer InferredFirst, ...infer InferredRest] ? (InferredRest extends readonly [] ? readonly [] : UnwrapArrayProperties<InferredRest>) extends infer InferredResult extends readonly any[] ? readonly [Unwrap<InferredFirst>, ...InferredResult] : never : readonly Unwrap<GenericValue[number]>[];
+export type UnwrapEntity<GenericEntity extends Entity> = SimplifyTopLevel<DeepReadonly<{
+    [Prop in Extract<keyof GenericEntity, string>]: GenericEntity[Prop] extends readonly any[] ? UnwrapArrayProperties<GenericEntity[Prop]> : Unwrap<GenericEntity[Prop]>;
+} & {
+    [Prop in "_entityName"]: GetKindValue<typeof entityKind, GenericEntity>;
+} & (GenericEntity extends Kind<typeof flagKind.definition, any> ? {
+    [Prop in "_flags"]: SimplifyTopLevel<GetKindValue<typeof flagKind, GenericEntity>>;
+} : {})>>;
+export declare function unwrapEntity<GenericEntity extends Entity>(entity: GenericEntity): UnwrapEntity<GenericEntity>;
+export {};

package/dist/clean/unwrapEntity.mjs

@@ -0,0 +1,24 @@
+import { entityKind } from './entity.mjs';
+import { flagKind } from './flag.mjs';
+import { unwrap } from '../common/unwrap.mjs';
+
+function unwrapEntity(entity) {
+    const unwrapEntity = {};
+    for (const prop in entity) {
+        if (prop === entityKind.runTimeKey) {
+            unwrapEntity._entityName = entity[prop];
+        }
+        else if (prop === flagKind.runTimeKey) {
+            unwrapEntity._flags = entity[prop];
+        }
+        else if (entity[prop] instanceof Array) {
+            unwrapEntity[prop] = entity[prop].map(unwrap);
+        }
+        else {
+            unwrapEntity[prop] = unwrap(entity[prop]);
+        }
+    }
+    return unwrapEntity;
+}
+
+export { unwrapEntity };

package/dist/common/index.d.ts

@@ -45,3 +45,5 @@ export * from "./truthy";
 export * from "./falsy";
 export * from "./hasSomeKinds";
 export * from "./hasKinds";
+export * from "./toCurriedPredicate";
+export * from "./pipeCall";

package/dist/common/override.cjs

@@ -1,33 +1,54 @@
 'use strict';
 
 var globalStore = require('./globalStore.cjs');
-var pipe = require('./pipe.cjs');
-var fromEntries = require('../object/fromEntries.cjs');
-var map = require('../array/map.cjs');
-var entry = require('../object/entry.cjs');
 
 const SymbolOverrideStore = Symbol.for("@duplojs/utils/override");
 const overrideStore = globalStore.createGlobalStore(SymbolOverrideStore, {});
 function createOverride(overrideName) {
-    const store = overrideStore.value[overrideName] ?? [];
-    overrideStore.set({
-        ...overrideStore.value,
-        [overrideName]: store,
-    });
+    const overridePropertiesStore = overrideStore.value[overrideName] ?? {};
+    overrideStore.value[overrideName] ||= overridePropertiesStore;
+    let cachedStoreKey = Object.keys(overridePropertiesStore);
     return {
         setMethod(prop, theFunction) {
-            store.push([prop, theFunction]);
+            overridePropertiesStore[prop] = theFunction;
+            cachedStoreKey = Object.keys(overridePropertiesStore);
         },
         setPropertyDefaultValue(prop, value) {
-            store.push([prop, value]);
+            overridePropertiesStore[prop] = value;
+            cachedStoreKey = Object.keys(overridePropertiesStore);
         },
         apply(overrideInterface) {
-            const self = {
-                ...overrideInterface,
-                ...pipe.pipe(store, map.map(([key, value]) => entry.entry(key, typeof value === "function"
-                    ? (...args) => value(self, ...args)
-                    : value)), fromEntries.fromEntries),
-            };
+            const cachedOverrideProperties = {};
+            const cachedKey = Object.keys(overrideInterface);
+            const self = new Proxy({}, {
+                get(target, prop) {
+                    if (overridePropertiesStore[prop]) {
+                        if (!cachedOverrideProperties[prop]) {
+                            cachedOverrideProperties[prop] = typeof overridePropertiesStore[prop] === "function"
+                                ? (...args) => overridePropertiesStore[prop](self, ...args)
+                                : overridePropertiesStore[prop];
+                        }
+                        return cachedOverrideProperties[prop];
+                    }
+                    return overrideInterface[prop];
+                },
+                ownKeys() {
+                    return [
+                        ...cachedKey,
+                        ...cachedStoreKey,
+                    ];
+                },
+                has(target, prop) {
+                    return cachedKey.includes(prop)
+                        || cachedStoreKey.includes(prop);
+                },
+                getOwnPropertyDescriptor() {
+                    return {
+                        enumerable: true,
+                        configurable: true,
+                    };
+                },
+            });
             return self;
         },
     };

package/dist/common/override.d.ts

@@ -1,17 +1,14 @@
-import { type GetPropsWithValueExtends } from "../object";
-import { type Adaptor, type AnyFunction, type AnyValue, type ObjectKey } from "./types";
+import { type Adaptor, type AnyFunction, type AnyValue } from "./types";
+import type * as DObject from "../object";
 declare const SymbolOverrideStore: unique symbol;
 declare module "./globalStore" {
     interface GlobalStore {
-        [SymbolOverrideStore]: Record<string, [
-            ObjectKey,
-            Exclude<AnyValue, AnyFunction> | AnyFunction<[object, ...unknown[]]>
-        ][]>;
+        [SymbolOverrideStore]: Record<string, Record<string, unknown>>;
     }
 }
 export interface OverrideHandler<GenericInterface extends object> {
-    setMethod<GenericProperty extends GetPropsWithValueExtends<GenericInterface, AnyFunction>>(prop: GenericProperty, theFunction: (self: GenericInterface, ...args: Parameters<GenericInterface[GenericProperty]>) => ReturnType<GenericInterface[GenericProperty]>): void;
-    setPropertyDefaultValue<GenericProperty extends Exclude<keyof GenericInterface, GetPropsWithValueExtends<GenericInterface, AnyFunction>>>(prop: GenericProperty, value: Adaptor<GenericInterface[GenericProperty], AnyValue>): void;
+    setMethod<GenericProperty extends DObject.GetPropsWithValueExtends<GenericInterface, AnyFunction>>(prop: GenericProperty, theFunction: (self: GenericInterface, ...args: Parameters<GenericInterface[GenericProperty]>) => ReturnType<GenericInterface[GenericProperty]>): void;
+    setPropertyDefaultValue<GenericProperty extends Exclude<keyof GenericInterface, DObject.GetPropsWithValueExtends<GenericInterface, AnyFunction>>>(prop: GenericProperty, value: Adaptor<GenericInterface[GenericProperty], AnyValue>): void;
     apply(overrideInterface: GenericInterface): GenericInterface;
 }
 export declare function createOverride<GenericInterface extends object>(overrideName: string): OverrideHandler<GenericInterface>;

package/dist/common/override.mjs

@@ -1,31 +1,52 @@
 import { createGlobalStore } from './globalStore.mjs';
-import { pipe } from './pipe.mjs';
-import { fromEntries } from '../object/fromEntries.mjs';
-import { map } from '../array/map.mjs';
-import { entry } from '../object/entry.mjs';
 
 const SymbolOverrideStore = Symbol.for("@duplojs/utils/override");
 const overrideStore = createGlobalStore(SymbolOverrideStore, {});
 function createOverride(overrideName) {
-    const store = overrideStore.value[overrideName] ?? [];
-    overrideStore.set({
-        ...overrideStore.value,
-        [overrideName]: store,
-    });
+    const overridePropertiesStore = overrideStore.value[overrideName] ?? {};
+    overrideStore.value[overrideName] ||= overridePropertiesStore;
+    let cachedStoreKey = Object.keys(overridePropertiesStore);
     return {
         setMethod(prop, theFunction) {
-            store.push([prop, theFunction]);
+            overridePropertiesStore[prop] = theFunction;
+            cachedStoreKey = Object.keys(overridePropertiesStore);
         },
         setPropertyDefaultValue(prop, value) {
-            store.push([prop, value]);
+            overridePropertiesStore[prop] = value;
+            cachedStoreKey = Object.keys(overridePropertiesStore);
         },
         apply(overrideInterface) {
-            const self = {
-                ...overrideInterface,
-                ...pipe(store, map(([key, value]) => entry(key, typeof value === "function"
-                    ? (...args) => value(self, ...args)
-                    : value)), fromEntries),
-            };
+            const cachedOverrideProperties = {};
+            const cachedKey = Object.keys(overrideInterface);
+            const self = new Proxy({}, {
+                get(target, prop) {
+                    if (overridePropertiesStore[prop]) {
+                        if (!cachedOverrideProperties[prop]) {
+                            cachedOverrideProperties[prop] = typeof overridePropertiesStore[prop] === "function"
+                                ? (...args) => overridePropertiesStore[prop](self, ...args)
+                                : overridePropertiesStore[prop];
+                        }
+                        return cachedOverrideProperties[prop];
+                    }
+                    return overrideInterface[prop];
+                },
+                ownKeys() {
+                    return [
+                        ...cachedKey,
+                        ...cachedStoreKey,
+                    ];
+                },
+                has(target, prop) {
+                    return cachedKey.includes(prop)
+                        || cachedStoreKey.includes(prop);
+                },
+                getOwnPropertyDescriptor() {
+                    return {
+                        enumerable: true,
+                        configurable: true,
+                    };
+                },
+            });
             return self;
         },
     };

package/dist/common/pipeCall.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+function pipeCall(theFunction) {
+    return theFunction;
+}
+
+exports.pipeCall = pipeCall;

package/dist/common/pipeCall.d.ts

@@ -0,0 +1 @@
+export declare function pipeCall<GenericInput extends unknown, GenericOutput extends unknown>(theFunction: (input: NoInfer<GenericInput>) => GenericOutput): (input: GenericInput) => NoInfer<GenericOutput>;

package/dist/common/pipeCall.mjs

@@ -0,0 +1,5 @@
+function pipeCall(theFunction) {
+    return theFunction;
+}
+
+export { pipeCall };

package/dist/common/toCurriedPredicate.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+function toCurriedPredicate(thePredicate) {
+    return thePredicate;
+}
+
+exports.toCurriedPredicate = toCurriedPredicate;

package/dist/common/toCurriedPredicate.d.ts

@@ -0,0 +1 @@
+export declare function toCurriedPredicate<GenericInput extends unknown, GenericPredicate extends GenericInput>(thePredicate: (input: GenericInput) => input is GenericPredicate): (input: GenericInput) => input is GenericPredicate;

package/dist/common/toCurriedPredicate.mjs

@@ -0,0 +1,5 @@
+function toCurriedPredicate(thePredicate) {
+    return thePredicate;
+}
+
+export { toCurriedPredicate };

package/dist/common/toWrappedValue.d.ts

@@ -1,4 +1,5 @@
 import { type WrappedValue } from "../common/wrapValue";
 import { type MaybeWrapped } from "./types/maybeWrapped";
 import { type AnyValue } from "./types";
-export declare function toWrappedValue<GenericInnerValue extends AnyValue, GenericValue extends MaybeWrapped<GenericInnerValue>>(value: GenericValue): GenericValue extends WrappedValue ? GenericValue : WrappedValue<GenericValue>;
+export type ToWrappedValue<GenericValue extends unknown> = GenericValue extends WrappedValue ? GenericValue : WrappedValue<GenericValue>;
+export declare function toWrappedValue<GenericInnerValue extends AnyValue, GenericValue extends MaybeWrapped<GenericInnerValue>>(value: GenericValue): ToWrappedValue<GenericValue>;

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

@@ -0,0 +1,3 @@
+export type DeepReadonly<GenericValue extends unknown> = GenericValue extends object ? {
+    readonly [Prop in keyof GenericValue]: DeepReadonly<GenericValue[Prop]>;
+} : GenericValue;

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

@@ -43,3 +43,4 @@ export * from "./onlyLiteral";
 export * from "./sortType";
 export * from "./maybeGetter";
 export * from "./falsyValue";
+export * from "./DeepReadonly";

package/dist/dataParser/extended/coerce/index.cjs

@@ -3,6 +3,7 @@
 var bigint = require('./bigint.cjs');
 var boolean = require('./boolean.cjs');
 var date = require('./date.cjs');
+var time = require('./time.cjs');
 var empty = require('./empty.cjs');
 var nil = require('./nil.cjs');
 var number = require('./number.cjs');
@@ -13,6 +14,7 @@ var string = require('./string.cjs');
 exports.bigint = bigint.bigint;
 exports.boolean = boolean.boolean;
 exports.date = date.date;
+exports.time = time.time;
 exports.empty = empty.empty;
 exports.nil = nil.nil;
 exports.number = number.number;

package/dist/dataParser/extended/coerce/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./bigint";
 export * from "./boolean";
 export * from "./date";
+export * from "./time";
 export * from "./empty";
 export * from "./nil";
 export * from "./number";

package/dist/dataParser/extended/coerce/index.mjs

@@ -1,6 +1,7 @@
 export { bigint } from './bigint.mjs';
 export { boolean } from './boolean.mjs';
 export { date } from './date.mjs';
+export { time } from './time.mjs';
 export { empty } from './empty.mjs';
 export { nil } from './nil.mjs';
 export { number } from './number.mjs';

package/dist/dataParser/extended/coerce/time.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var time$1 = require('../time.cjs');
+
+function time(definition) {
+    return time$1.time({
+        ...definition,
+        coerce: true,
+    });
+}
+
+exports.time = time;

package/dist/dataParser/extended/coerce/time.d.ts

@@ -0,0 +1,7 @@
+import { type NeverCoalescing } from "../../../common";
+import { type MergeDefinition } from "../../types";
+import type * as dataParsers from "../../parsers";
+import * as dataParsersExtended from "..";
+export declare function time<const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionTime, "coerce">> = never>(definition?: GenericDefinition): dataParsersExtended.DataParserTimeExtended<MergeDefinition<dataParsers.DataParserDefinitionTime, NeverCoalescing<GenericDefinition, {}> & {
+    coerce: true;
+}>>;

package/dist/dataParser/extended/coerce/time.mjs

@@ -0,0 +1,10 @@
+import { time as time$1 } from '../time.mjs';
+
+function time(definition) {
+    return time$1({
+        ...definition,
+        coerce: true,
+    });
+}
+
+export { time };

package/dist/dataParser/extended/index.cjs

@@ -6,6 +6,7 @@ var array = require('./array.cjs');
 var bigint = require('./bigint.cjs');
 var number = require('./number.cjs');
 var date = require('./date.cjs');
+var time = require('./time.cjs');
 var transform = require('./transform.cjs');
 var union = require('./union.cjs');
 var boolean = require('./boolean.cjs');
@@ -35,6 +36,7 @@ exports.bigint = bigint.bigint;
 exports.int = number.int;
 exports.number = number.number;
 exports.date = date.date;
+exports.time = time.time;
 exports.transform = transform.transform;
 exports.union = union.union;
 exports.boolean = boolean.boolean;

package/dist/dataParser/extended/index.d.ts

@@ -4,6 +4,7 @@ export * from "./array";
 export * from "./bigint";
 export * from "./number";
 export * from "./date";
+export * from "./time";
 export * from "./transform";
 export * from "./union";
 export * from "./boolean";

package/dist/dataParser/extended/index.mjs

@@ -5,6 +5,7 @@ export { array } from './array.mjs';
 export { bigint } from './bigint.mjs';
 export { int, number } from './number.mjs';
 export { date } from './date.mjs';
+export { time } from './time.mjs';
 export { transform } from './transform.mjs';
 export { union } from './union.mjs';
 export { boolean } from './boolean.mjs';

package/dist/dataParser/extended/object.cjs

@@ -4,6 +4,7 @@ var baseExtended = require('../baseExtended.cjs');
 var index = require('../parsers/object/index.cjs');
 var required = require('../parsers/object/required.cjs');
 var partial = require('../parsers/object/partial.cjs');
+var _extends = require('../parsers/object/extends.cjs');
 var pick = require('../parsers/object/pick.cjs');
 var omit = require('../parsers/object/omit.cjs');
 var override = require('../../common/override.cjs');
@@ -18,6 +19,10 @@ function object(shape, definition) {
             const newShape = pick.pickShape(self.definition.shape, pickObject);
             return object(newShape, definition);
         },
+        extends: (self, extension, definition) => {
+            const newShape = _extends.extendsShape(self.definition.shape, extension);
+            return object(newShape, definition);
+        },
         partial: (self, definition) => {
             const newShape = partial.partialShape(self.definition.shape);
             return object(newShape, definition);

package/dist/dataParser/extended/object.d.ts

@@ -3,6 +3,7 @@ import { type DataParserExtended } from "../baseExtended";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
 import { type Output } from "../base";
+import { type AssignObjects } from "../../object";
 type _DataParserObjectExtended<GenericDefinition extends dataParsers.DataParserDefinitionObject> = (Kind<typeof dataParsers.objectKind.definition> & DataParserExtended<GenericDefinition, dataParsers.DataParserObjectShapeOutput<GenericDefinition["shape"]>, dataParsers.DataParserObjectShapeInput<GenericDefinition["shape"]>>);
 export interface DataParserObjectExtended<GenericDefinition extends dataParsers.DataParserDefinitionObject = dataParsers.DataParserDefinitionObject> extends _DataParserObjectExtended<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
@@ -25,6 +26,9 @@ export interface DataParserObjectExtended<GenericDefinition extends dataParsers.
     pick<const GenericPickObject extends Partial<Record<keyof GenericDefinition["shape"], true>>, const GenericSubDefinition extends Partial<Omit<dataParsers.DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(pickObject: GenericPickObject, definition?: GenericDefinition): DataParserObjectExtended<MergeDefinition<dataParsers.DataParserDefinitionObject, NeverCoalescing<GenericSubDefinition, {}> & {
         readonly shape: SimplifyTopLevel<Pick<GenericDefinition["shape"], Adaptor<keyof GenericPickObject, keyof GenericDefinition["shape"]>>>;
     }>>;
+    extends<const GenericExtension extends dataParsers.DataParserObjectShape, const GenericSubDefinition extends Partial<Omit<dataParsers.DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(extension: GenericExtension, definition?: GenericDefinition): DataParserObjectExtended<MergeDefinition<dataParsers.DataParserDefinitionObject, NeverCoalescing<GenericSubDefinition, {}> & {
+        readonly shape: AssignObjects<GenericDefinition["shape"], GenericExtension>;
+    }>>;
     partial<const GenericSubDefinition extends Partial<Omit<dataParsers.DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(definition?: GenericDefinition): DataParserObjectExtended<MergeDefinition<dataParsers.DataParserDefinitionObject, NeverCoalescing<GenericSubDefinition, {}> & {
         readonly shape: dataParsers.PartialDataParserObject<GenericDefinition["shape"]>;
     }>>;

package/dist/dataParser/extended/object.mjs

@@ -2,6 +2,7 @@ import { dataParserExtendedInit } from '../baseExtended.mjs';
 import { object as object$1 } from '../parsers/object/index.mjs';
 import { requiredShape } from '../parsers/object/required.mjs';
 import { partialShape } from '../parsers/object/partial.mjs';
+import { extendsShape } from '../parsers/object/extends.mjs';
 import { pickShape } from '../parsers/object/pick.mjs';
 import { omitShape } from '../parsers/object/omit.mjs';
 import { createOverride } from '../../common/override.mjs';
@@ -16,6 +17,10 @@ function object(shape, definition) {
             const newShape = pickShape(self.definition.shape, pickObject);
             return object(newShape, definition);
         },
+        extends: (self, extension, definition) => {
+            const newShape = extendsShape(self.definition.shape, extension);
+            return object(newShape, definition);
+        },
         partial: (self, definition) => {
             const newShape = partialShape(self.definition.shape);
             return object(newShape, definition);

package/dist/dataParser/extended/time.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+var baseExtended = require('../baseExtended.cjs');
+var index = require('../parsers/time/index.cjs');
+var max = require('../parsers/time/checkers/max.cjs');
+var min = require('../parsers/time/checkers/min.cjs');
+var override = require('../../common/override.cjs');
+
+function time(definition) {
+    const self = baseExtended.dataParserExtendedInit(index.time(definition), {
+        min(self, min$1, definition) {
+            return self.addChecker(min.checkerTimeMin(min$1, definition));
+        },
+        max(self, max$1, definition) {
+            return self.addChecker(max.checkerTimeMax(max$1, definition));
+        },
+    });
+    return time.overrideHandler.apply(self);
+}
+time.overrideHandler = override.createOverride("@duplojs/utils/data-parser-extended/time");
+
+exports.time = time;

package/dist/dataParser/extended/time.d.ts

@@ -0,0 +1,34 @@
+import { type FixDeepFunctionInfer, type Kind, type NeverCoalescing } from "../../common";
+import { type DataParserExtended } from "../baseExtended";
+import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
+import * as dataParsers from "../parsers";
+import { type Output } from "../base";
+import { type TheTime } from "../../date";
+type _DataParserTimeExtended<GenericDefinition extends dataParsers.DataParserDefinitionTime> = (Kind<typeof dataParsers.timeKind.definition> & DataParserExtended<GenericDefinition, TheTime, TheTime>);
+export interface DataParserTimeExtended<GenericDefinition extends dataParsers.DataParserDefinitionTime = dataParsers.DataParserDefinitionTime> extends _DataParserTimeExtended<GenericDefinition> {
+    addChecker<GenericChecker extends readonly [
+        dataParsers.DataParserTimeCheckers,
+        ...dataParsers.DataParserTimeCheckers[]
+    ]>(...args: FixDeepFunctionInfer<readonly [
+        dataParsers.DataParserTimeCheckers,
+        ...dataParsers.DataParserTimeCheckers[]
+    ], GenericChecker>): DataParserTimeExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    /**
+     * @deprecated Method with unreliable typing.
+     */
+    construct<const GenericDefinition extends dataParsers.DataParserDefinitionTime>(definition: GenericDefinition): DataParserTimeExtended<MergeDefinition<dataParsers.DataParserDefinitionTime, GenericDefinition>>;
+    refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserTimeExtended<AddCheckersToDefinition<GenericDefinition, [
+        dataParsers.CheckerRefineImplementation<Output<this>>
+    ]>>;
+    min(min: TheTime, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionTimeMin, "min">>): DataParserTimeExtended<AddCheckersToDefinition<GenericDefinition, [
+        dataParsers.DataParserCheckerTimeMin
+    ]>>;
+    max(max: TheTime, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionTimeMax, "max">>): DataParserTimeExtended<AddCheckersToDefinition<GenericDefinition, [
+        dataParsers.DataParserCheckerTimeMax
+    ]>>;
+}
+export declare function time<const GenericDefinition extends Partial<dataParsers.DataParserDefinitionTime> = never>(definition?: GenericDefinition): DataParserTimeExtended<MergeDefinition<dataParsers.DataParserDefinitionTime, NeverCoalescing<GenericDefinition, {}>>>;
+export declare namespace time {
+    var overrideHandler: import("../../common").OverrideHandler<DataParserTimeExtended<dataParsers.DataParserDefinitionTime>>;
+}
+export {};

package/dist/dataParser/extended/time.mjs

@@ -0,0 +1,20 @@
+import { dataParserExtendedInit } from '../baseExtended.mjs';
+import { time as time$1 } from '../parsers/time/index.mjs';
+import { checkerTimeMax } from '../parsers/time/checkers/max.mjs';
+import { checkerTimeMin } from '../parsers/time/checkers/min.mjs';
+import { createOverride } from '../../common/override.mjs';
+
+function time(definition) {
+    const self = dataParserExtendedInit(time$1(definition), {
+        min(self, min, definition) {
+            return self.addChecker(checkerTimeMin(min, definition));
+        },
+        max(self, max, definition) {
+            return self.addChecker(checkerTimeMax(max, definition));
+        },
+    });
+    return time.overrideHandler.apply(self);
+}
+time.overrideHandler = createOverride("@duplojs/utils/data-parser-extended/time");
+
+export { time };