@duplojs/utils 1.4.45 → 1.4.47

package/dist/dataParser/base.cjs

@@ -42,6 +42,7 @@ function dataParserInit(kind, definition, exec, specificOverrideHandler) {
         : {
             sync: exec,
             async: exec,
+            isAsynchronous: () => false,
         };
     function middleExec(data, error$1) {
         let result = formattedExec.sync(data, error$1, self);
@@ -163,6 +164,9 @@ function dataParserInit(kind, definition, exec, specificOverrideHandler) {
             }
             return result;
         },
+        isAsynchronous() {
+            return formattedExec.isAsynchronous(self);
+        },
     }, (value) => dataParserKind.setTo(value, null), kind.setTo, (value) => dataParserInit.overrideHandler.apply(value), (value) => specificOverrideHandler.apply(value));
     return self;
 }

package/dist/dataParser/base.d.ts

@@ -204,10 +204,44 @@ export interface DataParser<GenericDefinition extends DataParserDefinition = Dat
      * 
      */
     asyncParseOrThrow(data: unknown): Promise<GenericOutput>;
+    /**
+     * The isAsynchronous() method tells whether a data parser requires async execution.
+     * 
+     * **Supported call styles:**
+     * - Method: `dataParser.isAsynchronous()` -> returns a boolean
+     * 
+     * It checks the parser definition (and nested parsers when relevant) and does not run any parsing.
+     * 
+     * ```ts
+     * const syncParser = DDataParser.string();
+     * syncParser.isAsynchronous(); // false
+     * 
+     * const asyncTransform = DDataParser.transform(
+     * 	DDataParser.number(),
+     * 	async(value) => {
+     * 		const result = await Promise.resolve(value);
+     * 
+     * 		return result;
+     * 	},
+     * );
+     * asyncTransform.isAsynchronous(); // true
+     * 
+     * const asyncArray = DDataParser.array(asyncTransform);
+     * asyncArray.isAsynchronous(); // true
+     * 
+     * ```
+     * 
+     * @see https://utils.duplojs.dev/en/v1/api/dataParser/isAsynchronous
+     * 
+     * @namespace DP
+     * 
+     */
+    isAsynchronous(): boolean;
 }
 interface DataParserInitExecParams<GenericDataParser extends DataParser> {
     sync(...args: [...Parameters<GenericDataParser["exec"]>, self: GenericDataParser]): (GetKindValue<typeof dataParserKind, GenericDataParser>["output"] | SymbolDataParserErrorIssue | SymbolDataParserErrorPromiseIssue);
     async(...args: [...Parameters<GenericDataParser["exec"]>, self: GenericDataParser]): Promise<GetKindValue<typeof dataParserKind, GenericDataParser>["output"] | SymbolDataParserErrorIssue | SymbolDataParserErrorPromiseIssue>;
+    isAsynchronous(self: GenericDataParser): boolean;
 }
 declare const DataParserThrowError_base: new (params: {
     "@DuplojsUtilsError/dataParserThrowError"?: unknown;

package/dist/dataParser/base.mjs

@@ -40,6 +40,7 @@ function dataParserInit(kind, definition, exec, specificOverrideHandler) {
         : {
             sync: exec,
             async: exec,
+            isAsynchronous: () => false,
         };
     function middleExec(data, error) {
         let result = formattedExec.sync(data, error, self);
@@ -161,6 +162,9 @@ function dataParserInit(kind, definition, exec, specificOverrideHandler) {
             }
             return result;
         },
+        isAsynchronous() {
+            return formattedExec.isAsynchronous(self);
+        },
     }, (value) => dataParserKind.setTo(value, null), kind.setTo, (value) => dataParserInit.overrideHandler.apply(value), (value) => specificOverrideHandler.apply(value));
     return self;
 }

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

@@ -42,7 +42,7 @@ export interface DataParserNullableExtended<GenericDefinition extends dataParser
  * @namespace DPE
  * 
  */
