@duplojs/utils 1.0.7 → 1.1.7

package/dist/dataParser/extended/coerce/empty.mjs

@@ -0,0 +1,11 @@
+import '../../../pattern/result.mjs';
+import { empty as empty$1 } from '../empty.mjs';
+
+function empty(definition) {
+    return empty$1({
+        ...definition,
+        coerce: true,
+    });
+}
+
+export { empty };

package/dist/dataParser/extended/coerce/index.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+var bigint = require('./bigint.cjs');
+var boolean = require('./boolean.cjs');
+var empty = require('./empty.cjs');
+var nil = require('./nil.cjs');
+var number = require('./number.cjs');
+var string = require('./string.cjs');
+
+
+
+exports.bigint = bigint.bigint;
+exports.boolean = boolean.boolean;
+exports.empty = empty.empty;
+exports.nil = nil.nil;
+exports.number = number.number;
+exports.string = string.string;

package/dist/dataParser/extended/coerce/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./bigint";
+export * from "./boolean";
+export * from "./empty";
+export * from "./nil";
+export * from "./number";
+export * from "./string";

package/dist/dataParser/extended/coerce/index.mjs

@@ -0,0 +1,6 @@
+export { bigint } from './bigint.mjs';
+export { boolean } from './boolean.mjs';
+export { empty } from './empty.mjs';
+export { nil } from './nil.mjs';
+export { number } from './number.mjs';
+export { string } from './string.mjs';

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

@@ -0,0 +1,13 @@
+'use strict';
+
+require('../../../pattern/result.cjs');
+var nil$1 = require('../nil.cjs');
+
+function nil(definition) {
+    return nil$1.nil({
+        ...definition,
+        coerce: true,
+    });
+}
+
+exports.nil = nil;

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

@@ -0,0 +1,7 @@
+import { type NeverCoalescing } from "../../../common";
+import { type MergeDefinition } from "../../types";
+import type * as dataParsers from "../../parsers";
+import * as dataParsersExtended from "..";
+export declare function nil<const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionNil, "coerce">> = never>(definition?: GenericDefinition): dataParsersExtended.DataParserNilExtended<MergeDefinition<dataParsers.DataParserDefinitionNil, NeverCoalescing<GenericDefinition, {}> & {
+    coerce: true;
+}>>;

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

@@ -0,0 +1,11 @@
+import '../../../pattern/result.mjs';
+import { nil as nil$1 } from '../nil.mjs';
+
+function nil(definition) {
+    return nil$1({
+        ...definition,
+        coerce: true,
+    });
+}
+
+export { nil };

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

@@ -0,0 +1,13 @@
+'use strict';
+
+require('../../../pattern/result.cjs');
+var number$1 = require('../number.cjs');
+
+function number(definition) {
+    return number$1.number({
+        ...definition,
+        coerce: true,
+    });
+}
+
+exports.number = number;

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

@@ -0,0 +1,7 @@
+import { type NeverCoalescing } from "../../../common";
+import { type MergeDefinition } from "../../types";
+import type * as dataParsers from "../../parsers";
+import * as dataParsersExtended from "..";
+export declare function number<const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionNumber, "coerce">> = never>(definition?: GenericDefinition): dataParsersExtended.DataParserNumberExtended<MergeDefinition<dataParsers.DataParserDefinitionNumber, NeverCoalescing<GenericDefinition, {}> & {
+    coerce: true;
+}>>;

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

@@ -0,0 +1,11 @@
+import '../../../pattern/result.mjs';
+import { number as number$1 } from '../number.mjs';
+
+function number(definition) {
+    return number$1({
+        ...definition,
+        coerce: true,
+    });
+}
+
+export { number };

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

@@ -0,0 +1,13 @@
+'use strict';
+
+var string$1 = require('../string.cjs');
+require('../../../pattern/result.cjs');
+
+function string(definition) {
+    return string$1.string({
+        ...definition,
+        coerce: true,
+    });
+}
+
+exports.string = string;

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

@@ -0,0 +1,7 @@
+import { type NeverCoalescing } from "../../../common";
+import { type MergeDefinition } from "../../types";
+import type * as dataParsers from "../../parsers";
+import * as dataParsersExtended from "../";
+export declare function string<const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionString, "coerce">> = never>(definition?: GenericDefinition): dataParsersExtended.DataParserStringExtended<MergeDefinition<dataParsers.DataParserDefinitionString, NeverCoalescing<GenericDefinition, {}> & {
+    coerce: true;
+}>>;

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

