@duplojs/utils 1.6.2 → 1.6.3

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

@@ -1,5 +1,5 @@
 import { dataParserInit } from '../../base.mjs';
-import { SymbolDataParserErrorIssue } from '../../error.mjs';
+import { addIssue } from '../../error.mjs';
 import { createDataParserKind } from '../../kind.mjs';
 import { createTemplateLiteralPattern } from './createTemplateLiteralPattern.mjs';
 import { pipe } from '../../../common/pipe.mjs';
@@ -16,11 +16,11 @@ function templateLiteral(template, definition) {
         checkers: definition?.checkers ?? [],
         template,
         pattern,
-    }, (data, _error, self) => {
+    }, (data, error, self) => {
         if (typeof data === "string" && self.definition.pattern.test(data)) {
             return data;
         }
-        return SymbolDataParserErrorIssue;
+        return addIssue(error, `string matching template literal pattern ${self.definition.pattern.source}`, data, self.definition.errorMessage);
     }, templateLiteral.overrideHandler);
     return self;
 }

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

@@ -15,7 +15,9 @@ function checkerTimeMax(max, definition = {}) {
             ...definition,
             max,
         },
-    }, (value, self) => lessTime.lessTime(value, self.definition.max) ? value : error.SymbolDataParserErrorIssue);
+    }, (value, error$1, self) => lessTime.lessTime(value, self.definition.max)
+        ? value
+        : error.addIssue(error$1, `time <= ${self.definition.max.toString()}`, value, self.definition.errorMessage));
 }
 
 exports.checkerTimeMax = checkerTimeMax;

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

@@ -1,5 +1,5 @@
 import { dataParserCheckerInit } from '../../../base.mjs';
-import { SymbolDataParserErrorIssue } from '../../../error.mjs';
+import { addIssue } from '../../../error.mjs';
 import { createDataParserKind } from '../../../kind.mjs';
 import { lessTime } from '../../../../date/operators/lessTime.mjs';
 
@@ -13,7 +13,9 @@ function checkerTimeMax(max, definition = {}) {
             ...definition,
             max,
         },
-    }, (value, self) => lessTime(value, self.definition.max) ? value : SymbolDataParserErrorIssue);
+    }, (value, error, self) => lessTime(value, self.definition.max)
+        ? value
+        : addIssue(error, `time <= ${self.definition.max.toString()}`, value, self.definition.errorMessage));
 }
 
 export { checkerTimeMax, checkerTimeMaxKind };

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

@@ -15,7 +15,9 @@ function checkerTimeMin(min, definition = {}) {
             ...definition,
             min,
         },
-    }, (value, self) => greaterTime.greaterTime(value, self.definition.min) ? value : error.SymbolDataParserErrorIssue);
+    }, (value, error$1, self) => greaterTime.greaterTime(value, self.definition.min)
+        ? value
+        : error.addIssue(error$1, `time >= ${self.definition.min.toString()}`, value, self.definition.errorMessage));
 }
 
 exports.checkerTimeMin = checkerTimeMin;

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

@@ -1,5 +1,5 @@
 import { dataParserCheckerInit } from '../../../base.mjs';
-import { SymbolDataParserErrorIssue } from '../../../error.mjs';
+import { addIssue } from '../../../error.mjs';
 import { createDataParserKind } from '../../../kind.mjs';
 import { greaterTime } from '../../../../date/operators/greaterTime.mjs';
 
@@ -13,7 +13,9 @@ function checkerTimeMin(min, definition = {}) {
             ...definition,
             min,
         },
-    }, (value, self) => greaterTime(value, self.definition.min) ? value : SymbolDataParserErrorIssue);
+    }, (value, error, self) => greaterTime(value, self.definition.min)
+        ? value
+        : addIssue(error, `time >= ${self.definition.min.toString()}`, value, self.definition.errorMessage));
 }
 
 export { checkerTimeMin, checkerTimeMinKind };

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

