@duplojs/utils 1.4.52 → 1.4.53

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");
 

package/dist/dataParser/extended/object.mjs

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

package/dist/dataParser/extended/optional.cjs

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

package/dist/dataParser/extended/optional.mjs

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

package/dist/dataParser/extended/pipe.cjs

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

package/dist/dataParser/extended/pipe.mjs

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

package/dist/dataParser/extended/record.cjs

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

package/dist/dataParser/extended/record.mjs

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

package/dist/dataParser/extended/recover.cjs

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

package/dist/dataParser/extended/recover.mjs

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

package/dist/dataParser/extended/string.cjs

@@ -23,8 +23,8 @@ function string(definition) {
         regex(self, regex$1, definition) {
             return self.addChecker(regex.checkerStringRegex(regex$1, definition));
         },
-    });
-    return string.overrideHandler.apply(self);
+    }, string.overrideHandler);
+    return self;
 }
 string.overrideHandler = override.createOverride("@duplojs/utils/data-parser-extended/string");
 /**

package/dist/dataParser/extended/string.mjs

@@ -21,8 +21,8 @@ function string(definition) {
         regex(self, regex, definition) {
             return self.addChecker(checkerStringRegex(regex, definition));
         },
-    });
-    return string.overrideHandler.apply(self);
+    }, string.overrideHandler);
+    return self;
 }
 string.overrideHandler = createOverride("@duplojs/utils/data-parser-extended/string");
 /**

package/dist/dataParser/extended/templateLiteral.cjs

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

package/dist/dataParser/extended/templateLiteral.mjs

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

package/dist/dataParser/extended/time.cjs

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

package/dist/dataParser/extended/time.mjs

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

package/dist/dataParser/extended/transform.cjs

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

package/dist/dataParser/extended/transform.mjs

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

package/dist/dataParser/extended/tuple.cjs

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

package/dist/dataParser/extended/tuple.mjs

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

package/dist/dataParser/extended/union.cjs

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

package/dist/dataParser/extended/union.mjs

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

package/dist/dataParser/extended/unknown.cjs

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