@duplojs/utils 1.0.6 → 1.1.7

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;

package/dist/dataParser/extended/record.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 _DataParserRecordExtended<GenericDefinition extends dataParsers.DataParserDefinitionRecord> = (dataParsers.DataParserRecord<GenericDefinition> & DataParserExtended);
+export interface DataParserRecordExtended<GenericDefinition extends dataParsers.DataParserDefinitionRecord = dataParsers.DataParserDefinitionRecord> extends _DataParserRecordExtended<GenericDefinition> {
+}
+export declare function record<GenericDataParserKey extends dataParsers.DataParserRecordKey, GenericDataParserValue extends DataParsers, const GenericDefinition extends Partial<dataParsers.DataParserDefinitionRecord> = never>(key: GenericDataParserKey, value: GenericDataParserValue, definition?: GenericDefinition): DataParserRecordExtended<MergeDefinition<dataParsers.DataParserDefinitionRecord, NeverCoalescing<GenericDefinition, {}> & {
+    key: GenericDataParserKey;
+    value: GenericDataParserValue;
+}>>;
+export {};

package/dist/dataParser/extended/record.mjs

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

package/dist/dataParser/extended/string.cjs

@@ -0,0 +1,38 @@
+'use strict';
+
+var baseExtended = require('../baseExtended.cjs');
+var index = require('../parsers/string/index.cjs');
+require('../../pattern/result.cjs');
+var email$1 = require('../parsers/string/checkers/email.cjs');
+var url$1 = require('../parsers/string/checkers/url.cjs');
+var regex = require('../parsers/string/checkers/regex.cjs');
+var max = require('../parsers/string/checkers/max.cjs');
+var min = require('../parsers/string/checkers/min.cjs');
+
+function string(definition) {
+    return baseExtended.dataParserExtendedInit(index.string(definition), {
+        min(self, min$1, definition) {
+            return self.addChecker(min.checkerStringMin(min$1, definition));
+        },
+        max(self, max$1, definition) {
+            return self.addChecker(max.checkerStringMax(max$1, definition));
+        },
+        regex(self, regex$1, definition) {
+            return self.addChecker(regex.checkerStringRegex(regex$1, definition));
+        },
+    });
+}
+function email(definition) {
+    return string({
+        checkers: [email$1.checkerEmail(definition)],
+    });
+}
+function url(definition) {
+    return string({
+        checkers: [url$1.checkerUrl(definition)],
+    });
+}
+
+exports.email = email;
+exports.string = string;
+exports.url = url;

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

@@ -0,0 +1,32 @@
+import { type NeverCoalescing } from "../../common";
+import { type DataParserExtended } from "../baseExtended";
+import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
+import * as dataParsers from "../parsers";
+type _DataParserStringExtended<GenericDefinition extends dataParsers.DataParserDefinitionString> = (dataParsers.DataParserString<GenericDefinition> & DataParserExtended);
+export interface DataParserStringExtended<GenericDefinition extends dataParsers.DataParserDefinitionString = dataParsers.DataParserDefinitionString> extends _DataParserStringExtended<GenericDefinition> {
+    addChecker<GenericChecker extends readonly [
+        dataParsers.DataParserStringCheckers,
+        ...dataParsers.DataParserStringCheckers[]
+    ]>(...args: GenericChecker): DataParserStringExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    min(min: number, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionStringMin, "min">>): DataParserStringExtended<AddCheckersToDefinition<GenericDefinition, [
+        dataParsers.DataParserCheckerStringMin
+    ]>>;
+    max(max: number, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionStringMax, "max">>): DataParserStringExtended<AddCheckersToDefinition<GenericDefinition, [
+        dataParsers.DataParserCheckerStringMax
+    ]>>;
+    regex(regex: RegExp, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionStringRegex, "regex">>): DataParserStringExtended<AddCheckersToDefinition<GenericDefinition, [
+        dataParsers.DataParserCheckerStringRegex
+    ]>>;
+}
+export declare function string<const GenericDefinition extends Partial<dataParsers.DataParserDefinitionString> = never>(definition?: GenericDefinition): DataParserStringExtended<MergeDefinition<dataParsers.DataParserDefinitionString, NeverCoalescing<GenericDefinition, {}>>>;
+export declare function email(definition?: Partial<dataParsers.DataParserCheckerDefinitionEmail>): DataParserStringExtended<{
+    readonly checkers: readonly [dataParsers.DataParserCheckerEmail];
+    readonly errorMessage?: string | undefined;
+    readonly coerce: boolean;
+}>;
+export declare function url(definition?: Partial<dataParsers.DataParserCheckerDefinitionUrl>): DataParserStringExtended<{
+    readonly checkers: readonly [dataParsers.DataParserCheckerUrl];
+    readonly errorMessage?: string | undefined;
+    readonly coerce: boolean;
+}>;
+export {};