-export declare function nullable<GenericDataParser extends DataParser, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionNullable<Output<GenericDataParser> | null>, "inner">> = never>(inner: GenericDataParser, definition?: GenericDefinition): DataParserNullableExtended<MergeDefinition<dataParsers.DataParserDefinitionNullable, NeverCoalescing<GenericDefinition, {}> & {
+export declare function nullable<GenericDataParser extends DataParser, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionNullable<Output<GenericDataParser>>, "inner">> = never>(inner: GenericDataParser, definition?: GenericDefinition): DataParserNullableExtended<MergeDefinition<dataParsers.DataParserDefinitionNullable, NeverCoalescing<GenericDefinition, {}> & {
     inner: GenericDataParser;
 }>>;
 export declare namespace nullable {

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

@@ -42,7 +42,7 @@ export interface DataParserOptionalExtended<GenericDefinition extends dataParser
  * @namespace DPE
  * 
  */
-export declare function optional<GenericDataParser extends DataParser, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionOptional<Output<GenericDataParser> | undefined>, "inner">> = never>(inner: GenericDataParser, definition?: GenericDefinition): DataParserOptionalExtended<MergeDefinition<dataParsers.DataParserDefinitionOptional, NeverCoalescing<GenericDefinition, {}> & {
+export declare function optional<GenericDataParser extends DataParser, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionOptional<Output<GenericDataParser>>, "inner">> = never>(inner: GenericDataParser, definition?: GenericDefinition): DataParserOptionalExtended<MergeDefinition<dataParsers.DataParserDefinitionOptional, NeverCoalescing<GenericDefinition, {}> & {
     inner: GenericDataParser;
 }>>;
 export declare namespace optional {

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

@@ -41,7 +41,7 @@ export interface DataParserRecoverExtended<GenericDefinition extends dataParsers
  * @namespace DPE
  * 
  */
-export declare function recover<GenericDataParser extends DataParser, GenericRecoveredValue extends unknown, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionRecover, "inner" | "recoveredValue">> = never>(inner: GenericDataParser, recoveredValue: GenericRecoveredValue, definition?: GenericDefinition): DataParserRecoverExtended<MergeDefinition<dataParsers.DataParserDefinitionRecover, NeverCoalescing<GenericDefinition, {}> & {
+export declare function recover<GenericDataParser extends DataParser, GenericRecoveredValue extends Output<GenericDataParser>, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionRecover, "inner" | "recoveredValue">> = never>(inner: GenericDataParser, recoveredValue: GenericRecoveredValue, definition?: GenericDefinition): DataParserRecoverExtended<MergeDefinition<dataParsers.DataParserDefinitionRecover, NeverCoalescing<GenericDefinition, {}> & {
     inner: GenericDataParser;
     recoveredValue: GenericRecoveredValue;
 }>>;

package/dist/dataParser/parsers/array/index.cjs

@@ -59,6 +59,7 @@ function array(element, definition) {
             void (data.length && error.popErrorPath(error$1));
             return output;
         },
+        isAsynchronous: (self) => self.definition.element.isAsynchronous(),
     }, array.overrideHandler);
     return self;
 }

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

@@ -8,7 +8,7 @@ export * from "./checkers";
 export interface DataParserArrayCheckerCustom<GenericInput extends unknown[] = unknown[]> {
 }
 export type DataParserArrayCheckers<GenericInput extends unknown[] = unknown[]> = (DataParserArrayCheckerCustom<GenericInput>[GetPropsWithValueExtends<DataParserArrayCheckerCustom<GenericInput>, DataParserChecker>] | DataParserCheckerArrayMin | DataParserCheckerArrayMax | CheckerRefineImplementation<GenericInput>);
-export interface DataParserDefinitionArray extends DataParserDefinition<DataParserArrayCheckers> {
+export interface DataParserDefinitionArray extends DataParserDefinition<DataParserArrayCheckers<unknown[]>> {
     readonly element: DataParser;
 }
 export declare const arrayKind: import("../../../common").KindHandler<import("../../../common").KindDefinition<"@DuplojsUtilsDataParser/array", unknown>>;

package/dist/dataParser/parsers/array/index.mjs

@@ -57,6 +57,7 @@ function array(element, definition) {
             void (data.length && popErrorPath(error));
             return output;
         },
+        isAsynchronous: (self) => self.definition.element.isAsynchronous(),
     }, array.overrideHandler);
     return self;
 }

