@duplojs/utils 1.4.52 → 1.4.54

package/dist/clean/newType.mjs

@@ -6,13 +6,14 @@ import { pipe } from '../common/pipe.mjs';
 import { map } from '../array/map.mjs';
 import { entry } from '../object/entry.mjs';
 import { createErrorKind } from '../common/errorKindNamespace.mjs';
+import { fromEntries } from '../object/fromEntries.mjs';
+import { createOverride } from '../common/override.mjs';
 import { isLeft } from '../either/left/is.mjs';
 import { unwrap } from '../common/unwrap.mjs';
 import { left } from '../either/left/create.mjs';
 import { constrainedTypeKind } from './constraint/base.mjs';
 import { right } from '../either/right/create.mjs';
 import { wrapValue } from '../common/wrapValue.mjs';
-import { fromEntries } from '../object/fromEntries.mjs';
 
 const newTypeKind = createCleanKind("new-type");
 const newTypeHandlerKind = createCleanKind("new-type-handler");
@@ -78,7 +79,7 @@ function createNewType(name, dataParser, constraint) {
         }
         return true;
     }
-    return newTypeHandlerKind.setTo({
+    return pipe({
         name,
         dataParser: dataParserWithCheckers,
         constrains: constraints,
@@ -88,7 +89,8 @@ function createNewType(name, dataParser, constraint) {
         createWithUnknown: create,
         createWithUnknownOrThrow: createOrThrow,
         is,
-    });
+    }, newTypeHandlerKind.setTo, createNewType.overrideHandler.apply);
 }
+createNewType.overrideHandler = createOverride("@duplojs/utils/clean/new-type");
 
 export { CreateNewTypeError, createNewType, newTypeHandlerKind, newTypeKind };

package/dist/clean/primitive/base.cjs

@@ -3,12 +3,14 @@
 var kind = require('../kind.cjs');
 var kind$1 = require('../../common/kind.cjs');
 var index = require('../../dataParser/parsers/string/index.cjs');
+var pipe = require('../../common/pipe.cjs');
 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 override = require('../../common/override.cjs');
 var unwrap = require('../../common/unwrap.cjs');
 var is = require('../../either/right/is.cjs');
 var is$1 = require('../../either/left/is.cjs');
@@ -49,15 +51,16 @@ function createPrimitive(dataParser) {
         const result = dataParser.parse(unwrap.unwrap(input));
         return is.isRight(result);
     }
-    return primitiveHandlerKind.setTo({
+    return pipe.pipe({
         dataParser,
         create: create$2,
         createOrThrow,
         createWithUnknown: create$2,
         createWithUnknownOrThrow: createOrThrow,
         is: is$2,
-    });
+    }, primitiveHandlerKind.setTo, createPrimitive.overrideHandler.apply);
 }
+createPrimitive.overrideHandler = override.createOverride("@duplojs/utils/clean/primitive");
 /**
  * {@include clean/String/index.md}
  */

package/dist/clean/primitive/base.mjs

@@ -1,12 +1,14 @@
 import { createCleanKind } from '../kind.mjs';
 import { kindHeritage } from '../../common/kind.mjs';
 import { string } from '../../dataParser/parsers/string/index.mjs';
+import { pipe } from '../../common/pipe.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 { time } from '../../dataParser/parsers/time/index.mjs';
 import { createErrorKind } from '../../common/errorKindNamespace.mjs';
+import { createOverride } from '../../common/override.mjs';
 import { unwrap } from '../../common/unwrap.mjs';
 import { isRight } from '../../either/right/is.mjs';
 import { isLeft } from '../../either/left/is.mjs';
@@ -47,15 +49,16 @@ function createPrimitive(dataParser) {
         const result = dataParser.parse(unwrap(input));
         return isRight(result);
     }
-    return primitiveHandlerKind.setTo({
+    return pipe({
         dataParser,
         create,
         createOrThrow,
         createWithUnknown: create,
         createWithUnknownOrThrow: createOrThrow,
         is,
-    });
+    }, primitiveHandlerKind.setTo, createPrimitive.overrideHandler.apply);
 }