package/dist/dataParser/extended/string.mjs

@@ -0,0 +1,34 @@
+import { dataParserExtendedInit } from '../baseExtended.mjs';
+import { string as string$1 } from '../parsers/string/index.mjs';
+import '../../pattern/result.mjs';
+import { checkerEmail } from '../parsers/string/checkers/email.mjs';
+import { checkerUrl } from '../parsers/string/checkers/url.mjs';
+import { checkerStringRegex } from '../parsers/string/checkers/regex.mjs';
+import { checkerStringMax } from '../parsers/string/checkers/max.mjs';
+import { checkerStringMin } from '../parsers/string/checkers/min.mjs';
+
+function string(definition) {
+    return dataParserExtendedInit(string$1(definition), {
+        min(self, min, definition) {
+            return self.addChecker(checkerStringMin(min, definition));
+        },
+        max(self, max, definition) {
+            return self.addChecker(checkerStringMax(max, definition));
+        },
+        regex(self, regex, definition) {
+            return self.addChecker(checkerStringRegex(regex, definition));
+        },
+    });
+}
+function email(definition) {
+    return string({
+        checkers: [checkerEmail(definition)],
+    });
+}
+function url(definition) {
+    return string({
+        checkers: [checkerUrl(definition)],
+    });
+}
+
+export { email, string, url };

package/dist/dataParser/extended/templateLiteral.cjs

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

package/dist/dataParser/extended/templateLiteral.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 _DataParserTemplateLiteralExtended<GenericDefinition extends dataParsers.DataParserDefinitionTemplateLiteral> = (dataParsers.DataParserTemplateLiteral<GenericDefinition> & DataParserExtended);
+export interface DataParserTemplateLiteralExtended<GenericDefinition extends dataParsers.DataParserDefinitionTemplateLiteral = dataParsers.DataParserDefinitionTemplateLiteral> extends _DataParserTemplateLiteralExtended<GenericDefinition> {
+}
+export declare function templateLiteral<const GenericTemplate extends dataParsers.TemplateLiteralShape, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionTemplateLiteral, "template" | "pattern">> = never>(template: GenericTemplate, definition?: GenericDefinition): DataParserTemplateLiteralExtended<MergeDefinition<dataParsers.DataParserDefinitionTemplateLiteral, NeverCoalescing<GenericDefinition, {}> & {
+    template: GenericTemplate;
+}>>;
+export {};

package/dist/dataParser/extended/templateLiteral.mjs

@@ -0,0 +1,8 @@
+import { dataParserExtendedInit } from '../baseExtended.mjs';
+import { templateLiteral as templateLiteral$1 } from '../parsers/templateLiteral.mjs';
+
+function templateLiteral(template, definition) {
+    return dataParserExtendedInit(templateLiteral$1(template, definition), {});
+}
+
+export { templateLiteral };

package/dist/dataParser/extended/transform.cjs

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

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