package/dist/dataParser/parsers/lazy.cjs

@@ -17,6 +17,7 @@ function lazy(getter, definition) {
     }, {
         sync: (data, _error, self) => self.definition.getter.value.exec(data, _error),
         async: (data, _error, self) => self.definition.getter.value.asyncExec(data, _error),
+        isAsynchronous: (self) => self.definition.getter.value.isAsynchronous(),
     }, lazy.overrideHandler);
     return self;
 }

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

@@ -6,7 +6,7 @@ import { type GetPropsWithValueExtends } from "../../object";
 export interface DataParserLazyCheckerCustom<GenericInput extends unknown = unknown> {
 }
 export type DataParserLazyCheckers<GenericInput extends unknown = unknown> = (DataParserLazyCheckerCustom<GenericInput>[GetPropsWithValueExtends<DataParserLazyCheckerCustom<GenericInput>, DataParserChecker>] | CheckerRefineImplementation<GenericInput>);
-export interface DataParserDefinitionLazy extends DataParserDefinition<DataParserLazyCheckers> {
+export interface DataParserDefinitionLazy extends DataParserDefinition<DataParserLazyCheckers<unknown>> {
     getter: Memoized<DataParser>;
 }
 export declare const lazyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/lazy", unknown>>;

package/dist/dataParser/parsers/lazy.mjs

@@ -15,6 +15,7 @@ function lazy(getter, definition) {
     }, {
         sync: (data, _error, self) => self.definition.getter.value.exec(data, _error),
         async: (data, _error, self) => self.definition.getter.value.asyncExec(data, _error),
+        isAsynchronous: (self) => self.definition.getter.value.isAsynchronous(),
     }, lazy.overrideHandler);
     return self;
 }

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

@@ -7,7 +7,7 @@ export type LiteralValue = string | number | bigint | undefined | null | boolean
 export interface DataParserLiteralCheckerCustom<GenericInput extends LiteralValue = LiteralValue> {
 }
 export type DataParserLiteralCheckers<GenericInput extends LiteralValue = LiteralValue> = (DataParserLiteralCheckerCustom<GenericInput>[GetPropsWithValueExtends<DataParserLiteralCheckerCustom<GenericInput>, DataParserChecker>] | CheckerRefineImplementation<GenericInput>);
-export interface DataParserDefinitionLiteral extends DataParserDefinition<DataParserLiteralCheckers> {
+export interface DataParserDefinitionLiteral extends DataParserDefinition<DataParserLiteralCheckers<LiteralValue>> {
     readonly value: readonly LiteralValue[];
 }
 export declare const literalKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/literal", unknown>>;

package/dist/dataParser/parsers/nullable.cjs

@@ -27,6 +27,7 @@ function nullable(inner, definition) {
             }
             return self.definition.inner.asyncExec(data, error);
         },
+        isAsynchronous: (self) => self.definition.inner.isAsynchronous(),
     }, nullable.overrideHandler);
     return self;
 }

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

@@ -6,9 +6,9 @@ import { type GetPropsWithValueExtends } from "../../object";
 export interface DataParserNullableCheckerCustom<GenericInput extends unknown = unknown> {
 }
 export type DataParserNullableCheckers<GenericInput extends unknown = unknown> = (DataParserNullableCheckerCustom<GenericInput>[GetPropsWithValueExtends<DataParserNullableCheckerCustom<GenericInput>, DataParserChecker>] | CheckerRefineImplementation<GenericInput>);
