@duplojs/utils 1.1.16 → 1.2.17

package/dist/dataParser/parsers/object/omit.mjs

@@ -0,0 +1,13 @@
+import { object } from './index.mjs';
+import { pipe } from '../../../common/pipe.mjs';
+import { filter } from '../../../array/filter.mjs';
+import { isKeyof } from '../../../string/isKeyof.mjs';
+import { entries } from '../../../object/entries.mjs';
+import { fromEntries } from '../../../object/fromEntries.mjs';
+
+function omit(dataParser, omitObject, definition) {
+    const newShape = pipe(dataParser.definition.shape, entries, filter(([key]) => !isKeyof(key, omitObject)), fromEntries);
+    return object(newShape, definition);
+}
+
+export { omit };

package/dist/dataParser/parsers/object/pick.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var index = require('./index.cjs');
+var pipe = require('../../../common/pipe.cjs');
+var filter = require('../../../array/filter.cjs');
+var isKeyof = require('../../../string/isKeyof.cjs');
+var entries = require('../../../object/entries.cjs');
+var fromEntries = require('../../../object/fromEntries.cjs');
+
+function pick(dataParser, omitObject, definition) {
+    const newShape = pipe.pipe(dataParser.definition.shape, entries.entries, filter.filter(([key]) => isKeyof.isKeyof(key, omitObject)), fromEntries.fromEntries);
+    return index.object(newShape, definition);
+}
+
+exports.pick = pick;

package/dist/dataParser/parsers/object/pick.d.ts

@@ -0,0 +1,6 @@
+import { type MergeDefinition } from "../../../dataParser/types";
+import { type DataParserDefinitionObject, type DataParserObject } from ".";
+import { type SimplifyTopLevel, type NeverCoalescing, type Adaptor } from "../../../common";
+export declare function pick<GenericDataParserObject extends DataParserObject, const GenericOmitObject extends Partial<Record<keyof GenericDataParserObject["definition"]["shape"], true>>, const GenericDefinition extends Partial<Omit<DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(dataParser: GenericDataParserObject, omitObject: GenericOmitObject, definition?: GenericDefinition): DataParserObject<MergeDefinition<DataParserDefinitionObject, NeverCoalescing<GenericDefinition, {}> & {
+    readonly shape: SimplifyTopLevel<Pick<GenericDataParserObject["definition"]["shape"], Adaptor<keyof GenericOmitObject, keyof GenericDataParserObject["definition"]["shape"]>>>;
+}>>;

package/dist/dataParser/parsers/object/pick.mjs

@@ -0,0 +1,13 @@
+import { object } from './index.mjs';
+import { pipe } from '../../../common/pipe.mjs';
+import { filter } from '../../../array/filter.mjs';
+import { isKeyof } from '../../../string/isKeyof.mjs';
+import { entries } from '../../../object/entries.mjs';
+import { fromEntries } from '../../../object/fromEntries.mjs';
+
+function pick(dataParser, omitObject, definition) {
+    const newShape = pipe(dataParser.definition.shape, entries, filter(([key]) => isKeyof(key, omitObject)), fromEntries);
+    return object(newShape, definition);
+}
+
+export { pick };

package/dist/dataParser/parsers/optional.cjs

@@ -2,10 +2,11 @@
 
 var base = require('../base.cjs');
 var kind = require('../kind.cjs');