+createPrimitive.overrideHandler = createOverride("@duplojs/utils/clean/primitive");
 /**
  * {@include clean/String/index.md}
  */

package/dist/clean/repository.cjs

@@ -1,18 +1,21 @@
 'use strict';
 
 var kind = require('./kind.cjs');
+var pipe = require('../common/pipe.cjs');
+var override = require('../common/override.cjs');
 
 const repositoryHandlerKind = kind.createCleanKind("repository-handler");
 /**
  * {@include clean/createRepository/index.md}
  */
 function createRepository() {
-    return repositoryHandlerKind.setTo({
+    return pipe.pipe({
         createImplementation(implementation) {
             return implementation;
         },
-    });
+    }, repositoryHandlerKind.setTo, createRepository.overrideHandler.apply);
 }
+createRepository.overrideHandler = override.createOverride("@duplojs/utils/clean/repository");
 
 exports.createRepository = createRepository;
 exports.repositoryHandlerKind = repositoryHandlerKind;

package/dist/clean/repository.d.ts

@@ -93,3 +93,6 @@ export interface RepositoryHandler<GenericRepository extends object = object> ex
  * 
  */
 export declare function createRepository<GenericRepository extends object>(): RepositoryHandler<GenericRepository>;
+export declare namespace createRepository {
+    var overrideHandler: import("../common").OverrideHandler<RepositoryHandler<object>>;
+}

package/dist/clean/repository.mjs

@@ -1,15 +1,18 @@
 import { createCleanKind } from './kind.mjs';
+import { pipe } from '../common/pipe.mjs';
+import { createOverride } from '../common/override.mjs';
 
 const repositoryHandlerKind = createCleanKind("repository-handler");
 /**
  * {@include clean/createRepository/index.md}
  */
 function createRepository() {
-    return repositoryHandlerKind.setTo({
+    return pipe({
         createImplementation(implementation) {
             return implementation;
         },
-    });
+    }, repositoryHandlerKind.setTo, createRepository.overrideHandler.apply);
 }
+createRepository.overrideHandler = createOverride("@duplojs/utils/clean/repository");
 
 export { createRepository, repositoryHandlerKind };

package/dist/clean/useCase.cjs

@@ -7,19 +7,24 @@ var entry = require('../object/entry.cjs');
 var uncapitalize = require('../string/uncapitalize.cjs');
 var entries = require('../object/entries.cjs');
 var fromEntries = require('../object/fromEntries.cjs');
+var override = require('../common/override.cjs');
 
 const useCaseHandlerKind = kind.createCleanKind("use-case-handler");
 /**
  * {@include clean/createUseCase/index.md}
  */
 function createUseCase(dependencies, getUseCase) {
-    return useCaseHandlerKind.setTo({
+    return pipe.pipe({
         dependencies,
-        getUseCase: (repositories) => getUseCase(pipe.pipe(dependencies, entries.entries, map.map(([key, value]) => entry.entry(uncapitalize.uncapitalize(key), useCaseHandlerKind.has(value)
-            ? value.getUseCase(repositories)
-            : repositories[uncapitalize.uncapitalize(key)])), fromEntries.fromEntries)),
-    });
+        getUseCase: (injectedDependencies) => getUseCase(pipe.pipe(dependencies, entries.entries, map.map(([key, value]) => {
+            const formattedKey = uncapitalize.uncapitalize(key);
+            return entry.entry(formattedKey, useCaseHandlerKind.has(value) && !injectedDependencies[formattedKey]
+                ? value.getUseCase(injectedDependencies)
+                : injectedDependencies[formattedKey]);
+        }), fromEntries.fromEntries)),
+    }, useCaseHandlerKind.setTo, createUseCase.overrideHandler.apply);
 }
+createUseCase.overrideHandler = override.createOverride("@duplojs/utils/clean/use-case");
 /**
  * {@include clean/useCaseInstances/index.md}
  */

package/dist/clean/useCase.d.ts