-export interface DataParserDefinitionNullable<GenericCoalescingValue extends unknown = unknown> extends DataParserDefinition<DataParserNullableCheckers> {
+export interface DataParserDefinitionNullable<GenericOutput extends unknown = unknown> extends DataParserDefinition<DataParserNullableCheckers> {
     readonly inner: DataParser;
-    readonly coalescingValue: GenericCoalescingValue;
+    readonly coalescingValue: GenericOutput;
 }
 export declare const nullableKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/nullable", unknown>>;
 type _DataParserNullable<GenericDefinition extends DataParserDefinitionNullable> = (DataParser<GenericDefinition, IsEqual<GenericDefinition["coalescingValue"], unknown> extends true ? Output<GenericDefinition["inner"]> | null : Output<GenericDefinition["inner"]>, Input<GenericDefinition["inner"]> | null> & Kind<typeof nullableKind.definition>);

package/dist/dataParser/parsers/nullable.mjs

@@ -25,6 +25,7 @@ function nullable(inner, definition) {
             }
             return self.definition.inner.asyncExec(data, error);
         },
+        isAsynchronous: (self) => self.definition.inner.isAsynchronous(),
     }, nullable.overrideHandler);
     return self;
 }

package/dist/dataParser/parsers/object/index.cjs

@@ -4,6 +4,7 @@ var base = require('../../base.cjs');
 var error = require('../../error.cjs');
 var kind = require('../../kind.cjs');
 var memo = require('../../../common/memo.cjs');
+var some = require('../../../array/some.cjs');
 var pipe = require('../../../common/pipe.cjs');
 var map = require('../../../array/map.cjs');
 var filter = require('../../../array/filter.cjs');
@@ -69,6 +70,7 @@ function object(shape, definition) {
             void (self.definition.optimizedShape.value.length && error.popErrorPath(error$1));
             return output;
         },
+        isAsynchronous: (self) => some.some(self.definition.optimizedShape.value, (element) => element.value.isAsynchronous()),
     }, object.overrideHandler);
     return self;
 }

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

@@ -16,10 +16,10 @@ export type DataParserObjectShapeOutput<GenericShape extends DataParserObjectSha
 export type DataParserObjectShapeInput<GenericShape extends DataParserObjectShape> = {
     -readonly [Prop in keyof GenericShape as GenericShape[Prop] extends Kind<typeof dataParserKind.definition> ? Prop : never]: Input<GenericShape[Prop]>;
 } extends infer InferredResult extends object ? DObject.PartialKeys<InferredResult, DObject.GetPropsWithValueExtends<InferredResult, undefined>> : never;
-export interface DataParserObjectCheckerCustom<GenericInput extends DataParserObjectShape = DataParserObjectShape> {
+export interface DataParserObjectCheckerCustom<GenericInput extends object = object> {
 }
-export type DataParserObjectCheckers<GenericInput extends DataParserObjectShape = DataParserObjectShape> = (DataParserObjectCheckerCustom<GenericInput>[GetPropsWithValueExtends<DataParserObjectCheckerCustom<GenericInput>, DataParserChecker>] | CheckerRefineImplementation<GenericInput>);
-export interface DataParserDefinitionObject extends DataParserDefinition<DataParserObjectCheckers> {
+export type DataParserObjectCheckers<GenericInput extends object = object> = (DataParserObjectCheckerCustom<GenericInput>[GetPropsWithValueExtends<DataParserObjectCheckerCustom<GenericInput>, DataParserChecker>] | CheckerRefineImplementation<GenericInput>);
+export interface DataParserDefinitionObject extends DataParserDefinition<DataParserObjectCheckers<object>> {
     readonly shape: DataParserObjectShape;
     readonly optimizedShape: Memoized<{
         readonly key: string;

package/dist/dataParser/parsers/object/index.mjs

@@ -2,6 +2,7 @@ import { dataParserInit, SymbolDataParserError, dataParserKind } from '../../bas
 import { SymbolDataParserErrorIssue, setErrorPath, popErrorPath } from '../../error.mjs';
 import { createDataParserKind } from '../../kind.mjs';
 import { memo } from '../../../common/memo.mjs';
+import { some } from '../../../array/some.mjs';
 import { pipe } from '../../../common/pipe.mjs';
 import { map } from '../../../array/map.mjs';
 import { filter } from '../../../array/filter.mjs';
@@ -67,6 +68,7 @@ function object(shape, definition) {
             void (self.definition.optimizedShape.value.length && popErrorPath(error));
             return output;
         },
+        isAsynchronous: (self) => some(self.definition.optimizedShape.value, (element) => element.value.isAsynchronous()),
     }, object.overrideHandler);
     return self;
 }

package/dist/dataParser/parsers/optional.cjs

@@ -27,6 +27,7 @@ function optional(inner, definition) {
             }
             return self.definition.inner.asyncExec(data, error);
         },