@@ -0,0 +1,11 @@
+import { string as string$1 } from '../string.mjs';
+import '../../../pattern/result.mjs';
+
+function string(definition) {
+    return string$1({
+        ...definition,
+        coerce: true,
+    });
+}
+
+export { string };

package/dist/dataParser/extended/empty.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var baseExtended = require('../baseExtended.cjs');
+var empty$1 = require('../parsers/empty.cjs');
+require('../../pattern/result.cjs');
+
+function empty(definition) {
+    return baseExtended.dataParserExtendedInit(empty$1.empty(definition), {});
+}
+
+exports.empty = empty;

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

@@ -0,0 +1,9 @@
+import { type NeverCoalescing } from "../../common";
+import { type DataParserExtended } from "../baseExtended";
+import { type MergeDefinition } from "../types";
+import * as dataParsers from "../parsers";
+type _DataParserEmptyExtended<GenericDefinition extends dataParsers.DataParserDefinitionEmpty> = (dataParsers.DataParserEmpty<GenericDefinition> & DataParserExtended);
+export interface DataParserEmptyExtended<GenericDefinition extends dataParsers.DataParserDefinitionEmpty = dataParsers.DataParserDefinitionEmpty> extends _DataParserEmptyExtended<GenericDefinition> {
+}
+export declare function empty<const GenericDefinition extends Partial<dataParsers.DataParserDefinitionEmpty> = never>(definition?: GenericDefinition): DataParserEmptyExtended<MergeDefinition<dataParsers.DataParserDefinitionEmpty, NeverCoalescing<GenericDefinition, {}>>>;
+export {};

package/dist/dataParser/extended/empty.mjs

@@ -0,0 +1,9 @@
+import { dataParserExtendedInit } from '../baseExtended.mjs';
+import { empty as empty$1 } from '../parsers/empty.mjs';
+import '../../pattern/result.mjs';
+
+function empty(definition) {
+    return dataParserExtendedInit(empty$1(definition), {});
+}
+
+export { empty };

package/dist/dataParser/extended/index.cjs

@@ -0,0 +1,48 @@
+'use strict';
+
+var index = require('./coerce/index.cjs');
+var string = require('./string.cjs');
+var array = require('./array.cjs');
+var bigint = require('./bigint.cjs');
+var number = require('./number.cjs');
+var transform = require('./transform.cjs');
+var union = require('./union.cjs');
+var boolean = require('./boolean.cjs');
+var empty = require('./empty.cjs');
+var lazy = require('./lazy.cjs');
+var literal = require('./literal.cjs');
+var nil = require('./nil.cjs');
+var nullable = require('./nullable.cjs');
+var object = require('./object.cjs');
+var optional = require('./optional.cjs');
+var pipe = require('./pipe.cjs');
+var record = require('./record.cjs');
+var templateLiteral = require('./templateLiteral.cjs');
+var tuple = require('./tuple.cjs');
+var unknown = require('./unknown.cjs');
+
+
+
+exports.coerce = index;
+exports.email = string.email;
+exports.string = string.string;
+exports.url = string.url;
+exports.array = array.array;
+exports.bigint = bigint.bigint;
+exports.int = number.int;
+exports.number = number.number;
+exports.transform = transform.transform;
+exports.union = union.union;
+exports.boolean = boolean.boolean;
+exports.empty = empty.empty;
+exports.lazy = lazy.lazy;
+exports.literal = literal.literal;
+exports.nil = nil.nil;
+exports.nullable = nullable.nullable;
+exports.object = object.object;
+exports.optional = optional.optional;
+exports.pipe = pipe.pipe;
+exports.record = record.record;
+exports.templateLiteral = templateLiteral.templateLiteral;
+exports.tuple = tuple.tuple;
+exports.unknown = unknown.unknown;

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

@@ -0,0 +1,22 @@
+export * as coerce from "./coerce";
+export * from "./string";
+export * from "./array";
+export * from "./bigint";
+export * from "./number";
+export * from "./transform";
+export * from "./union";
+export * from "./boolean";
+export * from "./empty";
+export * from "./lazy";
+export * from "./literal";
+export * from "./nil";
+export * from "./nullable";
+export * from "./object";
+export * from "./optional";
+export * from "./pipe";
+export * from "./record";
+export * from "./templateLiteral";
+export * from "./transform";
+export * from "./tuple";
+export * from "./union";
+export * from "./unknown";

