@duplojs/utils 1.1.16 → 1.2.17

package/dist/dataParser/extended/nil.cjs

@@ -1,14 +1,13 @@
 'use strict';
 
 var baseExtended = require('../baseExtended.cjs');
-require('../base.cjs');
-require('../../common/globalStore.cjs');
-require('../../common/builder.cjs');
 var nil$1 = require('../parsers/nil.cjs');
-require('../../pattern/result.cjs');
+var override = require('../../common/override.cjs');
 
 function nil(definition) {
-    return baseExtended.dataParserExtendedInit(nil$1.nil(definition), {});
+    const self = baseExtended.dataParserExtendedInit(nil$1.nil(definition), {});
+    return nil.overrideHandler.apply(self);
 }
+nil.overrideHandler = override.createOverride("@duplojs/utils/data-parser-extended/nil");
 
 exports.nil = nil;

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

@@ -17,4 +17,7 @@ export interface DataParserNilExtended<GenericDefinition extends dataParsers.Dat
     ]>>;
 }
 export declare function nil<const GenericDefinition extends Partial<dataParsers.DataParserDefinitionNil> = never>(definition?: GenericDefinition): DataParserNilExtended<MergeDefinition<dataParsers.DataParserDefinitionNil, NeverCoalescing<GenericDefinition, {}>>>;
+export declare namespace nil {
+    var overrideHandler: import("../../common").OverrideHandler<DataParserNilExtended<dataParsers.DataParserDefinitionNil>>;
+}
 export {};

package/dist/dataParser/extended/nil.mjs

@@ -1,12 +1,11 @@
 import { dataParserExtendedInit } from '../baseExtended.mjs';
-import '../base.mjs';
-import '../../common/globalStore.mjs';
-import '../../common/builder.mjs';
 import { nil as nil$1 } from '../parsers/nil.mjs';
-import '../../pattern/result.mjs';
+import { createOverride } from '../../common/override.mjs';
 
 function nil(definition) {
-    return dataParserExtendedInit(nil$1(definition), {});
+    const self = dataParserExtendedInit(nil$1(definition), {});
+    return nil.overrideHandler.apply(self);
 }
+nil.overrideHandler = createOverride("@duplojs/utils/data-parser-extended/nil");
 
 export { nil };

package/dist/dataParser/extended/nullable.cjs

@@ -1,14 +1,13 @@
 'use strict';
 
 var baseExtended = require('../baseExtended.cjs');
-require('../base.cjs');
-require('../../common/globalStore.cjs');
-require('../../common/builder.cjs');
-require('../../pattern/result.cjs');
 var nullable$1 = require('../parsers/nullable.cjs');
+var override = require('../../common/override.cjs');
 
 function nullable(inner, definition) {
-    return baseExtended.dataParserExtendedInit(nullable$1.nullable(inner, definition), {});
+    const self = baseExtended.dataParserExtendedInit(nullable$1.nullable(inner, definition), {});
+    return nullable.overrideHandler.apply(self);
 }
+nullable.overrideHandler = override.createOverride("@duplojs/utils/data-parser-extended/nullable");
 
 exports.nullable = nullable;

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

@@ -19,4 +19,7 @@ export interface DataParserNullableExtended<GenericDefinition extends dataParser
 export declare function nullable<GenericDataParser extends DataParser, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionNullable<Output<GenericDataParser> | null>, "inner">> = never>(inner: GenericDataParser, definition?: GenericDefinition): DataParserNullableExtended<MergeDefinition<dataParsers.DataParserDefinitionNullable, NeverCoalescing<GenericDefinition, {}> & {
     inner: GenericDataParser;
 }>>;
+export declare namespace nullable {
+    var overrideHandler: import("../../common").OverrideHandler<DataParserNullableExtended<dataParsers.DataParserDefinitionNullable<unknown>>>;
+}
 export {};

package/dist/dataParser/extended/nullable.mjs

@@ -1,12 +1,11 @@
 import { dataParserExtendedInit } from '../baseExtended.mjs';
-import '../base.mjs';
-import '../../common/globalStore.mjs';
-import '../../common/builder.mjs';
-import '../../pattern/result.mjs';
 import { nullable as nullable$1 } from '../parsers/nullable.mjs';