+        isAsynchronous: (self) => self.definition.inner.isAsynchronous(),
     }, optional.overrideHandler);
     return self;
 }

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

@@ -6,9 +6,9 @@ import { type GetPropsWithValueExtends } from "../../object";
 export interface DataParserOptionalCheckerCustom<GenericInput extends unknown = unknown> {
 }
 export type DataParserOptionalCheckers<GenericInput extends unknown = unknown> = (DataParserOptionalCheckerCustom<GenericInput>[GetPropsWithValueExtends<DataParserOptionalCheckerCustom<GenericInput>, DataParserChecker>] | CheckerRefineImplementation<GenericInput>);
-export interface DataParserDefinitionOptional<GenericCoalescingValue extends unknown = unknown> extends DataParserDefinition<DataParserOptionalCheckers> {
+export interface DataParserDefinitionOptional<GenericOutput extends unknown = unknown> extends DataParserDefinition<DataParserOptionalCheckers> {
     readonly inner: DataParser;
-    readonly coalescingValue: GenericCoalescingValue;
+    readonly coalescingValue: GenericOutput;
 }
 export declare const optionalKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/optional", unknown>>;
 type _DataParserOptional<GenericDefinition extends DataParserDefinitionOptional> = (DataParser<GenericDefinition, IsEqual<GenericDefinition["coalescingValue"], unknown> extends true ? Output<GenericDefinition["inner"]> | undefined : Output<GenericDefinition["inner"]>, Input<GenericDefinition["inner"]> | undefined> & Kind<typeof optionalKind.definition>);
@@ -51,7 +51,7 @@ export interface DataParserOptional<GenericDefinition extends DataParserDefiniti
  * @namespace DP
  * 
  */
-export declare function optional<GenericDataParser extends DataParser, const GenericDefinition extends Partial<Omit<DataParserDefinitionOptional<Output<GenericDataParser>>, "inner">> = never>(inner: GenericDataParser, definition?: GenericDefinition): DataParserOptional<MergeDefinition<DataParserDefinitionOptional, NeverCoalescing<GenericDefinition, {}> & {
+export declare function optional<GenericDataParser extends DataParser, const GenericDefinition extends Partial<Omit<DataParserDefinitionOptional, "inner">> = never>(inner: GenericDataParser, definition?: GenericDefinition): DataParserOptional<MergeDefinition<DataParserDefinitionOptional, NeverCoalescing<GenericDefinition, {}> & {
     inner: GenericDataParser;
 }>>;
 export declare namespace optional {

package/dist/dataParser/parsers/optional.mjs

@@ -25,6 +25,7 @@ function optional(inner, definition) {
             }
             return self.definition.inner.asyncExec(data, error);
         },
+        isAsynchronous: (self) => self.definition.inner.isAsynchronous(),
     }, optional.overrideHandler);
     return self;
 }

package/dist/dataParser/parsers/pipe.cjs

@@ -29,6 +29,7 @@ function pipe(input, output, definition) {
             }
             return self.definition.output.asyncExec(result, error);
         },
+        isAsynchronous: (self) => self.definition.input.isAsynchronous() || self.definition.output.isAsynchronous(),
     }, pipe.overrideHandler);
     return self;
 }

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

@@ -6,7 +6,7 @@ import { type GetPropsWithValueExtends } from "../../object";
 export interface DataParserPipeCheckerCustom<GenericInput extends unknown = unknown> {
 }
 export type DataParserPipeCheckers<GenericInput extends unknown = unknown> = (DataParserPipeCheckerCustom<GenericInput>[GetPropsWithValueExtends<DataParserPipeCheckerCustom<GenericInput>, DataParserChecker>] | CheckerRefineImplementation<GenericInput>);