package/dist/dataParser/extended/index.mjs

@@ -0,0 +1,21 @@
+import * as index from './coerce/index.mjs';
+export { index as coerce };
+export { email, string, url } from './string.mjs';
+export { array } from './array.mjs';
+export { bigint } from './bigint.mjs';
+export { int, number } from './number.mjs';
+export { transform } from './transform.mjs';
+export { union } from './union.mjs';
+export { boolean } from './boolean.mjs';
+export { empty } from './empty.mjs';
+export { lazy } from './lazy.mjs';
+export { literal } from './literal.mjs';
+export { nil } from './nil.mjs';
+export { nullable } from './nullable.mjs';
+export { object } from './object.mjs';
+export { optional } from './optional.mjs';
+export { pipe } from './pipe.mjs';
+export { record } from './record.mjs';
+export { templateLiteral } from './templateLiteral.mjs';
+export { tuple } from './tuple.mjs';
+export { unknown } from './unknown.mjs';

package/dist/dataParser/extended/lazy.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var baseExtended = require('../baseExtended.cjs');
+require('../../pattern/result.cjs');
+var lazy$1 = require('../parsers/lazy.cjs');
+
+function lazy(getter, definition) {
+    return baseExtended.dataParserExtendedInit(lazy$1.lazy(getter, definition), {});
+}
+
+exports.lazy = lazy;

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

@@ -0,0 +1,11 @@
+import { type NeverCoalescing } from "../../common";
+import { type DataParserExtended } from "../baseExtended";
+import { type DataParsers, type MergeDefinition } from "../types";
+import * as dataParsers from "../parsers";
+type _DataParserLazyExtended<GenericDefinition extends dataParsers.DataParserDefinitionLazy> = (dataParsers.DataParserLazy<GenericDefinition> & DataParserExtended);
+export interface DataParserLazyExtended<GenericDefinition extends dataParsers.DataParserDefinitionLazy = dataParsers.DataParserDefinitionLazy> extends _DataParserLazyExtended<GenericDefinition> {
+}
+export declare function lazy<GenericDataParser extends DataParsers, const GenericDefinition extends Partial<dataParsers.DataParserDefinitionLazy> = never>(getter: () => GenericDataParser, definition?: GenericDefinition): DataParserLazyExtended<MergeDefinition<dataParsers.DataParserDefinitionLazy, NeverCoalescing<GenericDefinition, {}> & {
+    getter(): GenericDataParser;
+}>>;
+export {};

package/dist/dataParser/extended/lazy.mjs

@@ -0,0 +1,9 @@
+import { dataParserExtendedInit } from '../baseExtended.mjs';
+import '../../pattern/result.mjs';
+import { lazy as lazy$1 } from '../parsers/lazy.mjs';
+
+function lazy(getter, definition) {
+    return dataParserExtendedInit(lazy$1(getter, definition), {});
+}
+
+export { lazy };

package/dist/dataParser/extended/literal.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var baseExtended = require('../baseExtended.cjs');
+var literal$1 = require('../parsers/literal.cjs');
+require('../../pattern/result.cjs');
+
+function literal(value, definition) {
+    return baseExtended.dataParserExtendedInit(literal$1.literal(value, definition), {});
+}
+
+exports.literal = literal;

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

@@ -0,0 +1,11 @@
+import { type NeverCoalescing } from "../../common";
+import { type DataParserExtended } from "../baseExtended";
+import { type MergeDefinition } from "../types";
+import * as dataParsers from "../parsers";
+type _DataParserLiteralExtended<GenericDefinition extends dataParsers.DataParserDefinitionLiteral> = (dataParsers.DataParserLiteral<GenericDefinition> & DataParserExtended);
+export interface DataParserLiteralExtended<GenericDefinition extends dataParsers.DataParserDefinitionLiteral = dataParsers.DataParserDefinitionLiteral> extends _DataParserLiteralExtended<GenericDefinition> {
+}
+export declare function literal<const GenericValue extends dataParsers.LiteralValue, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionLiteral, "value">> = never>(value: GenericValue | GenericValue[], definition?: GenericDefinition): DataParserLiteralExtended<MergeDefinition<dataParsers.DataParserDefinitionLiteral, NeverCoalescing<GenericDefinition, {}> & {
+    value: GenericValue[];
+}>>;
+export {};

