@duplojs/utils 1.1.13 → 1.1.15

package/dist/either/optional/filled.cjs

@@ -4,11 +4,11 @@ var unwrap = require('../../common/unwrap.cjs');
 require('../../common/globalStore.cjs');
 require('../../common/builder.cjs');
 var kind = require('../kind.cjs');
-var base = require('./base.cjs');
-var create$1 = require('./create.cjs');
 var is$1 = require('../left/is.cjs');
 var create = require('../right/create.cjs');
 var is = require('../right/is.cjs');
+var create$1 = require('./create.cjs');
+var base = require('./base.cjs');
 
 const eitherOptionalFilledKind = kind.createEitherKind("optional-filled");
 function optionalFilled(value) {

package/dist/either/optional/filled.d.ts

@@ -12,6 +12,6 @@ type Either = EitherRight | EitherLeft;
 export declare function optionalFilled<const GenericValue extends unknown>(value: GenericValue): EitherOptionalFilled<GenericValue>;
 export declare function isOptionalFilled<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherOptionalFilled>;
 type ToOptionalEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof optional<GenericValue>>;
-export declare function whenIsOptionalFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToOptionalEither<GenericInput>, EitherOptionalFilled>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToOptionalEither<BreakGenericLink<GenericInput>>, EitherOptionalFilled>;
-export declare function whenIsOptionalFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToOptionalEither<GenericInput>, EitherOptionalFilled>>) => GenericOutput): GenericOutput | Exclude<ToOptionalEither<GenericInput>, EitherOptionalFilled>;
+export declare function whenIsOptionalFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToOptionalEither<BreakGenericLink<GenericInput>>, EitherOptionalFilled>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToOptionalEither<BreakGenericLink<GenericInput>>, EitherOptionalFilled>;
+export declare function whenIsOptionalFilled<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToOptionalEither<BreakGenericLink<GenericInput>>, EitherOptionalFilled>>) => GenericOutput): GenericOutput | Exclude<ToOptionalEither<GenericInput>, EitherOptionalFilled>;
 export {};

package/dist/either/optional/filled.mjs

@@ -2,11 +2,11 @@ import { unwrap } from '../../common/unwrap.mjs';
 import '../../common/globalStore.mjs';
 import '../../common/builder.mjs';
 import { createEitherKind } from '../kind.mjs';
-import { eitherOptionalKind } from './base.mjs';
-import { optional } from './create.mjs';
 import { isLeft } from '../left/is.mjs';
 import { right } from '../right/create.mjs';
 import { isRight } from '../right/is.mjs';