-export interface DataParserDefinitionPipe extends DataParserDefinition<DataParserPipeCheckers> {
+export interface DataParserDefinitionPipe extends DataParserDefinition<DataParserPipeCheckers<unknown>> {
     readonly input: DataParser;
     readonly output: DataParser;
 }

package/dist/dataParser/parsers/pipe.mjs

@@ -27,6 +27,7 @@ function pipe(input, output, definition) {
             }
             return self.definition.output.asyncExec(result, error);
         },
+        isAsynchronous: (self) => self.definition.input.isAsynchronous() || self.definition.output.isAsynchronous(),
     }, pipe.overrideHandler);
     return self;
 }

package/dist/dataParser/parsers/record/index.cjs

@@ -94,6 +94,7 @@ function record(key, value, definition) {
             }
             return output;
         },
+        isAsynchronous: (self) => self.definition.value.isAsynchronous(),
     }, record.overrideHandler);
     return self;
 }

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

@@ -18,7 +18,7 @@ export type DataParserRecordKey = (DataParserString | DataParserTemplateLiteral
 export interface DataParserRecordCheckerCustom<GenericInput extends Record<string, unknown> = Record<string, unknown>> {
 }
 export type DataParserRecordCheckers<GenericInput extends Record<string, unknown> = Record<string, unknown>> = (DataParserRecordCheckerCustom<GenericInput>[GetPropsWithValueExtends<DataParserRecordCheckerCustom<GenericInput>, DataParserChecker>] | CheckerRefineImplementation<GenericInput>);
-export interface DataParserDefinitionRecord extends DataParserDefinition<DataParserRecordCheckers> {
+export interface DataParserDefinitionRecord extends DataParserDefinition<DataParserRecordCheckers<Record<string, unknown>>> {
     readonly key: DataParserRecordKey;
     readonly value: DataParser;
     readonly requireKey: string[] | null;

package/dist/dataParser/parsers/record/index.mjs

@@ -93,6 +93,7 @@ function record(key, value, definition) {
             }
             return output;
         },
+        isAsynchronous: (self) => self.definition.value.isAsynchronous(),
     }, record.overrideHandler);
     return self;
 }

package/dist/dataParser/parsers/recover.cjs

@@ -27,6 +27,7 @@ function recover(inner, recoveredValue, definition) {
                 ? self.definition.recoveredValue
                 : result;
         },
+        isAsynchronous: (self) => self.definition.inner.isAsynchronous(),
     }, recover.overrideHandler);
     return self;
 }

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

@@ -41,9 +41,9 @@ export interface DataParserRecover<GenericDefinition extends DataParserDefinitio
  * const withString = DP.recover(DP.string(), "fallback");
  * const stringResult = withString.parse(123);
  * 
- * const withCheckers = DP.recover(DP.string(), "fallback", {
- * 	checkers: [DP.checkerRefine((value) => value.length > 0)],
- * });
+ * const withCheckers = DP.recover(DP.string(), "fallback")
+ * 	.addChecker(DP.checkerRefine((value) => value.length > 0));
+ * 
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/dataParser/recover

package/dist/dataParser/parsers/recover.mjs

@@ -25,6 +25,7 @@ function recover(inner, recoveredValue, definition) {
                 ? self.definition.recoveredValue
                 : result;
         },
+        isAsynchronous: (self) => self.definition.inner.isAsynchronous(),
     }, recover.overrideHandler);
     return self;
 }

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

@@ -46,7 +46,7 @@ export type TemplateLiteralShapeInput<GenericTemplate extends TemplateLiteralSha
 export interface DataParserTemplateLiteralCheckerCustom<GenericInput extends string = string> {
 }
 export type DataParserTemplateLiteralCheckers<GenericInput extends string = string> = (DataParserTemplateLiteralCheckerCustom<GenericInput>[GetPropsWithValueExtends<DataParserTemplateLiteralCheckerCustom<GenericInput>, DataParserChecker>] | CheckerRefineImplementation<GenericInput>);