package/dist/dataParser/extended/literal.mjs

@@ -0,0 +1,9 @@
+import { dataParserExtendedInit } from '../baseExtended.mjs';
+import { literal as literal$1 } from '../parsers/literal.mjs';
+import '../../pattern/result.mjs';
+
+function literal(value, definition) {
+    return dataParserExtendedInit(literal$1(value, definition), {});
+}
+
+export { literal };

package/dist/dataParser/extended/nil.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var baseExtended = require('../baseExtended.cjs');
+var nil$1 = require('../parsers/nil.cjs');
+require('../../pattern/result.cjs');
+
+function nil(definition) {
+    return baseExtended.dataParserExtendedInit(nil$1.nil(definition), {});
+}
+
+exports.nil = nil;

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

@@ -0,0 +1,9 @@
+import { type NeverCoalescing } from "../../common";
+import { type DataParserExtended } from "../baseExtended";
+import { type MergeDefinition } from "../types";
+import * as dataParsers from "../parsers";
+type _DataParserNilExtended<GenericDefinition extends dataParsers.DataParserDefinitionNil> = (dataParsers.DataParserNil<GenericDefinition> & DataParserExtended);
+export interface DataParserNilExtended<GenericDefinition extends dataParsers.DataParserDefinitionNil = dataParsers.DataParserDefinitionNil> extends _DataParserNilExtended<GenericDefinition> {
+}
+export declare function nil<const GenericDefinition extends Partial<dataParsers.DataParserDefinitionNil> = never>(definition?: GenericDefinition): DataParserNilExtended<MergeDefinition<dataParsers.DataParserDefinitionNil, NeverCoalescing<GenericDefinition, {}>>>;
+export {};

package/dist/dataParser/extended/nil.mjs

@@ -0,0 +1,9 @@
+import { dataParserExtendedInit } from '../baseExtended.mjs';
+import { nil as nil$1 } from '../parsers/nil.mjs';
+import '../../pattern/result.mjs';
+
+function nil(definition) {
+    return dataParserExtendedInit(nil$1(definition), {});
+}
+
+export { nil };

package/dist/dataParser/extended/nullable.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var baseExtended = require('../baseExtended.cjs');
+require('../../pattern/result.cjs');
+var nullable$1 = require('../parsers/nullable.cjs');
+
+function nullable(inner, definition) {
+    return baseExtended.dataParserExtendedInit(nullable$1.nullable(inner, definition), {});
+}
+
+exports.nullable = nullable;

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

@@ -0,0 +1,11 @@
+import { type NeverCoalescing } from "../../common";
+import { type DataParserExtended } from "../baseExtended";
+import { type DataParsers, type MergeDefinition } from "../types";
+import * as dataParsers from "../parsers";
+type _DataParserNullableExtended<GenericDefinition extends dataParsers.DataParserDefinitionNullable> = (dataParsers.DataParserNullable<GenericDefinition> & DataParserExtended);
+export interface DataParserNullableExtended<GenericDefinition extends dataParsers.DataParserDefinitionNullable = dataParsers.DataParserDefinitionNullable> extends _DataParserNullableExtended<GenericDefinition> {
+}
+export declare function nullable<GenericDataParser extends DataParsers, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionNullable, "inner">> = never>(inner: GenericDataParser, definition?: GenericDefinition): DataParserNullableExtended<MergeDefinition<dataParsers.DataParserDefinitionNullable, NeverCoalescing<GenericDefinition, {}> & {
+    inner: GenericDataParser;
+}>>;
+export {};

package/dist/dataParser/extended/nullable.mjs

@@ -0,0 +1,9 @@
+import { dataParserExtendedInit } from '../baseExtended.mjs';
+import '../../pattern/result.mjs';
+import { nullable as nullable$1 } from '../parsers/nullable.mjs';
+
+function nullable(inner, definition) {
+    return dataParserExtendedInit(nullable$1(inner, definition), {});
+}
+
+export { nullable };

package/dist/dataParser/extended/number.cjs

