@duplojs/utils 1.5.10 → 1.5.12

package/dist/array/at/default.d.ts

@@ -1,6 +1,5 @@
 import type { IsEqual } from "../../common";
-import type { AtTuple } from "../types";
-export type AtArray<GenericArray extends readonly unknown[], GenericIndex extends number> = IsEqual<GenericArray["length"], number> extends true ? GenericArray[number] | undefined : AtTuple<GenericArray, GenericIndex>;
+export type AtArray<GenericArray extends readonly unknown[], GenericIndex extends number> = IsEqual<GenericArray["length"], number> extends true ? GenericArray[number] | undefined : GenericIndex extends keyof GenericArray ? GenericArray[GenericIndex] : GenericArray[number] | undefined;
 /**
  * Accesses an element at a given index, supporting negative indices.
  * 

package/dist/array/at/last.d.ts

@@ -1,3 +1,4 @@
+import { type AnyTuple } from "../../common";
 /**
  * Gets the last element of an array.
  * 
@@ -23,4 +24,4 @@
  * @namespace A
  * 
  */
-export declare function last<GenericArray extends readonly unknown[]>(array: GenericArray): GenericArray extends readonly [...any[], infer InferredValue] ? InferredValue : GenericArray[number] | undefined;
+export declare function last<GenericArray extends readonly unknown[]>(array: GenericArray): GenericArray extends readonly [...any[], infer InferredValue] ? InferredValue : GenericArray extends AnyTuple ? GenericArray[number] : GenericArray[number] | undefined;

package/dist/array/pop.d.ts

@@ -1,5 +1,3 @@
-import { type AnyTuple } from "../common";
-import { type PopTuple } from "./types";
 /**
  * Removes the last element from an array.
  * 
@@ -31,4 +29,4 @@ import { type PopTuple } from "./types";
  * @namespace A
  * 
  */
-export declare function pop<const GenericArray extends readonly unknown[]>(array: GenericArray): GenericArray extends AnyTuple ? PopTuple<GenericArray> : GenericArray;
+export declare function pop<const GenericArray extends readonly unknown[]>(array: GenericArray): GenericArray extends readonly [...infer InferredRest, any] ? InferredRest : GenericArray;

package/dist/clean/entity/index.d.ts

@@ -1,4 +1,4 @@
-import { type SimplifyTopLevel, type Kind, type RemoveKind } from "../../common";
+import { type SimplifyTopLevel, type Kind, type RemoveKind, type GetKindValue } from "../../common";
 import * as DEither from "../../either";
 import * as DDataParser from "../../dataParser";
 import * as DObject from "../../object";