+import { optional } from './create.mjs';
+import { eitherOptionalKind } from './base.mjs';
 
 const eitherOptionalFilledKind = createEitherKind("optional-filled");
 function optionalFilled(value) {

package/dist/either/right/asyncPipe.cjs

@@ -3,10 +3,10 @@
 var unwrap = require('../../common/unwrap.cjs');
 require('../../common/globalStore.cjs');
 require('../../common/builder.cjs');
-var is = require('../left/is.cjs');
 var create = require('../future/create.cjs');
 var success = require('./success.cjs');
 var is$1 = require('./is.cjs');
+var is = require('../left/is.cjs');
 
 function rightAsyncPipe(input, ...pipes) {
     return create.future((async () => {

package/dist/either/right/asyncPipe.mjs

@@ -1,10 +1,10 @@
 import { unwrap } from '../../common/unwrap.mjs';
 import '../../common/globalStore.mjs';
 import '../../common/builder.mjs';
-import { isLeft } from '../left/is.mjs';
 import { future } from '../future/create.mjs';
 import { success } from './success.mjs';
 import { isRight } from './is.mjs';
+import { isLeft } from '../left/is.mjs';
 
 function rightAsyncPipe(input, ...pipes) {
     return future((async () => {

package/dist/either/right/pipe.cjs

@@ -3,9 +3,9 @@
 var unwrap = require('../../common/unwrap.cjs');
 require('../../common/globalStore.cjs');
 require('../../common/builder.cjs');
-var is = require('../left/is.cjs');
 var success = require('./success.cjs');
 var is$1 = require('./is.cjs');
+var is = require('../left/is.cjs');
 
 /* eslint-disable @typescript-eslint/max-params */
 function rightPipe(input, ...pipes) {

package/dist/either/right/pipe.mjs

@@ -1,9 +1,9 @@
 import { unwrap } from '../../common/unwrap.mjs';
 import '../../common/globalStore.mjs';
 import '../../common/builder.mjs';
-import { isLeft } from '../left/is.mjs';
 import { success } from './success.mjs';
 import { isRight } from './is.mjs';
+import { isLeft } from '../left/is.mjs';
 
 /* eslint-disable @typescript-eslint/max-params */
 function rightPipe(input, ...pipes) {

package/dist/either/right/when.d.ts

@@ -1,4 +1,4 @@
 import { type EscapeVoid, type AnyValue, type Unwrap, type BreakGenericLink } from "../../common";
 import { type EitherRight } from "./create";
-export declare function whenIsRight<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<GenericInput, EitherRight>>) => GenericOutput): (input: GenericInput) => Exclude<BreakGenericLink<GenericInput>, EitherRight> | GenericOutput;
-export declare function whenIsRight<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<GenericInput, EitherRight>>) => GenericOutput): Exclude<GenericInput, EitherRight> | GenericOutput;
+export declare function whenIsRight<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<BreakGenericLink<GenericInput>, EitherRight>>) => GenericOutput): (input: GenericInput) => Exclude<BreakGenericLink<GenericInput>, EitherRight> | GenericOutput;
+export declare function whenIsRight<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<BreakGenericLink<GenericInput>, EitherRight>>) => GenericOutput): Exclude<GenericInput, EitherRight> | GenericOutput;

package/dist/generator/asyncReduce.cjs

@@ -15,7 +15,7 @@ function asyncReduce(...args) {
     return (async () => {
         let index = 0;
         for await (const element of iterator) {
-            const result = theFunction({
+            const result = await theFunction({
                 element,
                 index,
                 lastValue,

package/dist/generator/asyncReduce.d.ts

@@ -1,3 +1,4 @@
-import { type GeneratorReduceFromValue, type GeneratorEligibleReduceFromValue, type GeneratorReduceExitOrNext, type GeneratorReduceFunctionParams } from "./reduce";
-export declare function asyncReduce<GenericElement extends unknown, GenericReduceFrom extends GeneratorEligibleReduceFromValue>(startValue: GenericReduceFrom, theFunction: (params: GeneratorReduceFunctionParams<GenericElement, GeneratorReduceFromValue<GenericReduceFrom>>) => GeneratorReduceExitOrNext<GeneratorReduceFromValue<GenericReduceFrom>>): (iterator: Iterable<GenericElement> | AsyncIterable<GenericElement>) => Promise<GeneratorReduceFromValue<GenericReduceFrom>>;
-export declare function asyncReduce<GenericElement extends unknown, GenericReduceFrom extends GeneratorEligibleReduceFromValue>(iterator: Iterable<GenericElement> | AsyncIterable<GenericElement>, startValue: GenericReduceFrom, theFunction: (params: GeneratorReduceFunctionParams<GenericElement, GeneratorReduceFromValue<GenericReduceFrom>>) => GeneratorReduceExitOrNext<GeneratorReduceFromValue<GenericReduceFrom>>): Promise<GeneratorReduceFromValue<GenericReduceFrom>>;
+import { type GeneratorReduceFromValue, type GeneratorEligibleReduceFromValue, type GeneratorReduceFunctionParams, type GeneratorReduceExit, type GeneratorReduceNext } from "./reduce";
+import { type IsEqual, type MaybePromise } from "../common";
+export declare function asyncReduce<GenericElement extends unknown, GenericReduceFrom extends GeneratorEligibleReduceFromValue, GenericExit extends GeneratorReduceExit = GeneratorReduceExit<never>>(startValue: GenericReduceFrom, theFunction: (params: GeneratorReduceFunctionParams<GenericElement, GeneratorReduceFromValue<GenericReduceFrom>>) => MaybePromise<GeneratorReduceNext<GeneratorReduceFromValue<GenericReduceFrom>> | GenericExit>): (iterator: Iterable<GenericElement> | AsyncIterable<GenericElement>) => Promise<GeneratorReduceFromValue<GenericReduceFrom> | (IsEqual<GenericExit, GeneratorReduceExit> extends true ? never : GenericExit["-exit"])>;
+export declare function asyncReduce<GenericElement extends unknown, GenericReduceFrom extends GeneratorEligibleReduceFromValue, GenericExit extends GeneratorReduceExit = GeneratorReduceExit<never>>(iterator: Iterable<GenericElement> | AsyncIterable<GenericElement>, startValue: GenericReduceFrom, theFunction: (params: GeneratorReduceFunctionParams<GenericElement, GeneratorReduceFromValue<GenericReduceFrom>>) => MaybePromise<GeneratorReduceNext<GeneratorReduceFromValue<GenericReduceFrom>> | GenericExit>): Promise<GeneratorReduceFromValue<GenericReduceFrom> | (IsEqual<GenericExit, GeneratorReduceExit> extends true ? never : GenericExit["-exit"])>;

package/dist/generator/asyncReduce.mjs

@@ -13,7 +13,7 @@ function asyncReduce(...args) {
     return (async () => {
         let index = 0;
         for await (const element of iterator) {
-            const result = theFunction({
+            const result = await theFunction({
                 element,
                 index,
                 lastValue,

package/dist/generator/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 GeneratorReduceNext<GenericOutput extends unknown> {
+import { type IsEqual, type ToLargeEnsemble } from "../common";
+export interface GeneratorReduceNext<GenericOutput extends unknown = unknown> {
     "-next": GenericOutput;
 }
-interface GeneratorReduceExit<GenericOutput extends unknown> {
+export interface GeneratorReduceExit<GenericOutput extends unknown = unknown> {
     "-exit": GenericOutput;
 }
-export type GeneratorReduceExitOrNext<GenericOutput extends unknown = unknown> = GeneratorReduceExit<GenericOutput> | GeneratorReduceNext<GenericOutput>;
 export interface GeneratorReduceFunctionParams<GenericElement extends unknown = unknown, GenericOutput extends unknown = unknown> {
     element: GenericElement;
     index: number;
     lastValue: GenericOutput;
     nextWithObject: GenericOutput extends object ? (object1: GenericOutput, object2: Partial<GenericOutput>) => GeneratorReduceNext<GenericOutput> : undefined;
     next(output: GenericOutput): GeneratorReduceNext<GenericOutput>;
-    exit(output: GenericOutput): GeneratorReduceExit<GenericOutput>;
+    exit<GenericExitValue extends unknown>(output: GenericExitValue): GeneratorReduceExit<GenericExitValue>;
 }
 declare const generatorReduceFromKind: import("../common").KindHandler<import("../common").KindDefinition<"generator-reduce-from", unknown>>;
 export interface GeneratorReduceFromResult<GenericValue extends unknown = unknown> extends Kind<typeof generatorReduceFromKind.definition>, WrappedValue<GenericValue> {
@@ -23,6 +22,6 @@ export interface GeneratorReduceFromResult<GenericValue extends unknown = unknow
 export declare function reduceFrom<GenericValue extends unknown>(value: GenericValue): GeneratorReduceFromResult<GenericValue>;
 export type GeneratorEligibleReduceFromValue = number | string | bigint | boolean | GeneratorReduceFromResult;
 export type GeneratorReduceFromValue<GenericValue extends GeneratorEligibleReduceFromValue> = GenericValue extends GeneratorReduceFromResult ? Unwrap<GenericValue> : ToLargeEnsemble<GenericValue>;
-export declare function reduce<GenericElement extends unknown, GenericReduceFrom extends GeneratorEligibleReduceFromValue>(startValue: GenericReduceFrom, theFunction: (params: GeneratorReduceFunctionParams<GenericElement, GeneratorReduceFromValue<GenericReduceFrom>>) => GeneratorReduceExitOrNext<GeneratorReduceFromValue<GenericReduceFrom>>): (iterator: Iterable<GenericElement>) => GeneratorReduceFromValue<GenericReduceFrom>;
-export declare function reduce<GenericElement extends unknown, GenericReduceFrom extends GeneratorEligibleReduceFromValue>(iterator: Iterable<GenericElement>, startValue: GenericReduceFrom, theFunction: (params: GeneratorReduceFunctionParams<GenericElement, GeneratorReduceFromValue<GenericReduceFrom>>) => GeneratorReduceExitOrNext<GeneratorReduceFromValue<GenericReduceFrom>>): GeneratorReduceFromValue<GenericReduceFrom>;
+export declare function reduce<GenericElement extends unknown, GenericReduceFrom extends GeneratorEligibleReduceFromValue, GenericExit extends GeneratorReduceExit = GeneratorReduceExit<never>>(startValue: GenericReduceFrom, theFunction: (params: GeneratorReduceFunctionParams<GenericElement, GeneratorReduceFromValue<GenericReduceFrom>>) => GeneratorReduceNext<GeneratorReduceFromValue<GenericReduceFrom>> | GenericExit): (iterator: Iterable<GenericElement>) => GeneratorReduceFromValue<GenericReduceFrom> | (IsEqual<GenericExit, GeneratorReduceExit> extends true ? never : GenericExit["-exit"]);
+export declare function reduce<GenericElement extends unknown, GenericReduceFrom extends GeneratorEligibleReduceFromValue, GenericExit extends GeneratorReduceExit = GeneratorReduceExit<never>>(iterator: Iterable<GenericElement>, startValue: GenericReduceFrom, theFunction: (params: GeneratorReduceFunctionParams<GenericElement, GeneratorReduceFromValue<GenericReduceFrom>>) => GeneratorReduceNext<GeneratorReduceFromValue<GenericReduceFrom>> | GenericExit): GeneratorReduceFromValue<GenericReduceFrom> | (IsEqual<GenericExit, GeneratorReduceExit> extends true ? never : GenericExit["-exit"]);
 export {};

package/dist/index.cjs

@@ -39,6 +39,7 @@ var memo = require('./common/memo.cjs');
 var instanceOf = require('./common/instanceOf.cjs');
 var globalStore = require('./common/globalStore.cjs');
 var builder = require('./common/builder.cjs');
+var createKindIdentifier = require('./common/createKindIdentifier.cjs');
 var index = require('./array/index.cjs');
 var index$1 = require('./number/index.cjs');
 var index$2 = require('./either/index.cjs');
@@ -103,6 +104,7 @@ exports.createGlobalStore = globalStore.createGlobalStore;
 exports.MissingBuilderMethodsError = builder.MissingBuilderMethodsError;
 exports.builderKind = builder.builderKind;
 exports.createBuilder = builder.createBuilder;
+exports.createKindIdentifier = createKindIdentifier.createKindIdentifier;
 exports.A = index;
 exports.DArray = index;
 exports.DNumber = index$1;

package/dist/index.mjs

@@ -37,6 +37,7 @@ export { memo } from './common/memo.mjs';
 export { instanceOf } from './common/instanceOf.mjs';
 export { createGlobalStore } from './common/globalStore.mjs';
 export { MissingBuilderMethodsError, builderKind, createBuilder } from './common/builder.mjs';
+export { createKindIdentifier } from './common/createKindIdentifier.mjs';
 import * as index from './array/index.mjs';
 export { index as A };
 export { index as DArray };

package/dist/object/entries.d.ts

@@ -1,7 +1,8 @@
+import { type DString } from "..";
 import { type IsEqual, type ObjectEntry, type ObjectKey } from "../common";
 import { type SimplifyTopLevel } from "../common/types/simplifyTopLevel";
 export type GetEntry<GenericKey extends ObjectKey, GenericValue extends unknown> = GenericValue extends any ? GenericKey extends string | number ? [`${GenericKey}`, GenericValue] : never : never;
-export type GetEntries<GenericObject extends object> = ({
+export type GetEntries<GenericObject extends object> = GenericObject extends readonly any[] ? [DString.Number, GenericObject[number]][] : ({
     [Prop in keyof GenericObject]-?: GetEntry<Prop, GenericObject[Prop]>;
 }[keyof GenericObject]) extends infer InferredResult extends ObjectEntry ? IsEqual<InferredResult, never> extends true ? [] : InferredResult[] : never;
 export declare function entries<GenericObject extends object>(object: GenericObject): SimplifyTopLevel<GetEntries<GenericObject>>;

package/dist/object/values.cjs

@@ -1,7 +1,14 @@
 'use strict';
 
+var kind = require('../common/kind.cjs');
+var wrapValue = require('../common/wrapValue.cjs');
+require('../common/globalStore.cjs');
+require('../common/builder.cjs');
+
 function values(object) {
-    return Object.values(object);
+    return Object.entries(object)
+        .filter(([key]) => !wrapValue.isRuntimeWrappedValueKey(key) && !kind.isRuntimeKind(key))
+        .map(([, value]) => value);
 }
 
 exports.values = values;

package/dist/object/values.d.ts

@@ -1,4 +1,2 @@
 import { type AnyValue } from "../common/types/anyValue";
-export declare function values<GenericValue extends AnyValue>(object: {
-    [key: string]: GenericValue;
-} | ArrayLike<GenericValue>): GenericValue[];
+export declare function values<GenericValue extends AnyValue>(object: Record<string, GenericValue>): GenericValue[];

package/dist/object/values.mjs

@@ -1,5 +1,12 @@
+import { isRuntimeKind } from '../common/kind.mjs';
+import { isRuntimeWrappedValueKey } from '../common/wrapValue.mjs';
+import '../common/globalStore.mjs';
+import '../common/builder.mjs';
+
 function values(object) {
-    return Object.values(object);
+    return Object.entries(object)
+        .filter(([key]) => !isRuntimeWrappedValueKey(key) && !isRuntimeKind(key))
+        .map(([, value]) => value);
 }
 
 export { values };

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

@@ -9,3 +9,4 @@ export * from "./stringLength";
 export * from "./forbiddenString";
 export * from "./number";
 export * from "./digit";
+export * from "./templateLiteralContainLargeType";

package/dist/string/types/templateLiteralContainLargeType.d.ts

@@ -0,0 +1,5 @@
+import { type IsEqual, type Or } from "../../common";
+export type TemplateLiteralContainLargeType<GenericValue extends string> = (GenericValue extends `${infer InferredFirst}${infer InferredLast}` ? Or<[
+    IsEqual<InferredFirst, `${number}`>,
+    IsEqual<InferredFirst, `${bigint}`>
+]> extends false ? TemplateLiteralContainLargeType<InferredLast> : true : GenericValue extends "" ? false : true) extends false ? false : true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/utils",
-  "version": "1.1.13",
+  "version": "1.1.15",
   "author": "mathcovax",
   "license": "MIT",
   "type": "module",
@@ -9,7 +9,7 @@
     "url": "git+https://github.com/duplojs/utils.git"
   },
   "scripts": {
-    "build": "rollup --config && tsc-alias -p tsconfig.build.json",
+    "build": "rollup --config",
     "test:tu": "vitest --coverage",
     "test:tu:bench": "vitest bench",
     "test:tu:watch": "vitest --coverage --watch",
@@ -98,7 +98,7 @@
     "rollup": "4.50.0",
     "rollup-plugin-delete": "3.0.1",
     "rollup-plugin-esbuild": "6.2.1",
-    "tsc-alias": "1.8.16",
+    "rollup-plugin-tsc-alias": "1.1.4",
     "tslib": "2.8.1",
     "tsx": "4.20.5",
     "typescript": "5.9.2",

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

@@ -1,30 +0,0 @@
-import { type NeverCoalescing, type Kind } from "../../common";
-import { type DataParserDefinition, type DataParser, type Output, type Input } from "../base";
-import { type MergeDefinition } from "../../dataParser/types";
-import { type DataParserString } from "./string";
-import { type DataParserTemplateLiteral } from "./templateLiteral";
-import { type DataParserDefinitionLiteral, type DataParserLiteral } from "./literal";
-import { type DataParserDefinitionNumber, type DataParserNumber } from "./number";
-import { type DataParserDefinitionUnion, type DataParserUnion } from "./union";
-export type DataParserRecordKey = (DataParserString | DataParserTemplateLiteral | DataParserLiteral<DataParserDefinitionLiteral & {
-    value: string[];
-}> | DataParserNumber<DataParserDefinitionNumber & {
-    coerce: true;
-}> | DataParserUnion<DataParserDefinitionUnion & {
-    options: DataParserRecordKey[];
-}>);
-export interface DataParserDefinitionRecord extends DataParserDefinition<never> {
-    readonly key: DataParserRecordKey;
-    readonly value: DataParser;
-}
-export declare const recordKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/record", unknown>>;
-export type DataParserRecordShapeOutput<GenericDataParserKey extends DataParserRecordKey, GenericDataParserValue extends DataParser> = Extract<Record<Output<GenericDataParserKey> extends infer InferredKey extends string | number ? `${InferredKey}` : never, Output<GenericDataParserValue> extends infer InferredValue ? InferredValue : never>, any>;
-export type DataParserRecordShapeInput<GenericDataParserKey extends DataParserRecordKey, GenericDataParserValue extends DataParser> = Extract<Record<Input<GenericDataParserKey> extends infer InferredKey extends string | number ? InferredKey : never, Input<GenericDataParserValue> extends infer InferredValue ? InferredValue : never>, any>;
-type _DataParserRecord<GenericDefinition extends DataParserDefinitionRecord> = (DataParser<GenericDefinition, DataParserRecordShapeOutput<GenericDefinition["key"], GenericDefinition["value"]> extends infer InferredOutput ? InferredOutput : never, DataParserRecordShapeInput<GenericDefinition["key"], GenericDefinition["value"]>> & Kind<typeof recordKind.definition>);
-export interface DataParserRecord<GenericDefinition extends DataParserDefinitionRecord = DataParserDefinitionRecord> extends _DataParserRecord<GenericDefinition> {
-}
-export declare function record<GenericDataParserKey extends DataParserRecordKey, GenericDataParserValue extends DataParser, const GenericDefinition extends Partial<DataParserDefinitionRecord> = never>(key: GenericDataParserKey, value: GenericDataParserValue, definition?: GenericDefinition): DataParserRecord<MergeDefinition<DataParserDefinitionRecord, NeverCoalescing<GenericDefinition, {}> & {
-    key: GenericDataParserKey;
-    value: GenericDataParserValue;
-}>>;
-export {};

package/dist/dataParser/parsers/templateLiteral.cjs

@@ -1,47 +0,0 @@
-'use strict';
-
-var escapeRegExp = require('../../common/escapeRegExp.cjs');
-var pipe = require('../../common/pipe.cjs');
-var innerPipe = require('../../common/innerPipe.cjs');
-var when$1 = require('../../common/when.cjs');
-var isType = require('../../common/isType.cjs');
-var whenElse = require('../../common/whenElse.cjs');
-var map = require('../../array/map.cjs');
-var join = require('../../array/join.cjs');
-require('../../common/globalStore.cjs');
-require('../../common/builder.cjs');
-var base = require('../base.cjs');
-var error = require('../error.cjs');
-require('../../pattern/result.cjs');
-var exhaustive = require('../../pattern/exhaustive.cjs');
-var when = require('../../pattern/when.cjs');
-var replace = require('../../string/replace.cjs');
-var index = require('./string/index.cjs');
-var index$2 = require('./number/index.cjs');
-var index$1 = require('./bigint/index.cjs');
-var literal = require('./literal.cjs');
-var empty = require('./empty.cjs');
-var nil = require('./nil.cjs');
-var boolean = require('./boolean.cjs');
-var kind = require('../kind.cjs');
-
-const templateLiteralKind = kind.createDataParserKind("template-literal");
-function templateLiteral(template, definition) {
-    const pattern = pipe.pipe(template, map.map(innerPipe.innerPipe(when.when(isType.isType("string"), (value) => `(?:${escapeRegExp.escapeRegExp(value)})`), when.when(index$2.numberKind.has, () => "(:?[0-9]+)"), when.when(index$1.bigIntKind.has, () => "(?:[0-9]+n)"), when.when(boolean.booleanKind.has, () => "(?:true|false)"), when.when(nil.nilKind.has, () => "(?:null)"), when.when(empty.emptyKind.has, () => "(?:undefined)"), when.when(literal.literalKind.has, (dataParser) => pipe.pipe(dataParser.definition.value, map.map(innerPipe.innerPipe(when$1.when(isType.isType("bigint"), (value) => `${value}n`), String, escapeRegExp.escapeRegExp)), join.join("|"), (pattern) => `(?:${pattern})`)), when.when(index.stringKind.has, innerPipe.innerPipe(whenElse.whenElse((dataParser) => !!dataParser.definition.checkers.length, (dataParser) => pipe.pipe(dataParser.definition.checkers, map.map((element) => pipe.pipe(element.definition.pattern.source, replace.replace(/^\^/, ""), replace.replace(/\$$/, ""))), join.join("")), () => "(?:[^]*)"))), when.when(templateLiteralKind.has, (dataParser) => pipe.pipe(dataParser.definition.pattern.source, replace.replace(/^\^/, ""), replace.replace(/\$$/, ""), (pattern) => `(?:${pattern})`)), exhaustive.exhaustive)), join.join(""), (pattern) => new RegExp(`^${pattern}$`));
-    return base.dataParserInit(templateLiteralKind, {
-        definition: {
-            errorMessage: definition?.errorMessage,
-            checkers: definition?.checkers ?? [],
-            template,
-            pattern,
-        },
-    }, (data, _error, self) => {
-        if (typeof data === "string" && self.definition.pattern.test(data)) {
-            return data;
-        }
-        return error.SymbolDataParserErrorIssue;
-    });
-}
-
-exports.templateLiteral = templateLiteral;
-exports.templateLiteralKind = templateLiteralKind;

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

@@ -1,49 +0,0 @@
-import { type Adaptor, type Kind, type NeverCoalescing } from "../../common";
-import { type DataParserDefinition, type DataParser, type Output, type Input } from "../base";
-import { type MergeDefinition } from "../../dataParser/types";
-import { type DataParserCheckerEmail, type DataParserDefinitionString, type DataParserString } from "./string";
-import { type DataParserDefinitionNumber, type DataParserNumber } from "./number";
-import { type DataParserDefinitionBigInt, type DataParserBigInt } from "./bigint";
-import { type DataParserDefinitionLiteral, type DataParserLiteral } from "./literal";
-import { type DataParserDefinitionEmpty, type DataParserEmpty } from "./empty";
-import { type DataParserDefinitionNil, type DataParserNil } from "./nil";
-import { type DataParserDefinitionBoolean, type DataParserBoolean } from "./boolean";
-export type DataParsersTemplateLiteral = (string | DataParserString<DataParserDefinitionString & {
-    readonly checkers: readonly (DataParserCheckerEmail)[];
-}> | DataParserNumber<DataParserDefinitionNumber & {
-    readonly checkers: readonly [];
-}> | DataParserBigInt<DataParserDefinitionBigInt & {
-    readonly checkers: readonly [];
-}> | DataParserBoolean<DataParserDefinitionBoolean & {
-    readonly checkers: readonly [];
-}> | DataParserLiteral<DataParserDefinitionLiteral & {
-    readonly checkers: readonly [];
-}> | DataParserEmpty<DataParserDefinitionEmpty & {
-    readonly checkers: readonly [];
-}> | DataParserNil<DataParserDefinitionNil & {
-    readonly checkers: readonly [];
-}> | DataParserTemplateLiteral<DataParserDefinitionTemplateLiteral & {
-    readonly checkers: readonly [];
-}>);
-export type TemplateLiteralShape = readonly [DataParsersTemplateLiteral, ...DataParsersTemplateLiteral[]];
-type EligibleTemplateLiteral = string | number | bigint | boolean | null | undefined;
-export type TemplateLiteralShapeOutput<GenericTemplate extends TemplateLiteralShape, GenericLastResult extends string = ""> = GenericTemplate extends readonly [
-    infer InferredFirst extends DataParsersTemplateLiteral,
-    ...infer InferredRest extends DataParsersTemplateLiteral[]
-] ? (`${GenericLastResult}${InferredFirst extends string ? InferredFirst : Adaptor<Output<Exclude<InferredFirst, string>>, EligibleTemplateLiteral>}`) extends infer InferredResult extends string ? InferredRest extends readonly [] ? InferredResult : InferredRest extends TemplateLiteralShape ? TemplateLiteralShapeOutput<InferredRest, InferredResult> : TemplateLiteralShapeOutput<[InferredRest[number]], InferredResult> : never : never;
-export type TemplateLiteralShapeInput<GenericTemplate extends TemplateLiteralShape, GenericLastResult extends string = ""> = GenericTemplate extends readonly [
-    infer InferredFirst extends DataParsersTemplateLiteral,
-    ...infer InferredRest extends DataParsersTemplateLiteral[]
-] ? (`${GenericLastResult}${InferredFirst extends string ? InferredFirst : Adaptor<Input<Exclude<InferredFirst, string>>, EligibleTemplateLiteral>}`) extends infer InferredResult extends string ? InferredRest extends readonly [] ? InferredResult : InferredRest extends TemplateLiteralShape ? TemplateLiteralShapeInput<InferredRest, InferredResult> : TemplateLiteralShapeInput<[InferredRest[number]], InferredResult> : never : never;
-export interface DataParserDefinitionTemplateLiteral extends DataParserDefinition<never> {
-    readonly template: TemplateLiteralShape;
-    readonly pattern: RegExp;
-}
-export declare const templateLiteralKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/template-literal", unknown>>;
-type _DataParserTemplateLiteral<GenericDefinition extends DataParserDefinitionTemplateLiteral> = (DataParser<GenericDefinition, TemplateLiteralShapeOutput<GenericDefinition["template"]>, TemplateLiteralShapeInput<GenericDefinition["template"]>> & Kind<typeof templateLiteralKind.definition>);
-export interface DataParserTemplateLiteral<GenericDefinition extends DataParserDefinitionTemplateLiteral = DataParserDefinitionTemplateLiteral> extends _DataParserTemplateLiteral<GenericDefinition> {
-}
-export declare function templateLiteral<const GenericTemplate extends TemplateLiteralShape, const GenericDefinition extends Partial<Omit<DataParserDefinitionTemplateLiteral, "template" | "pattern">> = never>(template: GenericTemplate, definition?: GenericDefinition): DataParserTemplateLiteral<MergeDefinition<DataParserDefinitionTemplateLiteral, NeverCoalescing<GenericDefinition, {}> & {
-    template: GenericTemplate;
-}>>;
-export {};

package/dist/dataParser/parsers/templateLiteral.mjs

@@ -1,44 +0,0 @@
-import { escapeRegExp } from '../../common/escapeRegExp.mjs';
-import { pipe } from '../../common/pipe.mjs';
-import { innerPipe } from '../../common/innerPipe.mjs';
-import { when as when$1 } from '../../common/when.mjs';
-import { isType } from '../../common/isType.mjs';
-import { whenElse } from '../../common/whenElse.mjs';
-import { map } from '../../array/map.mjs';
-import { join } from '../../array/join.mjs';
-import '../../common/globalStore.mjs';
-import '../../common/builder.mjs';
-import { dataParserInit } from '../base.mjs';
-import { SymbolDataParserErrorIssue } from '../error.mjs';
-import '../../pattern/result.mjs';
-import { exhaustive } from '../../pattern/exhaustive.mjs';
-import { when } from '../../pattern/when.mjs';
-import { replace } from '../../string/replace.mjs';
-import { stringKind } from './string/index.mjs';
-import { numberKind } from './number/index.mjs';
-import { bigIntKind } from './bigint/index.mjs';
-import { literalKind } from './literal.mjs';
-import { emptyKind } from './empty.mjs';
-import { nilKind } from './nil.mjs';
-import { booleanKind } from './boolean.mjs';
-import { createDataParserKind } from '../kind.mjs';
-
-const templateLiteralKind = createDataParserKind("template-literal");
-function templateLiteral(template, definition) {
-    const pattern = pipe(template, map(innerPipe(when(isType("string"), (value) => `(?:${escapeRegExp(value)})`), when(numberKind.has, () => "(:?[0-9]+)"), when(bigIntKind.has, () => "(?:[0-9]+n)"), when(booleanKind.has, () => "(?:true|false)"), when(nilKind.has, () => "(?:null)"), when(emptyKind.has, () => "(?:undefined)"), when(literalKind.has, (dataParser) => pipe(dataParser.definition.value, map(innerPipe(when$1(isType("bigint"), (value) => `${value}n`), String, escapeRegExp)), join("|"), (pattern) => `(?:${pattern})`)), when(stringKind.has, innerPipe(whenElse((dataParser) => !!dataParser.definition.checkers.length, (dataParser) => pipe(dataParser.definition.checkers, map((element) => pipe(element.definition.pattern.source, replace(/^\^/, ""), replace(/\$$/, ""))), join("")), () => "(?:[^]*)"))), when(templateLiteralKind.has, (dataParser) => pipe(dataParser.definition.pattern.source, replace(/^\^/, ""), replace(/\$$/, ""), (pattern) => `(?:${pattern})`)), exhaustive)), join(""), (pattern) => new RegExp(`^${pattern}$`));
-    return dataParserInit(templateLiteralKind, {
-        definition: {
-            errorMessage: definition?.errorMessage,
-            checkers: definition?.checkers ?? [],
-            template,
-            pattern,
-        },
-    }, (data, _error, self) => {
-        if (typeof data === "string" && self.definition.pattern.test(data)) {
-            return data;
-        }
-        return SymbolDataParserErrorIssue;
-    });
-}
-
-export { templateLiteral, templateLiteralKind };