@@ -0,0 +1,27 @@
+'use strict';
+
+var baseExtended = require('../baseExtended.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');
+
+function number(definition) {
+    return baseExtended.dataParserExtendedInit(index.number(definition), {
+        min(self, min$1, definition) {
+            return self.addChecker(min.checkerNumberMin(min$1, definition));
+        },
+        max(self, max$1, definition) {
+            return self.addChecker(max.checkerNumberMax(max$1, definition));
+        },
+    });
+}
+function int(definition) {
+    return number({
+        checkers: [int$1.checkerInt(definition)],
+    });
+}
+
+exports.int = int;
+exports.number = number;

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

@@ -0,0 +1,24 @@
+import { type NeverCoalescing } from "../../common";
+import { type DataParserExtended } from "../baseExtended";
+import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
+import * as dataParsers from "../parsers";
+type _DataParserNumberExtended<GenericDefinition extends dataParsers.DataParserDefinitionNumber> = (dataParsers.DataParserNumber<GenericDefinition> & DataParserExtended);
+export interface DataParserNumberExtended<GenericDefinition extends dataParsers.DataParserDefinitionNumber = dataParsers.DataParserDefinitionNumber> extends _DataParserNumberExtended<GenericDefinition> {
+    addChecker<GenericChecker extends readonly [
+        dataParsers.DataParserNumberCheckers,
+        ...dataParsers.DataParserNumberCheckers[]
+    ]>(...args: GenericChecker): DataParserNumberExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    min(min: number, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionNumberMin, "min">>): DataParserNumberExtended<AddCheckersToDefinition<GenericDefinition, [
+        dataParsers.DataParserCheckerNumberMin
+    ]>>;
+    max(max: number, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionNumberMax, "max">>): DataParserNumberExtended<AddCheckersToDefinition<GenericDefinition, [
+        dataParsers.DataParserCheckerNumberMax
+    ]>>;
+}
+export declare function number<const GenericDefinition extends Partial<dataParsers.DataParserDefinitionNumber> = never>(definition?: GenericDefinition): DataParserNumberExtended<MergeDefinition<dataParsers.DataParserDefinitionNumber, NeverCoalescing<GenericDefinition, {}>>>;
+export declare function int(definition?: Partial<dataParsers.DataParserCheckerDefinitionInt>): DataParserNumberExtended<{
+    readonly checkers: readonly [dataParsers.DataParserCheckerInt];
+    readonly errorMessage?: string | undefined;
+    readonly coerce: boolean;
+}>;
+export {};

package/dist/dataParser/extended/number.mjs

@@ -0,0 +1,24 @@
+import { dataParserExtendedInit } from '../baseExtended.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';
+
+function number(definition) {
+    return dataParserExtendedInit(number$1(definition), {
+        min(self, min, definition) {
+            return self.addChecker(checkerNumberMin(min, definition));
+        },
+        max(self, max, definition) {
+            return self.addChecker(checkerNumberMax(max, definition));
+        },
+    });
+}
+function int(definition) {
+    return number({
+        checkers: [checkerInt(definition)],
+    });
+}
+
+export { int, number };

package/dist/dataParser/extended/object.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var baseExtended = require('../baseExtended.cjs');
+var object$1 = require('../parsers/object.cjs');
+require('../../pattern/result.cjs');
+
+function object(shape, definition) {
+    return baseExtended.dataParserExtendedInit(object$1.object(shape, definition), {});
+}
+
+exports.object = object;

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

@@ -0,0 +1,11 @@
+import { type NeverCoalescing } from "../../common";
+import { type DataParserExtended } from "../baseExtended";
+import { type MergeDefinition } from "../types";
+import * as dataParsers from "../parsers";
+type _DataParserObjectExtended<GenericDefinition extends dataParsers.DataParserDefinitionObject> = (dataParsers.DataParserObject<GenericDefinition> & DataParserExtended);
+export interface DataParserObjectExtended<GenericDefinition extends dataParsers.DataParserDefinitionObject = dataParsers.DataParserDefinitionObject> extends _DataParserObjectExtended<GenericDefinition> {
+}
+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 {};

package/dist/dataParser/extended/object.mjs