@@ -0,0 +1,14 @@
+import { type NeverCoalescing } from "../../common";
+import { type DataParserExtended } from "../baseExtended";
+import { type DataParsers, type MergeDefinition } from "../types";
+import * as dataParsers from "../parsers";
+import { type Output } from "../base";
+import { type DataParserError } from "../error";
+type _DataParserTransformExtended<GenericDefinition extends dataParsers.DataParserDefinitionTransform> = (dataParsers.DataParserTransform<GenericDefinition> & DataParserExtended);
+export interface DataParserTransformExtended<GenericDefinition extends dataParsers.DataParserDefinitionTransform = dataParsers.DataParserDefinitionTransform> extends _DataParserTransformExtended<GenericDefinition> {
+}
+export declare function transform<GenericDataParser extends DataParsers, GenericOutput extends unknown, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionTransform, "inner" | "theFunction">> = never>(inner: GenericDataParser, theFunction: (input: Output<GenericDataParser>, error: DataParserError) => GenericOutput, definition?: GenericDefinition): DataParserTransformExtended<MergeDefinition<dataParsers.DataParserDefinitionTransform, NeverCoalescing<GenericDefinition, {}> & {
+    inner: GenericDataParser;
+    theFunction(input: Output<GenericDataParser>): GenericOutput;
+}>>;
+export {};

package/dist/dataParser/extended/transform.mjs

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

package/dist/dataParser/extended/tuple.cjs

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

package/dist/dataParser/extended/tuple.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 _DataParserTupleExtended<GenericDefinition extends dataParsers.DataParserDefinitionTuple> = (dataParsers.DataParserTuple<GenericDefinition> & DataParserExtended);
+export interface DataParserTupleExtended<GenericDefinition extends dataParsers.DataParserDefinitionTuple = dataParsers.DataParserDefinitionTuple> extends _DataParserTupleExtended<GenericDefinition> {
+}
+export declare function tuple<GenericShape extends dataParsers.TupleShape, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionTuple, "shape">> = never>(shape: GenericShape, definition?: GenericDefinition): DataParserTupleExtended<MergeDefinition<dataParsers.DataParserDefinitionTuple, NeverCoalescing<GenericDefinition, {}> & {
+    shape: GenericShape;
+}>>;
+export {};

package/dist/dataParser/extended/tuple.mjs

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

package/dist/dataParser/extended/union.cjs

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

package/dist/dataParser/extended/union.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 _DataParserUnionExtended<GenericDefinition extends dataParsers.DataParserDefinitionUnion> = (dataParsers.DataParserUnion<GenericDefinition> & DataParserExtended);
+export interface DataParserUnionExtended<GenericDefinition extends dataParsers.DataParserDefinitionUnion = dataParsers.DataParserDefinitionUnion> extends _DataParserUnionExtended<GenericDefinition> {
+}
+export declare function union<GenericOptions extends dataParsers.UnionOptions, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionUnion, "options">> = never>(options: GenericOptions, definition?: GenericDefinition): DataParserUnionExtended<MergeDefinition<dataParsers.DataParserDefinitionUnion, NeverCoalescing<GenericDefinition, {}> & {
+    options: GenericOptions;
+}>>;
+export {};

package/dist/dataParser/extended/union.mjs

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

package/dist/dataParser/extended/unknown.cjs

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

package/dist/dataParser/extended/unknown.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 _DataParserUnknownExtended<GenericDefinition extends dataParsers.DataParserDefinitionUnknown> = (dataParsers.DataParserUnknown<GenericDefinition> & DataParserExtended);
+export interface DataParserUnknownExtended<GenericDefinition extends dataParsers.DataParserDefinitionUnknown = dataParsers.DataParserDefinitionUnknown> extends _DataParserUnknownExtended<GenericDefinition> {
+}
+export declare function unknown<const GenericDefinition extends Partial<dataParsers.DataParserDefinitionUnknown> = never>(definition?: GenericDefinition): DataParserUnknownExtended<MergeDefinition<dataParsers.DataParserDefinitionUnknown, NeverCoalescing<GenericDefinition, {}>>>;
+export {};

package/dist/dataParser/extended/unknown.mjs

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

package/dist/dataParser/index.cjs