@@ -1,12 +1,12 @@
-import { type ObjectEntry, type Kind, type SimplifyTopLevel, type UnionToIntersection } from "../common";
+import { type ObjectEntry, type Kind, type SimplifyTopLevel, type UnionToIntersection, type Adaptor } from "../common";
 import { type RepositoryHandler } from "./repository";
 export type UseCaseDependencies = Record<string, RepositoryHandler | UseCaseHandler>;
 export type UseCaseDependenciesValue<GenericDependencies extends UseCaseDependencies> = SimplifyTopLevel<{
-    [Prop in keyof GenericDependencies as (Prop extends string ? Uncapitalize<Prop> : Prop)]: GenericDependencies[Prop] extends RepositoryHandler ? ReturnType<GenericDependencies[Prop]["createImplementation"]> : GenericDependencies[Prop] extends UseCaseHandler ? ReturnType<GenericDependencies[Prop]["getUseCase"]> : never;
+    [Prop in keyof GenericDependencies as Uncapitalize<Adaptor<Prop, string>>]: GenericDependencies[Prop] extends RepositoryHandler ? ReturnType<GenericDependencies[Prop]["createImplementation"]> : GenericDependencies[Prop] extends UseCaseHandler ? ReturnType<GenericDependencies[Prop]["getUseCase"]> : never;
 }>;
 export type GetAllRepositories<GenericDependenciesValue extends UseCaseDependencies> = GenericDependenciesValue extends any ? ({
     [Prop in keyof GenericDependenciesValue]: (GenericDependenciesValue[Prop] extends RepositoryHandler ? [
-        (Prop extends string ? Uncapitalize<Prop> : Prop),
+        Uncapitalize<Adaptor<Prop, string>>,
         ReturnType<GenericDependenciesValue[Prop]["createImplementation"]>
     ] : GenericDependenciesValue[Prop] extends UseCaseHandler ? GetAllRepositories<GenericDependenciesValue[Prop]["dependencies"]> : never);
 })[keyof GenericDependenciesValue] : never;
