@sinclair/typebox 0.32.0-dev-25 → 0.32.0-dev-27

package/build/import/type/type/json.d.mts

@@ -21,10 +21,10 @@ import { type TNull } from '../null/index.mjs';
 import { type TMappedKey } from '../mapped/index.mjs';
 import { type TNumber, type NumberOptions } from '../number/index.mjs';
 import { type TObject, type TProperties, type ObjectOptions } from '../object/index.mjs';
-import { type TOmit, type TOmitFromMappedKey } from '../omit/index.mjs';
+import { type TOmit, type TOmitFromMappedKey, type TOmitFromMappedResult } from '../omit/index.mjs';
 import { type TOptionalWithFlag, type TOptionalFromMappedResult } from '../optional/index.mjs';
 import { type TPartial, type TPartialFromMappedResult } from '../partial/index.mjs';
-import { type TPick, type TPickFromMappedKey } from '../pick/index.mjs';
+import { type TPick, type TPickFromMappedKey, type TPickFromMappedResult } from '../pick/index.mjs';
 import { type TReadonlyWithFlag, type TReadonlyFromMappedResult } from '../readonly/index.mjs';
 import { type TReadonlyOptional } from '../readonly-optional/index.mjs';
 import { type TRecordOrObject } from '../record/index.mjs';
