@duplojs/utils 1.1.15 → 1.2.16

package/dist/dataParser/parsers/coerce/nil.cjs

@@ -1,10 +1,27 @@
 'use strict';
 
-require('../../base.cjs');
-require('../../../common/globalStore.cjs');
-require('../../../common/builder.cjs');
+require('../string/index.cjs');
+require('../object/index.cjs');
+require('../number/index.cjs');
+require('../date.cjs');
+require('../literal.cjs');
+require('../union.cjs');
+require('../array/index.cjs');
+require('../bigint/index.cjs');
+require('../tuple.cjs');
+require('../transform.cjs');
 var nil$1 = require('../nil.cjs');
-require('../../../pattern/result.cjs');
+require('../boolean.cjs');
+require('../empty.cjs');
+require('../templateLiteral/index.cjs');
+require('../pipe.cjs');
+require('../optional.cjs');
+require('../nullable.cjs');
+require('../lazy.cjs');
+require('../unknown.cjs');
+require('../record/index.cjs');
+require('../refine.cjs');
+require('../recover.cjs');
 
 function nil(definition) {
     return nil$1.nil({

package/dist/dataParser/parsers/coerce/nil.mjs

@@ -1,8 +1,25 @@
-import '../../base.mjs';
-import '../../../common/globalStore.mjs';
-import '../../../common/builder.mjs';
+import '../string/index.mjs';
+import '../object/index.mjs';
+import '../number/index.mjs';
+import '../date.mjs';
+import '../literal.mjs';
+import '../union.mjs';
+import '../array/index.mjs';
+import '../bigint/index.mjs';
+import '../tuple.mjs';
+import '../transform.mjs';
 import { nil as nil$1 } from '../nil.mjs';
-import '../../../pattern/result.mjs';
+import '../boolean.mjs';
+import '../empty.mjs';
+import '../templateLiteral/index.mjs';
+import '../pipe.mjs';
+import '../optional.mjs';
+import '../nullable.mjs';
+import '../lazy.mjs';
+import '../unknown.mjs';
+import '../record/index.mjs';
+import '../refine.mjs';
+import '../recover.mjs';
 
 function nil(definition) {
     return nil$1({

package/dist/dataParser/parsers/coerce/number.cjs

@@ -1,10 +1,27 @@
 'use strict';
 
-require('../../base.cjs');
-require('../../../common/globalStore.cjs');
-require('../../../common/builder.cjs');
+require('../string/index.cjs');
+require('../object/index.cjs');
 var index = require('../number/index.cjs');
-require('../../../pattern/result.cjs');
+require('../date.cjs');
+require('../literal.cjs');
+require('../union.cjs');
+require('../array/index.cjs');
+require('../bigint/index.cjs');
+require('../tuple.cjs');
+require('../transform.cjs');
+require('../nil.cjs');
+require('../boolean.cjs');
+require('../empty.cjs');
+require('../templateLiteral/index.cjs');
+require('../pipe.cjs');
+require('../optional.cjs');
+require('../nullable.cjs');
+require('../lazy.cjs');
+require('../unknown.cjs');
+require('../record/index.cjs');
+require('../refine.cjs');
+require('../recover.cjs');
 
 function number(definition) {
     return index.number({

package/dist/dataParser/parsers/coerce/number.mjs

@@ -1,8 +1,25 @@
-import '../../base.mjs';
-import '../../../common/globalStore.mjs';
-import '../../../common/builder.mjs';
+import '../string/index.mjs';
+import '../object/index.mjs';
 import { number as number$1 } from '../number/index.mjs';
-import '../../../pattern/result.mjs';
+import '../date.mjs';
+import '../literal.mjs';
+import '../union.mjs';
+import '../array/index.mjs';
+import '../bigint/index.mjs';
+import '../tuple.mjs';
+import '../transform.mjs';
+import '../nil.mjs';
+import '../boolean.mjs';
+import '../empty.mjs';
+import '../templateLiteral/index.mjs';
+import '../pipe.mjs';
+import '../optional.mjs';
+import '../nullable.mjs';
+import '../lazy.mjs';
+import '../unknown.mjs';
+import '../record/index.mjs';
+import '../refine.mjs';
+import '../recover.mjs';
 
 function number(definition) {
     return number$1({

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

@@ -1,10 +1,27 @@
 'use strict';
 
 var index = require('../string/index.cjs');
-require('../../../common/globalStore.cjs');
-require('../../../common/builder.cjs');
-require('../../base.cjs');
-require('../../../pattern/result.cjs');
+require('../object/index.cjs');
+require('../number/index.cjs');
+require('../date.cjs');
+require('../literal.cjs');
+require('../union.cjs');
+require('../array/index.cjs');
+require('../bigint/index.cjs');
+require('../tuple.cjs');
+require('../transform.cjs');
+require('../nil.cjs');
+require('../boolean.cjs');
+require('../empty.cjs');
+require('../templateLiteral/index.cjs');
+require('../pipe.cjs');
+require('../optional.cjs');
+require('../nullable.cjs');
+require('../lazy.cjs');
+require('../unknown.cjs');
+require('../record/index.cjs');
+require('../refine.cjs');
+require('../recover.cjs');
 
 function string(definition) {
     return index.string({

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

@@ -1,8 +1,25 @@
 import { string as string$1 } from '../string/index.mjs';
-import '../../../common/globalStore.mjs';
-import '../../../common/builder.mjs';
-import '../../base.mjs';
-import '../../../pattern/result.mjs';
+import '../object/index.mjs';
+import '../number/index.mjs';
+import '../date.mjs';
+import '../literal.mjs';
+import '../union.mjs';
+import '../array/index.mjs';
+import '../bigint/index.mjs';
+import '../tuple.mjs';
+import '../transform.mjs';
+import '../nil.mjs';
+import '../boolean.mjs';
+import '../empty.mjs';
+import '../templateLiteral/index.mjs';
+import '../pipe.mjs';
+import '../optional.mjs';
+import '../nullable.mjs';
+import '../lazy.mjs';
+import '../unknown.mjs';
+import '../record/index.mjs';
+import '../refine.mjs';
+import '../recover.mjs';
 
 function string(definition) {
     return string$1({

package/dist/dataParser/parsers/date.cjs

@@ -0,0 +1,79 @@
+'use strict';
+
+require('../../common/stringToBytes.cjs');
+require('../../common/stringToMillisecond.cjs');
+require('../../common/globalStore.cjs');
+require('../../common/builder.cjs');
+require('../../either/bool/falsy.cjs');
+require('../../either/bool/truthy.cjs');
+require('../../either/bool/base.cjs');
+require('../../either/left/create.cjs');
+require('../../either/left/error.cjs');
+require('../../either/left/fail.cjs');
+require('../../either/kind.cjs');
+require('../../either/right/success.cjs');
+require('../../either/right/create.cjs');
+require('../../either/right/ok.cjs');
+require('../../either/future/success.cjs');
+require('../../either/future/error.cjs');
+require('../../either/future/base.cjs');
+require('../../either/nullable/empty.cjs');
+require('../../either/nullable/filled.cjs');
+require('../../either/nullable/base.cjs');
+require('../../either/nullish/empty.cjs');
+require('../../either/nullish/filled.cjs');
+require('../../either/nullish/base.cjs');
+require('../../either/optional/empty.cjs');
+require('../../either/optional/filled.cjs');
+require('../../either/optional/base.cjs');
+var override = require('../../common/override.cjs');
+var base = require('../base.cjs');
+var error = require('../error.cjs');
+var kind = require('../kind.cjs');
+require('../../date/types/timezone.cjs');
+var constants = require('../../date/constants.cjs');
+var isSafeTimestamp = require('../../date/isSafeTimestamp.cjs');
+require('../../date/toTimestamp.cjs');
+require('../../date/createOrThrow.cjs');
+
+const dateKind = kind.createDataParserKind("date");
+function date(definition) {
+    const self = base.dataParserInit(dateKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            coerce: definition?.coerce ?? false,
+        },
+    }, (data, _error, self) => {
+        if (self.definition.coerce) {
+            if (data instanceof Date) {
+                const timestamp = data.getTime();
+                if (!isSafeTimestamp.isSafeTimestamp(timestamp)) {
+                    return error.SymbolDataParserErrorIssue;
+                }
+                const isNegative = timestamp < 0;
+                return `date${Math.abs(timestamp)}${isNegative ? "-" : "+"}`;
+            }
+            if (typeof data === "number") {
+                if (!isSafeTimestamp.isSafeTimestamp(data)) {
+                    return error.SymbolDataParserErrorIssue;
+                }
+                const isNegative = data < 0;
+                return `date${Math.abs(data)}${isNegative ? "-" : "+"}`;
+            }
+        }
+        const theDateMatch = typeof data === "string" && data.match(constants.theDateRegex);
+        if (theDateMatch) {
+            if (!isSafeTimestamp.isSafeTimestamp(Number(theDateMatch.groups?.value))) {
+                return error.SymbolDataParserErrorIssue;
+            }
+            return data;
+        }
+        return error.SymbolDataParserErrorIssue;
+    });
+    return date.overrideHandler.apply(self);
+}
+date.overrideHandler = override.createOverride("@duplojs/utils/data-parser/date");
+
+exports.date = date;
+exports.dateKind = dateKind;

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

@@ -0,0 +1,28 @@
+import { type NeverCoalescing, type Kind, type FixDeepFunctionInfer } from "../../common";
+import { type DataParserDefinition, type DataParser, type DataParserChecker } from "../base";
+import { type AddCheckersToDefinition, type MergeDefinition } from "../../dataParser/types";
+import { type CheckerRefineImplementation } from "./refine";
+import { type GetPropsWithValueExtends } from "../../object";
+import { type TheDate } from "../../date";
+export interface DataParserDateCheckerCustom {
+}
+export type DataParserDateCheckers = (DataParserDateCheckerCustom[GetPropsWithValueExtends<DataParserDateCheckerCustom, DataParserChecker>] | CheckerRefineImplementation<TheDate>);
+export interface DataParserDefinitionDate extends DataParserDefinition<DataParserDateCheckers> {
+    readonly coerce: boolean;
+}
+export declare const dateKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/date", unknown>>;
+type _DataParserDate<GenericDefinition extends DataParserDefinitionDate> = (DataParser<GenericDefinition, TheDate, TheDate> & Kind<typeof dateKind.definition>);
+export interface DataParserDate<GenericDefinition extends DataParserDefinitionDate = DataParserDefinitionDate> extends _DataParserDate<GenericDefinition> {
+    addChecker<GenericChecker extends readonly [
+        DataParserDateCheckers,
+        ...DataParserDateCheckers[]
+    ]>(...args: FixDeepFunctionInfer<readonly [
+        DataParserDateCheckers,
+        ...DataParserDateCheckers[]
+    ], GenericChecker>): DataParserDate<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+}
+export declare function date<const GenericDefinition extends Partial<DataParserDefinitionDate> = never>(definition?: GenericDefinition): DataParserDate<MergeDefinition<DataParserDefinitionDate, NeverCoalescing<GenericDefinition, {}>>>;
+export declare namespace date {
+    var overrideHandler: import("../../common").OverrideHandler<DataParserDate<DataParserDefinitionDate>>;
+}
+export {};

package/dist/dataParser/parsers/date.mjs

@@ -0,0 +1,76 @@
+import '../../common/stringToBytes.mjs';
+import '../../common/stringToMillisecond.mjs';
+import '../../common/globalStore.mjs';
+import '../../common/builder.mjs';
+import '../../either/bool/falsy.mjs';
+import '../../either/bool/truthy.mjs';
+import '../../either/bool/base.mjs';
+import '../../either/left/create.mjs';
+import '../../either/left/error.mjs';
+import '../../either/left/fail.mjs';
+import '../../either/kind.mjs';
+import '../../either/right/success.mjs';
+import '../../either/right/create.mjs';
+import '../../either/right/ok.mjs';
+import '../../either/future/success.mjs';
+import '../../either/future/error.mjs';
+import '../../either/future/base.mjs';
+import '../../either/nullable/empty.mjs';
+import '../../either/nullable/filled.mjs';
+import '../../either/nullable/base.mjs';
+import '../../either/nullish/empty.mjs';
+import '../../either/nullish/filled.mjs';
+import '../../either/nullish/base.mjs';
+import '../../either/optional/empty.mjs';
+import '../../either/optional/filled.mjs';
+import '../../either/optional/base.mjs';
+import { createOverride } from '../../common/override.mjs';
+import { dataParserInit } from '../base.mjs';
+import { SymbolDataParserErrorIssue } from '../error.mjs';
+import { createDataParserKind } from '../kind.mjs';
+import '../../date/types/timezone.mjs';
+import { theDateRegex } from '../../date/constants.mjs';
+import { isSafeTimestamp } from '../../date/isSafeTimestamp.mjs';
+import '../../date/toTimestamp.mjs';
+import '../../date/createOrThrow.mjs';
+
+const dateKind = createDataParserKind("date");
+function date(definition) {
+    const self = dataParserInit(dateKind, {
+        definition: {
+            errorMessage: definition?.errorMessage,
+            checkers: definition?.checkers ?? [],
+            coerce: definition?.coerce ?? false,
+        },
+    }, (data, _error, self) => {
+        if (self.definition.coerce) {
+            if (data instanceof Date) {
+                const timestamp = data.getTime();
+                if (!isSafeTimestamp(timestamp)) {
+                    return SymbolDataParserErrorIssue;
+                }
+                const isNegative = timestamp < 0;
+                return `date${Math.abs(timestamp)}${isNegative ? "-" : "+"}`;
+            }
+            if (typeof data === "number") {
+                if (!isSafeTimestamp(data)) {
+                    return SymbolDataParserErrorIssue;
+                }
+                const isNegative = data < 0;
+                return `date${Math.abs(data)}${isNegative ? "-" : "+"}`;
+            }
+        }
+        const theDateMatch = typeof data === "string" && data.match(theDateRegex);
+        if (theDateMatch) {
+            if (!isSafeTimestamp(Number(theDateMatch.groups?.value))) {
+                return SymbolDataParserErrorIssue;
+            }
+            return data;
+        }
+        return SymbolDataParserErrorIssue;
+    });
+    return date.overrideHandler.apply(self);
+}
+date.overrideHandler = createOverride("@duplojs/utils/data-parser/date");
+
+export { date, dateKind };

package/dist/dataParser/parsers/empty.cjs

@@ -1,12 +1,39 @@
 'use strict';
 
+require('../../common/stringToBytes.cjs');
+require('../../common/stringToMillisecond.cjs');
+require('../../common/globalStore.cjs');
+require('../../common/builder.cjs');
+require('../../either/bool/falsy.cjs');
+require('../../either/bool/truthy.cjs');
+require('../../either/bool/base.cjs');
+require('../../either/left/create.cjs');
+require('../../either/left/error.cjs');
+require('../../either/left/fail.cjs');
+require('../../either/kind.cjs');
+require('../../either/right/success.cjs');
+require('../../either/right/create.cjs');
+require('../../either/right/ok.cjs');
+require('../../either/future/success.cjs');
+require('../../either/future/error.cjs');
+require('../../either/future/base.cjs');
+require('../../either/nullable/empty.cjs');
+require('../../either/nullable/filled.cjs');
+require('../../either/nullable/base.cjs');
+require('../../either/nullish/empty.cjs');
+require('../../either/nullish/filled.cjs');
+require('../../either/nullish/base.cjs');
+require('../../either/optional/empty.cjs');
+require('../../either/optional/filled.cjs');
+require('../../either/optional/base.cjs');
+var override = require('../../common/override.cjs');
 var base = require('../base.cjs');
 var error = require('../error.cjs');
 var kind = require('../kind.cjs');
 
 const emptyKind = kind.createDataParserKind("empty");
 function empty(definition) {
-    return base.dataParserInit(emptyKind, {
+    const self = base.dataParserInit(emptyKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -21,7 +48,9 @@ function empty(definition) {
         }
         return error.SymbolDataParserErrorIssue;
     });
+    return empty.overrideHandler.apply(self);
 }
+empty.overrideHandler = override.createOverride("@duplojs/utils/data-parser/empty");
 
 exports.empty = empty;
 exports.emptyKind = emptyKind;

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

@@ -21,4 +21,7 @@ export interface DataParserEmpty<GenericDefinition extends DataParserDefinitionE
     ], GenericChecker>): DataParserEmpty<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
 }
 export declare function empty<const GenericDefinition extends Partial<DataParserDefinitionEmpty> = never>(definition?: GenericDefinition): DataParserEmpty<MergeDefinition<DataParserDefinitionEmpty, NeverCoalescing<GenericDefinition, {}>>>;
+export declare namespace empty {
+    var overrideHandler: import("../../common").OverrideHandler<DataParserEmpty<DataParserDefinitionEmpty>>;
+}
 export {};

package/dist/dataParser/parsers/empty.mjs

@@ -1,10 +1,37 @@
+import '../../common/stringToBytes.mjs';
+import '../../common/stringToMillisecond.mjs';
+import '../../common/globalStore.mjs';
+import '../../common/builder.mjs';
+import '../../either/bool/falsy.mjs';
+import '../../either/bool/truthy.mjs';
+import '../../either/bool/base.mjs';
+import '../../either/left/create.mjs';
+import '../../either/left/error.mjs';
+import '../../either/left/fail.mjs';
+import '../../either/kind.mjs';
+import '../../either/right/success.mjs';
+import '../../either/right/create.mjs';
+import '../../either/right/ok.mjs';
+import '../../either/future/success.mjs';
+import '../../either/future/error.mjs';
+import '../../either/future/base.mjs';
+import '../../either/nullable/empty.mjs';
+import '../../either/nullable/filled.mjs';
+import '../../either/nullable/base.mjs';
+import '../../either/nullish/empty.mjs';
+import '../../either/nullish/filled.mjs';
+import '../../either/nullish/base.mjs';
+import '../../either/optional/empty.mjs';
+import '../../either/optional/filled.mjs';
+import '../../either/optional/base.mjs';
+import { createOverride } from '../../common/override.mjs';
 import { dataParserInit } from '../base.mjs';
 import { SymbolDataParserErrorIssue } from '../error.mjs';
 import { createDataParserKind } from '../kind.mjs';
 
 const emptyKind = createDataParserKind("empty");
 function empty(definition) {
-    return dataParserInit(emptyKind, {
+    const self = dataParserInit(emptyKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -19,6 +46,8 @@ function empty(definition) {
         }
         return SymbolDataParserErrorIssue;
     });
+    return empty.overrideHandler.apply(self);
 }
+empty.overrideHandler = createOverride("@duplojs/utils/data-parser/empty");
 
 export { empty, emptyKind };

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

@@ -2,6 +2,7 @@ export * as coerce from "./coerce";
 export * from "./string";
 export * from "./object";
 export * from "./number";
+export * from "./date";
 export * from "./literal";
 export * from "./union";
 export * from "./array";

package/dist/dataParser/parsers/lazy.cjs

@@ -1,21 +1,51 @@
 'use strict';
 
+require('../../common/stringToBytes.cjs');
+require('../../common/stringToMillisecond.cjs');
+var memo = require('../../common/memo.cjs');
+require('../../common/globalStore.cjs');
+require('../../common/builder.cjs');
+require('../../either/bool/falsy.cjs');
+require('../../either/bool/truthy.cjs');
+require('../../either/bool/base.cjs');
+require('../../either/left/create.cjs');
+require('../../either/left/error.cjs');
+require('../../either/left/fail.cjs');
+require('../../either/kind.cjs');
+require('../../either/right/success.cjs');
+require('../../either/right/create.cjs');
+require('../../either/right/ok.cjs');
+require('../../either/future/success.cjs');
+require('../../either/future/error.cjs');
+require('../../either/future/base.cjs');
+require('../../either/nullable/empty.cjs');
+require('../../either/nullable/filled.cjs');
+require('../../either/nullable/base.cjs');
+require('../../either/nullish/empty.cjs');
+require('../../either/nullish/filled.cjs');
+require('../../either/nullish/base.cjs');
+require('../../either/optional/empty.cjs');
+require('../../either/optional/filled.cjs');
+require('../../either/optional/base.cjs');
+var override = require('../../common/override.cjs');
 var base = require('../base.cjs');
 var kind = require('../kind.cjs');
 
 const lazyKind = kind.createDataParserKind("lazy");
 function lazy(getter, definition) {
-    return base.dataParserInit(lazyKind, {
+    const self = base.dataParserInit(lazyKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
-            getter,
+            getter: memo.memo(getter),
         },
     }, {
-        sync: (data, _error, self) => self.definition.getter().exec(data, _error),
-        async: (data, _error, self) => self.definition.getter().asyncExec(data, _error),
+        sync: (data, _error, self) => self.definition.getter.value.exec(data, _error),
+        async: (data, _error, self) => self.definition.getter.value.asyncExec(data, _error),
     });
+    return lazy.overrideHandler.apply(self);
 }
+lazy.overrideHandler = override.createOverride("@duplojs/utils/data-parser/lazy");
 
 exports.lazy = lazy;
 exports.lazyKind = lazyKind;

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

@@ -1,4 +1,4 @@
-import { type NeverCoalescing, type Kind, type FixDeepFunctionInfer } from "../../common";
+import { type NeverCoalescing, type Kind, type FixDeepFunctionInfer, type Memoized } from "../../common";
 import { type DataParserDefinition, type DataParser, type Output, type Input, type DataParserChecker } from "../base";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../../dataParser/types";
 import { type CheckerRefineImplementation } from "./refine";
@@ -7,10 +7,10 @@ export interface DataParserLazyCheckerCustom<GenericInput extends unknown = unkn
 }
 export type DataParserLazyCheckers<GenericInput extends unknown = unknown> = (DataParserLazyCheckerCustom<GenericInput>[GetPropsWithValueExtends<DataParserLazyCheckerCustom<GenericInput>, DataParserChecker>] | CheckerRefineImplementation<GenericInput>);
 export interface DataParserDefinitionLazy extends DataParserDefinition<DataParserLazyCheckers> {
-    getter(): DataParser;
+    getter: Memoized<DataParser>;
 }
 export declare const lazyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/lazy", unknown>>;
-type _DataParserLazy<GenericDefinition extends DataParserDefinitionLazy> = (DataParser<GenericDefinition, Output<ReturnType<GenericDefinition["getter"]>>, Input<ReturnType<GenericDefinition["getter"]>>> & Kind<typeof lazyKind.definition>);
+type _DataParserLazy<GenericDefinition extends DataParserDefinitionLazy> = (DataParser<GenericDefinition, Output<GenericDefinition["getter"]["value"]>, Input<GenericDefinition["getter"]["value"]>> & Kind<typeof lazyKind.definition>);
 export interface DataParserLazy<GenericDefinition extends DataParserDefinitionLazy = DataParserDefinitionLazy> extends _DataParserLazy<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
         DataParserLazyCheckers<Output<this>>,
@@ -21,6 +21,9 @@ export interface DataParserLazy<GenericDefinition extends DataParserDefinitionLa
     ], GenericChecker>): DataParserLazy<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
 }
 export declare function lazy<GenericDataParser extends DataParser, const GenericDefinition extends Partial<DataParserDefinitionLazy> = never>(getter: () => GenericDataParser, definition?: GenericDefinition): DataParserLazy<MergeDefinition<DataParserDefinitionLazy, NeverCoalescing<GenericDefinition, {}> & {
-    getter(): GenericDataParser;
+    getter: Memoized<GenericDataParser>;
 }>>;
+export declare namespace lazy {
+    var overrideHandler: import("../../common").OverrideHandler<DataParserLazyCheckerCustom<unknown>>;
+}
 export {};

package/dist/dataParser/parsers/lazy.mjs

@@ -1,18 +1,48 @@
+import '../../common/stringToBytes.mjs';
+import '../../common/stringToMillisecond.mjs';
+import { memo } from '../../common/memo.mjs';
+import '../../common/globalStore.mjs';
+import '../../common/builder.mjs';
+import '../../either/bool/falsy.mjs';
+import '../../either/bool/truthy.mjs';
+import '../../either/bool/base.mjs';
+import '../../either/left/create.mjs';
+import '../../either/left/error.mjs';
+import '../../either/left/fail.mjs';
+import '../../either/kind.mjs';
+import '../../either/right/success.mjs';
+import '../../either/right/create.mjs';
+import '../../either/right/ok.mjs';
+import '../../either/future/success.mjs';
+import '../../either/future/error.mjs';
+import '../../either/future/base.mjs';
+import '../../either/nullable/empty.mjs';
+import '../../either/nullable/filled.mjs';
+import '../../either/nullable/base.mjs';
+import '../../either/nullish/empty.mjs';
+import '../../either/nullish/filled.mjs';
+import '../../either/nullish/base.mjs';
+import '../../either/optional/empty.mjs';
+import '../../either/optional/filled.mjs';
+import '../../either/optional/base.mjs';
+import { createOverride } from '../../common/override.mjs';
 import { dataParserInit } from '../base.mjs';
 import { createDataParserKind } from '../kind.mjs';
 
 const lazyKind = createDataParserKind("lazy");
 function lazy(getter, definition) {
-    return dataParserInit(lazyKind, {
+    const self = dataParserInit(lazyKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
-            getter,
+            getter: memo(getter),
         },
     }, {
-        sync: (data, _error, self) => self.definition.getter().exec(data, _error),
-        async: (data, _error, self) => self.definition.getter().asyncExec(data, _error),
+        sync: (data, _error, self) => self.definition.getter.value.exec(data, _error),
+        async: (data, _error, self) => self.definition.getter.value.asyncExec(data, _error),
     });
+    return lazy.overrideHandler.apply(self);
 }
+lazy.overrideHandler = createOverride("@duplojs/utils/data-parser/lazy");
 
 export { lazy, lazyKind };