@@ -26,9 +26,11 @@ export interface UseCaseHandler<GenericDependencies extends UseCaseDependencies
      * ```
      * 
      */
-    getUseCase(repositories: (GetAllRepositories<GenericDependencies> extends infer InferredEntriesDependenciesValue extends ObjectEntry ? {
-        [Entry in InferredEntriesDependenciesValue as InferredEntriesDependenciesValue[0]]: InferredEntriesDependenciesValue[1];
-    } : never)): GenericUseCase;
+    getUseCase(repositories: ((GetAllRepositories<GenericDependencies> extends infer InferredEntriesDependenciesValue extends ObjectEntry ? {
+        [Entry in InferredEntriesDependenciesValue as Entry[0]]: Entry[1];
+    } : never) & ({
+        [Prop in keyof GenericDependencies as GenericDependencies[Prop] extends UseCaseHandler ? Uncapitalize<Adaptor<Prop, string>> : never]?: GenericDependencies[Prop] extends UseCaseHandler ? ReturnType<GenericDependencies[Prop]["getUseCase"]> : never;
+    }))): GenericUseCase;
 }
 /**
  * Creates a use case handler with explicit dependencies.
@@ -109,6 +111,9 @@ export interface UseCaseHandler<GenericDependencies extends UseCaseDependencies
  * 
  */
 export declare function createUseCase<const GenericDependencies extends UseCaseDependencies, GenericUseCase extends (input: any) => any>(dependencies: GenericDependencies, getUseCase: (dependenciesValue: UseCaseDependenciesValue<GenericDependencies>) => GenericUseCase): UseCaseHandler<GenericDependencies, GenericUseCase>;
+export declare namespace createUseCase {
+    var overrideHandler: import("../common").OverrideHandler<UseCaseHandler<any, any>>;
+}
 /**
  * Instantiates multiple use cases at once.
  * 
@@ -159,5 +164,7 @@ export declare function createUseCase<const GenericDependencies extends UseCaseD
  * 
  */
 export declare function useCaseInstances<GenericUseCases extends Record<string, UseCaseHandler>>(useCases: GenericUseCases, repositories: SimplifyTopLevel<UnionToIntersection<{
-    [Prop in keyof GenericUseCases]: Parameters<GenericUseCases[Prop]["getUseCase"]>[0];
+    [Prop in keyof GenericUseCases]: GetAllRepositories<GenericUseCases[Prop]["dependencies"]> extends infer InferredEntriesDependenciesValue extends ObjectEntry ? {
+        [Entry in InferredEntriesDependenciesValue as Entry[0]]: Entry[1];
+    } : never;
 }[keyof GenericUseCases]>>): UseCaseDependenciesValue<GenericUseCases>;

package/dist/clean/useCase.mjs

@@ -5,19 +5,24 @@ import { entry } from '../object/entry.mjs';
 import { uncapitalize } from '../string/uncapitalize.mjs';
 import { entries } from '../object/entries.mjs';
 import { fromEntries } from '../object/fromEntries.mjs';
+import { createOverride } from '../common/override.mjs';
 
 const useCaseHandlerKind = createCleanKind("use-case-handler");
 /**
  * {@include clean/createUseCase/index.md}
  */
 function createUseCase(dependencies, getUseCase) {
-    return useCaseHandlerKind.setTo({
+    return pipe({
         dependencies,
-        getUseCase: (repositories) => getUseCase(pipe(dependencies, entries, map(([key, value]) => entry(uncapitalize(key), useCaseHandlerKind.has(value)
-            ? value.getUseCase(repositories)
-            : repositories[uncapitalize(key)])), fromEntries)),
-    });
+        getUseCase: (injectedDependencies) => getUseCase(pipe(dependencies, entries, map(([key, value]) => {
+            const formattedKey = uncapitalize(key);
+            return entry(formattedKey, useCaseHandlerKind.has(value) && !injectedDependencies[formattedKey]
+                ? value.getUseCase(injectedDependencies)
+                : injectedDependencies[formattedKey]);
+        }), fromEntries)),
+    }, useCaseHandlerKind.setTo, createUseCase.overrideHandler.apply);
 }
+createUseCase.overrideHandler = createOverride("@duplojs/utils/clean/use-case");
 /**
  * {@include clean/useCaseInstances/index.md}
  */

package/dist/dataParser/base.d.ts

@@ -239,8 +239,8 @@ export interface DataParser<GenericDefinition extends DataParserDefinition = Dat
     isAsynchronous(): boolean;
 }
 interface DataParserInitExecParams<GenericDataParser extends DataParser> {
-    sync(...args: [...Parameters<GenericDataParser["exec"]>, self: GenericDataParser]): (GetKindValue<typeof dataParserKind, GenericDataParser>["output"] | SymbolDataParserErrorIssue | SymbolDataParserErrorPromiseIssue);
-    async(...args: [...Parameters<GenericDataParser["exec"]>, self: GenericDataParser]): Promise<GetKindValue<typeof dataParserKind, GenericDataParser>["output"] | SymbolDataParserErrorIssue | SymbolDataParserErrorPromiseIssue>;
+    sync(...args: [...Parameters<GenericDataParser["exec"]>, self: GenericDataParser]): (GetKindValue<typeof dataParserKind, GenericDataParser>["output"] | SymbolDataParserError | SymbolDataParserErrorIssue | SymbolDataParserErrorPromiseIssue);
+    async(...args: [...Parameters<GenericDataParser["exec"]>, self: GenericDataParser]): Promise<GetKindValue<typeof dataParserKind, GenericDataParser>["output"] | SymbolDataParserError | SymbolDataParserErrorIssue | SymbolDataParserErrorPromiseIssue>;
     isAsynchronous(self: GenericDataParser): boolean;
 }
 declare const DataParserThrowError_base: new (params: {

package/dist/dataParser/baseExtended.cjs

@@ -17,7 +17,7 @@ var array = require('./extended/array.cjs');
 var override = require('../common/override.cjs');
 
 const extendedKind = kind.createDataParserKind("extended");
-function dataParserExtendedInit(dataParser, rest) {
+function dataParserExtendedInit(dataParser, rest, specificOverrideHandler) {
     const self = pipe.pipe({
         ...dataParser,
         ...pipe.pipe(rest, entries.entries, map.map(([key, value]) => entry.entry(key, typeof value === "function"
@@ -48,13 +48,13 @@ function dataParserExtendedInit(dataParser, rest) {
             return union.union([self, option], definition);
         },
         addChecker(...checkers) {
-            return dataParserExtendedInit(dataParser.addChecker(...checkers), rest);
+            return dataParserExtendedInit(dataParser.addChecker(...checkers), rest, specificOverrideHandler);
         },
         clone() {
-            return dataParserExtendedInit(dataParser.clone(), rest);
+            return dataParserExtendedInit(dataParser.clone(), rest, specificOverrideHandler);
         },
         refine(theFunction) {
-            return dataParserExtendedInit(dataParser.addChecker(refine.checkerRefine(theFunction)), rest);
+            return dataParserExtendedInit(dataParser.addChecker(refine.checkerRefine(theFunction)), rest, specificOverrideHandler);
         },
         recover(recoveredValue, definition) {
             return recover.recover(self, recoveredValue, definition);
@@ -62,7 +62,7 @@ function dataParserExtendedInit(dataParser, rest) {
         contract() {
             return self;
         },
-    }, extendedKind.setTo, dataParserExtendedInit.overrideHandler.apply);
+    }, extendedKind.setTo, dataParserExtendedInit.overrideHandler.apply, specificOverrideHandler.apply);
     return self;
 }
 dataParserExtendedInit.overrideHandler = override.createOverride("@duplojs/utils/data-parser-extended/base");

package/dist/dataParser/baseExtended.d.ts

@@ -1,4 +1,4 @@
-import { type Kind, type NeverCoalescing, type AnyFunction, type SimplifyTopLevel, type AnyValue } from "../common";
+import { type Kind, type NeverCoalescing, type AnyFunction, type SimplifyTopLevel, type AnyValue, type OverrideHandler } from "../common";
 import { type MergeDefinition } from "./types";
 import { type Output, type DataParser, type DataParserDefinition } from "./base";
 import type * as DEither from "../either";
@@ -411,9 +411,9 @@ export interface DataParserExtended<GenericDefinition extends DataParserDefiniti
 }
 export declare function dataParserExtendedInit<GenericDataParser extends DataParser, GenericDataParserExtended extends GenericDataParser & DataParserExtended>(dataParser: NoInfer<GenericDataParser>, rest: NoInfer<{
     [Prop in Exclude<keyof GenericDataParserExtended, keyof (GenericDataParser & DataParserExtended)>]: GenericDataParserExtended[Prop] extends AnyFunction ? (self: GenericDataParserExtended, ...args: Parameters<GenericDataParserExtended[Prop]>) => ReturnType<GenericDataParserExtended[Prop]> : GenericDataParserExtended[Prop];
-}>): GenericDataParserExtended;
+}>, specificOverrideHandler: OverrideHandler<NoInfer<GenericDataParserExtended>>): GenericDataParserExtended;
 export declare namespace dataParserExtendedInit {
-    var overrideHandler: import("../common").OverrideHandler<DataParserExtended<DataParserDefinition<import("./base").DataParserChecker<import("./base").DataParserCheckerDefinition, unknown>>, unknown, unknown>>;
+    var overrideHandler: OverrideHandler<DataParserExtended<DataParserDefinition<import("./base").DataParserChecker<import("./base").DataParserCheckerDefinition, unknown>>, unknown, unknown>>;
 }
 export type ContractExtended<GenericOutput extends unknown, GenericInput extends unknown = GenericOutput> = DataParserExtended<DataParserDefinition<never>, GenericOutput, GenericInput>;
 export {};

package/dist/dataParser/baseExtended.mjs

@@ -15,7 +15,7 @@ import { array } from './extended/array.mjs';
 import { createOverride } from '../common/override.mjs';
 
 const extendedKind = createDataParserKind("extended");
-function dataParserExtendedInit(dataParser, rest) {
+function dataParserExtendedInit(dataParser, rest, specificOverrideHandler) {
     const self = pipe({
         ...dataParser,
         ...pipe(rest, entries, map(([key, value]) => entry(key, typeof value === "function"
@@ -46,13 +46,13 @@ function dataParserExtendedInit(dataParser, rest) {
             return union([self, option], definition);
         },
         addChecker(...checkers) {
-            return dataParserExtendedInit(dataParser.addChecker(...checkers), rest);
+            return dataParserExtendedInit(dataParser.addChecker(...checkers), rest, specificOverrideHandler);
         },
         clone() {
-            return dataParserExtendedInit(dataParser.clone(), rest);
+            return dataParserExtendedInit(dataParser.clone(), rest, specificOverrideHandler);
         },
         refine(theFunction) {
-            return dataParserExtendedInit(dataParser.addChecker(checkerRefine(theFunction)), rest);
+            return dataParserExtendedInit(dataParser.addChecker(checkerRefine(theFunction)), rest, specificOverrideHandler);
         },
         recover(recoveredValue, definition) {
             return recover(self, recoveredValue, definition);
@@ -60,7 +60,7 @@ function dataParserExtendedInit(dataParser, rest) {
         contract() {
             return self;
         },
-    }, extendedKind.setTo, dataParserExtendedInit.overrideHandler.apply);
+    }, extendedKind.setTo, dataParserExtendedInit.overrideHandler.apply, specificOverrideHandler.apply);
     return self;
 }
 dataParserExtendedInit.overrideHandler = createOverride("@duplojs/utils/data-parser-extended/base");

package/dist/dataParser/extended/array.cjs

@@ -17,8 +17,8 @@ function array(element, definition) {
         max(self, max$1, definition) {
             return self.addChecker(max.checkerArrayMax(max$1, definition));
         },
-    });
-    return array.overrideHandler.apply(self);
+    }, array.overrideHandler);
+    return self;
 }
 array.overrideHandler = override.createOverride("@duplojs/utils/data-parser-extended/array");
 

package/dist/dataParser/extended/array.mjs

@@ -15,8 +15,8 @@ function array(element, definition) {
         max(self, max, definition) {
             return self.addChecker(checkerArrayMax(max, definition));
         },
-    });
-    return array.overrideHandler.apply(self);
+    }, array.overrideHandler);
+    return self;
 }
 array.overrideHandler = createOverride("@duplojs/utils/data-parser-extended/array");
 

package/dist/dataParser/extended/bigint.cjs

@@ -17,8 +17,8 @@ function bigint(definition) {
         max(self, max$1, definition) {
             return self.addChecker(max.checkerBigIntMax(max$1, definition));
         },
-    });
-    return bigint.overrideHandler.apply(self);
+    }, bigint.overrideHandler);
+    return self;
 }
 bigint.overrideHandler = override.createOverride("@duplojs/utils/data-parser-extended/bigint");
 

package/dist/dataParser/extended/bigint.mjs

@@ -15,8 +15,8 @@ function bigint(definition) {
         max(self, max, definition) {
             return self.addChecker(checkerBigIntMax(max, definition));
         },
-    });
-    return bigint.overrideHandler.apply(self);
+    }, bigint.overrideHandler);
+    return self;
 }
 bigint.overrideHandler = createOverride("@duplojs/utils/data-parser-extended/bigint");
 

package/dist/dataParser/extended/boolean.cjs

@@ -8,8 +8,8 @@ var override = require('../../common/override.cjs');
  * {@include dataParser/extended/boolean/index.md}
  */
 function boolean(definition) {
-    const self = baseExtended.dataParserExtendedInit(boolean$1.boolean(definition), {});
-    return boolean.overrideHandler.apply(self);
+    const self = baseExtended.dataParserExtendedInit(boolean$1.boolean(definition), {}, boolean.overrideHandler);
+    return self;
 }
 boolean.overrideHandler = override.createOverride("@duplojs/utils/data-parser-extended/boolean");
 

package/dist/dataParser/extended/boolean.mjs

@@ -6,8 +6,8 @@ import { createOverride } from '../../common/override.mjs';
  * {@include dataParser/extended/boolean/index.md}
  */
 function boolean(definition) {
-    const self = dataParserExtendedInit(boolean$1(definition), {});
-    return boolean.overrideHandler.apply(self);
+    const self = dataParserExtendedInit(boolean$1(definition), {}, boolean.overrideHandler);
+    return self;
 }
 boolean.overrideHandler = createOverride("@duplojs/utils/data-parser-extended/boolean");
 

package/dist/dataParser/extended/date.cjs

@@ -8,8 +8,8 @@ var override = require('../../common/override.cjs');
  * {@include dataParser/extended/date/index.md}
  */
 function date(definition) {
-    const self = baseExtended.dataParserExtendedInit(date$1.date(definition), {});
-    return date.overrideHandler.apply(self);
+    const self = baseExtended.dataParserExtendedInit(date$1.date(definition), {}, date.overrideHandler);
+    return self;
 }
 date.overrideHandler = override.createOverride("@duplojs/utils/data-parser-extended/date");
 

package/dist/dataParser/extended/date.mjs

@@ -6,8 +6,8 @@ import { createOverride } from '../../common/override.mjs';
  * {@include dataParser/extended/date/index.md}
  */
 function date(definition) {
-    const self = dataParserExtendedInit(date$1(definition), {});
-    return date.overrideHandler.apply(self);
+    const self = dataParserExtendedInit(date$1(definition), {}, date.overrideHandler);
+    return self;
 }
 date.overrideHandler = createOverride("@duplojs/utils/data-parser-extended/date");
 

package/dist/dataParser/extended/empty.cjs

@@ -8,8 +8,8 @@ var override = require('../../common/override.cjs');
  * {@include dataParser/extended/empty/index.md}
  */
 function empty(definition) {
-    const self = baseExtended.dataParserExtendedInit(empty$1.empty(definition), {});
-    return empty.overrideHandler.apply(self);
+    const self = baseExtended.dataParserExtendedInit(empty$1.empty(definition), {}, empty.overrideHandler);
+    return self;
 }
 empty.overrideHandler = override.createOverride("@duplojs/utils/data-parser-extended/empty");
 

package/dist/dataParser/extended/empty.mjs

@@ -6,8 +6,8 @@ import { createOverride } from '../../common/override.mjs';
  * {@include dataParser/extended/empty/index.md}
  */
 function empty(definition) {
-    const self = dataParserExtendedInit(empty$1(definition), {});
-    return empty.overrideHandler.apply(self);
+    const self = dataParserExtendedInit(empty$1(definition), {}, empty.overrideHandler);
+    return self;
 }
 empty.overrideHandler = createOverride("@duplojs/utils/data-parser-extended/empty");
 

package/dist/dataParser/extended/lazy.cjs

@@ -8,8 +8,8 @@ var override = require('../../common/override.cjs');
  * {@include dataParser/extended/lazy/index.md}
  */
 function lazy(getter, definition) {
-    const self = baseExtended.dataParserExtendedInit(lazy$1.lazy(getter, definition), {});
-    return lazy.overrideHandler.apply(self);
+    const self = baseExtended.dataParserExtendedInit(lazy$1.lazy(getter, definition), {}, lazy.overrideHandler);
+    return self;
 }
 lazy.overrideHandler = override.createOverride("@duplojs/utils/data-parser-extended/lazy");
 

package/dist/dataParser/extended/lazy.mjs

@@ -6,8 +6,8 @@ import { createOverride } from '../../common/override.mjs';
  * {@include dataParser/extended/lazy/index.md}
  */
 function lazy(getter, definition) {
-    const self = dataParserExtendedInit(lazy$1(getter, definition), {});
-    return lazy.overrideHandler.apply(self);
+    const self = dataParserExtendedInit(lazy$1(getter, definition), {}, lazy.overrideHandler);
+    return self;
 }
 lazy.overrideHandler = createOverride("@duplojs/utils/data-parser-extended/lazy");
 

package/dist/dataParser/extended/literal.cjs

@@ -8,8 +8,8 @@ var override = require('../../common/override.cjs');
  * {@include dataParser/extended/literal/index.md}
  */
 function literal(value, definition) {
-    const self = baseExtended.dataParserExtendedInit(literal$1.literal(value, definition), {});
-    return literal.overrideHandler.apply(self);
+    const self = baseExtended.dataParserExtendedInit(literal$1.literal(value, definition), {}, literal.overrideHandler);
+    return self;
 }
 literal.overrideHandler = override.createOverride("@duplojs/utils/data-parser-extended/literal");
 

package/dist/dataParser/extended/literal.mjs

@@ -6,8 +6,8 @@ import { createOverride } from '../../common/override.mjs';
  * {@include dataParser/extended/literal/index.md}
  */
 function literal(value, definition) {
-    const self = dataParserExtendedInit(literal$1(value, definition), {});
-    return literal.overrideHandler.apply(self);
+    const self = dataParserExtendedInit(literal$1(value, definition), {}, literal.overrideHandler);
+    return self;
 }
 literal.overrideHandler = createOverride("@duplojs/utils/data-parser-extended/literal");
 

package/dist/dataParser/extended/nil.cjs

@@ -8,8 +8,8 @@ var override = require('../../common/override.cjs');
  * {@include dataParser/extended/nil/index.md}
  */
 function nil(definition) {
-    const self = baseExtended.dataParserExtendedInit(nil$1.nil(definition), {});
-    return nil.overrideHandler.apply(self);
+    const self = baseExtended.dataParserExtendedInit(nil$1.nil(definition), {}, nil.overrideHandler);
+    return self;
 }
 nil.overrideHandler = override.createOverride("@duplojs/utils/data-parser-extended/nil");
 

package/dist/dataParser/extended/nil.mjs

@@ -6,8 +6,8 @@ import { createOverride } from '../../common/override.mjs';
  * {@include dataParser/extended/nil/index.md}
  */
 function nil(definition) {
-    const self = dataParserExtendedInit(nil$1(definition), {});
-    return nil.overrideHandler.apply(self);
+    const self = dataParserExtendedInit(nil$1(definition), {}, nil.overrideHandler);
+    return self;
 }
 nil.overrideHandler = createOverride("@duplojs/utils/data-parser-extended/nil");
 

package/dist/dataParser/extended/nullable.cjs

@@ -8,8 +8,8 @@ var override = require('../../common/override.cjs');
  * {@include dataParser/extended/nullable/index.md}
  */
 function nullable(inner, definition) {
-    const self = baseExtended.dataParserExtendedInit(nullable$1.nullable(inner, definition), {});
-    return nullable.overrideHandler.apply(self);
+    const self = baseExtended.dataParserExtendedInit(nullable$1.nullable(inner, definition), {}, nullable.overrideHandler);
+    return self;
 }
 nullable.overrideHandler = override.createOverride("@duplojs/utils/data-parser-extended/nullable");
 

package/dist/dataParser/extended/nullable.mjs

@@ -6,8 +6,8 @@ import { createOverride } from '../../common/override.mjs';
  * {@include dataParser/extended/nullable/index.md}
  */
 function nullable(inner, definition) {
-    const self = dataParserExtendedInit(nullable$1(inner, definition), {});
-    return nullable.overrideHandler.apply(self);
+    const self = dataParserExtendedInit(nullable$1(inner, definition), {}, nullable.overrideHandler);
+    return self;
 }
 nullable.overrideHandler = createOverride("@duplojs/utils/data-parser-extended/nullable");
 

package/dist/dataParser/extended/number.cjs

@@ -21,8 +21,8 @@ function number(definition) {
         int(self, definition) {
             return self.addChecker(int$1.checkerInt(definition));
         },
-    });
-    return number.overrideHandler.apply(self);
+    }, number.overrideHandler);
+    return self;
 }
 number.overrideHandler = override.createOverride("@duplojs/utils/data-parser-extended/number");
 /**

package/dist/dataParser/extended/number.mjs

@@ -19,8 +19,8 @@ function number(definition) {
         int(self, definition) {
             return self.addChecker(checkerInt(definition));
         },
-    });
-    return number.overrideHandler.apply(self);
+    }, number.overrideHandler);
+    return self;
 }
 number.overrideHandler = createOverride("@duplojs/utils/data-parser-extended/number");
 /**

package/dist/dataParser/extended/object.cjs

@@ -34,8 +34,8 @@ function object(shape, definition) {
             const newShape = required.requiredShape(self.definition.shape);
             return object(newShape, definition);
         },
-    });
-    return object.overrideHandler.apply(self);
+    }, object.overrideHandler);
+    return self;
 }
 object.overrideHandler = override.createOverride("@duplojs/utils/data-parser-extended/object");