@@ -127,6 +127,8 @@ export declare class JsonTypeBuilder {
     /** `[Json]` Creates an Object type */
     Object<T extends TProperties>(properties: T, options?: ObjectOptions): TObject<T>;
     /** `[Json]` Constructs a type whose keys are omitted from the given type */
+    Omit<T extends TMappedResult, K extends PropertyKey[]>(T: T, K: [...K], options?: SchemaOptions): TOmitFromMappedResult<T, K>;
+    /** `[Json]` Constructs a type whose keys are omitted from the given type */
     Omit<T extends TSchema, K extends TMappedKey>(T: T, K: K): TOmitFromMappedKey<T, K>;
     /** `[Json]` Constructs a type whose keys are omitted from the given type */
     Omit<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TOmit<T, I>;
@@ -137,6 +139,8 @@ export declare class JsonTypeBuilder {
     /** `[Json]` Constructs a type where all properties are optional */
     Partial<T extends TSchema>(schema: T, options?: ObjectOptions): TPartial<T>;
     /** `[Json]` Constructs a type whose keys are picked from the given type */
+    Pick<T extends TMappedResult, K extends PropertyKey[]>(T: T, K: [...K]): TPickFromMappedResult<T, K>;
+    /** `[Json]` Constructs a type whose keys are picked from the given type */
     Pick<T extends TSchema, K extends TMappedKey>(T: T, K: K): TPickFromMappedKey<T, K>;
     /** `[Json]` Constructs a type whose keys are picked from the given type */
     Pick<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TPick<T, I>;

package/build/import/type/union/union-evaluated.mjs

@@ -7,25 +7,14 @@ import { UnionCreate } from './union-create.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 import { IsOptional } from '../guard/type.mjs';
 // prettier-ignore
 function IsUnionOptional(T) {
-    const [L, ...R] = T;
-    return (T.length > 0
-        ? IsOptional(L)
-            ? true
-            : IsUnionOptional(R)
-        : false);
+    return T.some(L => IsOptional(L));
 }
 // prettier-ignore
-function RemoveOptionalFromRest(T, Acc = []) {
-    const [L, ...R] = T;
-    return (T.length > 0
-        ? IsOptional(L)
-            ? RemoveOptionalFromRest(R, [...Acc, RemoveOptionalFromType(L)])
-            : RemoveOptionalFromRest(R, [...Acc, L])
-        : Acc);
+function RemoveOptionalFromRest(T) {
+    return T.map(L => IsOptional(L) ? RemoveOptionalFromType(L) : L);
 }
 // prettier-ignore
 function RemoveOptionalFromType(T) {

package/build/require/errors/errors.js

@@ -128,8 +128,8 @@ exports.ValueErrorIterator = ValueErrorIterator;
 // --------------------------------------------------------------------------
 // Create
 // --------------------------------------------------------------------------
-function Create(type, schema, path, value) {
-    return { type, schema, path, value, message: (0, function_1.GetErrorFunction)()(schema, type) };
+function Create(errorType, schema, path, value) {
+    return { type: errorType, schema, path, value, message: (0, function_1.GetErrorFunction)()({ errorType, path, schema, value }) };
 }
 // --------------------------------------------------------------------------
 // Types

package/build/require/errors/function.d.ts

@@ -1,9 +1,19 @@
 import { TSchema } from '../type/schema/index';
 import { ValueErrorType } from './errors';
 /** Creates an error message using en-US as the default locale */
-export declare function DefaultErrorFunction(schema: TSchema, errorType: ValueErrorType): string;
-export type ErrorFunction = (schema: TSchema, type: ValueErrorType) => string;
-/** Sets the error function used to generate error messages */
+export declare function DefaultErrorFunction(error: ErrorFunctionParameter): string;
+export type ErrorFunctionParameter = {
+    /** The type of validation error */
+    errorType: ValueErrorType;
+    /** The path of the error */
+    path: string;
+    /** The schema associated with the error */
+    schema: TSchema;
+    /** The value associated with the error */
+    value: unknown;
+};
+export type ErrorFunction = (parameter: ErrorFunctionParameter) => string;
+/** Sets the error function used to generate error messages. */
 export declare function SetErrorFunction(callback: ErrorFunction): void;
 /** Gets the error function used to generate error messages */
 export declare function GetErrorFunction(): ErrorFunction;

package/build/require/errors/function.js

@@ -5,18 +5,18 @@ exports.GetErrorFunction = exports.SetErrorFunction = exports.DefaultErrorFuncti
 const index_1 = require("../type/symbols/index");
 const errors_1 = require("./errors");
 /** Creates an error message using en-US as the default locale */
-function DefaultErrorFunction(schema, errorType) {
-    switch (errorType) {
+function DefaultErrorFunction(error) {
+    switch (error.errorType) {
         case errors_1.ValueErrorType.ArrayContains:
             return 'Expected array to contain at least one matching value';
         case errors_1.ValueErrorType.ArrayMaxContains:
-            return `Expected array to contain no more than ${schema.maxContains} matching values`;
+            return `Expected array to contain no more than ${error.schema.maxContains} matching values`;
         case errors_1.ValueErrorType.ArrayMinContains:
-            return `Expected array to contain at least ${schema.minContains} matching values`;
+            return `Expected array to contain at least ${error.schema.minContains} matching values`;
         case errors_1.ValueErrorType.ArrayMaxItems:
-            return `Expected array length to be less or equal to ${schema.maxItems}`;
+            return `Expected array length to be less or equal to ${error.schema.maxItems}`;
         case errors_1.ValueErrorType.ArrayMinItems:
-            return `Expected array length to be greater or equal to ${schema.minItems}`;
+            return `Expected array length to be greater or equal to ${error.schema.minItems}`;
         case errors_1.ValueErrorType.ArrayUniqueItems:
             return 'Expected array elements to be unique';
         case errors_1.ValueErrorType.Array:
@@ -24,43 +24,43 @@ function DefaultErrorFunction(schema, errorType) {
         case errors_1.ValueErrorType.AsyncIterator:
             return 'Expected AsyncIterator';
         case errors_1.ValueErrorType.BigIntExclusiveMaximum:
-            return `Expected bigint to be less than ${schema.exclusiveMaximum}`;
+            return `Expected bigint to be less than ${error.schema.exclusiveMaximum}`;
         case errors_1.ValueErrorType.BigIntExclusiveMinimum:
-            return `Expected bigint to be greater than ${schema.exclusiveMinimum}`;
+            return `Expected bigint to be greater than ${error.schema.exclusiveMinimum}`;
         case errors_1.ValueErrorType.BigIntMaximum:
-            return `Expected bigint to be less or equal to ${schema.maximum}`;
+            return `Expected bigint to be less or equal to ${error.schema.maximum}`;
         case errors_1.ValueErrorType.BigIntMinimum:
-            return `Expected bigint to be greater or equal to ${schema.minimum}`;
+            return `Expected bigint to be greater or equal to ${error.schema.minimum}`;
         case errors_1.ValueErrorType.BigIntMultipleOf:
-            return `Expected bigint to be a multiple of ${schema.multipleOf}`;
+            return `Expected bigint to be a multiple of ${error.schema.multipleOf}`;
         case errors_1.ValueErrorType.BigInt:
             return 'Expected bigint';
         case errors_1.ValueErrorType.Boolean:
             return 'Expected boolean';
         case errors_1.ValueErrorType.DateExclusiveMinimumTimestamp:
-            return `Expected Date timestamp to be greater than ${schema.exclusiveMinimumTimestamp}`;
+            return `Expected Date timestamp to be greater than ${error.schema.exclusiveMinimumTimestamp}`;
         case errors_1.ValueErrorType.DateExclusiveMaximumTimestamp:
-            return `Expected Date timestamp to be less than ${schema.exclusiveMaximumTimestamp}`;
+            return `Expected Date timestamp to be less than ${error.schema.exclusiveMaximumTimestamp}`;
         case errors_1.ValueErrorType.DateMinimumTimestamp:
-            return `Expected Date timestamp to be greater or equal to ${schema.minimumTimestamp}`;
+            return `Expected Date timestamp to be greater or equal to ${error.schema.minimumTimestamp}`;
         case errors_1.ValueErrorType.DateMaximumTimestamp:
-            return `Expected Date timestamp to be less or equal to ${schema.maximumTimestamp}`;
+            return `Expected Date timestamp to be less or equal to ${error.schema.maximumTimestamp}`;
         case errors_1.ValueErrorType.DateMultipleOfTimestamp:
-            return `Expected Date timestamp to be a multiple of ${schema.multipleOfTimestamp}`;
+            return `Expected Date timestamp to be a multiple of ${error.schema.multipleOfTimestamp}`;
         case errors_1.ValueErrorType.Date:
             return 'Expected Date';
         case errors_1.ValueErrorType.Function:
             return 'Expected function';
         case errors_1.ValueErrorType.IntegerExclusiveMaximum:
-            return `Expected integer to be less than ${schema.exclusiveMaximum}`;
+            return `Expected integer to be less than ${error.schema.exclusiveMaximum}`;
         case errors_1.ValueErrorType.IntegerExclusiveMinimum:
-            return `Expected integer to be greater than ${schema.exclusiveMinimum}`;
+            return `Expected integer to be greater than ${error.schema.exclusiveMinimum}`;
         case errors_1.ValueErrorType.IntegerMaximum:
-            return `Expected integer to be less or equal to ${schema.maximum}`;
+            return `Expected integer to be less or equal to ${error.schema.maximum}`;
         case errors_1.ValueErrorType.IntegerMinimum:
-            return `Expected integer to be greater or equal to ${schema.minimum}`;
+            return `Expected integer to be greater or equal to ${error.schema.minimum}`;
         case errors_1.ValueErrorType.IntegerMultipleOf:
-            return `Expected integer to be a multiple of ${schema.multipleOf}`;
+            return `Expected integer to be a multiple of ${error.schema.multipleOf}`;
         case errors_1.ValueErrorType.Integer:
             return 'Expected integer';
         case errors_1.ValueErrorType.IntersectUnevaluatedProperties:
@@ -70,7 +70,7 @@ function DefaultErrorFunction(schema, errorType) {
         case errors_1.ValueErrorType.Iterator:
             return 'Expected Iterator';
         case errors_1.ValueErrorType.Literal:
-            return `Expected ${typeof schema.const === 'string' ? `'${schema.const}'` : schema.const}`;
+            return `Expected ${typeof error.schema.const === 'string' ? `'${error.schema.const}'` : error.schema.const}`;
         case errors_1.ValueErrorType.Never:
             return 'Never';
         case errors_1.ValueErrorType.Not:
@@ -78,15 +78,15 @@ function DefaultErrorFunction(schema, errorType) {
         case errors_1.ValueErrorType.Null:
             return 'Expected null';
         case errors_1.ValueErrorType.NumberExclusiveMaximum:
-            return `Expected number to be less than ${schema.exclusiveMaximum}`;
+            return `Expected number to be less than ${error.schema.exclusiveMaximum}`;
         case errors_1.ValueErrorType.NumberExclusiveMinimum:
-            return `Expected number to be greater than ${schema.exclusiveMinimum}`;
+            return `Expected number to be greater than ${error.schema.exclusiveMinimum}`;
         case errors_1.ValueErrorType.NumberMaximum:
-            return `Expected number to be less or equal to ${schema.maximum}`;
+            return `Expected number to be less or equal to ${error.schema.maximum}`;
         case errors_1.ValueErrorType.NumberMinimum:
-            return `Expected number to be greater or equal to ${schema.minimum}`;
+            return `Expected number to be greater or equal to ${error.schema.minimum}`;
         case errors_1.ValueErrorType.NumberMultipleOf:
-            return `Expected number to be a multiple of ${schema.multipleOf}`;
+            return `Expected number to be a multiple of ${error.schema.multipleOf}`;
         case errors_1.ValueErrorType.Number:
             return 'Expected number';
         case errors_1.ValueErrorType.Object:
@@ -94,35 +94,35 @@ function DefaultErrorFunction(schema, errorType) {
         case errors_1.ValueErrorType.ObjectAdditionalProperties:
             return 'Unexpected property';
         case errors_1.ValueErrorType.ObjectMaxProperties:
-            return `Expected object to have no more than ${schema.maxProperties} properties`;
+            return `Expected object to have no more than ${error.schema.maxProperties} properties`;
         case errors_1.ValueErrorType.ObjectMinProperties:
-            return `Expected object to have at least ${schema.minProperties} properties`;
+            return `Expected object to have at least ${error.schema.minProperties} properties`;
         case errors_1.ValueErrorType.ObjectRequiredProperty:
             return 'Required property';
         case errors_1.ValueErrorType.Promise:
             return 'Expected Promise';
         case errors_1.ValueErrorType.StringFormatUnknown:
-            return `Unknown format '${schema.format}'`;
+            return `Unknown format '${error.schema.format}'`;
         case errors_1.ValueErrorType.StringFormat:
-            return `Expected string to match '${schema.format}' format`;
+            return `Expected string to match '${error.schema.format}' format`;
         case errors_1.ValueErrorType.StringMaxLength:
-            return `Expected string length less or equal to ${schema.maxLength}`;
+            return `Expected string length less or equal to ${error.schema.maxLength}`;
         case errors_1.ValueErrorType.StringMinLength:
-            return `Expected string length greater or equal to ${schema.minLength}`;
+            return `Expected string length greater or equal to ${error.schema.minLength}`;
         case errors_1.ValueErrorType.StringPattern:
-            return `Expected string to match '${schema.pattern}'`;
+            return `Expected string to match '${error.schema.pattern}'`;
         case errors_1.ValueErrorType.String:
             return 'Expected string';
         case errors_1.ValueErrorType.Symbol:
             return 'Expected symbol';
         case errors_1.ValueErrorType.TupleLength:
-            return `Expected tuple to have ${schema.maxItems || 0} elements`;
+            return `Expected tuple to have ${error.schema.maxItems || 0} elements`;
         case errors_1.ValueErrorType.Tuple:
             return 'Expected tuple';
         case errors_1.ValueErrorType.Uint8ArrayMaxByteLength:
-            return `Expected byte length less or equal to ${schema.maxByteLength}`;
+            return `Expected byte length less or equal to ${error.schema.maxByteLength}`;
         case errors_1.ValueErrorType.Uint8ArrayMinByteLength:
-            return `Expected byte length greater or equal to ${schema.minByteLength}`;
+            return `Expected byte length greater or equal to ${error.schema.minByteLength}`;
         case errors_1.ValueErrorType.Uint8Array:
             return 'Expected Uint8Array';
         case errors_1.ValueErrorType.Undefined:
@@ -132,7 +132,7 @@ function DefaultErrorFunction(schema, errorType) {
         case errors_1.ValueErrorType.Void:
             return 'Expected void';
         case errors_1.ValueErrorType.Kind:
-            return `Expected kind '${schema[index_1.Kind]}'`;
+            return `Expected kind '${error.schema[index_1.Kind]}'`;
         default:
             return 'Unknown error type';
     }
@@ -140,7 +140,7 @@ function DefaultErrorFunction(schema, errorType) {
 exports.DefaultErrorFunction = DefaultErrorFunction;
 /** Manages error message providers */
 let errorFunction = DefaultErrorFunction;
-/** Sets the error function used to generate error messages */
+/** Sets the error function used to generate error messages. */
 function SetErrorFunction(callback) {
     errorFunction = callback;
 }

package/build/require/index.d.ts

@@ -36,11 +36,11 @@ export { Not, type TNot } from './type/not/index';
 export { Null, type TNull } from './type/null/index';
 export { Number, type TNumber, type NumberOptions } from './type/number/index';
 export { Object, type TObject, type TProperties, type ObjectOptions } from './type/object/index';
-export { Omit, type TOmit, type TOmitFromMappedKey } from './type/omit/index';
+export { Omit, type TOmit, type TOmitFromMappedKey, type TOmitFromMappedResult } from './type/omit/index';
 export { Optional, OptionalFromMappedResult, type TOptional, type TOptionalWithFlag, type TOptionalFromMappedResult } from './type/optional/index';
 export { Parameters, type TParameters } from './type/parameters/index';
 export { Partial, PartialFromMappedResult, type TPartial, type TPartialFromMappedResult } from './type/partial/index';
-export { Pick, type TPick, type TPickFromMappedKey } from './type/pick/index';
+export { Pick, type TPick, type TPickFromMappedKey, type TPickFromMappedResult } from './type/pick/index';
 export { Promise, type TPromise } from './type/promise/index';
 export { Readonly, ReadonlyFromMappedResult, type TReadonly, type TReadonlyWithFlag, type TReadonlyFromMappedResult } from './type/readonly/index';
 export { ReadonlyOptional, type TReadonlyOptional } from './type/readonly-optional/index';

package/build/require/type/awaited/awaited.js

@@ -8,14 +8,10 @@ const type_1 = require("../clone/type");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 const type_2 = require("../guard/type");
 // prettier-ignore
-function FromRest(T, Acc = []) {
-    const [L, ...R] = T;
-    return (T.length > 0
-        ? FromRest(R, [...Acc, FromSchema(L)])
-        : Acc);
+function FromRest(T) {
+    return T.map(L => FromSchema(L));
 }
 // prettier-ignore
 function FromIntersect(T) {

package/build/require/type/composite/composite.d.ts

@@ -7,8 +7,7 @@ type TCompositeIndex<T extends TIntersect<TObject[]>, K extends string[], Acc ex
     [_ in L]: TIndex<T, [L]>;
 }> : Acc;
 type TCompositeReduce<T extends TObject[]> = UnionToTuple<TCompositeKeys<T>> extends infer K ? Evaluate<TCompositeIndex<TIntersect<T>, Assert<K, string[]>>> : {};
-export type TCompositeResolve<T extends TObject[]> = TIntersect<T> extends TIntersect ? TObject<TCompositeReduce<T>> : TObject<{}>;
-export declare function CompositeResolve<T extends TObject[]>(T: [...T]): TCompositeResolve<T>;
+type TCompositeResolve<T extends TObject[]> = TIntersect<T> extends TIntersect ? TObject<TCompositeReduce<T>> : TObject<{}>;
 export type TComposite<T extends TObject[]> = TCompositeResolve<T>;
 /** `[Json]` Creates a Composite object type */
 export declare function Composite<T extends TObject[]>(T: [...T], options?: ObjectOptions): TComposite<T>;

package/build/require/type/composite/composite.js

@@ -1,19 +1,18 @@
 "use strict";
 
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Composite = exports.CompositeResolve = void 0;
+exports.Composite = void 0;
 const index_1 = require("../object/index");
 const index_2 = require("../intersect/index");
-const index_3 = require("../keyof/index");
-const index_4 = require("../indexed/index");
+const index_3 = require("../indexed/index");
+const index_4 = require("../keyof/index");
 const type_1 = require("../clone/type");
 function CompositeResolve(T) {
     const intersect = (0, index_2.Intersect)(T, {});
-    const keys = (0, index_3.KeyOfPropertyKeys)(intersect);
-    const properties = keys.reduce((acc, key) => ({ ...acc, [key]: (0, index_4.Index)(intersect, [key]) }), {});
+    const keys = (0, index_4.KeyOfPropertyKeys)(intersect);
+    const properties = keys.reduce((acc, key) => ({ ...acc, [key]: (0, index_3.Index)(intersect, [key]) }), {});
     return (0, index_1.Object)(properties);
 }
-exports.CompositeResolve = CompositeResolve;
 /** `[Json]` Creates a Composite object type */
 function Composite(T, options) {
     return (0, type_1.CloneType)(CompositeResolve(T), options);

package/build/require/type/const/const.js

@@ -2,7 +2,6 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Const = void 0;
-const value_1 = require("../guard/value");
 const index_1 = require("../any/index");
 const index_2 = require("../bigint/index");
 const index_3 = require("../date/index");
@@ -17,12 +16,13 @@ const index_11 = require("../undefined/index");
 const index_12 = require("../uint8array/index");
 const index_13 = require("../unknown/index");
 const index_14 = require("../clone/index");
+// ------------------------------------------------------------------
+// ValueGuard
+// ------------------------------------------------------------------
+const value_1 = require("../guard/value");
 // prettier-ignore
 function FromArray(T) {
-    const [L, ...R] = T;
-    return (T.length > 0
-        ? [FromValue(L, false), ...FromArray(R)]
-        : []);
+    return T.map(L => FromValue(L, false));
 }
 // prettier-ignore
 function FromProperties(value) {
@@ -37,7 +37,7 @@ function ConditionalReadonly(T, root) {
 function FromValue(value, root) {
     return ((0, value_1.IsAsyncIterator)(value) ? ConditionalReadonly((0, index_1.Any)(), root) :
         (0, value_1.IsIterator)(value) ? ConditionalReadonly((0, index_1.Any)(), root) :
-            (0, value_1.IsArray)(value) ? (0, index_10.Readonly)((0, index_9.Tuple)(FromArray(value))) : // Always Readonly
+            (0, value_1.IsArray)(value) ? (0, index_10.Readonly)((0, index_9.Tuple)(FromArray(value))) :
                 (0, value_1.IsUint8Array)(value) ? (0, index_12.Uint8Array)() :
                     (0, value_1.IsDate)(value) ? (0, index_3.Date)() :
                         (0, value_1.IsObject)(value) ? ConditionalReadonly((0, index_7.Object)(FromProperties(value)), root) :

package/build/require/type/constructor/constructor.d.ts

@@ -4,7 +4,7 @@ import type { Ensure } from '../helpers/index';
 import { Kind } from '../symbols/index';
 type ConstructorStaticReturnType<T extends TSchema, P extends unknown[]> = Static<T, P>;
 type ConstructorStaticParameters<T extends TSchema[], P extends unknown[], Acc extends unknown[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? ConstructorStaticParameters<R, P, [...Acc, Static<L, P>]> : Acc;
-export type ConstructorStatic<T extends TSchema[], U extends TSchema, P extends unknown[]> = (Ensure<new (...param: ConstructorStaticParameters<T, P>) => ConstructorStaticReturnType<U, P>>);
+type ConstructorStatic<T extends TSchema[], U extends TSchema, P extends unknown[]> = (Ensure<new (...param: ConstructorStaticParameters<T, P>) => ConstructorStaticReturnType<U, P>>);
 export interface TConstructor<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Constructor';
     static: ConstructorStatic<T, U, this['params']>;

package/build/require/type/constructor/constructor.js

@@ -2,8 +2,8 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Constructor = void 0;
-const index_1 = require("../symbols/index");
 const type_1 = require("../clone/type");
+const index_1 = require("../symbols/index");
 /** `[JavaScript]` Creates a Constructor type */
 function Constructor(parameters, returns, options) {
     return {

package/build/require/type/deref/deref.js

@@ -8,7 +8,6 @@ const value_1 = require("../guard/value");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 const type_2 = require("../guard/type");
 function FromRest(schema, references) {
     return schema.map((schema) => Deref(schema, references));

package/build/require/type/discard/discard.js

@@ -2,11 +2,11 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Discard = void 0;
-function Key(value, key) {
+function DiscardKey(value, key) {
     const { [key]: _, ...rest } = value;
     return rest;
 }
 function Discard(value, keys) {
-    return keys.reduce((acc, key) => Key(acc, key), value);
+    return keys.reduce((acc, key) => DiscardKey(acc, key), value);
 }
 exports.Discard = Discard;

package/build/require/type/enum/enum.js

@@ -5,6 +5,9 @@ exports.Enum = void 0;
 const index_1 = require("../literal/index");
 const index_2 = require("../symbols/index");
 const index_3 = require("../union/index");
+// ------------------------------------------------------------------
+// ValueGuard
+// ------------------------------------------------------------------
 const value_1 = require("../guard/value");
 /** `[Json]` Creates a Enum type */
 function Enum(item, options = {}) {

package/build/require/type/exclude/exclude-from-mapped-result.d.ts

@@ -2,10 +2,10 @@ import type { TSchema, SchemaOptions } from '../schema/index';
 import type { TProperties } from '../object/index';
 import { type TMappedResult } from '../mapped/index';
 import { type TExclude } from './exclude';
-type TFromProperties<K extends TProperties, U extends TSchema> = ({
-    [K2 in keyof K]: TExclude<K[K2], U>;
+type TFromProperties<K extends TProperties, T extends TSchema> = ({
+    [K2 in keyof K]: TExclude<K[K2], T>;
 });
-type TFromMappedResult<K extends TMappedResult, U extends TSchema> = (TFromProperties<K['properties'], U>);
-export type TExcludeFromMappedResult<T extends TMappedResult, U extends TSchema, P extends TProperties = TFromMappedResult<T, U>> = (TMappedResult<P>);
-export declare function ExcludeFromMappedResult<T extends TMappedResult, U extends TSchema, P extends TProperties = TFromMappedResult<T, U>>(T: T, U: U, options: SchemaOptions): TMappedResult<P>;
+type TFromMappedResult<R extends TMappedResult, T extends TSchema> = (TFromProperties<R['properties'], T>);
+export type TExcludeFromMappedResult<R extends TMappedResult, T extends TSchema, P extends TProperties = TFromMappedResult<R, T>> = (TMappedResult<P>);
+export declare function ExcludeFromMappedResult<R extends TMappedResult, T extends TSchema, P extends TProperties = TFromMappedResult<R, T>>(R: R, T: T, options: SchemaOptions): TMappedResult<P>;
 export {};

package/build/require/type/exclude/exclude-from-mapped-result.js

@@ -5,18 +5,18 @@ exports.ExcludeFromMappedResult = void 0;
 const index_1 = require("../mapped/index");
 const exclude_1 = require("./exclude");
 // prettier-ignore
-function FromProperties(K, U, options) {
-    return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
-        return { ...Acc, [K2]: (0, exclude_1.Exclude)(K[K2], U, options) };
+function FromProperties(P, U, options) {
+    return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
+        return { ...Acc, [K2]: (0, exclude_1.Exclude)(P[K2], U, options) };
     }, {});
 }
 // prettier-ignore
-function FromMappedResult(K, U, options) {
-    return FromProperties(K.properties, U, options);
+function FromMappedResult(R, T, options) {
+    return FromProperties(R.properties, T, options);
 }
 // prettier-ignore
-function ExcludeFromMappedResult(T, U, options) {
-    const P = FromMappedResult(T, U, options);
+function ExcludeFromMappedResult(R, T, options) {
+    const P = FromMappedResult(R, T, options);
     return (0, index_1.MappedResult)(P);
 }
 exports.ExcludeFromMappedResult = ExcludeFromMappedResult;

package/build/require/type/exclude/exclude.js

@@ -11,7 +11,6 @@ const exclude_from_mapped_result_1 = require("./exclude-from-mapped-result");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 const type_2 = require("../guard/type");
 // prettier-ignore
 function ExcludeResolve(L, R) {

package/build/require/type/extends/extends-from-mapped-key.d.ts

@@ -2,7 +2,7 @@ import type { TSchema, SchemaOptions } from '../schema/index';
 import type { TProperties } from '../object/index';
 import type { Assert } from '../helpers/index';
 import { type TMappedResult, type TMappedKey } from '../mapped/index';
-import { TLiteral, TLiteralValue } from '../literal/index';
+import { type TLiteral, type TLiteralValue } from '../literal/index';
 import { type TExtends } from './extends';
 type TFromPropertyKey<K extends PropertyKey, U extends TSchema, L extends TSchema, R extends TSchema> = {
     [_ in K]: TExtends<TLiteral<Assert<K, TLiteralValue>>, U, L, R>;

package/build/require/type/extends/extends-from-mapped-key.js

@@ -12,11 +12,10 @@ function FromPropertyKey(K, U, L, R, options) {
     };
 }
 // prettier-ignore
-function FromPropertyKeys(K, U, L, R, options, Acc = {}) {
-    const [LK, ...RK] = K;
-    return (K.length > 0
-        ? FromPropertyKeys(RK, U, L, R, options, { ...Acc, ...FromPropertyKey(LK, U, L, R, options) })
-        : Acc);
+function FromPropertyKeys(K, U, L, R, options) {
+    return K.reduce((Acc, LK) => {
+        return { ...Acc, ...FromPropertyKey(LK, U, L, R, options) };
+    }, {});
 }
 // prettier-ignore
 function FromMappedKey(K, U, L, R, options) {

package/build/require/type/extends/extends-from-mapped-result.d.ts

@@ -2,10 +2,10 @@ import type { TSchema, SchemaOptions } from '../schema/index';
 import type { TProperties } from '../object/index';
 import { type TMappedResult } from '../mapped/index';
 import { type TExtends } from './extends';
-type TFromProperties<K extends TProperties, U extends TSchema, L extends TSchema, R extends TSchema> = ({
-    [K2 in keyof K]: TExtends<K[K2], U, L, R>;
+type TFromProperties<P extends TProperties, Right extends TSchema, False extends TSchema, True extends TSchema> = ({
+    [K2 in keyof P]: TExtends<P[K2], Right, False, True>;
 });
-type TFromMappedResult<K extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema> = (TFromProperties<K['properties'], U, L, R>);
-export type TExtendsFromMappedResult<T extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = TFromMappedResult<T, U, L, R>> = (TMappedResult<P>);
-export declare function ExtendsFromMappedResult<T extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = TFromMappedResult<T, U, L, R>>(T: T, U: U, L: L, R: R, options: SchemaOptions): TMappedResult<P>;
+type TFromMappedResult<Left extends TMappedResult, Right extends TSchema, True extends TSchema, False extends TSchema> = (TFromProperties<Left['properties'], Right, True, False>);
+export type TExtendsFromMappedResult<Left extends TMappedResult, Right extends TSchema, True extends TSchema, False extends TSchema, P extends TProperties = TFromMappedResult<Left, Right, True, False>> = (TMappedResult<P>);
+export declare function ExtendsFromMappedResult<Left extends TMappedResult, Right extends TSchema, True extends TSchema, False extends TSchema, P extends TProperties = TFromMappedResult<Left, Right, True, False>>(Left: Left, Right: Right, True: True, False: False, options: SchemaOptions): TMappedResult<P>;
 export {};

package/build/require/type/extends/extends-from-mapped-result.js

@@ -5,18 +5,18 @@ exports.ExtendsFromMappedResult = void 0;
 const index_1 = require("../mapped/index");
 const extends_1 = require("./extends");
 // prettier-ignore
-function FromProperties(K, U, L, R, options) {
-    return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
-        return { ...Acc, [K2]: (0, extends_1.Extends)(K[K2], U, L, R, options) };
+function FromProperties(P, Right, True, False, options) {
+    return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
+        return { ...Acc, [K2]: (0, extends_1.Extends)(P[K2], Right, True, False, options) };
     }, {});
 }
 // prettier-ignore
-function FromMappedResult(K, U, L, R, options) {
-    return FromProperties(K.properties, U, L, R, options);
+function FromMappedResult(Left, Right, True, False, options) {
+    return FromProperties(Left.properties, Right, True, False, options);
 }
 // prettier-ignore
-function ExtendsFromMappedResult(T, U, L, R, options) {
-    const P = FromMappedResult(T, U, L, R, options);
+function ExtendsFromMappedResult(Left, Right, True, False, options) {
+    const P = FromMappedResult(Left, Right, True, False, options);
     return (0, index_1.MappedResult)(P);
 }
 exports.ExtendsFromMappedResult = ExtendsFromMappedResult;

package/build/require/type/extends/extends.js

@@ -10,7 +10,6 @@ const extends_from_mapped_result_1 = require("./extends-from-mapped-result");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 const type_2 = require("../guard/type");
 // prettier-ignore
 function ExtendsResolve(left, right, trueType, falseType) {

package/build/require/type/extract/extract-from-mapped-result.d.ts

@@ -2,10 +2,10 @@ import type { TSchema, SchemaOptions } from '../schema/index';
 import type { TProperties } from '../object/index';
 import { type TMappedResult } from '../mapped/index';
 import { type TExtract } from './extract';
-type TFromProperties<K extends TProperties, U extends TSchema> = ({
-    [K2 in keyof K]: TExtract<K[K2], U>;
+type TFromProperties<P extends TProperties, T extends TSchema> = ({
+    [K2 in keyof P]: TExtract<P[K2], T>;
 });
-type TFromMappedResult<K extends TMappedResult, U extends TSchema> = (TFromProperties<K['properties'], U>);
-export type TExtractFromMappedResult<T extends TMappedResult, U extends TSchema, P extends TProperties = TFromMappedResult<T, U>> = (TMappedResult<P>);
-export declare function ExtractFromMappedResult<T extends TMappedResult, U extends TSchema, P extends TProperties = TFromMappedResult<T, U>>(T: T, U: U, options: SchemaOptions): TMappedResult<P>;
+type TFromMappedResult<R extends TMappedResult, T extends TSchema> = (TFromProperties<R['properties'], T>);
+export type TExtractFromMappedResult<R extends TMappedResult, T extends TSchema, P extends TProperties = TFromMappedResult<R, T>> = (TMappedResult<P>);
+export declare function ExtractFromMappedResult<R extends TMappedResult, T extends TSchema, P extends TProperties = TFromMappedResult<R, T>>(R: R, T: T, options: SchemaOptions): TMappedResult<P>;
 export {};