-export interface DataParserDefinitionTemplateLiteral extends DataParserDefinition<DataParserTemplateLiteralCheckers> {
+export interface DataParserDefinitionTemplateLiteral extends DataParserDefinition<DataParserTemplateLiteralCheckers<string>> {
     readonly template: TemplateLiteralShape;
     readonly pattern: RegExp;
 }

package/dist/dataParser/parsers/transform.cjs

@@ -38,6 +38,7 @@ function transform(inner, theFunction, definition) {
             }
             return result;
         },
+        isAsynchronous: (self) => self.definition.theFunction.constructor.name === "AsyncFunction",
     }, transform.overrideHandler);
     return self;
 }

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

@@ -7,7 +7,7 @@ import { type GetPropsWithValueExtends } from "../../object";
 export interface DataParserTransformCheckerCustom<GenericInput extends unknown = unknown> {
 }
 export type DataParserTransformCheckers<GenericInput extends unknown = unknown> = (DataParserTransformCheckerCustom<GenericInput>[GetPropsWithValueExtends<DataParserTransformCheckerCustom<GenericInput>, DataParserChecker>] | CheckerRefineImplementation<GenericInput>);
-export interface DataParserDefinitionTransform extends DataParserDefinition<DataParserTransformCheckers> {
+export interface DataParserDefinitionTransform extends DataParserDefinition<DataParserTransformCheckers<unknown>> {
     readonly inner: DataParser;
     theFunction(input: any, error: DataParserError): unknown;
 }

package/dist/dataParser/parsers/transform.mjs

@@ -36,6 +36,7 @@ function transform(inner, theFunction, definition) {
             }
             return result;
         },
+        isAsynchronous: (self) => self.definition.theFunction.constructor.name === "AsyncFunction",
     }, transform.overrideHandler);
     return self;
 }

package/dist/dataParser/parsers/tuple.cjs

@@ -3,6 +3,7 @@
 var base = require('../base.cjs');
 var error = require('../error.cjs');
 var kind = require('../kind.cjs');
+var some = require('../../array/some.cjs');
 var override = require('../../common/override.cjs');
 
 const tupleKind = kind.createDataParserKind("tuple");
@@ -78,6 +79,7 @@ function tuple(shape, definition) {
             void (self.definition.shape.length && error.popErrorPath(error$1));
             return output;
         },
+        isAsynchronous: (self) => some.some(self.definition.shape, (element) => element.isAsynchronous()) || !!self.definition.rest?.isAsynchronous(),
     }, tuple.overrideHandler);
     return self;
 }

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

@@ -22,7 +22,7 @@ export type DataParserTupleShapeInput<GenericShape extends TupleShape, GenericRe
 export interface DataParserTupleCheckerCustom<GenericInput extends AnyTuple<unknown> = AnyTuple<unknown>> {
 }
 export type DataParserTupleCheckers<GenericInput extends AnyTuple<unknown> = AnyTuple<unknown>> = (DataParserTupleCheckerCustom<GenericInput>[GetPropsWithValueExtends<DataParserTupleCheckerCustom<GenericInput>, DataParserChecker>] | DataParserCheckerArrayMin | DataParserCheckerArrayMax | CheckerRefineImplementation<GenericInput>);
-export interface DataParserDefinitionTuple extends DataParserDefinition<DataParserTupleCheckers> {
+export interface DataParserDefinitionTuple extends DataParserDefinition<DataParserTupleCheckers<AnyTuple<unknown>>> {
     readonly shape: TupleShape;
     readonly rest?: DataParser;
 }

package/dist/dataParser/parsers/tuple.mjs

@@ -1,6 +1,7 @@
 import { dataParserInit, SymbolDataParserError } from '../base.mjs';
 import { SymbolDataParserErrorIssue, setErrorPath, popErrorPath } from '../error.mjs';
 import { createDataParserKind } from '../kind.mjs';
+import { some } from '../../array/some.mjs';
 import { createOverride } from '../../common/override.mjs';
 
 const tupleKind = createDataParserKind("tuple");
@@ -76,6 +77,7 @@ function tuple(shape, definition) {
             void (self.definition.shape.length && popErrorPath(error));
             return output;
         },
+        isAsynchronous: (self) => some(self.definition.shape, (element) => element.isAsynchronous()) || !!self.definition.rest?.isAsynchronous(),
     }, tuple.overrideHandler);
     return self;
 }