@@ -22,12 +22,12 @@ function time(definition) {
         errorMessage: definition?.errorMessage,
         checkers: definition?.checkers ?? [],
         coerce: definition?.coerce ?? false,
-    }, (data, _error, self) => {
+    }, (data, error$1, self) => {
         if (self.definition.coerce) {
             if (typeof data === "string" && constants.isoTimeRegex.test(data)) {
                 const result = createTime.createTime({ value: data });
                 if (is.isLeft(result)) {
-                    return error.SymbolDataParserErrorIssue;
+                    return error.addIssue(error$1, "time", data, self.definition.errorMessage);
                 }
                 return unwrap.unwrap(result);
             }
@@ -40,11 +40,11 @@ function time(definition) {
         }
         else if (typeof data === "number") {
             if (!isSafeTimeValue.isSafeTimeValue(data)) {
-                return error.SymbolDataParserErrorIssue;
+                return error.addIssue(error$1, "time", data, self.definition.errorMessage);
             }
             return theTime.TheTime.new(data);
         }
-        return error.SymbolDataParserErrorIssue;
+        return error.addIssue(error$1, "time", data, self.definition.errorMessage);
     }, time.overrideHandler);
     return self;
 }

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

@@ -1,5 +1,5 @@
 import { dataParserInit } from '../../base.mjs';
-import { SymbolDataParserErrorIssue } from '../../error.mjs';
+import { addIssue } from '../../error.mjs';
 import { createDataParserKind } from '../../kind.mjs';
 import { isoTimeRegex } from '../../../date/constants.mjs';
 import { createTime } from '../../../date/createTime.mjs';
@@ -20,12 +20,12 @@ function time(definition) {
         errorMessage: definition?.errorMessage,
         checkers: definition?.checkers ?? [],
         coerce: definition?.coerce ?? false,
-    }, (data, _error, self) => {
+    }, (data, error, self) => {
         if (self.definition.coerce) {
             if (typeof data === "string" && isoTimeRegex.test(data)) {
                 const result = createTime({ value: data });
                 if (isLeft(result)) {
-                    return SymbolDataParserErrorIssue;
+                    return addIssue(error, "time", data, self.definition.errorMessage);
                 }
                 return unwrap(result);
             }
@@ -38,11 +38,11 @@ function time(definition) {
         }
         else if (typeof data === "number") {
             if (!isSafeTimeValue(data)) {
-                return SymbolDataParserErrorIssue;
+                return addIssue(error, "time", data, self.definition.errorMessage);
             }
             return TheTime.new(data);
         }
-        return SymbolDataParserErrorIssue;
+        return addIssue(error, "time", data, self.definition.errorMessage);
     }, time.overrideHandler);
     return self;
 }

package/dist/dataParser/parsers/transform.cjs