+var override = require('../../common/override.cjs');
 
 const optionalKind = kind.createDataParserKind("optional");
 function optional(inner, definition) {
-    return base.dataParserInit(optionalKind, {
+    const self = base.dataParserInit(optionalKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -26,7 +27,9 @@ function optional(inner, definition) {
             return self.definition.inner.asyncExec(data, error);
         },
     });
+    return optional.overrideHandler.apply(self);
 }
+optional.overrideHandler = override.createOverride("@duplojs/utils/data-parser/optional");
 
 exports.optional = optional;
 exports.optionalKind = optionalKind;

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

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

package/dist/dataParser/parsers/optional.mjs

@@ -1,9 +1,10 @@
 import { dataParserInit } from '../base.mjs';
 import { createDataParserKind } from '../kind.mjs';
+import { createOverride } from '../../common/override.mjs';
 
 const optionalKind = createDataParserKind("optional");
 function optional(inner, definition) {
-    return dataParserInit(optionalKind, {
+    const self = dataParserInit(optionalKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -24,6 +25,8 @@ function optional(inner, definition) {
             return self.definition.inner.asyncExec(data, error);
         },
     });
+    return optional.overrideHandler.apply(self);
 }
+optional.overrideHandler = createOverride("@duplojs/utils/data-parser/optional");
 
 export { optional, optionalKind };

package/dist/dataParser/parsers/pipe.cjs

@@ -2,10 +2,11 @@
 
 var base = require('../base.cjs');
 var kind = require('../kind.cjs');
+var override = require('../../common/override.cjs');
 
 const pipeKind = kind.createDataParserKind("pipe");
 function pipe(input, output, definition) {
-    return base.dataParserInit(pipeKind, {
+    const self = base.dataParserInit(pipeKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -28,7 +29,9 @@ function pipe(input, output, definition) {
             return self.definition.output.asyncExec(result, error);
         },
     });
+    return pipe.overrideHandler.apply(self);
 }
+pipe.overrideHandler = override.createOverride("@duplojs/utils/data-parser/pipe");
 
 exports.pipe = pipe;
 exports.pipeKind = pipeKind;

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

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

package/dist/dataParser/parsers/pipe.mjs

@@ -1,9 +1,10 @@
 import { dataParserInit, SymbolDataParserError } from '../base.mjs';
 import { createDataParserKind } from '../kind.mjs';
+import { createOverride } from '../../common/override.mjs';
 
 const pipeKind = createDataParserKind("pipe");
 function pipe(input, output, definition) {
-    return dataParserInit(pipeKind, {
+    const self = dataParserInit(pipeKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -26,6 +27,8 @@ function pipe(input, output, definition) {
             return self.definition.output.asyncExec(result, error);
         },
     });
+    return pipe.overrideHandler.apply(self);
 }
+pipe.overrideHandler = createOverride("@duplojs/utils/data-parser/pipe");
 
 export { pipe, pipeKind };

package/dist/dataParser/parsers/record/findRecordRequiredKey.cjs

@@ -1,25 +1,5 @@
 'use strict';
 
-var pipe = require('../../../common/pipe.cjs');
-var innerPipe = require('../../../common/innerPipe.cjs');
-var when$1 = require('../../../common/when.cjs');
-var isType = require('../../../common/isType.cjs');
-var or = require('../../../common/or.cjs');
-var justReturn = require('../../../common/justReturn.cjs');
-var filter = require('../../../array/filter.cjs');
-var reduce = require('../../../array/reduce.cjs');
-var includes = require('../../../array/includes.cjs');
-var map = require('../../../array/map.cjs');
-var flat = require('../../../array/flat.cjs');
-var flatMap = require('../../../array/flatMap.cjs');
-var notIncludes = require('../../../array/notIncludes.cjs');
-require('../../../common/globalStore.cjs');
-require('../../../common/builder.cjs');
-require('../../../pattern/result.cjs');
-var exhaustive = require('../../../pattern/exhaustive.cjs');
-var otherwise = require('../../../pattern/otherwise.cjs');
-var when = require('../../../pattern/when.cjs');
-var concat = require('../../../string/concat.cjs');
 var index$1 = require('../string/index.cjs');
 var index$2 = require('../number/index.cjs');
 var literal = require('../literal.cjs');
@@ -29,6 +9,23 @@ var index$3 = require('../bigint/index.cjs');
 var boolean = require('../boolean.cjs');
 var empty = require('../empty.cjs');
 var nil = require('../nil.cjs');
+var pipe = require('../../../common/pipe.cjs');
+var reduce = require('../../../array/reduce.cjs');
+var when = require('../../../pattern/when.cjs');
+var justReturn = require('../../../common/justReturn.cjs');
+var isType = require('../../../common/isType.cjs');
+var map = require('../../../array/map.cjs');
+var concat = require('../../../string/concat.cjs');
+var flatMap = require('../../../array/flatMap.cjs');
+var exhaustive = require('../../../pattern/exhaustive.cjs');
+var innerPipe = require('../../../common/innerPipe.cjs');
+var notIncludes = require('../../../array/notIncludes.cjs');
+var flat = require('../../../array/flat.cjs');
+var otherwise = require('../../../pattern/otherwise.cjs');
+var when$1 = require('../../../common/when.cjs');
+var or = require('../../../common/or.cjs');
+var includes = require('../../../array/includes.cjs');
+var filter = require('../../../array/filter.cjs');
 
 function findRecordRequiredKeyOnTemplateLiteralPart(templatePart) {
     return pipe.pipe(templatePart, map.map(innerPipe.innerPipe(when.when((value) => index$1.stringKind.has(value)

package/dist/dataParser/parsers/record/findRecordRequiredKey.mjs

@@ -1,23 +1,3 @@
-import { pipe } from '../../../common/pipe.mjs';
-import { innerPipe } from '../../../common/innerPipe.mjs';
-import { when as when$1 } from '../../../common/when.mjs';
-import { isType } from '../../../common/isType.mjs';
-import { or } from '../../../common/or.mjs';
-import { justReturn } from '../../../common/justReturn.mjs';
-import { filter } from '../../../array/filter.mjs';
-import { reduce, reduceFrom } from '../../../array/reduce.mjs';
-import { includes } from '../../../array/includes.mjs';
-import { map } from '../../../array/map.mjs';
-import { flat } from '../../../array/flat.mjs';
-import { flatMap } from '../../../array/flatMap.mjs';
-import { notIncludes } from '../../../array/notIncludes.mjs';
-import '../../../common/globalStore.mjs';
-import '../../../common/builder.mjs';
-import '../../../pattern/result.mjs';
-import { exhaustive } from '../../../pattern/exhaustive.mjs';
-import { otherwise } from '../../../pattern/otherwise.mjs';
-import { when } from '../../../pattern/when.mjs';
-import { concat } from '../../../string/concat.mjs';
 import { stringKind } from '../string/index.mjs';
 import { numberKind } from '../number/index.mjs';
 import { literalKind } from '../literal.mjs';
@@ -27,6 +7,23 @@ import { bigIntKind } from '../bigint/index.mjs';
 import { booleanKind } from '../boolean.mjs';
 import { emptyKind } from '../empty.mjs';
 import { nilKind } from '../nil.mjs';
+import { pipe } from '../../../common/pipe.mjs';
+import { reduce, reduceFrom } from '../../../array/reduce.mjs';
+import { when } from '../../../pattern/when.mjs';
+import { justReturn } from '../../../common/justReturn.mjs';
+import { isType } from '../../../common/isType.mjs';
+import { map } from '../../../array/map.mjs';
+import { concat } from '../../../string/concat.mjs';
+import { flatMap } from '../../../array/flatMap.mjs';
+import { exhaustive } from '../../../pattern/exhaustive.mjs';
+import { innerPipe } from '../../../common/innerPipe.mjs';
+import { notIncludes } from '../../../array/notIncludes.mjs';
+import { flat } from '../../../array/flat.mjs';
+import { otherwise } from '../../../pattern/otherwise.mjs';
+import { when as when$1 } from '../../../common/when.mjs';
+import { or } from '../../../common/or.mjs';
+import { includes } from '../../../array/includes.mjs';
+import { filter } from '../../../array/filter.mjs';
 
 function findRecordRequiredKeyOnTemplateLiteralPart(templatePart) {
     return pipe(templatePart, map(innerPipe(when((value) => stringKind.has(value)

package/dist/dataParser/parsers/record/index.cjs

@@ -4,10 +4,11 @@ var base = require('../../base.cjs');
 var error = require('../../error.cjs');
 var kind = require('../../kind.cjs');
 var findRecordRequiredKey = require('./findRecordRequiredKey.cjs');
+var override = require('../../../common/override.cjs');
 
 const recordKind = kind.createDataParserKind("record");
 function record(key, value, definition) {
-    return base.dataParserInit(recordKind, {
+    const self = base.dataParserInit(recordKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -93,7 +94,9 @@ function record(key, value, definition) {
             return output;
         },
     });
+    return record.overrideHandler.apply(self);
 }
+record.overrideHandler = override.createOverride("@duplojs/utils/data-parser/record");
 
 exports.findRecordRequiredKey = findRecordRequiredKey.findRecordRequiredKey;
 exports.findRecordRequiredKeyOnTemplateLiteralPart = findRecordRequiredKey.findRecordRequiredKeyOnTemplateLiteralPart;

package/dist/dataParser/parsers/record/index.d.ts

@@ -40,3 +40,6 @@ export declare function record<GenericDataParserKey extends DataParserRecordKey,
     key: GenericDataParserKey;
     value: GenericDataParserValue;
 }>>;
+export declare namespace record {
+    var overrideHandler: import("../../../common").OverrideHandler<DataParserRecord<DataParserDefinitionRecord>>;
+}

package/dist/dataParser/parsers/record/index.mjs

@@ -3,10 +3,11 @@ import { SymbolDataParserErrorIssue, setErrorPath, popErrorPath } from '../../er
 import { createDataParserKind } from '../../kind.mjs';
 import { findRecordRequiredKey } from './findRecordRequiredKey.mjs';
 export { findRecordRequiredKeyOnTemplateLiteralPart } from './findRecordRequiredKey.mjs';
+import { createOverride } from '../../../common/override.mjs';
 
 const recordKind = createDataParserKind("record");
 function record(key, value, definition) {
-    return dataParserInit(recordKind, {
+    const self = dataParserInit(recordKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -92,6 +93,8 @@ function record(key, value, definition) {
             return output;
         },
     });
+    return record.overrideHandler.apply(self);
 }
+record.overrideHandler = createOverride("@duplojs/utils/data-parser/record");
 
 export { findRecordRequiredKey, record, recordKind };

package/dist/dataParser/parsers/recover.cjs

@@ -2,10 +2,11 @@
 
 var base = require('../base.cjs');
 var kind = require('../kind.cjs');
+var override = require('../../common/override.cjs');
 
 const recoverKind = kind.createDataParserKind("recover");
 function recover(inner, recoveredValue, definition) {
-    return base.dataParserInit(recoverKind, {
+    const self = base.dataParserInit(recoverKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -26,7 +27,9 @@ function recover(inner, recoveredValue, definition) {
                 : result;
         },
     });
+    return recover.overrideHandler.apply(self);
 }
+recover.overrideHandler = override.createOverride("@duplojs/utils/data-parser/recover");
 
 exports.recover = recover;
 exports.recoverKind = recoverKind;

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

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

package/dist/dataParser/parsers/recover.mjs

@@ -1,9 +1,10 @@
 import { dataParserInit, SymbolDataParserError } from '../base.mjs';
 import { createDataParserKind } from '../kind.mjs';
+import { createOverride } from '../../common/override.mjs';
 
 const recoverKind = createDataParserKind("recover");
 function recover(inner, recoveredValue, definition) {
-    return dataParserInit(recoverKind, {
+    const self = dataParserInit(recoverKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -24,6 +25,8 @@ function recover(inner, recoveredValue, definition) {
                 : result;
         },
     });
+    return recover.overrideHandler.apply(self);
 }
+recover.overrideHandler = createOverride("@duplojs/utils/data-parser/recover");
 
 export { recover, recoverKind };

package/dist/dataParser/parsers/string/index.cjs

@@ -3,10 +3,11 @@
 var base = require('../../base.cjs');
 var error = require('../../error.cjs');
 var kind = require('../../kind.cjs');
+var override = require('../../../common/override.cjs');
 
 const stringKind = kind.createDataParserKind("string");
 function string(definition) {
-    return base.dataParserInit(stringKind, {
+    const self = base.dataParserInit(stringKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -25,7 +26,9 @@ function string(definition) {
         }
         return error.SymbolDataParserErrorIssue;
     });
+    return string.overrideHandler.apply(self);
 }
+string.overrideHandler = override.createOverride("@duplojs/utils/data-parser/string");
 
 exports.string = string;
 exports.stringKind = stringKind;

package/dist/dataParser/parsers/string/index.d.ts

@@ -23,3 +23,6 @@ export interface DataParserString<GenericDefinition extends DataParserDefinition
     ], GenericChecker>): DataParserString<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
 }
 export declare function string<const GenericDefinition extends Partial<DataParserDefinitionString> = never>(definition?: GenericDefinition): DataParserString<MergeDefinition<DataParserDefinitionString, NeverCoalescing<GenericDefinition, {}>>>;
+export declare namespace string {
+    var overrideHandler: import("../../../common").OverrideHandler<DataParserString<DataParserDefinitionString>>;
+}

package/dist/dataParser/parsers/string/index.mjs

@@ -1,10 +1,11 @@
 import { dataParserInit } from '../../base.mjs';
 import { SymbolDataParserErrorIssue } from '../../error.mjs';
 import { createDataParserKind } from '../../kind.mjs';
+import { createOverride } from '../../../common/override.mjs';
 
 const stringKind = createDataParserKind("string");
 function string(definition) {
-    return dataParserInit(stringKind, {
+    const self = dataParserInit(stringKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -23,6 +24,8 @@ function string(definition) {
         }
         return SymbolDataParserErrorIssue;
     });
+    return string.overrideHandler.apply(self);
 }
+string.overrideHandler = createOverride("@duplojs/utils/data-parser/string");
 
 export { string, stringKind };

package/dist/dataParser/parsers/templateLiteral/createTemplateLiteralPattern.cjs

@@ -1,23 +1,6 @@
 'use strict';
 
-var escapeRegExp = require('../../../common/escapeRegExp.cjs');
-var pipe = require('../../../common/pipe.cjs');
-var innerPipe = require('../../../common/innerPipe.cjs');
-var when$1 = require('../../../common/when.cjs');
-var isType = require('../../../common/isType.cjs');
-var or = require('../../../common/or.cjs');
-var justReturn = require('../../../common/justReturn.cjs');
-var find = require('../../../array/find.cjs');
-var to = require('../../../object/to.cjs');
-var map = require('../../../array/map.cjs');
-var join = require('../../../array/join.cjs');
-require('../../../common/globalStore.cjs');
-require('../../../common/builder.cjs');
 var index = require('./index.cjs');
-require('../../../pattern/result.cjs');
-var exhaustive = require('../../../pattern/exhaustive.cjs');
-var when = require('../../../pattern/when.cjs');
-var replace = require('../../../string/replace.cjs');
 var index$3 = require('../number/index.cjs');
 var index$2 = require('../bigint/index.cjs');
 var boolean = require('../boolean.cjs');
@@ -26,11 +9,25 @@ var empty = require('../empty.cjs');
 var literal = require('../literal.cjs');
 var index$1 = require('../string/index.cjs');
 var union = require('../union.cjs');
+var innerPipe = require('../../../common/innerPipe.cjs');
 var regex = require('../string/checkers/regex.cjs');
+var when$1 = require('../../../common/when.cjs');
 var max = require('../string/checkers/max.cjs');
 var min = require('../string/checkers/min.cjs');
 var email = require('../string/checkers/email.cjs');
 var int = require('../number/checkers/int.cjs');
+var justReturn = require('../../../common/justReturn.cjs');
+var isType = require('../../../common/isType.cjs');
+var escapeRegExp = require('../../../common/escapeRegExp.cjs');
+var or = require('../../../common/or.cjs');
+var pipe = require('../../../common/pipe.cjs');
+var join = require('../../../array/join.cjs');
+var map = require('../../../array/map.cjs');
+var when = require('../../../pattern/when.cjs');
+var replace = require('../../../string/replace.cjs');
+var exhaustive = require('../../../pattern/exhaustive.cjs');
+var to = require('../../../object/to.cjs');
+var find = require('../../../array/find.cjs');
 
 function createTemplateLiteralPattern(templatePart) {
     return pipe.pipe(templatePart, map.map(innerPipe.innerPipe(when.when(or.or([

package/dist/dataParser/parsers/templateLiteral/createTemplateLiteralPattern.mjs

@@ -1,21 +1,4 @@
-import { escapeRegExp } from '../../../common/escapeRegExp.mjs';
-import { pipe } from '../../../common/pipe.mjs';
-import { innerPipe } from '../../../common/innerPipe.mjs';
-import { when as when$1 } from '../../../common/when.mjs';
-import { isType } from '../../../common/isType.mjs';
-import { or } from '../../../common/or.mjs';
-import { justReturn } from '../../../common/justReturn.mjs';
-import { find } from '../../../array/find.mjs';
-import { to } from '../../../object/to.mjs';
-import { map } from '../../../array/map.mjs';
-import { join } from '../../../array/join.mjs';
-import '../../../common/globalStore.mjs';
-import '../../../common/builder.mjs';
 import { templateLiteralKind } from './index.mjs';
-import '../../../pattern/result.mjs';
-import { exhaustive } from '../../../pattern/exhaustive.mjs';
-import { when } from '../../../pattern/when.mjs';
-import { replace } from '../../../string/replace.mjs';
 import { numberKind } from '../number/index.mjs';
 import { bigIntKind } from '../bigint/index.mjs';
 import { booleanKind } from '../boolean.mjs';
@@ -24,11 +7,25 @@ import { emptyKind } from '../empty.mjs';
 import { literalKind } from '../literal.mjs';
 import { stringKind } from '../string/index.mjs';
 import { unionKind } from '../union.mjs';
+import { innerPipe } from '../../../common/innerPipe.mjs';
 import { checkerStringRegexKind } from '../string/checkers/regex.mjs';
+import { when as when$1 } from '../../../common/when.mjs';
 import { checkerStringMaxKind } from '../string/checkers/max.mjs';
 import { checkerStringMinKind } from '../string/checkers/min.mjs';
 import { checkerEmailKind } from '../string/checkers/email.mjs';
 import { checkerIntKind } from '../number/checkers/int.mjs';
+import { justReturn } from '../../../common/justReturn.mjs';
+import { isType } from '../../../common/isType.mjs';
+import { escapeRegExp } from '../../../common/escapeRegExp.mjs';
+import { or } from '../../../common/or.mjs';
+import { pipe } from '../../../common/pipe.mjs';
+import { join } from '../../../array/join.mjs';
+import { map } from '../../../array/map.mjs';
+import { when } from '../../../pattern/when.mjs';
+import { replace } from '../../../string/replace.mjs';
+import { exhaustive } from '../../../pattern/exhaustive.mjs';
+import { to } from '../../../object/to.mjs';
+import { find } from '../../../array/find.mjs';
 
 function createTemplateLiteralPattern(templatePart) {
     return pipe(templatePart, map(innerPipe(when(or([

package/dist/dataParser/parsers/templateLiteral/index.cjs

@@ -1,17 +1,16 @@
 'use strict';
 
-var pipe = require('../../../common/pipe.cjs');
-require('../../../common/globalStore.cjs');
-require('../../../common/builder.cjs');
 var base = require('../../base.cjs');
 var error = require('../../error.cjs');
 var kind = require('../../kind.cjs');
 var createTemplateLiteralPattern = require('./createTemplateLiteralPattern.cjs');
+var pipe = require('../../../common/pipe.cjs');
+var override = require('../../../common/override.cjs');
 
 const templateLiteralKind = kind.createDataParserKind("template-literal");
 function templateLiteral(template, definition) {
     const pattern = pipe.pipe(createTemplateLiteralPattern.createTemplateLiteralPattern(template), (result) => new RegExp(`^${result}$`));
-    return base.dataParserInit(templateLiteralKind, {
+    const self = base.dataParserInit(templateLiteralKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -24,7 +23,9 @@ function templateLiteral(template, definition) {
         }
         return error.SymbolDataParserErrorIssue;
     });
+    return templateLiteral.overrideHandler.apply(self);
 }
+templateLiteral.overrideHandler = override.createOverride("@duplojs/utils/data-parser/templateLiteral");
 
 exports.createTemplateLiteralPattern = createTemplateLiteralPattern.createTemplateLiteralPattern;
 exports.templateLiteral = templateLiteral;

package/dist/dataParser/parsers/templateLiteral/index.d.ts

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

package/dist/dataParser/parsers/templateLiteral/index.mjs

@@ -1,15 +1,14 @@
-import { pipe } from '../../../common/pipe.mjs';
-import '../../../common/globalStore.mjs';
-import '../../../common/builder.mjs';
 import { dataParserInit } from '../../base.mjs';
 import { SymbolDataParserErrorIssue } from '../../error.mjs';
 import { createDataParserKind } from '../../kind.mjs';
 import { createTemplateLiteralPattern } from './createTemplateLiteralPattern.mjs';
+import { pipe } from '../../../common/pipe.mjs';
+import { createOverride } from '../../../common/override.mjs';
 
 const templateLiteralKind = createDataParserKind("template-literal");
 function templateLiteral(template, definition) {
     const pattern = pipe(createTemplateLiteralPattern(template), (result) => new RegExp(`^${result}$`));
-    return dataParserInit(templateLiteralKind, {
+    const self = dataParserInit(templateLiteralKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -22,6 +21,8 @@ function templateLiteral(template, definition) {
         }
         return SymbolDataParserErrorIssue;
     });
+    return templateLiteral.overrideHandler.apply(self);
 }
+templateLiteral.overrideHandler = createOverride("@duplojs/utils/data-parser/templateLiteral");
 
 export { createTemplateLiteralPattern, templateLiteral, templateLiteralKind };

package/dist/dataParser/parsers/transform.cjs

@@ -3,10 +3,11 @@
 var base = require('../base.cjs');
 var error = require('../error.cjs');
 var kind = require('../kind.cjs');
+var override = require('../../common/override.cjs');
 
 const transformKind = kind.createDataParserKind("transform");
 function transform(inner, theFunction, definition) {
-    return base.dataParserInit(transformKind, {
+    const self = base.dataParserInit(transformKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -37,7 +38,9 @@ function transform(inner, theFunction, definition) {
             return result;
         },
     });
+    return transform.overrideHandler.apply(self);
 }
+transform.overrideHandler = override.createOverride("@duplojs/utils/data-parser/transform");
 
 exports.transform = transform;
 exports.transformKind = transformKind;

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

@@ -26,4 +26,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<DataParserTransform<DataParserDefinitionTransform>>;
+}
 export {};