package/dist/dataParser/parsers/union.cjs

@@ -3,6 +3,7 @@
 var base = require('../base.cjs');
 var error = require('../error.cjs');
 var kind = require('../kind.cjs');
+var some = require('../../array/some.cjs');
 var override = require('../../common/override.cjs');
 
 const unionKind = kind.createDataParserKind("union");
@@ -33,6 +34,7 @@ function union(options, definition) {
             }
             return error.SymbolDataParserErrorIssue;
         },
+        isAsynchronous: (self) => some.some(self.definition.options, (element) => element.isAsynchronous()),
     }, union.overrideHandler);
     return self;
 }

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

@@ -7,7 +7,7 @@ export type UnionOptions = readonly [DataParser, ...DataParser[]];
 export interface DataParserUnionCheckerCustom<GenericInput extends unknown = unknown> {
 }
 export type DataParserUnionCheckers<GenericInput extends unknown = unknown> = (DataParserUnionCheckerCustom<GenericInput>[GetPropsWithValueExtends<DataParserUnionCheckerCustom<GenericInput>, DataParserChecker>] | CheckerRefineImplementation<GenericInput>);
-export interface DataParserDefinitionUnion extends DataParserDefinition<DataParserUnionCheckers> {
+export interface DataParserDefinitionUnion extends DataParserDefinition<DataParserUnionCheckers<unknown>> {
     readonly options: UnionOptions;
 }
 export declare const unionKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/union", unknown>>;

package/dist/dataParser/parsers/union.mjs

@@ -1,6 +1,7 @@
 import { dataParserInit, SymbolDataParserError } from '../base.mjs';
 import { SymbolDataParserErrorIssue } from '../error.mjs';
 import { createDataParserKind } from '../kind.mjs';
+import { some } from '../../array/some.mjs';
 import { createOverride } from '../../common/override.mjs';
 
 const unionKind = createDataParserKind("union");
@@ -31,6 +32,7 @@ function union(options, definition) {
             }
             return SymbolDataParserErrorIssue;
         },
+        isAsynchronous: (self) => some(self.definition.options, (element) => element.isAsynchronous()),
     }, union.overrideHandler);
     return self;
 }

package/dist/string/isIn.d.ts

@@ -43,5 +43,5 @@
  * @namespace S
  * 
  */
-export declare function isIn<GenericInput extends string, GenericValue extends GenericInput>(array: readonly GenericValue[]): (input: GenericInput) => input is Extract<GenericInput, GenericValue>;
-export declare function isIn<GenericInput extends string, GenericValue extends GenericInput>(input: GenericInput, array: readonly GenericValue[]): input is Extract<GenericInput, GenericValue>;
+export declare function isIn<GenericValue extends string>(array: readonly (GenericValue | string)[]): (input: string) => input is GenericValue;
+export declare function isIn<GenericValue extends string>(input: string, array: readonly (GenericValue | string)[]): input is GenericValue;

package/dist/string/slice.d.ts

@@ -10,7 +10,7 @@
  * ```ts
  * S.slice("DuploJS Utils", 0, 7); // "DuploJS"
  * 
- * S.slice("DuploJS Utils", -5); // "Utils"
+ * S.slice("DuploJS Utils", -5, Infinity); // "Utils"
  * 
  * pipe(
  * 	"DuploJS Utils",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/utils",
-  "version": "1.4.45",
+  "version": "1.4.47",
   "author": {
     "name": "mathcovax",
     "url": "https://github.com/mathcovax"