@@ -0,0 +1,128 @@
+'use strict';
+
+var base = require('./base.cjs');
+var baseExtended = require('./baseExtended.cjs');
+var error = require('./error.cjs');
+var index$1 = require('./parsers/coerce/index.cjs');
+var index$2 = require('./parsers/string/index.cjs');
+var object = require('./parsers/object.cjs');
+var index$3 = require('./parsers/number/index.cjs');
+var literal = require('./parsers/literal.cjs');
+var union = require('./parsers/union.cjs');
+var index$4 = require('./parsers/array/index.cjs');
+var index$5 = require('./parsers/bigint/index.cjs');
+var tuple = require('./parsers/tuple.cjs');
+var transform = require('./parsers/transform.cjs');
+var nil = require('./parsers/nil.cjs');
+var boolean = require('./parsers/boolean.cjs');
+var empty = require('./parsers/empty.cjs');
+var templateLiteral = require('./parsers/templateLiteral.cjs');
+var pipe = require('./parsers/pipe.cjs');
+var optional = require('./parsers/optional.cjs');
+var nullable = require('./parsers/nullable.cjs');
+var lazy = require('./parsers/lazy.cjs');
+var unknown = require('./parsers/unknown.cjs');
+var record = require('./parsers/record.cjs');
+var index = require('./extended/index.cjs');
+var url = require('./parsers/string/checkers/url.cjs');
+var email = require('./parsers/string/checkers/email.cjs');
+var max = require('./parsers/string/checkers/max.cjs');
+var min = require('./parsers/string/checkers/min.cjs');
+var regex = require('./parsers/string/checkers/regex.cjs');
+var int = require('./parsers/number/checkers/int.cjs');
+var min$1 = require('./parsers/number/checkers/min.cjs');
+var max$1 = require('./parsers/number/checkers/max.cjs');
+var min$2 = require('./parsers/array/checkers/min.cjs');
+var max$2 = require('./parsers/array/checkers/max.cjs');
+var min$3 = require('./parsers/bigint/checkers/min.cjs');
+var max$3 = require('./parsers/bigint/checkers/max.cjs');
+
+
+
+exports.SymbolDataParserError = base.SymbolDataParserError;
+exports.SymbolDataParserErrorLabel = base.SymbolDataParserErrorLabel;
+exports.dataParserCheckerInit = base.dataParserCheckerInit;
+exports.dataParserCheckerKind = base.dataParserCheckerKind;
+exports.dataParserInit = base.dataParserInit;
+exports.dataParserKind = base.dataParserKind;
+exports.dataParserExtendedInit = baseExtended.dataParserExtendedInit;
+exports.dataParserExtendedKind = baseExtended.dataParserExtendedKind;
+exports.SymbolDataParserErrorIssue = error.SymbolDataParserErrorIssue;
+exports.SymbolDataParserErrorIssueLabel = error.SymbolDataParserErrorIssueLabel;
+exports.SymbolDataParserErrorPromiseIssue = error.SymbolDataParserErrorPromiseIssue;
+exports.SymbolDataParserErrorPromiseIssueLabel = error.SymbolDataParserErrorPromiseIssueLabel;
+exports.addIssue = error.addIssue;
+exports.addPromiseIssue = error.addPromiseIssue;
+exports.createError = error.createError;
+exports.dataParserErrorIssueKind = error.dataParserErrorIssueKind;
+exports.dataParserErrorKind = error.dataParserErrorKind;
+exports.dataParserErrorPromiseIssueKind = error.dataParserErrorPromiseIssueKind;
+exports.popErrorPath = error.popErrorPath;
+exports.setErrorPath = error.setErrorPath;
+exports.coerce = index$1;
+exports.dataParserStringKind = index$2.dataParserStringKind;
+exports.string = index$2.string;
+exports.dataParserObjectKind = object.dataParserObjectKind;
+exports.object = object.object;
+exports.dataParserNumberKind = index$3.dataParserNumberKind;
+exports.number = index$3.number;
+exports.dataParserLiteralKind = literal.dataParserLiteralKind;
+exports.literal = literal.literal;
+exports.dataParserUnionKind = union.dataParserUnionKind;
+exports.union = union.union;
+exports.array = index$4.array;
+exports.dataParserArrayKind = index$4.dataParserArrayKind;
+exports.bigint = index$5.bigint;
+exports.dataParserBigIntKind = index$5.dataParserBigIntKind;
+exports.dataParserTupleKind = tuple.dataParserTupleKind;
+exports.tuple = tuple.tuple;
+exports.dataParserTransformKind = transform.dataParserTransformKind;
+exports.transform = transform.transform;
+exports.dataParserNilKind = nil.dataParserNilKind;
+exports.nil = nil.nil;
+exports.boolean = boolean.boolean;
+exports.dataParserBooleanKind = boolean.dataParserBooleanKind;
+exports.dataParserEmptyKind = empty.dataParserEmptyKind;
+exports.empty = empty.empty;
+exports.dataParserTemplateLiteralKind = templateLiteral.dataParserTemplateLiteralKind;
+exports.templateLiteral = templateLiteral.templateLiteral;
+exports.dataParserPipeKind = pipe.dataParserPipeKind;
+exports.pipe = pipe.pipe;
+exports.dataParserOptionalKind = optional.dataParserOptionalKind;
+exports.optional = optional.optional;
+exports.dataParserNullableKind = nullable.dataParserNullableKind;
+exports.nullable = nullable.nullable;
+exports.dataParserLazyKind = lazy.dataParserLazyKind;
+exports.lazy = lazy.lazy;
+exports.dataParserUnknownKind = unknown.dataParserUnknownKind;
+exports.unknown = unknown.unknown;
+exports.dataParserRecordKind = record.dataParserRecordKind;
+exports.record = record.record;
+exports.extended = index;
+exports.checkerUrl = url.checkerUrl;
+exports.dataParserCheckerUrlKind = url.dataParserCheckerUrlKind;
+exports.url = url.url;
+exports.checkerEmail = email.checkerEmail;
+exports.dataParserCheckerEmailKind = email.dataParserCheckerEmailKind;
+exports.email = email.email;
+exports.checkerStringMax = max.checkerStringMax;
+exports.dataParserCheckerStringMaxKind = max.dataParserCheckerStringMaxKind;
+exports.checkerStringMin = min.checkerStringMin;
+exports.dataParserCheckerStringMinKind = min.dataParserCheckerStringMinKind;
+exports.checkerStringRegex = regex.checkerStringRegex;
+exports.dataParserCheckerStringRegexKind = regex.dataParserCheckerStringRegexKind;
+exports.checkerInt = int.checkerInt;
+exports.dataParserCheckerIntKind = int.dataParserCheckerIntKind;
+exports.int = int.int;
+exports.checkerNumberMin = min$1.checkerNumberMin;
+exports.dataParserCheckerNumberMinKind = min$1.dataParserCheckerNumberMinKind;
+exports.checkerNumberMax = max$1.checkerNumberMax;
+exports.dataParserCheckerNumberMaxKind = max$1.dataParserCheckerNumberMaxKind;
+exports.checkerArrayMin = min$2.checkerArrayMin;
+exports.dataParserCheckerArrayMinKind = min$2.dataParserCheckerArrayMinKind;
+exports.checkerArrayMax = max$2.checkerArrayMax;
+exports.dataParserCheckerArrayMaxKind = max$2.dataParserCheckerArrayMaxKind;
+exports.checkerBigIntMin = min$3.checkerBigIntMin;
+exports.dataParserCheckerBigIntMinKind = min$3.dataParserCheckerBigIntMinKind;
+exports.checkerBigIntMax = max$3.checkerBigIntMax;
+exports.dataParserCheckerBigIntMaxKind = max$3.dataParserCheckerBigIntMaxKind;

package/dist/dataParser/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./base";
+export * from "./baseExtended";
+export * from "./error";
+export * from "./types";
+export * from "./parsers";
+export * as extended from "./extended";