@@ -102,7 +102,7 @@ export interface EntityHandler<GenericName extends string = string, GenericPrope
      * ```
      * 
      */
-    update<const GenericEntity extends Entity<GenericName>, const GenericProperties extends Partial<EntityProperties<GenericPropertiesDefinition>>>(entity: GenericEntity, properties: GenericProperties): Entity<GenericName> & DObject.AssignObjects<RemoveKind<GenericEntity>, GenericProperties>;
+    update<const GenericEntity extends Entity<GenericName>, const GenericProperties extends Partial<EntityProperties<GenericPropertiesDefinition>>>(entity: GenericEntity, properties: GenericProperties): EntityUpdate<GenericEntity, GenericProperties>;
 }
 declare const CreateEntityError_base: new (params: {
     "@DuplojsUtilsError/create-entity-error"?: unknown;
@@ -220,3 +220,6 @@ export declare namespace createEntity {
     var overrideHandler: import("../../common").OverrideHandler<EntityHandler<string, Readonly<Record<string, EntityPropertyDefinition>>>>;
 }
 export type GetEntity<GenericEntityHandler extends EntityHandler<string, any>> = Extract<ReturnType<GenericEntityHandler["new"]>, any>;
+export type EntityUpdate<GenericEntity extends Entity, GenericNewProperties extends Partial<RemoveKind<Entity>>> = Extract<(Entity<GetKindValue<typeof entityKind, GenericEntity>> & SimplifyTopLevel<RemoveKind<GenericEntity> extends infer InferredProperties ? {
+    [Prop in keyof InferredProperties]: Prop extends keyof GenericNewProperties ? GenericNewProperties[Prop] extends infer InferredNewValue ? InferredNewValue extends undefined ? InferredProperties[Prop] : InferredNewValue : never : InferredProperties[Prop];
+} : never>), any>;

package/dist/clean/newType.d.ts

@@ -156,5 +156,5 @@ export declare function createNewType<GenericName extends string, GenericDataPar
 export declare namespace createNewType {
     var overrideHandler: import("..").OverrideHandler<NewTypeHandler<string, unknown, readonly ConstraintHandler<string, EligiblePrimitive, readonly DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, unknown>[], unknown>[], unknown>>;
 }
-export type GetNewType<GenericHandler extends NewTypeHandler<string, unknown, readonly any[]>> = Extract<GenericHandler extends any ? NewType<GenericHandler["name"], DDataParser.Output<GenericHandler["dataParser"]>, GenericHandler["constraints"][number]["name"]> : never, any>;
+export type GetNewType<GenericHandler extends NewTypeHandler<string, unknown, readonly any[]>, GenericValue extends DDataParser.Output<GenericHandler["dataParser"]> = DDataParser.Output<GenericHandler["dataParser"]>> = Extract<GenericHandler extends any ? NewType<GenericHandler["name"], GenericValue, GenericHandler["constraints"][number]["name"]> : never, any>;
 export {};

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

@@ -12,36 +12,33 @@ var nil = require('../nil.cjs');
 var pipe = require('../../../common/pipe.cjs');
 var reduce = require('../../../array/reduce.cjs');
 var when = require('../../../pattern/when.cjs');
-var justReturn = require('../../../common/justReturn.cjs');
-var isType = require('../../../common/isType.cjs');
 var map = require('../../../array/map.cjs');
 var concat = require('../../../string/concat.cjs');
+var isType = require('../../../common/isType.cjs');
 var flatMap = require('../../../array/flatMap.cjs');
 var prepend = require('../../../string/prepend.cjs');
 var exhaustive = require('../../../pattern/exhaustive.cjs');
 var innerPipe = require('../../../common/innerPipe.cjs');
-var notIncludes = require('../../../array/notIncludes.cjs');
 var flat = require('../../../array/flat.cjs');
-var otherwise = require('../../../pattern/otherwise.cjs');
+var justReturn = require('../../../common/justReturn.cjs');
 var when$1 = require('../../../common/when.cjs');
+var to = require('../../../string/to.cjs');
 var or = require('../../../common/or.cjs');
-var includes = require('../../../array/includes.cjs');
-var filter = require('../../../array/filter.cjs');
 
 function findRecordRequiredKeyOnTemplateLiteralPart(templatePart) {
     return pipe.pipe(templatePart, map.map(innerPipe.innerPipe(when.when((value) => index$1.stringKind.has(value)
         || index$2.numberKind.has(value)
-        || index$3.bigIntKind.has(value), justReturn.justReturn(null)), when.when(or.or([
+        || index$3.bigIntKind.has(value), justReturn.justReturn([])), when.when(or.or([
         isType.isType("bigint"),
         isType.isType("boolean"),
         isType.isType("null"),
         isType.isType("number"),
         isType.isType("string"),
         isType.isType("undefined"),
-    ]), innerPipe.innerPipe(when$1.when(isType.isType("bigint"), (value) => `${value}n`), String)), when.when(literal.literalKind.has, (value) => findRecordRequiredKey(value)), when.when(index.templateLiteralKind.has, (value) => findRecordRequiredKeyOnTemplateLiteralPart(value.definition.template)), when.when(boolean.booleanKind.has, justReturn.justReturn(["true", "false"])), when.when(empty.emptyKind.has, justReturn.justReturn("undefined")), when.when(nil.nilKind.has, justReturn.justReturn("null")), when.when(union.unionKind.has, (dataParser) => pipe.pipe(dataParser.definition.options, map.map((element) => findRecordRequiredKeyOnTemplateLiteralPart([element])), when.when(notIncludes.notIncludes(null), flat.flat), otherwise.otherwise(justReturn.justReturn(null)))), exhaustive.exhaustive)), reduce.reduce(reduce.reduceFrom([""]), ({ lastValue, element, exit, next }) => pipe.pipe(element, when.when(isType.isType("null"), justReturn.justReturn(exit(null))), when.when(isType.isType("string"), (element) => next(map.map(lastValue, concat.concat(element)))), when.when(isType.isType("array"), (elements) => next(flatMap.flatMap(lastValue, (value) => map.map(elements, prepend.prepend(value))))), exhaustive.exhaustive)));
+    ]), innerPipe.innerPipe(when$1.when(isType.isType("bigint"), (value) => `${value}n`), to.to)), when.when(literal.literalKind.has, (value) => pipe.pipe(value.definition.value, map.map((element) => findRecordRequiredKeyOnTemplateLiteralPart([element])), flat.flat)), when.when(index.templateLiteralKind.has, (value) => findRecordRequiredKeyOnTemplateLiteralPart(value.definition.template)), when.when(boolean.booleanKind.has, justReturn.justReturn(["true", "false"])), when.when(empty.emptyKind.has, justReturn.justReturn("undefined")), when.when(nil.nilKind.has, justReturn.justReturn("null")), when.when(union.unionKind.has, (dataParser) => pipe.pipe(dataParser.definition.options, map.map((element) => findRecordRequiredKeyOnTemplateLiteralPart([element])), flat.flat)), exhaustive.exhaustive)), reduce.reduce(reduce.reduceFrom([""]), ({ lastValue, element, next }) => pipe.pipe(element, when.when(isType.isType("string"), (element) => next(map.map(lastValue, concat.concat(element)))), when.when(isType.isType("array"), (elements) => next(flatMap.flatMap(lastValue, (value) => map.map(elements, prepend.prepend(value))))), exhaustive.exhaustive)));
 }
 function findRecordRequiredKey(keyParser) {
-    return pipe.pipe(keyParser, when.when((value) => index$1.stringKind.has(value) || index$2.numberKind.has(value), justReturn.justReturn(null)), 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)))), when.when(union.unionKind.has, (dataParser) => pipe.pipe(dataParser.definition.options, map.map(findRecordRequiredKey), when.when(includes.includes(null), justReturn.justReturn(null)), otherwise.otherwise(innerPipe.innerPipe(filter.filter(isType.isType("array")), flat.flat)))), when.when(index.templateLiteralKind.has, (dataParser) => findRecordRequiredKeyOnTemplateLiteralPart(dataParser.definition.template)), exhaustive.exhaustive);
+    return pipe.pipe(keyParser, when.when((value) => index$1.stringKind.has(value) || index$2.numberKind.has(value), justReturn.justReturn([])), when.when(literal.literalKind.has, (dataParser) => dataParser.definition.value), when.when(union.unionKind.has, (dataParser) => pipe.pipe(dataParser.definition.options, map.map(findRecordRequiredKey), flat.flat)), when.when(index.templateLiteralKind.has, (dataParser) => findRecordRequiredKeyOnTemplateLiteralPart(dataParser.definition.template)), exhaustive.exhaustive);
 }
 
 exports.findRecordRequiredKey = findRecordRequiredKey;

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

@@ -1,4 +1,4 @@
 import { type DataParserRecordKey } from ".";
 import { type TemplateLiteralParts } from "../templateLiteral";
-export declare function findRecordRequiredKeyOnTemplateLiteralPart(templatePart: readonly TemplateLiteralParts[]): string[] | null;
-export declare function findRecordRequiredKey(keyParser: DataParserRecordKey): string[] | null;
+export declare function findRecordRequiredKeyOnTemplateLiteralPart(templatePart: readonly TemplateLiteralParts[]): readonly string[];
+export declare function findRecordRequiredKey(keyParser: DataParserRecordKey): readonly string[];

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

@@ -10,36 +10,33 @@ import { nilKind } from '../nil.mjs';
 import { pipe } from '../../../common/pipe.mjs';
 import { reduce, reduceFrom } from '../../../array/reduce.mjs';
 import { when } from '../../../pattern/when.mjs';
-import { justReturn } from '../../../common/justReturn.mjs';
-import { isType } from '../../../common/isType.mjs';
 import { map } from '../../../array/map.mjs';
 import { concat } from '../../../string/concat.mjs';
+import { isType } from '../../../common/isType.mjs';
 import { flatMap } from '../../../array/flatMap.mjs';
 import { prepend } from '../../../string/prepend.mjs';
 import { exhaustive } from '../../../pattern/exhaustive.mjs';
 import { innerPipe } from '../../../common/innerPipe.mjs';
-import { notIncludes } from '../../../array/notIncludes.mjs';
 import { flat } from '../../../array/flat.mjs';
-import { otherwise } from '../../../pattern/otherwise.mjs';
+import { justReturn } from '../../../common/justReturn.mjs';
 import { when as when$1 } from '../../../common/when.mjs';
+import { to } from '../../../string/to.mjs';
 import { or } from '../../../common/or.mjs';
-import { includes } from '../../../array/includes.mjs';
-import { filter } from '../../../array/filter.mjs';
 
 function findRecordRequiredKeyOnTemplateLiteralPart(templatePart) {
     return pipe(templatePart, map(innerPipe(when((value) => stringKind.has(value)
         || numberKind.has(value)
-        || bigIntKind.has(value), justReturn(null)), when(or([
+        || bigIntKind.has(value), justReturn([])), when(or([
         isType("bigint"),
         isType("boolean"),
         isType("null"),
         isType("number"),
         isType("string"),
         isType("undefined"),
-    ]), innerPipe(when$1(isType("bigint"), (value) => `${value}n`), String)), when(literalKind.has, (value) => findRecordRequiredKey(value)), when(templateLiteralKind.has, (value) => findRecordRequiredKeyOnTemplateLiteralPart(value.definition.template)), when(booleanKind.has, justReturn(["true", "false"])), when(emptyKind.has, justReturn("undefined")), when(nilKind.has, justReturn("null")), when(unionKind.has, (dataParser) => pipe(dataParser.definition.options, map((element) => findRecordRequiredKeyOnTemplateLiteralPart([element])), when(notIncludes(null), flat), otherwise(justReturn(null)))), exhaustive)), reduce(reduceFrom([""]), ({ lastValue, element, exit, next }) => pipe(element, when(isType("null"), justReturn(exit(null))), when(isType("string"), (element) => next(map(lastValue, concat(element)))), when(isType("array"), (elements) => next(flatMap(lastValue, (value) => map(elements, prepend(value))))), exhaustive)));
+    ]), innerPipe(when$1(isType("bigint"), (value) => `${value}n`), to)), when(literalKind.has, (value) => pipe(value.definition.value, map((element) => findRecordRequiredKeyOnTemplateLiteralPart([element])), flat)), when(templateLiteralKind.has, (value) => findRecordRequiredKeyOnTemplateLiteralPart(value.definition.template)), when(booleanKind.has, justReturn(["true", "false"])), when(emptyKind.has, justReturn("undefined")), when(nilKind.has, justReturn("null")), when(unionKind.has, (dataParser) => pipe(dataParser.definition.options, map((element) => findRecordRequiredKeyOnTemplateLiteralPart([element])), flat)), exhaustive)), reduce(reduceFrom([""]), ({ lastValue, element, next }) => pipe(element, when(isType("string"), (element) => next(map(lastValue, concat(element)))), when(isType("array"), (elements) => next(flatMap(lastValue, (value) => map(elements, prepend(value))))), exhaustive)));
 }
 function findRecordRequiredKey(keyParser) {
-    return pipe(keyParser, when((value) => stringKind.has(value) || numberKind.has(value), justReturn(null)), when(literalKind.has, (dataParser) => pipe(dataParser.definition.value, map(innerPipe(when$1(isType("bigint"), (value) => `${value}n`), String)))), when(unionKind.has, (dataParser) => pipe(dataParser.definition.options, map(findRecordRequiredKey), when(includes(null), justReturn(null)), otherwise(innerPipe(filter(isType("array")), flat)))), when(templateLiteralKind.has, (dataParser) => findRecordRequiredKeyOnTemplateLiteralPart(dataParser.definition.template)), exhaustive);
+    return pipe(keyParser, when((value) => stringKind.has(value) || numberKind.has(value), justReturn([])), when(literalKind.has, (dataParser) => dataParser.definition.value), when(unionKind.has, (dataParser) => pipe(dataParser.definition.options, map(findRecordRequiredKey), flat)), when(templateLiteralKind.has, (dataParser) => findRecordRequiredKeyOnTemplateLiteralPart(dataParser.definition.template)), exhaustive);
 }
 
 export { findRecordRequiredKey, findRecordRequiredKeyOnTemplateLiteralPart };

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

@@ -4,6 +4,10 @@ var base = require('../../base.cjs');
 var error = require('../../error.cjs');
 var kind = require('../../kind.cjs');
 var findRecordRequiredKey = require('./findRecordRequiredKey.cjs');
+var pipe = require('../../../common/pipe.cjs');
+var map = require('../../../array/map.cjs');
+var entry = require('../../../object/entry.cjs');
+var fromEntries = require('../../../object/fromEntries.cjs');
 var override = require('../../../common/override.cjs');
 
 const recordKind = kind.createDataParserKind("record");
@@ -11,12 +15,14 @@ const recordKind = kind.createDataParserKind("record");
  * {@include dataParser/classic/record/index.md}
  */
 function record(key, value, definition) {
+    const requireKey = findRecordRequiredKey.findRecordRequiredKey(key);
     const self = base.dataParserInit(recordKind, {
         errorMessage: definition?.errorMessage,
         checkers: definition?.checkers ?? [],
         key,
         value,
-        requireKey: findRecordRequiredKey.findRecordRequiredKey(key),
+        requireKey,
+        baseData: pipe.pipe(requireKey, map.map((key) => entry.entry(key, undefined)), fromEntries.fromEntries),
     }, {
         sync: (data, error$1, self) => {
             if (!data
@@ -25,8 +31,12 @@ function record(key, value, definition) {
                 return error.SymbolDataParserErrorIssue;
             }
             let output = {};
+            const fromData = {
+                ...self.definition.baseData,
+                ...data,
+            };
             const currentIndexPath = error$1.currentPath.length;
-            for (const key in data) {
+            for (const key in fromData) {
                 error.setErrorPath(error$1, key, currentIndexPath);
                 const resultKey = self
                     .definition
@@ -38,7 +48,7 @@ function record(key, value, definition) {
                 const resultValue = self
                     .definition
                     .value
-                    .exec(data[key], error$1);
+                    .exec(fromData[key], error$1);
                 if (resultValue === base.SymbolDataParserError) {
                     output = base.SymbolDataParserError;
                 }
@@ -50,10 +60,6 @@ function record(key, value, definition) {
             if (output === base.SymbolDataParserError) {
                 return output;
             }
-            if (self.definition.requireKey
-                && self.definition.requireKey.length !== Object.keys(output).length) {
-                return error.SymbolDataParserErrorIssue;
-            }
             return output;
         },
         async: async (data, error$1, self) => {
@@ -63,8 +69,12 @@ function record(key, value, definition) {
                 return error.SymbolDataParserErrorIssue;
             }
             let output = {};
+            const fromData = {
+                ...self.definition.baseData,
+                ...data,
+            };
             const currentIndexPath = error$1.currentPath.length;
-            for (const key in data) {
+            for (const key in fromData) {
                 error.setErrorPath(error$1, key, currentIndexPath);
                 const resultKey = await self
                     .definition
@@ -76,7 +86,7 @@ function record(key, value, definition) {
                 const resultValue = await self
                     .definition
                     .value
-                    .asyncExec(data[key], error$1);
+                    .asyncExec(fromData[key], error$1);
                 if (resultValue === base.SymbolDataParserError) {
                     output = base.SymbolDataParserError;
                 }
@@ -88,10 +98,6 @@ function record(key, value, definition) {
             if (output === base.SymbolDataParserError) {
                 return output;
             }
-            if (self.definition.requireKey
-                && self.definition.requireKey.length !== Object.keys(output).length) {
-                return error.SymbolDataParserErrorIssue;
-            }
             return output;
         },
         isAsynchronous: (self) => self.definition.value.isAsynchronous(),

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

@@ -1,16 +1,17 @@
-import { type NeverCoalescing, type Kind, type FixDeepFunctionInfer, type Adaptor } from "../../../common";
+import { type NeverCoalescing, type Kind, type FixDeepFunctionInfer, type IsEqual } from "../../../common";
 import { type DataParserDefinition, type DataParser, type Output, type Input, type DataParserChecker } from "../../base";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../../../dataParser/types";
 import { type DataParserString } from "../string";
 import { type DataParserTemplateLiteral } from "../templateLiteral";
-import { type DataParserLiteral } from "../literal";
+import { type DataParserDefinitionLiteral, type DataParserLiteral } from "../literal";
 import { type DataParserDefinitionNumber, type DataParserNumber } from "../number";
 import { type DataParserDefinitionUnion, type DataParserUnion } from "../union";
 import { type CheckerRefineImplementation } from "../refine";
-import { type TemplateLiteralContainLargeType } from "../../../string";
 import { type GetPropsWithValueExtends } from "../../../object";
 export * from "./findRecordRequiredKey";
-export type DataParserRecordKey = (DataParserString | DataParserTemplateLiteral | DataParserLiteral | DataParserNumber<DataParserDefinitionNumber & {
+export type DataParserRecordKey = (DataParserString | DataParserTemplateLiteral | DataParserLiteral<DataParserDefinitionLiteral & {
+    value: readonly string[];
+}> | DataParserNumber<DataParserDefinitionNumber & {
     coerce: true;
 }> | DataParserUnion<DataParserDefinitionUnion & {
     options: DataParserRecordKey[];
@@ -21,11 +22,12 @@ export type DataParserRecordCheckers<GenericInput extends Record<string, unknown
 export interface DataParserDefinitionRecord extends DataParserDefinition<DataParserRecordCheckers<Record<string, unknown>>> {
     readonly key: DataParserRecordKey;
     readonly value: DataParser;
-    readonly requireKey: string[] | null;
+    readonly baseData: Partial<Record<string, undefined>>;
+    readonly requireKey: readonly string[];
 }
 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> extends infer InferredOutput extends Record<string, unknown> ? TemplateLiteralContainLargeType<Adaptor<keyof InferredOutput, string>> extends true ? Partial<InferredOutput> : InferredOutput : never;
-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> extends infer InferredInput extends Record<string, unknown> ? TemplateLiteralContainLargeType<Adaptor<keyof InferredInput, string>> extends true ? Partial<InferredInput> : InferredInput : never;
+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> extends infer InferredResult extends Record<string, unknown> ? IsEqual<Extract<InferredResult[keyof InferredResult], undefined>, never> extends true ? InferredResult : Partial<InferredResult> : 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> extends infer InferredResult extends Record<string, unknown> ? IsEqual<Extract<InferredResult[keyof InferredResult], undefined>, never> extends true ? InferredResult : Partial<InferredResult> : never, any>;
 type _DataParserRecord<GenericDefinition extends DataParserDefinitionRecord> = (DataParser<GenericDefinition, DataParserRecordShapeOutput<GenericDefinition["key"], GenericDefinition["value"]>, DataParserRecordShapeInput<GenericDefinition["key"], GenericDefinition["value"]>> & Kind<typeof recordKind.definition>);
 export interface DataParserRecord<GenericDefinition extends DataParserDefinitionRecord = DataParserDefinitionRecord> extends _DataParserRecord<GenericDefinition> {
     addChecker<GenericChecker extends readonly [

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

@@ -3,6 +3,10 @@ import { SymbolDataParserErrorIssue, setErrorPath, popErrorPath } from '../../er
 import { createDataParserKind } from '../../kind.mjs';
 import { findRecordRequiredKey } from './findRecordRequiredKey.mjs';
 export { findRecordRequiredKeyOnTemplateLiteralPart } from './findRecordRequiredKey.mjs';
+import { pipe } from '../../../common/pipe.mjs';
+import { map } from '../../../array/map.mjs';
+import { entry } from '../../../object/entry.mjs';
+import { fromEntries } from '../../../object/fromEntries.mjs';
 import { createOverride } from '../../../common/override.mjs';
 
 const recordKind = createDataParserKind("record");
@@ -10,12 +14,14 @@ const recordKind = createDataParserKind("record");
  * {@include dataParser/classic/record/index.md}
  */
 function record(key, value, definition) {
+    const requireKey = findRecordRequiredKey(key);
     const self = dataParserInit(recordKind, {
         errorMessage: definition?.errorMessage,
         checkers: definition?.checkers ?? [],
         key,
         value,
-        requireKey: findRecordRequiredKey(key),
+        requireKey,
+        baseData: pipe(requireKey, map((key) => entry(key, undefined)), fromEntries),
     }, {
         sync: (data, error, self) => {
             if (!data
@@ -24,8 +30,12 @@ function record(key, value, definition) {
                 return SymbolDataParserErrorIssue;
             }
             let output = {};
+            const fromData = {
+                ...self.definition.baseData,
+                ...data,
+            };
             const currentIndexPath = error.currentPath.length;
-            for (const key in data) {
+            for (const key in fromData) {
                 setErrorPath(error, key, currentIndexPath);
                 const resultKey = self
                     .definition
@@ -37,7 +47,7 @@ function record(key, value, definition) {
                 const resultValue = self
                     .definition
                     .value
-                    .exec(data[key], error);
+                    .exec(fromData[key], error);
                 if (resultValue === SymbolDataParserError) {
                     output = SymbolDataParserError;
                 }
@@ -49,10 +59,6 @@ function record(key, value, definition) {
             if (output === SymbolDataParserError) {
                 return output;
             }
-            if (self.definition.requireKey
-                && self.definition.requireKey.length !== Object.keys(output).length) {
-                return SymbolDataParserErrorIssue;
-            }
             return output;
         },
         async: async (data, error, self) => {
@@ -62,8 +68,12 @@ function record(key, value, definition) {
                 return SymbolDataParserErrorIssue;
             }
             let output = {};
+            const fromData = {
+                ...self.definition.baseData,
+                ...data,
+            };
             const currentIndexPath = error.currentPath.length;
-            for (const key in data) {
+            for (const key in fromData) {
                 setErrorPath(error, key, currentIndexPath);
                 const resultKey = await self
                     .definition
@@ -75,7 +85,7 @@ function record(key, value, definition) {
                 const resultValue = await self
                     .definition
                     .value
-                    .asyncExec(data[key], error);
+                    .asyncExec(fromData[key], error);
                 if (resultValue === SymbolDataParserError) {
                     output = SymbolDataParserError;
                 }
@@ -87,10 +97,6 @@ function record(key, value, definition) {
             if (output === SymbolDataParserError) {
                 return output;
             }
-            if (self.definition.requireKey
-                && self.definition.requireKey.length !== Object.keys(output).length) {
-                return SymbolDataParserErrorIssue;
-            }
             return output;
         },
         isAsynchronous: (self) => self.definition.value.isAsynchronous(),

package/dist/dataParser/types/checkers.d.ts

@@ -1,7 +1,6 @@
-import { type GetPropsWithValueExtends } from "../../object";
 import { type DataParserChecker } from "../base";
 import type * as AllDataParser from "../parsers";
 export interface CheckerCustom {
     base: DataParserChecker;
 }
-export type DataParserCheckers = (CheckerCustom[GetPropsWithValueExtends<CheckerCustom, DataParserChecker>] | AllDataParser.DataParserCheckerUrl | AllDataParser.DataParserCheckerArrayMax | AllDataParser.DataParserCheckerArrayMin | AllDataParser.DataParserCheckerBigIntMax | AllDataParser.DataParserCheckerBigIntMin | AllDataParser.DataParserCheckerNumberMax | AllDataParser.DataParserCheckerNumberMin | AllDataParser.DataParserCheckerInt | AllDataParser.DataParserCheckerEmail | AllDataParser.DataParserCheckerRefine | AllDataParser.DataParserCheckerTimeMin | AllDataParser.DataParserCheckerTimeMax);
+export type DataParserCheckers = (CheckerCustom[keyof CheckerCustom] | AllDataParser.DataParserCheckerUrl | AllDataParser.DataParserCheckerArrayMax | AllDataParser.DataParserCheckerArrayMin | AllDataParser.DataParserCheckerBigIntMax | AllDataParser.DataParserCheckerBigIntMin | AllDataParser.DataParserCheckerNumberMax | AllDataParser.DataParserCheckerNumberMin | AllDataParser.DataParserCheckerInt | AllDataParser.DataParserCheckerEmail | AllDataParser.DataParserCheckerRefine | AllDataParser.DataParserCheckerTimeMin | AllDataParser.DataParserCheckerTimeMax);

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

@@ -1,3 +1,5 @@
 import type { IsEqual } from "../../common";
 import type { TemplateLiteralContainLargeType } from "./templateLiteralContainLargeType";
-export type Pop<GenericValue extends string> = TemplateLiteralContainLargeType<GenericValue> extends true ? string : IsEqual<GenericValue, ""> extends true ? "" : GenericValue extends `${infer InferredFirst}${infer InferredRest}` ? IsEqual<InferredRest, ""> extends true ? "" : Pop<InferredRest> extends infer InferredResult extends string ? `${InferredFirst}${InferredResult}` : never : string;
+type _Pop<GenericValue extends string, GenericCount extends never[] = []> = IsEqual<GenericCount["length"], 250> extends true ? string : GenericValue extends `${infer InferredFirst}${infer InferredRest}` ? IsEqual<InferredRest, ""> extends true ? "" : _Pop<InferredRest, [...GenericCount, never]> extends infer InferredResult extends string ? `${InferredFirst}${InferredResult}` : never : string;
+export type Pop<GenericValue extends string> = TemplateLiteralContainLargeType<GenericValue> extends true ? string : IsEqual<GenericValue, ""> extends true ? "" : _Pop<GenericValue>;
+export {};

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

@@ -1,7 +1,9 @@
 import { type Or, type IsEqual } from "../../common";
 import { type Includes } from "./includes";
 import { type TemplateLiteralContainLargeType } from "./templateLiteralContainLargeType";
-export type Split<GenericString extends string, GenericSeparator extends string, GenericLimit extends number = number, GenericLastResult extends string[] = []> = IsEqual<GenericLimit, 0> extends true ? [] : Or<[
+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[]] : 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];
+]> extends true ? [string, ...string[]] : _Split<GenericString, GenericSeparator, GenericLimit>;
+export {};

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

@@ -1,6 +1 @@
-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}`>,
-    IsEqual<InferredFirst, string>
-]> extends false ? TemplateLiteralContainLargeType<InferredLast> : true : GenericValue extends "" ? false : true) extends false ? false : true;
+export type TemplateLiteralContainLargeType<GenericValue extends string> = (GenericValue extends string ? {} extends Record<GenericValue, never> ? true : false : never) extends false ? false : true;

package/package.json

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