+import { createOverride } from '../../common/override.mjs';
 
 function nullable(inner, definition) {
-    return dataParserExtendedInit(nullable$1(inner, definition), {});
+    const self = dataParserExtendedInit(nullable$1(inner, definition), {});
+    return nullable.overrideHandler.apply(self);
 }
+nullable.overrideHandler = createOverride("@duplojs/utils/data-parser-extended/nullable");
 
 export { nullable };

package/dist/dataParser/extended/number.cjs

@@ -1,17 +1,14 @@
 'use strict';
 
 var baseExtended = require('../baseExtended.cjs');
-require('../base.cjs');
-require('../../common/globalStore.cjs');
-require('../../common/builder.cjs');
 var index = require('../parsers/number/index.cjs');
-require('../../pattern/result.cjs');
 var int$1 = require('../parsers/number/checkers/int.cjs');
 var max = require('../parsers/number/checkers/max.cjs');
 var min = require('../parsers/number/checkers/min.cjs');
+var override = require('../../common/override.cjs');
 
 function number(definition) {
-    return baseExtended.dataParserExtendedInit(index.number(definition), {
+    const self = baseExtended.dataParserExtendedInit(index.number(definition), {
         min(self, min$1, definition) {
             return self.addChecker(min.checkerNumberMin(min$1, definition));
         },
@@ -19,7 +16,9 @@ function number(definition) {
             return self.addChecker(max.checkerNumberMax(max$1, definition));
         },
     });
+    return number.overrideHandler.apply(self);
 }
+number.overrideHandler = override.createOverride("@duplojs/utils/data-parser-extended/number");
 function int(definition) {
     return number({
         checkers: [int$1.checkerInt(definition)],

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

@@ -23,6 +23,9 @@ export interface DataParserNumberExtended<GenericDefinition extends dataParsers.
     ]>>;
 }
 export declare function number<const GenericDefinition extends Partial<dataParsers.DataParserDefinitionNumber> = never>(definition?: GenericDefinition): DataParserNumberExtended<MergeDefinition<dataParsers.DataParserDefinitionNumber, NeverCoalescing<GenericDefinition, {}>>>;
+export declare namespace number {
+    var overrideHandler: import("../../common").OverrideHandler<DataParserNumberExtended<dataParsers.DataParserDefinitionNumber>>;
+}
 export declare function int(definition?: Partial<dataParsers.DataParserCheckerDefinitionInt>): DataParserNumberExtended<{
     readonly checkers: readonly [dataParsers.DataParserCheckerInt];
     readonly errorMessage?: string | undefined;

package/dist/dataParser/extended/number.mjs

@@ -1,15 +1,12 @@
 import { dataParserExtendedInit } from '../baseExtended.mjs';
-import '../base.mjs';
-import '../../common/globalStore.mjs';
-import '../../common/builder.mjs';
 import { number as number$1 } from '../parsers/number/index.mjs';
-import '../../pattern/result.mjs';
 import { checkerInt } from '../parsers/number/checkers/int.mjs';
 import { checkerNumberMax } from '../parsers/number/checkers/max.mjs';
 import { checkerNumberMin } from '../parsers/number/checkers/min.mjs';
+import { createOverride } from '../../common/override.mjs';
 
 function number(definition) {
-    return dataParserExtendedInit(number$1(definition), {
+    const self = dataParserExtendedInit(number$1(definition), {
         min(self, min, definition) {
             return self.addChecker(checkerNumberMin(min, definition));
         },
@@ -17,7 +14,9 @@ function number(definition) {
             return self.addChecker(checkerNumberMax(max, definition));
         },
     });
+    return number.overrideHandler.apply(self);
 }
+number.overrideHandler = createOverride("@duplojs/utils/data-parser-extended/number");
 function int(definition) {
     return number({
         checkers: [checkerInt(definition)],

package/dist/dataParser/extended/object.cjs

@@ -1,14 +1,27 @@
 'use strict';
 
 var baseExtended = require('../baseExtended.cjs');
-require('../base.cjs');
-require('../../common/globalStore.cjs');
-require('../../common/builder.cjs');
-var object$1 = require('../parsers/object.cjs');
-require('../../pattern/result.cjs');
+var index = require('../parsers/object/index.cjs');
+var pipe = require('../../common/pipe.cjs');
+var fromEntries = require('../../object/fromEntries.cjs');
+var filter = require('../../array/filter.cjs');
+var isKeyof = require('../../string/isKeyof.cjs');
+var entries = require('../../object/entries.cjs');
+var override = require('../../common/override.cjs');
 
 function object(shape, definition) {
-    return baseExtended.dataParserExtendedInit(object$1.object(shape, definition), {});
+    const self = baseExtended.dataParserExtendedInit(index.object(shape, definition), {
+        omit: (self, omitObject, definition) => {
+            const newShape = pipe.pipe(self.definition.shape, entries.entries, filter.filter(([key]) => !isKeyof.isKeyof(key, omitObject)), fromEntries.fromEntries);
+            return object(newShape, definition);
+        },
+        pick: (self, omitObject, definition) => {
+            const newShape = pipe.pipe(self.definition.shape, entries.entries, filter.filter(([key]) => isKeyof.isKeyof(key, omitObject)), fromEntries.fromEntries);
+            return object(newShape, definition);
+        },
+    });
+    return object.overrideHandler.apply(self);
 }
+object.overrideHandler = override.createOverride("@duplojs/utils/data-parser-extended/object");
 
 exports.object = object;

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

@@ -15,8 +15,13 @@ export interface DataParserObjectExtended<GenericDefinition extends dataParsers.
     refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserObjectExtended<AddCheckersToDefinition<GenericDefinition, [
         dataParsers.CheckerRefineImplementation<Output<this>>
     ]>>;
+    omit<const GenericOmitObject extends Partial<Record<keyof GenericDefinition["shape"], true>>, const GenericSubDefinition extends Partial<Omit<dataParsers.DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(omitObject: GenericOmitObject, definition?: GenericDefinition): ReturnType<typeof dataParsers.omit<dataParsers.DataParserObject<GenericDefinition>, GenericOmitObject, GenericSubDefinition>>;
+    pick<const GenericPickObject extends Partial<Record<keyof GenericDefinition["shape"], true>>, const GenericSubDefinition extends Partial<Omit<dataParsers.DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(pickObject: GenericPickObject, definition?: GenericDefinition): ReturnType<typeof dataParsers.pick<dataParsers.DataParserObject<GenericDefinition>, GenericPickObject, GenericSubDefinition>>;
 }
 export declare function object<const GenericShape extends dataParsers.DataParserObjectShape, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionObject, "shape">> = never>(shape: GenericShape, definition?: GenericDefinition): DataParserObjectExtended<MergeDefinition<dataParsers.DataParserDefinitionObject, NeverCoalescing<GenericDefinition, {}> & {
     shape: GenericShape;
 }>>;
+export declare namespace object {
+    var overrideHandler: import("../../common").OverrideHandler<DataParserObjectExtended<dataParsers.DataParserDefinitionObject>>;
+}
 export {};

package/dist/dataParser/extended/object.mjs

@@ -1,12 +1,25 @@
 import { dataParserExtendedInit } from '../baseExtended.mjs';
-import '../base.mjs';
-import '../../common/globalStore.mjs';
-import '../../common/builder.mjs';
-import { object as object$1 } from '../parsers/object.mjs';
-import '../../pattern/result.mjs';
+import { object as object$1 } from '../parsers/object/index.mjs';
+import { pipe } from '../../common/pipe.mjs';
+import { fromEntries } from '../../object/fromEntries.mjs';
+import { filter } from '../../array/filter.mjs';
+import { isKeyof } from '../../string/isKeyof.mjs';
+import { entries } from '../../object/entries.mjs';
+import { createOverride } from '../../common/override.mjs';
 
 function object(shape, definition) {
-    return dataParserExtendedInit(object$1(shape, definition), {});
+    const self = dataParserExtendedInit(object$1(shape, definition), {
+        omit: (self, omitObject, definition) => {
+            const newShape = pipe(self.definition.shape, entries, filter(([key]) => !isKeyof(key, omitObject)), fromEntries);
+            return object(newShape, definition);
+        },
+        pick: (self, omitObject, definition) => {
+            const newShape = pipe(self.definition.shape, entries, filter(([key]) => isKeyof(key, omitObject)), fromEntries);
+            return object(newShape, definition);
+        },
+    });
+    return object.overrideHandler.apply(self);
 }
+object.overrideHandler = createOverride("@duplojs/utils/data-parser-extended/object");
 
 export { object };

package/dist/dataParser/extended/optional.cjs

@@ -1,14 +1,13 @@
 'use strict';
 
 var baseExtended = require('../baseExtended.cjs');
-require('../base.cjs');
-require('../../common/globalStore.cjs');
-require('../../common/builder.cjs');
-require('../../pattern/result.cjs');
 var optional$1 = require('../parsers/optional.cjs');
+var override = require('../../common/override.cjs');
 
 function optional(inner, definition) {
-    return baseExtended.dataParserExtendedInit(optional$1.optional(inner, definition), {});
+    const self = baseExtended.dataParserExtendedInit(optional$1.optional(inner, definition), {});
+    return optional.overrideHandler.apply(self);
 }
+optional.overrideHandler = override.createOverride("@duplojs/utils/data-parser-extended/optional");
 
 exports.optional = optional;

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

@@ -19,4 +19,7 @@ export interface DataParserOptionalExtended<GenericDefinition extends dataParser
 export declare function optional<GenericDataParser extends DataParser, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionOptional<Output<GenericDataParser> | undefined>, "inner">> = never>(inner: GenericDataParser, definition?: GenericDefinition): DataParserOptionalExtended<MergeDefinition<dataParsers.DataParserDefinitionOptional, NeverCoalescing<GenericDefinition, {}> & {
     inner: GenericDataParser;
 }>>;
+export declare namespace optional {
+    var overrideHandler: import("../../common").OverrideHandler<DataParserOptionalExtended<dataParsers.DataParserDefinitionOptional<unknown>>>;
+}
 export {};

package/dist/dataParser/extended/optional.mjs

@@ -1,12 +1,11 @@
 import { dataParserExtendedInit } from '../baseExtended.mjs';
-import '../base.mjs';
-import '../../common/globalStore.mjs';
-import '../../common/builder.mjs';
-import '../../pattern/result.mjs';
 import { optional as optional$1 } from '../parsers/optional.mjs';
+import { createOverride } from '../../common/override.mjs';
 
 function optional(inner, definition) {
-    return dataParserExtendedInit(optional$1(inner, definition), {});
+    const self = dataParserExtendedInit(optional$1(inner, definition), {});
+    return optional.overrideHandler.apply(self);
 }
+optional.overrideHandler = createOverride("@duplojs/utils/data-parser-extended/optional");
 
 export { optional };

package/dist/dataParser/extended/pipe.cjs

@@ -1,14 +1,13 @@
 'use strict';
 
 var baseExtended = require('../baseExtended.cjs');
-require('../base.cjs');
-require('../../common/globalStore.cjs');
-require('../../common/builder.cjs');
-require('../../pattern/result.cjs');
 var pipe$1 = require('../parsers/pipe.cjs');
+var override = require('../../common/override.cjs');
 
 function pipe(input, output, definition) {
-    return baseExtended.dataParserExtendedInit(pipe$1.pipe(input, output, definition), {});
+    const self = baseExtended.dataParserExtendedInit(pipe$1.pipe(input, output, definition), {});
+    return pipe.overrideHandler.apply(self);
 }
+pipe.overrideHandler = override.createOverride("@duplojs/utils/data-parser-extended/pipe");
 
 exports.pipe = pipe;

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

@@ -20,4 +20,7 @@ export declare function pipe<GenericInput extends DataParser, GenericOutput exte
     input: GenericInput;
     output: GenericOutput;
 }>>;
+export declare namespace pipe {
+    var overrideHandler: import("../../common").OverrideHandler<DataParserPipeExtended<dataParsers.DataParserDefinitionPipe>>;
+}
 export {};

package/dist/dataParser/extended/pipe.mjs

@@ -1,12 +1,11 @@
 import { dataParserExtendedInit } from '../baseExtended.mjs';
-import '../base.mjs';
-import '../../common/globalStore.mjs';
-import '../../common/builder.mjs';
-import '../../pattern/result.mjs';
 import { pipe as pipe$1 } from '../parsers/pipe.mjs';
+import { createOverride } from '../../common/override.mjs';
 
 function pipe(input, output, definition) {
-    return dataParserExtendedInit(pipe$1(input, output, definition), {});
+    const self = dataParserExtendedInit(pipe$1(input, output, definition), {});
+    return pipe.overrideHandler.apply(self);
 }
+pipe.overrideHandler = createOverride("@duplojs/utils/data-parser-extended/pipe");
 
 export { pipe };

package/dist/dataParser/extended/record.cjs

@@ -1,14 +1,13 @@
 'use strict';
 
 var baseExtended = require('../baseExtended.cjs');
-require('../base.cjs');
-require('../../common/globalStore.cjs');
-require('../../common/builder.cjs');
-require('../../pattern/result.cjs');
 var index = require('../parsers/record/index.cjs');
+var override = require('../../common/override.cjs');
 
 function record(key, value, definition) {
-    return baseExtended.dataParserExtendedInit(index.record(key, value, definition), {});
+    const self = baseExtended.dataParserExtendedInit(index.record(key, value, definition), {});
+    return record.overrideHandler.apply(self);
 }
+record.overrideHandler = override.createOverride("@duplojs/utils/data-parser-extended/record");
 
 exports.record = record;

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

@@ -20,4 +20,7 @@ export declare function record<GenericDataParserKey extends dataParsers.DataPars
     key: GenericDataParserKey;
     value: GenericDataParserValue;
 }>>;
+export declare namespace record {
+    var overrideHandler: import("../../common").OverrideHandler<DataParserRecordExtended<dataParsers.DataParserDefinitionRecord>>;
+}
 export {};

package/dist/dataParser/extended/record.mjs

@@ -1,12 +1,11 @@
 import { dataParserExtendedInit } from '../baseExtended.mjs';
-import '../base.mjs';
-import '../../common/globalStore.mjs';
-import '../../common/builder.mjs';
-import '../../pattern/result.mjs';
 import { record as record$1 } from '../parsers/record/index.mjs';
+import { createOverride } from '../../common/override.mjs';
 
 function record(key, value, definition) {
-    return dataParserExtendedInit(record$1(key, value, definition), {});
+    const self = dataParserExtendedInit(record$1(key, value, definition), {});
+    return record.overrideHandler.apply(self);
 }
+record.overrideHandler = createOverride("@duplojs/utils/data-parser-extended/record");
 
 export { record };

package/dist/dataParser/extended/recover.cjs

@@ -1,14 +1,13 @@
 'use strict';
 
 var baseExtended = require('../baseExtended.cjs');
-require('../base.cjs');
-require('../../common/globalStore.cjs');
-require('../../common/builder.cjs');
-require('../../pattern/result.cjs');
 var recover$1 = require('../parsers/recover.cjs');
+var override = require('../../common/override.cjs');
 
 function recover(inner, recoveredValue, definition) {
-    return baseExtended.dataParserExtendedInit(recover$1.recover(inner, recoveredValue, definition), {});
+    const self = baseExtended.dataParserExtendedInit(recover$1.recover(inner, recoveredValue, definition), {});
+    return recover.overrideHandler.apply(self);
 }
+recover.overrideHandler = override.createOverride("@duplojs/utils/data-parser-extended/recover");
 
 exports.recover = recover;

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

@@ -20,4 +20,7 @@ export declare function recover<GenericDataParser extends DataParser, GenericRec
     inner: GenericDataParser;
     recoveredValue: GenericRecoveredValue;
 }>>;
+export declare namespace recover {
+    var overrideHandler: import("../../common").OverrideHandler<DataParserRecoverExtended<dataParsers.DataParserDefinitionRecover>>;
+}
 export {};

package/dist/dataParser/extended/recover.mjs

@@ -1,12 +1,11 @@
 import { dataParserExtendedInit } from '../baseExtended.mjs';
-import '../base.mjs';
-import '../../common/globalStore.mjs';
-import '../../common/builder.mjs';
-import '../../pattern/result.mjs';
 import { recover as recover$1 } from '../parsers/recover.mjs';
+import { createOverride } from '../../common/override.mjs';
 
 function recover(inner, recoveredValue, definition) {
-    return dataParserExtendedInit(recover$1(inner, recoveredValue, definition), {});
+    const self = dataParserExtendedInit(recover$1(inner, recoveredValue, definition), {});
+    return recover.overrideHandler.apply(self);
 }
+recover.overrideHandler = createOverride("@duplojs/utils/data-parser-extended/recover");
 
 export { recover };

package/dist/dataParser/extended/string.cjs

@@ -2,18 +2,15 @@
 
 var baseExtended = require('../baseExtended.cjs');
 var index = require('../parsers/string/index.cjs');
-require('../../common/globalStore.cjs');
-require('../../common/builder.cjs');
-require('../base.cjs');
-require('../../pattern/result.cjs');
 var email$1 = require('../parsers/string/checkers/email.cjs');
 var url$1 = require('../parsers/string/checkers/url.cjs');
 var regex = require('../parsers/string/checkers/regex.cjs');
 var max = require('../parsers/string/checkers/max.cjs');
 var min = require('../parsers/string/checkers/min.cjs');
+var override = require('../../common/override.cjs');
 
 function string(definition) {
-    return baseExtended.dataParserExtendedInit(index.string(definition), {
+    const self = baseExtended.dataParserExtendedInit(index.string(definition), {
         min(self, min$1, definition) {
             return self.addChecker(min.checkerStringMin(min$1, definition));
         },
@@ -24,7 +21,9 @@ function string(definition) {
             return self.addChecker(regex.checkerStringRegex(regex$1, definition));
         },
     });
+    return string.overrideHandler.apply(self);
 }
+string.overrideHandler = override.createOverride("@duplojs/utils/data-parser-extended/string");
 function email(definition) {
     return string({
         checkers: [email$1.checkerEmail(definition)],

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

@@ -26,6 +26,9 @@ export interface DataParserStringExtended<GenericDefinition extends dataParsers.
     ]>>;
 }
 export declare function string<const GenericDefinition extends Partial<dataParsers.DataParserDefinitionString> = never>(definition?: GenericDefinition): DataParserStringExtended<MergeDefinition<dataParsers.DataParserDefinitionString, NeverCoalescing<GenericDefinition, {}>>>;
+export declare namespace string {
+    var overrideHandler: import("../../common").OverrideHandler<DataParserStringExtended<dataParsers.DataParserDefinitionString>>;
+}
 export declare function email(definition?: Partial<dataParsers.DataParserCheckerDefinitionEmail>): DataParserStringExtended<{
     readonly checkers: readonly [dataParsers.DataParserCheckerEmail];
     readonly errorMessage?: string | undefined;

package/dist/dataParser/extended/string.mjs

@@ -1,17 +1,14 @@
 import { dataParserExtendedInit } from '../baseExtended.mjs';
 import { string as string$1 } from '../parsers/string/index.mjs';
-import '../../common/globalStore.mjs';
-import '../../common/builder.mjs';
-import '../base.mjs';
-import '../../pattern/result.mjs';
 import { checkerEmail } from '../parsers/string/checkers/email.mjs';
 import { checkerUrl } from '../parsers/string/checkers/url.mjs';
 import { checkerStringRegex } from '../parsers/string/checkers/regex.mjs';
 import { checkerStringMax } from '../parsers/string/checkers/max.mjs';
 import { checkerStringMin } from '../parsers/string/checkers/min.mjs';
+import { createOverride } from '../../common/override.mjs';
 
 function string(definition) {
-    return dataParserExtendedInit(string$1(definition), {
+    const self = dataParserExtendedInit(string$1(definition), {
         min(self, min, definition) {
             return self.addChecker(checkerStringMin(min, definition));
         },
@@ -22,7 +19,9 @@ function string(definition) {
             return self.addChecker(checkerStringRegex(regex, definition));
         },
     });
+    return string.overrideHandler.apply(self);
 }
+string.overrideHandler = createOverride("@duplojs/utils/data-parser-extended/string");
 function email(definition) {
     return string({
         checkers: [checkerEmail(definition)],

package/dist/dataParser/extended/templateLiteral.cjs

@@ -1,14 +1,13 @@
 'use strict';
 
 var baseExtended = require('../baseExtended.cjs');
-require('../base.cjs');
-require('../../common/globalStore.cjs');
-require('../../common/builder.cjs');
 var index = require('../parsers/templateLiteral/index.cjs');
-require('../../pattern/result.cjs');
+var override = require('../../common/override.cjs');
 
 function templateLiteral(template, definition) {
-    return baseExtended.dataParserExtendedInit(index.templateLiteral(template, definition), {});
+    const self = baseExtended.dataParserExtendedInit(index.templateLiteral(template, definition), {});
+    return templateLiteral.overrideHandler.apply(self);
 }
+templateLiteral.overrideHandler = override.createOverride("@duplojs/utils/data-parser-extended/templateLiteral");
 
 exports.templateLiteral = templateLiteral;

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

@@ -19,4 +19,7 @@ export interface DataParserTemplateLiteralExtended<GenericDefinition extends dat
 export declare function templateLiteral<const GenericTemplate extends dataParsers.TemplateLiteralShape, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionTemplateLiteral, "template" | "pattern">> = never>(template: GenericTemplate, definition?: GenericDefinition): DataParserTemplateLiteralExtended<MergeDefinition<dataParsers.DataParserDefinitionTemplateLiteral, NeverCoalescing<GenericDefinition, {}> & {
     template: GenericTemplate;
 }>>;
+export declare namespace templateLiteral {
+    var overrideHandler: import("../../common").OverrideHandler<DataParserTemplateLiteralExtended<dataParsers.DataParserDefinitionTemplateLiteral>>;
+}
 export {};

package/dist/dataParser/extended/templateLiteral.mjs

@@ -1,12 +1,11 @@
 import { dataParserExtendedInit } from '../baseExtended.mjs';
-import '../base.mjs';
-import '../../common/globalStore.mjs';
-import '../../common/builder.mjs';
 import { templateLiteral as templateLiteral$1 } from '../parsers/templateLiteral/index.mjs';
-import '../../pattern/result.mjs';
+import { createOverride } from '../../common/override.mjs';
 
 function templateLiteral(template, definition) {
-    return dataParserExtendedInit(templateLiteral$1(template, definition), {});
+    const self = dataParserExtendedInit(templateLiteral$1(template, definition), {});
+    return templateLiteral.overrideHandler.apply(self);
 }
+templateLiteral.overrideHandler = createOverride("@duplojs/utils/data-parser-extended/templateLiteral");
 
 export { templateLiteral };

package/dist/dataParser/extended/transform.cjs

@@ -1,14 +1,13 @@
 'use strict';
 
 var baseExtended = require('../baseExtended.cjs');
-require('../base.cjs');
-require('../../common/globalStore.cjs');
-require('../../common/builder.cjs');
 var transform$1 = require('../parsers/transform.cjs');
-require('../../pattern/result.cjs');
+var override = require('../../common/override.cjs');
 
 function transform(inner, theFunction, definition) {
-    return baseExtended.dataParserExtendedInit(transform$1.transform(inner, theFunction, definition), {});
+    const self = baseExtended.dataParserExtendedInit(transform$1.transform(inner, theFunction, definition), {});
+    return transform.overrideHandler.apply(self);
 }
+transform.overrideHandler = override.createOverride("@duplojs/utils/data-parser-extended/transform");
 
 exports.transform = transform;

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

@@ -21,4 +21,7 @@ export declare function transform<GenericDataParser extends DataParser, GenericO
     inner: GenericDataParser;
     theFunction(input: Output<GenericDataParser>): GenericOutput;
 }>>;
+export declare namespace transform {
+    var overrideHandler: import("../../common").OverrideHandler<DataParserTransformExtended<dataParsers.DataParserDefinitionTransform>>;
+}
 export {};

package/dist/dataParser/extended/transform.mjs

@@ -1,12 +1,11 @@
 import { dataParserExtendedInit } from '../baseExtended.mjs';
-import '../base.mjs';
-import '../../common/globalStore.mjs';
-import '../../common/builder.mjs';
 import { transform as transform$1 } from '../parsers/transform.mjs';
-import '../../pattern/result.mjs';
+import { createOverride } from '../../common/override.mjs';
 
 function transform(inner, theFunction, definition) {
-    return dataParserExtendedInit(transform$1(inner, theFunction, definition), {});
+    const self = dataParserExtendedInit(transform$1(inner, theFunction, definition), {});
+    return transform.overrideHandler.apply(self);
 }
+transform.overrideHandler = createOverride("@duplojs/utils/data-parser-extended/transform");
 
 export { transform };