@duplojs/utils 1.0.7 → 1.1.8

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

package/dist/dataParser/index.mjs

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

package/dist/dataParser/kind.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+var kind = require('../common/kind.cjs');
+
+const createDataParserKind = kind.createKindNamespace("DataParser");
+
+exports.createDataParserKind = createDataParserKind;

package/dist/dataParser/kind.d.ts

@@ -0,0 +1 @@
+export declare const createDataParserKind: <GenericName extends string, GenericKindValue extends unknown = unknown>(name: GenericName & import("../string").ForbiddenCharacters<GenericName, "@" | "/">) => import("../common").KindHandler<import("../common").KindDefinition<`@DataParser/${GenericName}`, GenericKindValue>>;

package/dist/dataParser/kind.mjs

@@ -0,0 +1,5 @@
+import { createKindNamespace } from '../common/kind.mjs';
+
+const createDataParserKind = createKindNamespace("DataParser");
+
+export { createDataParserKind };

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

@@ -0,0 +1,2 @@
+export * from "./min";
+export * from "./max";

package/dist/dataParser/parsers/array/checkers/max.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+var base = require('../../../base.cjs');
+var error = require('../../../error.cjs');
+var kind = require('../../../kind.cjs');
+
+const dataParserCheckerArrayMaxKind = kind.createDataParserKind("checker-array-max");
+function checkerArrayMax(max, definition = {}) {
+    return base.dataParserCheckerInit(dataParserCheckerArrayMaxKind, {
+        definition: {
+            ...definition,
+            max,
+        },
+    }, (data, self) => {
+        if (data.length > self.definition.max) {
+            return error.SymbolDataParserErrorIssue;
+        }
+        return data;
+    });
+}
+
+exports.checkerArrayMax = checkerArrayMax;
+exports.dataParserCheckerArrayMaxKind = dataParserCheckerArrayMaxKind;

package/dist/dataParser/parsers/array/checkers/max.d.ts

@@ -0,0 +1,11 @@
+import { type Kind } from "../../../../common";
+import { type DataParserCheckerDefinition, type DataParserChecker } from "../../../../dataParser/base";
+export interface DataParserCheckerDefinitionArrayMax extends DataParserCheckerDefinition {
+    max: number;
+}
+export declare const dataParserCheckerArrayMaxKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DataParser/checker-array-max", unknown>>;
+type _DataParserCheckerArrayMax = (Kind<typeof dataParserCheckerArrayMaxKind.definition> & DataParserChecker<DataParserCheckerDefinitionArrayMax, unknown[]>);
+export interface DataParserCheckerArrayMax extends _DataParserCheckerArrayMax {
+}
+export declare function checkerArrayMax(max: number, definition?: Partial<Omit<DataParserCheckerDefinitionArrayMax, "max">>): DataParserCheckerArrayMax;
+export {};

package/dist/dataParser/parsers/array/checkers/max.mjs

@@ -0,0 +1,20 @@
+import { dataParserCheckerInit } from '../../../base.mjs';
+import { SymbolDataParserErrorIssue } from '../../../error.mjs';
+import { createDataParserKind } from '../../../kind.mjs';
+
+const dataParserCheckerArrayMaxKind = createDataParserKind("checker-array-max");
+function checkerArrayMax(max, definition = {}) {
+    return dataParserCheckerInit(dataParserCheckerArrayMaxKind, {
+        definition: {
+            ...definition,
+            max,
+        },
+    }, (data, self) => {
+        if (data.length > self.definition.max) {
+            return SymbolDataParserErrorIssue;
+        }
+        return data;
+    });
+}
+
+export { checkerArrayMax, dataParserCheckerArrayMaxKind };

package/dist/dataParser/parsers/array/checkers/min.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+var base = require('../../../base.cjs');
+var error = require('../../../error.cjs');
+var kind = require('../../../kind.cjs');
+
+const dataParserCheckerArrayMinKind = kind.createDataParserKind("checker-array-min");
+function checkerArrayMin(min, definition = {}) {
+    return base.dataParserCheckerInit(dataParserCheckerArrayMinKind, {
+        definition: {
+            ...definition,
+            min,
+        },
+    }, (data, self) => {
+        if (data.length < self.definition.min) {
+            return error.SymbolDataParserErrorIssue;
+        }
+        return data;
+    });
+}
+
+exports.checkerArrayMin = checkerArrayMin;
+exports.dataParserCheckerArrayMinKind = dataParserCheckerArrayMinKind;

package/dist/dataParser/parsers/array/checkers/min.d.ts

@@ -0,0 +1,11 @@
+import { type Kind } from "../../../../common";
+import { type DataParserCheckerDefinition, type DataParserChecker } from "../../../../dataParser/base";
+export interface DataParserCheckerDefinitionArrayMin extends DataParserCheckerDefinition {
+    min: number;
+}
+export declare const dataParserCheckerArrayMinKind: import("../../../../common").KindHandler<import("../../../../common").KindDefinition<"@DataParser/checker-array-min", unknown>>;
+type _DataParserCheckerArrayMin = (Kind<typeof dataParserCheckerArrayMinKind.definition> & DataParserChecker<DataParserCheckerDefinitionArrayMin, unknown[]>);
+export interface DataParserCheckerArrayMin extends _DataParserCheckerArrayMin {
+}
+export declare function checkerArrayMin(min: number, definition?: Partial<Omit<DataParserCheckerDefinitionArrayMin, "min">>): DataParserCheckerArrayMin;
+export {};

package/dist/dataParser/parsers/array/checkers/min.mjs

@@ -0,0 +1,20 @@
+import { dataParserCheckerInit } from '../../../base.mjs';
+import { SymbolDataParserErrorIssue } from '../../../error.mjs';
+import { createDataParserKind } from '../../../kind.mjs';
+
+const dataParserCheckerArrayMinKind = createDataParserKind("checker-array-min");
+function checkerArrayMin(min, definition = {}) {
+    return dataParserCheckerInit(dataParserCheckerArrayMinKind, {
+        definition: {
+            ...definition,
+            min,
+        },
+    }, (data, self) => {
+        if (data.length < self.definition.min) {
+            return SymbolDataParserErrorIssue;
+        }
+        return data;
+    });
+}
+
+export { checkerArrayMin, dataParserCheckerArrayMinKind };