@@ -0,0 +1,9 @@
+import { dataParserExtendedInit } from '../baseExtended.mjs';
+import { object as object$1 } from '../parsers/object.mjs';
+import '../../pattern/result.mjs';
+
+function object(shape, definition) {
+    return dataParserExtendedInit(object$1(shape, definition), {});
+}
+
+export { object };

package/dist/dataParser/extended/optional.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var baseExtended = require('../baseExtended.cjs');
+require('../../pattern/result.cjs');
+var optional$1 = require('../parsers/optional.cjs');
+
+function optional(inner, definition) {
+    return baseExtended.dataParserExtendedInit(optional$1.optional(inner, definition), {});
+}
+
+exports.optional = optional;

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

@@ -0,0 +1,11 @@
+import { type NeverCoalescing } from "../../common";
+import { type DataParserExtended } from "../baseExtended";
+import { type DataParsers, type MergeDefinition } from "../types";
+import * as dataParsers from "../parsers";
+type _DataParserOptionalExtended<GenericDefinition extends dataParsers.DataParserDefinitionOptional> = (dataParsers.DataParserOptional<GenericDefinition> & DataParserExtended);
+export interface DataParserOptionalExtended<GenericDefinition extends dataParsers.DataParserDefinitionOptional = dataParsers.DataParserDefinitionOptional> extends _DataParserOptionalExtended<GenericDefinition> {
+}
+export declare function optional<GenericDataParser extends DataParsers, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionOptional, "inner">> = never>(inner: GenericDataParser, definition?: GenericDefinition): DataParserOptionalExtended<MergeDefinition<dataParsers.DataParserDefinitionOptional, NeverCoalescing<GenericDefinition, {}> & {
+    inner: GenericDataParser;
+}>>;
+export {};

package/dist/dataParser/extended/optional.mjs

@@ -0,0 +1,9 @@
+import { dataParserExtendedInit } from '../baseExtended.mjs';
+import '../../pattern/result.mjs';
+import { optional as optional$1 } from '../parsers/optional.mjs';
+
+function optional(inner, definition) {
+    return dataParserExtendedInit(optional$1(inner, definition), {});
+}
+
+export { optional };

package/dist/dataParser/extended/pipe.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var baseExtended = require('../baseExtended.cjs');
+require('../../pattern/result.cjs');
+var pipe$1 = require('../parsers/pipe.cjs');
+
+function pipe(input, output, definition) {
+    return baseExtended.dataParserExtendedInit(pipe$1.pipe(input, output, definition), {});
+}
+
+exports.pipe = pipe;

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

@@ -0,0 +1,12 @@
+import { type NeverCoalescing } from "../../common";
+import { type DataParserExtended } from "../baseExtended";
+import { type DataParsers, type MergeDefinition } from "../types";
+import * as dataParsers from "../parsers";
+type _DataParserPipeExtended<GenericDefinition extends dataParsers.DataParserDefinitionPipe> = (dataParsers.DataParserPipe<GenericDefinition> & DataParserExtended);
+export interface DataParserPipeExtended<GenericDefinition extends dataParsers.DataParserDefinitionPipe = dataParsers.DataParserDefinitionPipe> extends _DataParserPipeExtended<GenericDefinition> {
+}
+export declare function pipe<GenericInput extends DataParsers, GenericOutput extends DataParsers, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionPipe, "input" | "output">> = never>(input: GenericInput, output: GenericOutput, definition?: GenericDefinition): DataParserPipeExtended<MergeDefinition<dataParsers.DataParserDefinitionPipe, NeverCoalescing<GenericDefinition, {}> & {
+    input: GenericInput;
+    output: GenericOutput;
+}>>;
+export {};

package/dist/dataParser/extended/pipe.mjs

@@ -0,0 +1,9 @@
+import { dataParserExtendedInit } from '../baseExtended.mjs';
+import '../../pattern/result.mjs';
+import { pipe as pipe$1 } from '../parsers/pipe.mjs';
+
+function pipe(input, output, definition) {
+    return dataParserExtendedInit(pipe$1(input, output, definition), {});
+}
+
+export { pipe };

package/dist/dataParser/extended/record.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var baseExtended = require('../baseExtended.cjs');
+require('../../pattern/result.cjs');
+var record$1 = require('../parsers/record.cjs');
+
+function record(key, value, definition) {
+    return baseExtended.dataParserExtendedInit(record$1.record(key, value, definition), {});
+}
+
+exports.record = record;