@@ -18,23 +18,23 @@ function transform(inner, theFunction, definition) {
     }, {
         sync: (data, error$1, self) => {
             const innerResult = self.definition.inner.exec(data, error$1);
-            if (innerResult === base.SymbolDataParserError) {
-                return base.SymbolDataParserError;
+            if (innerResult === error.SymbolDataParserError) {
+                return error.SymbolDataParserError;
             }
             const result = self.definition.theFunction(innerResult, error$1);
             if (result instanceof Promise) {
-                return error.SymbolDataParserErrorPromiseIssue;
+                return error.addIssue(error$1, "non-promise transform result", result, self.definition.errorMessage);
             }
             return result;
         },
         async: async (data, error$1, self) => {
             const innerResult = await self.definition.inner.asyncExec(data, error$1);
-            if (innerResult === base.SymbolDataParserError) {
-                return base.SymbolDataParserError;
+            if (innerResult === error.SymbolDataParserError) {
+                return error.SymbolDataParserError;
             }
             let result = self.definition.theFunction(innerResult, error$1);
             if (result instanceof Promise) {
-                result = result.catch(() => error.SymbolDataParserErrorPromiseIssue);
+                result = await result.catch(() => error.addIssue(error$1, "successful async transform result", result, self.definition.errorMessage));
             }
             return result;
         },

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

@@ -1,7 +1,7 @@
 import { type FixDeepFunctionInfer, type Kind, type NeverCoalescing } from "../../common";
 import { type DataParserDefinition, type DataParser, type Input, type Output, SymbolDataParserError, type DataParserChecker } from "../base";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../../dataParser/types";
-import { type DataParserError, type SymbolDataParserErrorIssue, SymbolDataParserErrorPromiseIssue } from "../../dataParser/error";
+import { type DataParserError } from "../../dataParser/error";
 import { type CheckerRefineImplementation } from "./refine";
 import { type GetPropsWithValueExtends } from "../../object";
 export interface DataParserTransformCheckerCustom<GenericInput extends unknown = unknown> {
@@ -12,7 +12,7 @@ export interface DataParserDefinitionTransform extends DataParserDefinition<Data
     theFunction(input: any, error: DataParserError): unknown;
 }
 export declare const transformKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/transform", unknown>>;
-export type DataParserTransformOutput<GenericTheFunction extends DataParserDefinitionTransform["theFunction"]> = Exclude<Awaited<ReturnType<GenericTheFunction>>, SymbolDataParserError | SymbolDataParserErrorIssue | SymbolDataParserErrorPromiseIssue>;
+export type DataParserTransformOutput<GenericTheFunction extends DataParserDefinitionTransform["theFunction"]> = Exclude<Awaited<ReturnType<GenericTheFunction>>, SymbolDataParserError>;
 type _DataParserTransform<GenericDefinition extends DataParserDefinitionTransform> = (DataParser<GenericDefinition, DataParserTransformOutput<GenericDefinition["theFunction"]>, Input<GenericDefinition["inner"]>> & Kind<typeof transformKind.definition>);
 export interface DataParserTransform<GenericDefinition extends DataParserDefinitionTransform = DataParserDefinitionTransform> extends _DataParserTransform<GenericDefinition> {
     addChecker<GenericChecker extends readonly [

package/dist/dataParser/parsers/transform.mjs

@@ -1,5 +1,5 @@
-import { dataParserInit, SymbolDataParserError } from '../base.mjs';
-import { SymbolDataParserErrorPromiseIssue } from '../error.mjs';
+import { dataParserInit } from '../base.mjs';
+import { SymbolDataParserError, addIssue } from '../error.mjs';
 import { createDataParserKind } from '../kind.mjs';
 import { createOverride } from '../../common/override.mjs';
 
@@ -21,7 +21,7 @@ function transform(inner, theFunction, definition) {
             }
             const result = self.definition.theFunction(innerResult, error);
             if (result instanceof Promise) {
-                return SymbolDataParserErrorPromiseIssue;
+                return addIssue(error, "non-promise transform result", result, self.definition.errorMessage);
             }
             return result;
         },
@@ -32,7 +32,7 @@ function transform(inner, theFunction, definition) {
             }
             let result = self.definition.theFunction(innerResult, error);
             if (result instanceof Promise) {
-                result = result.catch(() => SymbolDataParserErrorPromiseIssue);
+                result = await result.catch(() => addIssue(error, "successful async transform result", result, self.definition.errorMessage));
             }
             return result;
         },

package/dist/dataParser/parsers/tuple.cjs

@@ -19,17 +19,17 @@ function tuple(shape, definition) {
     }, {
         sync: (data, error$1, self) => {
             if (!(data instanceof Array)) {
-                return error.SymbolDataParserErrorIssue;
+                return error.addIssue(error$1, "tuple array", data, self.definition.errorMessage);
             }
             let output = [];
             const currentIndexPath = error$1.currentPath.length;
             for (let index = 0; index < self.definition.shape.length; index++) {
                 error.setErrorPath(error$1, `[${index}]`, currentIndexPath);
                 const result = self.definition.shape[index]?.exec(data[index], error$1);
-                if (result === base.SymbolDataParserError) {
-                    output = base.SymbolDataParserError;
+                if (result === error.SymbolDataParserError) {
+                    output = error.SymbolDataParserError;
                 }
-                else if (output !== base.SymbolDataParserError) {
+                else if (output !== error.SymbolDataParserError) {
                     output.push(result);
                 }
             }
@@ -37,10 +37,10 @@ function tuple(shape, definition) {
                 for (let index = self.definition.shape.length; index < data.length; index++) {
                     error.setErrorPath(error$1, `[${index}]`, currentIndexPath);
                     const result = self.definition.rest.exec(data[index], error$1);
-                    if (result === base.SymbolDataParserError) {
-                        output = base.SymbolDataParserError;
+                    if (result === error.SymbolDataParserError) {
+                        output = error.SymbolDataParserError;
                     }
-                    else if (output !== base.SymbolDataParserError) {
+                    else if (output !== error.SymbolDataParserError) {
                         output.push(result);
                     }
                 }
@@ -50,17 +50,17 @@ function tuple(shape, definition) {
         },
         async: async (data, error$1, self) => {
             if (!(data instanceof Array)) {
-                return error.SymbolDataParserErrorIssue;
+                return error.addIssue(error$1, "tuple array", data, self.definition.errorMessage);
             }
             let output = [];
             const currentIndexPath = error$1.currentPath.length;
             for (let index = 0; index < self.definition.shape.length; index++) {
                 error.setErrorPath(error$1, `[${index}]`, currentIndexPath);
                 const result = await self.definition.shape[index]?.asyncExec(data[index], error$1);
-                if (result === base.SymbolDataParserError) {
-                    output = base.SymbolDataParserError;
+                if (result === error.SymbolDataParserError) {
+                    output = error.SymbolDataParserError;
                 }
-                else if (output !== base.SymbolDataParserError) {
+                else if (output !== error.SymbolDataParserError) {
                     output.push(result);
                 }
             }
@@ -68,10 +68,10 @@ function tuple(shape, definition) {
                 for (let index = self.definition.shape.length; index < data.length; index++) {
                     error.setErrorPath(error$1, `[${index}]`, currentIndexPath);
                     const result = await self.definition.rest.asyncExec(data[index], error$1);
-                    if (result === base.SymbolDataParserError) {
-                        output = base.SymbolDataParserError;
+                    if (result === error.SymbolDataParserError) {
+                        output = error.SymbolDataParserError;
                     }
-                    else if (output !== base.SymbolDataParserError) {
+                    else if (output !== error.SymbolDataParserError) {
                         output.push(result);
                     }
                 }

package/dist/dataParser/parsers/tuple.mjs

@@ -1,5 +1,5 @@
-import { dataParserInit, SymbolDataParserError } from '../base.mjs';
-import { SymbolDataParserErrorIssue, setErrorPath, popErrorPath } from '../error.mjs';
+import { dataParserInit } from '../base.mjs';
+import { addIssue, setErrorPath, SymbolDataParserError, popErrorPath } from '../error.mjs';
 import { createDataParserKind } from '../kind.mjs';
 import { some } from '../../array/some.mjs';
 import { createOverride } from '../../common/override.mjs';
@@ -17,7 +17,7 @@ function tuple(shape, definition) {
     }, {
         sync: (data, error, self) => {
             if (!(data instanceof Array)) {
-                return SymbolDataParserErrorIssue;
+                return addIssue(error, "tuple array", data, self.definition.errorMessage);
             }
             let output = [];
             const currentIndexPath = error.currentPath.length;
@@ -48,7 +48,7 @@ function tuple(shape, definition) {
         },
         async: async (data, error, self) => {
             if (!(data instanceof Array)) {
-                return SymbolDataParserErrorIssue;
+                return addIssue(error, "tuple array", data, self.definition.errorMessage);
             }
             let output = [];
             const currentIndexPath = error.currentPath.length;

package/dist/dataParser/parsers/union.cjs

@@ -17,22 +17,40 @@ function union(options, definition) {
         options,
     }, {
         sync: (data, error$1, self) => {
-            for (const dataParser of self.definition.options) {
-                const result = dataParser.exec(data, error$1);
-                if (result !== base.SymbolDataParserError) {
+            const unionError = {
+                ...error$1,
+                currentPath: [...error$1.currentPath],
+                issues: [],
+            };
+            const currentIndexPath = unionError.currentPath.length;
+            for (let index = 0; index < self.definition.options.length; index++) {
+                error.setErrorPath(unionError, `(option: ${index})`, currentIndexPath);
+                const dataParser = self.definition.options[index];
+                const result = dataParser.exec(data, unionError);
+                if (result !== error.SymbolDataParserError) {
                     return result;
                 }
             }
-            return error.SymbolDataParserErrorIssue;
+            error$1.issues.push(...unionError.issues);
+            return error.addIssue(error$1, "respect at least one union value", data, self.definition.errorMessage);
         },
         async: async (data, error$1, self) => {
-            for (const dataParser of self.definition.options) {
-                const result = await dataParser.asyncExec(data, error$1);
-                if (result !== base.SymbolDataParserError) {
+            const unionError = {
+                ...error$1,
+                currentPath: [...error$1.currentPath],
+                issues: [],
+            };
+            const currentIndexPath = unionError.currentPath.length;
+            for (let index = 0; index < self.definition.options.length; index++) {
+                error.setErrorPath(unionError, `(option: ${index})`, currentIndexPath);
+                const dataParser = self.definition.options[index];
+                const result = await dataParser.asyncExec(data, unionError);
+                if (result !== error.SymbolDataParserError) {
                     return result;
                 }
             }
-            return error.SymbolDataParserErrorIssue;
+            error$1.issues.push(...unionError.issues);
+            return error.addIssue(error$1, "respect at least one union value", data, self.definition.errorMessage);
         },
         isAsynchronous: (self) => some.some(self.definition.options, (element) => element.isAsynchronous()),
     }, union.overrideHandler);

package/dist/dataParser/parsers/union.mjs

@@ -1,5 +1,5 @@
-import { dataParserInit, SymbolDataParserError } from '../base.mjs';
-import { SymbolDataParserErrorIssue } from '../error.mjs';
+import { dataParserInit } from '../base.mjs';
+import { setErrorPath, SymbolDataParserError, addIssue } from '../error.mjs';
 import { createDataParserKind } from '../kind.mjs';
 import { some } from '../../array/some.mjs';
 import { createOverride } from '../../common/override.mjs';
@@ -15,22 +15,40 @@ function union(options, definition) {
         options,
     }, {
         sync: (data, error, self) => {
-            for (const dataParser of self.definition.options) {
-                const result = dataParser.exec(data, error);
+            const unionError = {
+                ...error,
+                currentPath: [...error.currentPath],
+                issues: [],
+            };
+            const currentIndexPath = unionError.currentPath.length;
+            for (let index = 0; index < self.definition.options.length; index++) {
+                setErrorPath(unionError, `(option: ${index})`, currentIndexPath);
+                const dataParser = self.definition.options[index];
+                const result = dataParser.exec(data, unionError);
                 if (result !== SymbolDataParserError) {
                     return result;
                 }
             }
-            return SymbolDataParserErrorIssue;
+            error.issues.push(...unionError.issues);
+            return addIssue(error, "respect at least one union value", data, self.definition.errorMessage);
         },
         async: async (data, error, self) => {
-            for (const dataParser of self.definition.options) {
-                const result = await dataParser.asyncExec(data, error);
+            const unionError = {
+                ...error,
+                currentPath: [...error.currentPath],
+                issues: [],
+            };
+            const currentIndexPath = unionError.currentPath.length;
+            for (let index = 0; index < self.definition.options.length; index++) {
+                setErrorPath(unionError, `(option: ${index})`, currentIndexPath);
+                const dataParser = self.definition.options[index];
+                const result = await dataParser.asyncExec(data, unionError);
                 if (result !== SymbolDataParserError) {
                     return result;
                 }
             }
-            return SymbolDataParserErrorIssue;
+            error.issues.push(...unionError.issues);
+            return addIssue(error, "respect at least one union value", data, self.definition.errorMessage);
         },
         isAsynchronous: (self) => some(self.definition.options, (element) => element.isAsynchronous()),
     }, union.overrideHandler);

package/dist/index.cjs

@@ -69,6 +69,7 @@ var toRegExp = require('./common/toRegExp.cjs');
 var justExec = require('./common/justExec.cjs');
 var callThen = require('./common/callThen.cjs');
 var queue = require('./common/queue.cjs');
+var printer = require('./common/printer.cjs');
 
 
 
@@ -176,3 +177,7 @@ exports.justExec = justExec.justExec;
 exports.callThen = callThen.callThen;
 exports.createQueue = queue.createQueue;
 exports.queueKind = queue.queueKind;
+Object.defineProperty(exports, "Printer", {
+	enumerable: true,
+	get: function () { return printer.Printer; }
+});

package/dist/index.mjs

@@ -93,3 +93,4 @@ export { toRegExp } from './common/toRegExp.mjs';
 export { justExec } from './common/justExec.mjs';
 export { callThen } from './common/callThen.mjs';
 export { createQueue, queueKind } from './common/queue.mjs';
+export { Printer } from './common/printer.mjs';

package/dist/metadata.json

@@ -645,6 +645,15 @@
             {
               "name": "base.mjs"
             },
+            {
+              "name": "cast.cjs"
+            },
+            {
+              "name": "cast.d.ts"
+            },
+            {
+              "name": "cast.mjs"
+            },
             {
               "name": "index.d.ts"
             },
@@ -1038,6 +1047,15 @@
         {
           "name": "repository.mjs"
         },
+        {
+          "name": "toMapDataParser.cjs"
+        },
+        {
+          "name": "toMapDataParser.d.ts"
+        },
+        {
+          "name": "toMapDataParser.mjs"
+        },
         {
           "name": "useCase.cjs"
         },
@@ -1561,6 +1579,15 @@
         {
           "name": "pipeCall.mjs"
         },
+        {
+          "name": "printer.cjs"
+        },
+        {
+          "name": "printer.d.ts"
+        },
+        {
+          "name": "printer.mjs"
+        },
         {
           "name": "promiseObject.cjs"
         },

package/dist/number/types/isGreater.d.ts

@@ -25,10 +25,33 @@ type CheckIsGreater<GreaterSplitValue extends AnyTuple<DString.Digit>, GreaterTa
     infer InferredRestSplitValue extends AnyTuple<DString.Digit>,
     infer InferredRestSplitReference extends AnyTuple<FigureGreaterThanTableValue>
 ] ? CheckIsGreater<InferredRestSplitValue, InferredRestSplitReference> : never : false;
-export type IsGreater<GenericValue extends number, GenericReference extends number> = IsEqual<GenericValue, GenericReference> extends true ? true : [
-    `${GenericValue}`,
-    `${GenericReference}`
+type toStringDecimal<GenericValue extends number> = `${GenericValue}` extends `${DString.Number}.${DString.Number}` ? `${GenericValue}` : `${GenericValue}.0`;
+type PrepareValues<GenericValue extends number, GenericReference extends number> = [
+    toStringDecimal<GenericValue>,
+    toStringDecimal<GenericReference>
 ] extends [
+    `${infer InferredValueInteger extends DString.Number}.${infer InferredValueDecimals extends DString.Number}`,
+    `${infer InferredReferenceInteger extends DString.Number}.${infer InferredReferenceDecimals extends DString.Number}`
+] ? And<[
+    IsEqual<InferredValueDecimals, "0">,
+    IsEqual<InferredReferenceDecimals, "0">
+]> extends true ? [InferredValueInteger, InferredReferenceInteger] : IsEqual<InferredValueInteger, InferredReferenceInteger> extends true ? [
+    DString.Split<InferredValueDecimals, "">,
+    DString.Split<InferredReferenceDecimals, "">
+] extends [
+    infer InferredSplitValue extends AnyTuple<DString.Digit>,
+    infer InferredSplitReference extends AnyTuple<DString.Digit>
+] ? (IsEqual<InferredSplitValue["length"], InferredSplitReference["length"]> extends true ? [
+    DArray.JoinTuple<InferredSplitValue, "">,
+    DArray.JoinTuple<InferredSplitReference, "">
+] : (DArray.CreateTuple<any, InferredSplitValue["length"]> extends [...DArray.CreateTuple<any, InferredSplitReference["length"]>, ...any[]] ? InferredSplitValue["length"] : InferredSplitReference["length"]) extends infer InferredLength extends number ? [
+    DArray.JoinTuple<Extract<IsEqual<InferredLength, InferredSplitValue["length"]> extends true ? InferredSplitValue : DArray.CreateTuple<"0", InferredLength, InferredSplitValue>, AnyTuple<string>>, "">,
+    DArray.JoinTuple<Extract<IsEqual<InferredLength, InferredSplitReference["length"]> extends true ? InferredSplitReference : DArray.CreateTuple<"0", InferredLength, InferredSplitReference>, AnyTuple<string>>, "">
+] : never) extends [
+    `${infer InferredResultValue}`,
+    `${infer InferredResultReference}`
+] ? [`${InferredResultValue}`, `${InferredResultReference}`] : never : never : [InferredValueInteger, InferredReferenceInteger] : never;
+export type IsGreater<GenericValue extends number, GenericReference extends number> = IsEqual<GenericValue, GenericReference> extends true ? true : PrepareValues<GenericValue, GenericReference> extends [
     infer InferredValue extends DString.Number,
     infer InferredReference extends DString.Number
 ] ? And<[

package/dist/string/length.d.ts

@@ -1,4 +1,4 @@
-import { type StringLength } from "./types/stringLength";
+import { type TemplateLiteralContainLargeType, type StringLength } from "./types";
 /**
  * Returns the length of a string.
  * 
@@ -23,4 +23,4 @@ import { type StringLength } from "./types/stringLength";
  * @namespace S
  * 
  */
-export declare function length<GenericInput extends string>(input: GenericInput): StringLength<GenericInput>;
+export declare function length<GenericInput extends string>(input: GenericInput): TemplateLiteralContainLargeType<GenericInput> extends true ? number : StringLength<GenericInput>;

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

@@ -1,9 +1,10 @@
-import { type Or, type IsEqual } from "../../common";
+import { type IsEqual } from "../../common";
 import { type Includes } from "./includes";
 import { type TemplateLiteralContainLargeType } from "./templateLiteralContainLargeType";
+import { type CreateTuple } from "../../array";
 type _Split<GenericString extends string, GenericSeparator extends string, GenericLimit extends number = number, GenericLastResult extends string[] = []> = GenericString extends `${infer InferredBefore}${GenericSeparator}${infer InferredAfter}` ? [...GenericLastResult, InferredBefore] extends infer InferredResult extends any[] ? IsEqual<InferredAfter, ""> extends true ? InferredResult : IsEqual<InferredResult["length"], 250> extends true ? Includes<InferredAfter, GenericSeparator> extends true ? [...InferredResult, ...string[]] : InferredResult : IsEqual<InferredResult["length"], GenericLimit> extends true ? InferredResult : _Split<InferredAfter, GenericSeparator, GenericLimit, InferredResult> : never : [...GenericLastResult, GenericString];
-export type Split<GenericString extends string, GenericSeparator extends string, GenericLimit extends number = number> = IsEqual<GenericLimit, 0> extends true ? [] : Or<[
-    TemplateLiteralContainLargeType<GenericString>,
-    TemplateLiteralContainLargeType<GenericSeparator>
-]> extends true ? [string, ...string[]] : _Split<GenericString, GenericSeparator, GenericLimit>;
+export type Split<GenericString extends string, GenericSeparator extends string, GenericLimit extends number = number> = IsEqual<GenericLimit, 0> extends true ? [] : TemplateLiteralContainLargeType<GenericSeparator> extends true ? [string, ...string[]] : TemplateLiteralContainLargeType<GenericString> extends true ? [
+    ...CreateTuple<string, _Split<GenericString, GenericSeparator, GenericLimit>["length"]>,
+    ...string[]
+] : _Split<GenericString, GenericSeparator, GenericLimit>;
 export {};

package/package.json

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