@duplojs/utils 1.1.12 → 1.1.14

package/dist/array/flat.cjs

@@ -1,18 +1,6 @@
 'use strict';
 
-function flat(...args) {
-    if (args.length === 0) {
-        return (array) => flat(array);
-    }
-    if (args.length === 1) {
-        const [depthOrArray] = args;
-        if (Array.isArray(depthOrArray)) {
-            return depthOrArray.flat(1);
-        }
-        const depth = depthOrArray;
-        return (array) => flat(array, depth);
-    }
-    const [array, depth] = args;
+function flat(array, depth) {
     return array.flat(depth);
 }
 

package/dist/array/flat.d.ts

@@ -1,4 +1 @@
-export declare function flat(): <const GenericArray extends readonly unknown[]>(array: GenericArray) => FlatArray<GenericArray, 1>[];
-export declare function flat<const Depth extends number>(depth: Depth): <const GenericArray extends readonly unknown[]>(array: GenericArray) => FlatArray<GenericArray, Depth>[];
-export declare function flat<const GenericArray extends readonly unknown[], const Depth extends number>(array: GenericArray, depth: Depth): FlatArray<GenericArray, Depth>[];
-export declare function flat<const GenericArray extends readonly unknown[]>(array: GenericArray): FlatArray<GenericArray, 1>[];
+export declare function flat<const GenericArray extends readonly unknown[], const Depth extends number = 1>(array: GenericArray, depth?: Depth): FlatArray<GenericArray, Depth>[];

package/dist/array/flat.mjs

@@ -1,16 +1,4 @@
-function flat(...args) {
-    if (args.length === 0) {
-        return (array) => flat(array);
-    }
-    if (args.length === 1) {
-        const [depthOrArray] = args;
-        if (Array.isArray(depthOrArray)) {
-            return depthOrArray.flat(1);
-        }
-        const depth = depthOrArray;
-        return (array) => flat(array, depth);
-    }
-    const [array, depth] = args;
+function flat(array, depth) {
     return array.flat(depth);
 }
 

package/dist/array/index.cjs

@@ -51,6 +51,7 @@ var sum = require('./sum.cjs');
 var length = require('./length.cjs');
 var coalescing = require('./coalescing.cjs');
 var toTuple = require('./toTuple.cjs');
+var notIncludes = require('./notIncludes.cjs');
 
 
 
@@ -107,3 +108,4 @@ exports.sum = sum.sum;
 exports.length = length.length;
 exports.coalescing = coalescing.coalescing;
 exports.toTuple = toTuple.toTuple;
+exports.notIncludes = notIncludes.notIncludes;

package/dist/array/index.d.ts

@@ -41,3 +41,4 @@ export * from "./sum";
 export * from "./length";
 export * from "./coalescing";
 export * from "./toTuple";
+export * from "./notIncludes";

package/dist/array/index.mjs

@@ -49,3 +49,4 @@ export { sum } from './sum.mjs';
 export { length } from './length.mjs';
 export { coalescing } from './coalescing.mjs';
 export { toTuple } from './toTuple.mjs';
+export { notIncludes } from './notIncludes.mjs';

package/dist/array/notIncludes.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+function notIncludes(...args) {
+    if (args.length === 1) {
+        const [value] = args;
+        return (array) => notIncludes(array, value);
+    }
+    const [array, value] = args;
+    return !array.includes(value);
+}
+
+exports.notIncludes = notIncludes;

package/dist/array/notIncludes.d.ts

@@ -0,0 +1,4 @@
+import { type RemoveFromUnion } from "../common";
+export type NotIncludeValue = string | null | undefined | boolean | number | bigint | symbol;
+export declare function notIncludes<GenericArrayValue extends unknown, const GenericNotIncludeValue extends RemoveFromUnion<Extract<GenericArrayValue, NotIncludeValue>, Exclude<NotIncludeValue, null | undefined>>>(value: GenericNotIncludeValue): (input: readonly GenericArrayValue[]) => input is Exclude<GenericArrayValue, GenericNotIncludeValue>[];
+export declare function notIncludes<GenericArrayValue extends unknown, const GenericNotIncludeValue extends RemoveFromUnion<Extract<GenericArrayValue, NotIncludeValue>, Exclude<NotIncludeValue, null | undefined>>>(input: readonly GenericArrayValue[], value: GenericNotIncludeValue): input is Exclude<GenericArrayValue, GenericNotIncludeValue>[];

package/dist/array/notIncludes.mjs

@@ -0,0 +1,10 @@
+function notIncludes(...args) {
+    if (args.length === 1) {
+        const [value] = args;
+        return (array) => notIncludes(array, value);
+    }
+    const [array, value] = args;
+    return !array.includes(value);
+}
+
+export { notIncludes };

package/dist/array/reduce.d.ts

@@ -1,21 +1,20 @@
 import { type Kind } from "../common/kind";
 import { type WrappedValue } from "../common/wrapValue";
 import { type Unwrap } from "../common/unwrap";
-import { type ToLargeEnsemble } from "../common";
-interface ArrayReduceNext<GenericOutput extends unknown> {
+import { type IsEqual, type ToLargeEnsemble } from "../common";
+export interface ArrayReduceNext<GenericOutput extends unknown = unknown> {
     "-next": GenericOutput;
 }
-interface ArrayReduceExit<GenericOutput extends unknown> {
+export interface ArrayReduceExit<GenericOutput extends unknown = unknown> {
     "-exit": GenericOutput;
 }
-export type ArrayReduceExitOrNext<GenericOutput extends unknown = unknown> = ArrayReduceExit<GenericOutput> | ArrayReduceNext<GenericOutput>;
 export interface ArrayReduceFunctionParams<GenericElement extends unknown = unknown, GenericOutput extends unknown = unknown> {
     element: GenericElement;
     index: number;
     lastValue: GenericOutput;
     nextWithObject: GenericOutput extends object ? (object1: GenericOutput, object2: Partial<GenericOutput>) => ArrayReduceNext<GenericOutput> : undefined;
     next(output: GenericOutput): ArrayReduceNext<GenericOutput>;
-    exit(output: GenericOutput): ArrayReduceExit<GenericOutput>;
+    exit<GenericExitValue extends unknown>(output: GenericExitValue): ArrayReduceExit<GenericExitValue>;
 }
 declare const arrayReduceFromKind: import("../common").KindHandler<import("../common").KindDefinition<"array-reduce-from", unknown>>;
 export interface ArrayReduceFromResult<GenericValue extends unknown = unknown> extends Kind<typeof arrayReduceFromKind.definition>, WrappedValue<GenericValue> {
@@ -23,6 +22,6 @@ export interface ArrayReduceFromResult<GenericValue extends unknown = unknown> e
 export declare function reduceFrom<GenericValue extends unknown>(value: GenericValue): ArrayReduceFromResult<GenericValue>;
 export type ArrayEligibleReduceFromValue = number | string | bigint | boolean | ArrayReduceFromResult;
 export type ArrayReduceFromValue<GenericValue extends ArrayEligibleReduceFromValue> = GenericValue extends ArrayReduceFromResult ? Unwrap<GenericValue> : ToLargeEnsemble<GenericValue>;
-export declare function reduce<GenericElement extends unknown, GenericReduceFrom extends ArrayEligibleReduceFromValue>(startValue: GenericReduceFrom, theFunction: (params: ArrayReduceFunctionParams<GenericElement, ArrayReduceFromValue<GenericReduceFrom>>) => ArrayReduceExitOrNext<ArrayReduceFromValue<GenericReduceFrom>>): (array: readonly GenericElement[]) => ArrayReduceFromValue<GenericReduceFrom>;
-export declare function reduce<GenericElement extends unknown, GenericReduceFrom extends number | string | bigint | boolean | ArrayReduceFromResult>(array: readonly GenericElement[], startValue: GenericReduceFrom, theFunction: (params: ArrayReduceFunctionParams<GenericElement, ArrayReduceFromValue<GenericReduceFrom>>) => ArrayReduceExitOrNext<ArrayReduceFromValue<GenericReduceFrom>>): ArrayReduceFromValue<GenericReduceFrom>;
+export declare function reduce<GenericElement extends unknown, GenericReduceFrom extends ArrayEligibleReduceFromValue, GenericExit extends ArrayReduceExit = ArrayReduceExit<never>>(startValue: GenericReduceFrom, theFunction: (params: ArrayReduceFunctionParams<GenericElement, ArrayReduceFromValue<GenericReduceFrom>>) => ArrayReduceNext<ArrayReduceFromValue<GenericReduceFrom>> | GenericExit): (array: readonly GenericElement[]) => ArrayReduceFromValue<GenericReduceFrom> | (IsEqual<GenericExit, ArrayReduceExit> extends true ? never : GenericExit["-exit"]);
+export declare function reduce<GenericElement extends unknown, GenericReduceFrom extends number | string | bigint | boolean | ArrayReduceFromResult, GenericExit extends ArrayReduceExit = ArrayReduceExit<never>>(array: readonly GenericElement[], startValue: GenericReduceFrom, theFunction: (params: ArrayReduceFunctionParams<GenericElement, ArrayReduceFromValue<GenericReduceFrom>>) => ArrayReduceNext<ArrayReduceFromValue<GenericReduceFrom>> | GenericExit): ArrayReduceFromValue<GenericReduceFrom> | (IsEqual<GenericExit, ArrayReduceExit> extends true ? never : GenericExit["-exit"]);
 export {};

package/dist/array/reduceRight.d.ts

@@ -1,3 +1,4 @@
-import { type ArrayReduceFunctionParams, type ArrayReduceFromResult, type ArrayReduceExitOrNext, type ArrayReduceFromValue } from "./reduce";
-export declare function reduceRight<GenericElement extends unknown, GenericReduceFrom extends number | string | bigint | boolean | ArrayReduceFromResult>(startValue: GenericReduceFrom, theFunction: (params: ArrayReduceFunctionParams<GenericElement, ArrayReduceFromValue<GenericReduceFrom>>) => ArrayReduceExitOrNext<ArrayReduceFromValue<GenericReduceFrom>>): (array: readonly GenericElement[]) => ArrayReduceFromValue<GenericReduceFrom>;
-export declare function reduceRight<GenericElement extends unknown, GenericReduceFrom extends number | string | bigint | boolean | ArrayReduceFromResult>(array: readonly GenericElement[], startValue: GenericReduceFrom, theFunction: (params: ArrayReduceFunctionParams<GenericElement, ArrayReduceFromValue<GenericReduceFrom>>) => ArrayReduceExitOrNext<ArrayReduceFromValue<GenericReduceFrom>>): ArrayReduceFromValue<GenericReduceFrom>;
+import { type ArrayReduceFunctionParams, type ArrayReduceFromResult, type ArrayReduceFromValue, type ArrayReduceExit, type ArrayReduceNext } from "./reduce";
+import { type IsEqual } from "../common";
+export declare function reduceRight<GenericElement extends unknown, GenericReduceFrom extends number | string | bigint | boolean | ArrayReduceFromResult, GenericExit extends ArrayReduceExit = ArrayReduceExit<never>>(startValue: GenericReduceFrom, theFunction: (params: ArrayReduceFunctionParams<GenericElement, ArrayReduceFromValue<GenericReduceFrom>>) => ArrayReduceNext<ArrayReduceFromValue<GenericReduceFrom>> | GenericExit): (array: readonly GenericElement[]) => ArrayReduceFromValue<GenericReduceFrom> | (IsEqual<GenericExit, ArrayReduceExit> extends true ? never : GenericExit["-exit"]);
+export declare function reduceRight<GenericElement extends unknown, GenericReduceFrom extends number | string | bigint | boolean | ArrayReduceFromResult, GenericExit extends ArrayReduceExit = ArrayReduceExit<never>>(array: readonly GenericElement[], startValue: GenericReduceFrom, theFunction: (params: ArrayReduceFunctionParams<GenericElement, ArrayReduceFromValue<GenericReduceFrom>>) => ArrayReduceNext<ArrayReduceFromValue<GenericReduceFrom>> | GenericExit): ArrayReduceFromValue<GenericReduceFrom> | (IsEqual<GenericExit, ArrayReduceExit> extends true ? never : GenericExit["-exit"]);

package/dist/common/createKindIdentifier.cjs

@@ -0,0 +1,27 @@
+'use strict';
+
+require('./globalStore.cjs');
+require('./builder.cjs');
+var error = require('../either/left/error.cjs');
+var success = require('../either/right/success.cjs');
+var coalescing = require('../array/coalescing.cjs');
+
+function createKindIdentifier() {
+    function identifier(...args) {
+        if (args.length === 1) {
+            const [kind] = args;
+            return (input) => identifier(input, kind);
+        }
+        const [input, kind] = args;
+        const formattedKind = coalescing.coalescing(kind);
+        for (const kind of formattedKind) {
+            if (!kind.has(input)) {
+                return error.error(input);
+            }
+        }
+        return success.success(input);
+    }
+    return identifier;
+}
+
+exports.createKindIdentifier = createKindIdentifier;

package/dist/common/createKindIdentifier.d.ts

@@ -0,0 +1,7 @@
+import { type GetKindHandler, type Kind, type KindDefinition, type KindHandler } from "./kind";
+import { type UnionContain, type UnionToIntersection } from "./types";
+import * as DEither from "../either";
+export declare function createKindIdentifier<GenericParent extends Kind<KindDefinition>, GenericChildren extends GenericParent>(): {
+    <GenericKindHandler extends GenericChildren extends infer InferredChildren ? InferredChildren extends GenericParent ? GetKindHandler<InferredChildren> : never : never, GenericInput extends GenericParent, GenericResult extends Extract<GenericChildren, UnionToIntersection<GenericKindHandler extends KindHandler ? Kind<GenericKindHandler["definition"]> : never>>>(kind: GenericKindHandler | GenericKindHandler[]): (input: GenericInput) => ((GenericInput extends any ? UnionContain<GetKindHandler<GenericInput>, GenericKindHandler> extends true ? DEither.EitherSuccess<GenericInput> : DEither.EitherError<GenericInput> : never) | DEither.EitherSuccess<GenericResult>);
+    <GenericKindHandler extends GenericChildren extends infer InferredChildren ? InferredChildren extends GenericParent ? GetKindHandler<InferredChildren> : never : never, GenericInput extends GenericParent, GenericResult extends Extract<GenericChildren, UnionToIntersection<GenericKindHandler extends KindHandler ? Kind<GenericKindHandler["definition"]> : never>>>(input: GenericInput, kind: GenericKindHandler | GenericKindHandler[]): ((GenericInput extends any ? UnionContain<GetKindHandler<GenericInput>, GenericKindHandler> extends true ? DEither.EitherSuccess<GenericInput> : DEither.EitherError<GenericInput> : never) | DEither.EitherSuccess<GenericResult>);
+};

package/dist/common/createKindIdentifier.mjs

@@ -0,0 +1,25 @@
+import './globalStore.mjs';
+import './builder.mjs';
+import { error } from '../either/left/error.mjs';
+import { success } from '../either/right/success.mjs';
+import { coalescing } from '../array/coalescing.mjs';
+
+function createKindIdentifier() {
+    function identifier(...args) {
+        if (args.length === 1) {
+            const [kind] = args;
+            return (input) => identifier(input, kind);
+        }
+        const [input, kind] = args;
+        const formattedKind = coalescing(kind);
+        for (const kind of formattedKind) {
+            if (!kind.has(input)) {
+                return error(input);
+            }
+        }
+        return success(input);
+    }
+    return identifier;
+}
+
+export { createKindIdentifier };

package/dist/common/index.d.ts

@@ -38,3 +38,4 @@ export * from "./memo";
 export * from "./instanceOf";
 export * from "./globalStore";
 export * from "./builder";
+export * from "./createKindIdentifier";

package/dist/common/kind.cjs

@@ -35,22 +35,21 @@ function createKindNamespace(namespace) {
         return kindHandler;
     };
 }
-function kindHeritage(uniqueName, kind) {
+function kindHeritage(uniqueName, kind, parent) {
     const uniqueKind = createKind(uniqueName);
     const kinds = kind instanceof Array
         ? kind
         : [kind];
-    const ParentKindClass = (function ParentKindClass(params = {}) {
-        for (const kind of kinds) {
-            this[kind.runTimeKey] = params[kind.definition.name] ?? null;
-        }
-    });
-    kinds.forEach((value) => {
-        ParentKindClass.prototype[value.runTimeKey] = null;
+    const Extendable = (parent ?? class {
     });
-    ParentKindClass.prototype[uniqueKind.runTimeKey] = null;
-    Object.defineProperty(ParentKindClass, Symbol.hasInstance, {
-        value: (value) => {
+    const ParentKindClass = (class extends Extendable {
+        constructor(params = {}, parentParams = []) {
+            super(...parentParams);
+            for (const kind of kinds) {
+                this[kind.runTimeKey] = params[kind.definition.name] ?? null;
+            }
+        }
+        static [Symbol.hasInstance](value) {
             if (!uniqueKind.has(value)) {
                 return false;
             }
@@ -60,8 +59,12 @@ function kindHeritage(uniqueName, kind) {
                 }
             }
             return true;
-        },
+        }
     });
+    kinds.forEach((value) => {
+        ParentKindClass.prototype[value.runTimeKey] = null;
+    });
+    ParentKindClass.prototype[uniqueKind.runTimeKey] = null;
     return ParentKindClass;
 }
 function isRuntimeKind(value) {

package/dist/common/kind.d.ts

@@ -1,5 +1,5 @@
 import { type ForbiddenString } from "../string";
-import { type Or, type IsEqual, type BreakGenericLink, type Adaptor, type UnionToIntersection } from "./types";
+import { type Or, type IsEqual, type BreakGenericLink, type Adaptor, type UnionToIntersection, type AnyConstructor, type And } from "./types";
 import { type GetPropsWithValue, type PartialKeys } from "../object";
 export interface KindHandler<GenericKindDefinition extends KindDefinition = KindDefinition> {
     definition: GenericKindDefinition;
@@ -49,6 +49,6 @@ export declare function createKindNamespace<GenericNamespace extends string>(nam
 export type KindHeritageConstructorParams<GenericKindHandler extends KindHandler> = {
     [KindHandler in GenericKindHandler as KindHandler["definition"]["name"]]: KindHandler["definition"]["value"];
 } extends infer InferredResult extends object ? PartialKeys<InferredResult, GetPropsWithValue<InferredResult, unknown>> : never;
-export declare function kindHeritage<GenericUniqueName extends string, GenericKindHandler extends KindHandler>(uniqueName: GenericUniqueName & ForbiddenKindCharacters<GenericUniqueName>, kind: GenericKindHandler | GenericKindHandler[]): new (...args: IsEqual<GenericKindHandler extends KindHandler ? IsEqual<GenericKindHandler["definition"]["value"], unknown> : never, true> extends true ? [params?: KindHeritageConstructorParams<GenericKindHandler>] : [params: KindHeritageConstructorParams<GenericKindHandler>]) => UnionToIntersection<(GenericKindHandler extends KindHandler ? Kind<GenericKindHandler["definition"]> : never) | Kind<KindDefinition<GenericUniqueName, unknown>>>;
+export declare function kindHeritage<GenericUniqueName extends string, GenericKindHandler extends KindHandler, GenericParent extends AnyConstructor = AnyConstructor<unknown[], never>>(uniqueName: GenericUniqueName & ForbiddenKindCharacters<GenericUniqueName>, kind: GenericKindHandler | GenericKindHandler[], parent?: GenericParent): new (...args: And<[IsEqual<GenericKindHandler extends KindHandler ? IsEqual<GenericKindHandler["definition"]["value"], unknown> : never, true>, IsEqual<InstanceType<GenericParent>, never>]> extends true ? [params?: KindHeritageConstructorParams<GenericKindHandler>] : [params: KindHeritageConstructorParams<GenericKindHandler>, ...parentArgs: IsEqual<ConstructorParameters<GenericParent>, unknown[]> extends true ? [parentParams?: ConstructorParameters<GenericParent>] : [parentParams: ConstructorParameters<GenericParent>]]) => UnionToIntersection<(GenericKindHandler extends KindHandler ? Kind<GenericKindHandler["definition"]> : never) | Kind<KindDefinition<GenericUniqueName, unknown>> | InstanceType<GenericParent>>;
 export declare function isRuntimeKind(value: string): boolean;
 export {};

package/dist/common/kind.mjs

@@ -33,22 +33,21 @@ function createKindNamespace(namespace) {
         return kindHandler;
     };
 }
-function kindHeritage(uniqueName, kind) {
+function kindHeritage(uniqueName, kind, parent) {
     const uniqueKind = createKind(uniqueName);
     const kinds = kind instanceof Array
         ? kind
         : [kind];
-    const ParentKindClass = (function ParentKindClass(params = {}) {
-        for (const kind of kinds) {
-            this[kind.runTimeKey] = params[kind.definition.name] ?? null;
-        }
-    });
-    kinds.forEach((value) => {
-        ParentKindClass.prototype[value.runTimeKey] = null;
+    const Extendable = (parent ?? class {
     });
-    ParentKindClass.prototype[uniqueKind.runTimeKey] = null;
-    Object.defineProperty(ParentKindClass, Symbol.hasInstance, {
-        value: (value) => {
+    const ParentKindClass = (class extends Extendable {
+        constructor(params = {}, parentParams = []) {
+            super(...parentParams);
+            for (const kind of kinds) {
+                this[kind.runTimeKey] = params[kind.definition.name] ?? null;
+            }
+        }
+        static [Symbol.hasInstance](value) {
             if (!uniqueKind.has(value)) {
                 return false;
             }
@@ -58,8 +57,12 @@ function kindHeritage(uniqueName, kind) {
                 }
             }
             return true;
-        },
+        }
     });
+    kinds.forEach((value) => {
+        ParentKindClass.prototype[value.runTimeKey] = null;
+    });
+    ParentKindClass.prototype[uniqueKind.runTimeKey] = null;
     return ParentKindClass;
 }
 function isRuntimeKind(value) {

package/dist/common/or.d.ts

@@ -1,23 +1,23 @@
-import { type AnyFunction } from "./types";
-type ExtractPredicate<GenericInput extends unknown, GenericPredicatedInput extends AnyFunction<any[], boolean>[]> = GenericPredicatedInput extends [
-    (input: any) => input is infer InferredPredicate,
-    ...infer InferredRest extends AnyFunction<any[], boolean>[]
-] ? InferredRest extends readonly [] ? InferredPredicate : InferredPredicate | ExtractPredicate<GenericInput, InferredRest> : GenericInput;
-export declare function or<GenericInput extends unknown, GenericArrayPredicatedInput extends [
+import { type AnyPredicate, type AnyFunction, type IsEqual } from "./types";
+type ExtractPredicate<GenericPredicatedInput extends readonly AnyFunction<any[], boolean>[]> = GenericPredicatedInput extends readonly [
+    (input: any, ...args: any[]) => input is infer InferredPredicate,
+    ...infer InferredRest extends readonly AnyPredicate[]
+] ? InferredRest extends readonly [] ? InferredPredicate : ExtractPredicate<InferredRest> extends infer InferredResult ? IsEqual<InferredResult, never> extends true ? never : InferredPredicate | InferredResult : never : never;
+export declare function or<GenericInput extends unknown, const GenericArrayPredicatedInput extends readonly [
     (input: GenericInput) => input is any,
     (input: GenericInput) => input is any,
     ...((input: GenericInput) => input is any)[]
-]>(predicatedList: GenericArrayPredicatedInput): (input: GenericInput) => input is Extract<GenericInput, ExtractPredicate<GenericInput, GenericArrayPredicatedInput>>;
+]>(predicatedList: GenericArrayPredicatedInput): (input: GenericInput) => input is Extract<GenericInput, ExtractPredicate<GenericArrayPredicatedInput>>;
 export declare function or<GenericInput extends unknown>(predicatedList: [
     (input: GenericInput) => boolean,
     (input: GenericInput) => boolean,
     ...((input: GenericInput) => boolean)[]
 ]): (input: GenericInput) => boolean;
-export declare function or<GenericInput extends unknown, GenericArrayPredicatedInput extends [
+export declare function or<GenericInput extends unknown, const GenericArrayPredicatedInput extends readonly [
     (input: GenericInput) => input is any,
     (input: GenericInput) => input is any,
     ...((input: GenericInput) => input is any)[]
-]>(input: GenericInput, predicatedList: GenericArrayPredicatedInput): input is Extract<GenericInput, ExtractPredicate<GenericInput, GenericArrayPredicatedInput>>;
+]>(input: GenericInput, predicatedList: GenericArrayPredicatedInput): input is Extract<GenericInput, ExtractPredicate<GenericArrayPredicatedInput>>;
 export declare function or<GenericInput extends unknown>(input: GenericInput, predicatedList: [
     (input: GenericInput) => boolean,
     (input: GenericInput) => boolean,

package/dist/common/types/index.d.ts

@@ -38,3 +38,5 @@ export * from "./maybeWrapped";
 export * from "./anyConstructor";
 export * from "./anyPredicate";
 export * from "./removeFromUnion";
+export * from "./unwrapArray";
+export * from "./onlyLiteral";

package/dist/common/types/onlyLiteral.d.ts

@@ -0,0 +1,18 @@
+declare const SymbolErrorOnlyLiteral: unique symbol;
+export type OnlyLiteralString<GenericValue extends unknown> = string extends GenericValue ? {
+    [SymbolErrorOnlyLiteral]: "Input must be a literal string.";
+} : GenericValue;
+export type OnlyLiteralNumber<GenericValue extends unknown> = number extends GenericValue ? {
+    [SymbolErrorOnlyLiteral]: "Input must be a literal number.";
+} : GenericValue;
+export type OnlyLiteralSymbol<GenericValue extends unknown> = symbol extends GenericValue ? {
+    [SymbolErrorOnlyLiteral]: "Input must be a literal symbol.";
+} : GenericValue;
+export type OnlyLiteralBigInt<GenericValue extends unknown> = bigint extends GenericValue ? {
+    [SymbolErrorOnlyLiteral]: "Input must be a literal bigint.";
+} : GenericValue;
+export type OnlyLiteralBoolean<GenericValue extends unknown> = boolean extends GenericValue ? {
+    [SymbolErrorOnlyLiteral]: "Input must be a literal boolean.";
+} : GenericValue;
+export type OnlyLiteral<GenericValue extends unknown> = (OnlyLiteralString<GenericValue> & OnlyLiteralNumber<GenericValue> & OnlyLiteralSymbol<GenericValue> & OnlyLiteralBigInt<GenericValue> & OnlyLiteralBoolean<GenericValue>);
+export {};

package/dist/common/types/unwrapArray.d.ts

@@ -0,0 +1 @@
+export type UnwrapArray<GenericValue extends unknown> = GenericValue extends readonly any[] ? GenericValue[number] : GenericValue;

package/dist/dataParser/base.cjs

@@ -1,11 +1,12 @@
 'use strict';
 
 var simpleClone = require('../common/simpleClone.cjs');
+var wrapValue = require('../common/wrapValue.cjs');
 require('../common/globalStore.cjs');
 require('../common/builder.cjs');
-var error = require('./error.cjs');
 var error$1 = require('../either/left/error.cjs');
 var success = require('../either/right/success.cjs');
+var error = require('./error.cjs');
 var kind = require('./kind.cjs');
 
 const SymbolDataParserErrorLabel = "SymbolDataParserError";
@@ -18,6 +19,14 @@ function dataParserCheckerInit(kind, params, exec) {
     }));
 }
 const dataParserKind = kind.createDataParserKind("base");
+// This allows for better performance WTF ???
+const SDPEI = error.SymbolDataParserErrorIssue;
+const SDPEPI = error.SymbolDataParserErrorPromiseIssue;
+const SDPE = SymbolDataParserError;
+const DPE = error.createError();
+const EE = error$1.error(null);
+const ES = success.success(null);
+const KWV = wrapValue.keyWrappedValue;
 function dataParserInit(kind, params, exec) {
     const formattedExec = typeof exec === "object"
         ? exec
@@ -27,21 +36,21 @@ function dataParserInit(kind, params, exec) {
         };
     function middleExec(data, error$1) {
         let result = formattedExec.sync(data, error$1, dataParser);
-        if (result === error.SymbolDataParserErrorIssue) {
+        if (result === SDPEI) {
             error.addIssue(error$1, dataParser, data);
-            return SymbolDataParserError;
+            return SDPE;
         }
-        else if (result === error.SymbolDataParserErrorPromiseIssue) {
+        else if (result === SDPEPI) {
             error.addPromiseIssue(error$1, dataParser, data);
-            return SymbolDataParserError;
+            return SDPE;
         }
-        else if (result !== SymbolDataParserError
+        else if (result !== SDPE
             && dataParser.definition.checkers.length) {
             for (const checker of dataParser.definition.checkers) {
                 const checkerResult = checker.exec(result, checker);
-                if (checkerResult === error.SymbolDataParserErrorIssue) {
+                if (checkerResult === SDPEI) {
                     error.addIssue(error$1, checker, result);
-                    return SymbolDataParserError;
+                    return SDPE;
                 }
                 else {
                     result = checkerResult;
@@ -52,21 +61,21 @@ function dataParserInit(kind, params, exec) {
     }
     async function middleAsyncExec(data, error$1) {
         let result = await formattedExec.async(data, error$1, dataParser);
-        if (result === error.SymbolDataParserErrorIssue) {
+        if (result === SDPEI) {
             error.addIssue(error$1, dataParser, data);
-            return SymbolDataParserError;
+            return SDPE;
         }
-        else if (result === error.SymbolDataParserErrorPromiseIssue) {
+        else if (result === SDPEPI) {
             error.addPromiseIssue(error$1, dataParser, data);
-            return SymbolDataParserError;
+            return SDPE;
         }
-        else if (result !== SymbolDataParserError
+        else if (result !== SDPE
             && dataParser.definition.checkers.length) {
             for (const checker of dataParser.definition.checkers) {
                 const checkerResult = checker.exec(result, checker);
-                if (checkerResult === error.SymbolDataParserErrorIssue) {
+                if (checkerResult === SDPEI) {
                     error.addIssue(error$1, checker, result);
-                    return SymbolDataParserError;
+                    return SDPE;
                 }
                 else {
                     result = checkerResult;
@@ -80,20 +89,40 @@ function dataParserInit(kind, params, exec) {
         exec: middleExec,
         asyncExec: middleAsyncExec,
         parse(data) {
-            const error$2 = error.createError();
-            const result = middleExec(data, error$2);
-            if (result === SymbolDataParserError) {
-                return error$1.error(error$2);
+            const error = {
+                ...DPE,
+                issues: [],
+                currentPath: [],
+            };
+            const result = middleExec(data, error);
+            if (result === SDPE) {
+                return {
+                    ...EE,
+                    [KWV]: error,
+                };
             }
-            return success.success(result);
+            return {
+                ...ES,
+                [KWV]: result,
+            };
         },
         async asyncParse(data) {
-            const error$2 = error.createError();
-            const result = await middleAsyncExec(data, error$2);
-            if (result === SymbolDataParserError) {
-                return error$1.error(error$2);
+            const error = {
+                ...DPE,
+                issues: [],
+                currentPath: [],
+            };
+            const result = await middleAsyncExec(data, error);
+            if (result === SDPE) {
+                return {
+                    ...EE,
+                    [KWV]: error,
+                };
             }
-            return success.success(result);
+            return {
+                ...ES,
+                [KWV]: result,
+            };
         },
         addChecker: (...checkers) => dataParserInit(kind, simpleClone.simpleClone({
             ...params,
@@ -103,10 +132,7 @@ function dataParserInit(kind, params, exec) {
             },
         }), exec),
         clone: () => dataParserInit(kind, simpleClone.simpleClone(params), exec),
-    }, {
-        output: undefined,
-        input: undefined,
-    }));
+    }, null));
     return dataParser;
 }
 

package/dist/dataParser/base.d.ts

@@ -19,7 +19,7 @@ export declare const dataParserKind: KindHandler<import("../common").KindDefinit
 }>>;
 export interface DataParserDefinition<GenericChecker extends DataParserChecker = DataParserChecker> {
     readonly errorMessage?: string;
-    readonly checkers: readonly GenericChecker[];
+    readonly checkers: readonly (GenericChecker)[];
 }
 export interface DataParser<GenericDefinition extends DataParserDefinition = DataParserDefinition, GenericOutput extends unknown = unknown, GenericInput extends unknown = GenericOutput> extends Kind<typeof dataParserKind.definition, {
     input: GenericInput;