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

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

@@ -4,9 +4,10 @@ import { type TRecursive } from '../recursive/index.mjs';
 import { type TIntersect } from '../intersect/index.mjs';
 import { type TUnion } from '../union/index.mjs';
 import { type TObject, type TProperties } from '../object/index.mjs';
+import type { TMappedKey, TMappedResult } from '../mapped/index.mjs';
 import { type TIndexPropertyKeys } from '../indexed/index.mjs';
-import { TMappedKey } from '../mapped/index.mjs';
 import { type TPickFromMappedKey } from './pick-from-mapped-key.mjs';
+import { type TPickFromMappedResult } from './pick-from-mapped-result.mjs';
 type FromIntersect<T extends TSchema[], K extends PropertyKey[], Acc extends TSchema[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? FromIntersect<R, K, [...Acc, PickResolve<L, K>]> : Acc;
 declare function FromIntersect<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K): FromIntersect<T, K, []>;
 type FromUnion<T extends TSchema[], K extends PropertyKey[], Acc extends TSchema[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? FromUnion<R, K, [...Acc, PickResolve<L, K>]> : Acc;
@@ -17,7 +18,9 @@ export type PickResolve<T extends TProperties, K extends PropertyKey[]> = T exte
 export declare function PickResolve<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): PickResolve<T, K>;
 export type TPick<T extends TSchema, K extends PropertyKey[]> = PickResolve<T, K>;
 /** `[Json]` Constructs a type whose keys are picked from the given type */
-export declare function Pick<T extends TSchema, K extends TMappedKey>(T: T, K: K): TPickFromMappedKey<T, K>;
+export declare function Pick<T extends TMappedResult, K extends PropertyKey[]>(T: T, K: [...K], options?: SchemaOptions): TPickFromMappedResult<T, K>;
+/** `[Json]` Constructs a type whose keys are picked from the given type */
+export declare function Pick<T extends TSchema, K extends TMappedKey>(T: T, K: K, options?: SchemaOptions): TPickFromMappedKey<T, K>;
 /** `[Json]` Constructs a type whose keys are picked from the given type */
 export declare function Pick<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TPick<T, I>;
 /** `[Json]` Constructs a type whose keys are picked from the given type */

package/build/import/type/pick/pick.mjs

@@ -6,11 +6,11 @@ import { Discard } from '../discard/index.mjs';
 import { TransformKind } from '../symbols/index.mjs';
 import { CloneType } from '../clone/type.mjs';
 import { PickFromMappedKey } from './pick-from-mapped-key.mjs';
+import { PickFromMappedResult } from './pick-from-mapped-result.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
-import { IsMappedKey, IsIntersect, IsUnion, IsObject, IsSchema, } from '../guard/type.mjs';
+import { IsMappedKey, IsMappedResult, IsIntersect, IsUnion, IsObject, IsSchema } from '../guard/type.mjs';
 function FromIntersect(T, K) {
     return T.map((T) => PickResolve(T, K));
 }
@@ -32,13 +32,14 @@ export function PickResolve(T, K) {
                 Object({}));
 }
 export function Pick(T, K, options = {}) {
-    if (IsMappedKey(K)) {
+    // mapped
+    if (IsMappedKey(K))
         return PickFromMappedKey(T, K, options);
-    }
-    else {
-        const I = IsSchema(K) ? IndexPropertyKeys(K) : K;
-        const D = Discard(T, [TransformKind, '$id', 'required']);
-        const R = CloneType(PickResolve(T, I), options);
-        return { ...D, ...R };
-    }
+    if (IsMappedResult(T))
+        return PickFromMappedResult(T, K, options);
+    // non-mapped
+    const I = IsSchema(K) ? IndexPropertyKeys(K) : K;
+    const D = Discard(T, [TransformKind, '$id', 'required']);
+    const R = CloneType(PickResolve(T, I), options);
+    return { ...D, ...R };
 }

package/build/import/type/promise/promise.mjs

@@ -1,5 +1,5 @@
-import { Kind } from '../symbols/index.mjs';
 import { CloneType } from '../clone/type.mjs';
+import { Kind } from '../symbols/index.mjs';
 /** `[JavaScript]` Creates a Promise type */
 export function Promise(item, options = {}) {
     return {

package/build/import/type/readonly/readonly-from-mapped-result.d.mts

@@ -1,10 +1,10 @@
 import type { TProperties } from '../object/index.mjs';
 import { type TMappedResult } from '../mapped/index.mjs';
 import { type TReadonlyWithFlag } from './readonly.mjs';
-type TFromProperties<K extends TProperties, F extends boolean> = ({
-    [K2 in keyof K]: TReadonlyWithFlag<K[K2], F>;
+type TFromProperties<P extends TProperties, F extends boolean> = ({
+    [K2 in keyof P]: TReadonlyWithFlag<P[K2], F>;
 });
-type TFromMappedResult<K extends TMappedResult, F extends boolean> = (TFromProperties<K['properties'], F>);
-export type TReadonlyFromMappedResult<T extends TMappedResult, F extends boolean, P extends TProperties = TFromMappedResult<T, F>> = (TMappedResult<P>);
-export declare function ReadonlyFromMappedResult<T extends TMappedResult, F extends boolean, P extends TProperties = TFromMappedResult<T, F>>(T: T, F: F): TMappedResult<P>;
+type TFromMappedResult<R extends TMappedResult, F extends boolean> = (TFromProperties<R['properties'], F>);
+export type TReadonlyFromMappedResult<R extends TMappedResult, F extends boolean, P extends TProperties = TFromMappedResult<R, F>> = (TMappedResult<P>);
+export declare function ReadonlyFromMappedResult<R extends TMappedResult, F extends boolean, P extends TProperties = TFromMappedResult<R, F>>(R: R, F: F): TMappedResult<P>;
 export {};

package/build/import/type/readonly/readonly-from-mapped-result.mjs

@@ -7,11 +7,11 @@ function FromProperties(K, F) {
     }, {});
 }
 // prettier-ignore
-function FromMappedResult(K, F) {
-    return FromProperties(K.properties, F);
+function FromMappedResult(R, F) {
+    return FromProperties(R.properties, F);
 }
 // prettier-ignore
-export function ReadonlyFromMappedResult(T, F) {
-    const P = FromMappedResult(T, F);
+export function ReadonlyFromMappedResult(R, F) {
+    const P = FromMappedResult(R, F);
     return MappedResult(P);
 }

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

@@ -2,14 +2,14 @@ import type { TSchema } from '../schema/index.mjs';
 import type { Static } from '../static/index.mjs';
 import type { Evaluate, Ensure, Assert } from '../helpers/index.mjs';
 import { type TObject, type TProperties, type TAdditionalProperties, type ObjectOptions } from '../object/index.mjs';
-import { type TLiteral, TLiteralValue } from '../literal/index.mjs';
+import { type TLiteral, type TLiteralValue } from '../literal/index.mjs';
 import { type TNever } from '../never/index.mjs';
 import { type TUnion } from '../union/index.mjs';
 import { type TString } from '../string/index.mjs';
 import { type TInteger } from '../integer/index.mjs';
 import { type TNumber } from '../number/index.mjs';
 import { type TEnum } from '../enum/index.mjs';
-import { TTemplateLiteral, TIsTemplateLiteralFinite } from '../template-literal/index.mjs';
+import { TIsTemplateLiteralFinite, type TTemplateLiteral } from '../template-literal/index.mjs';
 import { Kind } from '../symbols/index.mjs';
 type TFromTemplateLiteralKeyInfinite<K extends TTemplateLiteral, T extends TSchema> = Ensure<TRecord<K, T>>;
 type TFromTemplateLiteralKeyFinite<K extends TTemplateLiteral, T extends TSchema, I extends string = Static<K>> = (Ensure<TObject<Evaluate<{

package/build/import/type/record/record.mjs

@@ -6,6 +6,9 @@ import { PatternStringExact, PatternNumberExact } from '../patterns/index.mjs';
 import { IndexPropertyKeys } from '../indexed/index.mjs';
 import { Kind, Hint } from '../symbols/index.mjs';
 import { CloneType } from '../clone/type.mjs';
+// ------------------------------------------------------------------
+// ValueGuard
+// ------------------------------------------------------------------
 import { IsUndefined } from '../guard/value.mjs';
 // ------------------------------------------------------------------
 // TypeGuard

package/build/import/type/ref/ref.mjs

@@ -1,6 +1,6 @@
 import { Kind } from '../symbols/index.mjs';
 // ------------------------------------------------------------------
-// TypeGuard
+// ValueGuard
 // ------------------------------------------------------------------
 import { IsString, IsUndefined } from '../guard/value.mjs';
 /** `[Json]` Creates a Ref type. */

package/build/import/type/required/required-from-mapped-result.d.mts

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

package/build/import/type/required/required-from-mapped-result.mjs

@@ -1,17 +1,17 @@
 import { MappedResult } from '../mapped/index.mjs';
 import { Required } from './required.mjs';
 // prettier-ignore
-function FromProperties(K, options) {
-    return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
-        return { ...Acc, [K2]: Required(K[K2], options) };
+function FromProperties(P, options) {
+    return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
+        return { ...Acc, [K2]: Required(P[K2], options) };
     }, {});
 }
 // prettier-ignore
-function FromMappedResult(K, options) {
-    return FromProperties(K.properties, options);
+function FromMappedResult(R, options) {
+    return FromProperties(R.properties, options);
 }
 // prettier-ignore
-export function RequiredFromMappedResult(T, options) {
-    const P = FromMappedResult(T, options);
+export function RequiredFromMappedResult(R, options) {
+    const P = FromMappedResult(R, options);
     return MappedResult(P);
 }

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

@@ -9,12 +9,11 @@ import { type TIntersect } from '../intersect/index.mjs';
 import { type TUnion } from '../union/index.mjs';
 import { type TObject, type TProperties } from '../object/index.mjs';
 import { type TRequiredFromMappedResult } from './required-from-mapped-result.mjs';
-type TFromIntersect<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromIntersect<R, [...Acc, TRequiredResolve<L>]> : Acc);
-type TFromUnion<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromUnion<R, [...Acc, TRequiredResolve<L>]> : Acc);
+type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Acc, TRequiredResolve<L>]> : Acc);
 type TFromProperties<T extends TProperties> = Evaluate<{
     [K in keyof T]: T[K] extends (TReadonlyOptional<infer S>) ? TReadonly<S> : T[K] extends (TReadonly<infer S>) ? TReadonly<S> : T[K] extends (TOptional<infer S>) ? S : T[K];
 }>;
-type TRequiredResolve<T extends TSchema> = (T extends TRecursive<infer S> ? TRecursive<TRequiredResolve<S>> : T extends TIntersect<infer S> ? TIntersect<TFromIntersect<S>> : T extends TUnion<infer S> ? TUnion<TFromUnion<S>> : T extends TObject<infer S> ? TObject<TFromProperties<S>> : TObject<{}>);
+type TRequiredResolve<T extends TSchema> = (T extends TRecursive<infer S> ? TRecursive<TRequiredResolve<S>> : T extends TIntersect<infer S> ? TIntersect<TFromRest<S>> : T extends TUnion<infer S> ? TUnion<TFromRest<S>> : T extends TObject<infer S> ? TObject<TFromProperties<S>> : TObject<{}>);
 export type TRequired<T extends TSchema> = TRequiredResolve<T>;
 /** `[Json]` Constructs a type where all properties are required */
 export declare function Required<T extends TMappedResult>(T: T, options?: SchemaOptions): TRequiredFromMappedResult<T>;

package/build/import/type/required/required.mjs

@@ -10,18 +10,8 @@ import { RequiredFromMappedResult } from './required-from-mapped-result.mjs';
 // ------------------------------------------------------------------
 import { IsMappedResult, IsIntersect, IsUnion, IsObject } from '../guard/type.mjs';
 // prettier-ignore
-function FromIntersect(T, Acc = []) {
-    const [L, ...R] = T;
-    return (T.length > 0
-        ? FromIntersect(R, [...Acc, RequiredResolve(L)])
-        : Acc);
-}
-// prettier-ignore
-function FromUnion(T, Acc = []) {
-    const [L, ...R] = T;
-    return (T.length > 0
-        ? FromUnion(R, [...Acc, RequiredResolve(L)])
-        : Acc);
+function FromRest(T) {
+    return T.map(L => RequiredResolve(L));
 }
 // prettier-ignore
 function FromProperties(T) {
@@ -31,8 +21,8 @@ function FromProperties(T) {
 }
 // prettier-ignore
 function RequiredResolve(T) {
-    return (IsIntersect(T) ? Intersect(FromIntersect(T.allOf)) :
-        IsUnion(T) ? Union(FromUnion(T.anyOf)) :
+    return (IsIntersect(T) ? Intersect(FromRest(T.allOf)) :
+        IsUnion(T) ? Union(FromRest(T.anyOf)) :
             IsObject(T) ? Object(FromProperties(T.properties)) :
                 Object({}));
 }

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

@@ -2,9 +2,9 @@ import type { TSchema } from '../schema/index.mjs';
 import type { TIntersect } from '../intersect/index.mjs';
 import type { TUnion } from '../union/index.mjs';
 import type { TTuple } from '../tuple/index.mjs';
-export type TRestResolve<T extends TSchema> = T extends TIntersect<infer S> ? [...S] : T extends TUnion<infer S> ? [...S] : T extends TTuple<infer S> ? [...S] : [
+type TRestResolve<T extends TSchema> = T extends TIntersect<infer S> ? [...S] : T extends TUnion<infer S> ? [...S] : T extends TTuple<infer S> ? [...S] : [
 ];
-export declare function RestResolve<T extends TSchema>(T: T): TRestResolve<T>;
 export type TRest<T extends TSchema> = TRestResolve<T>;
 /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
 export declare function Rest<T extends TSchema>(T: T): TRest<T>;
+export {};

package/build/import/type/rest/rest.mjs

@@ -2,10 +2,9 @@ import { CloneRest } from '../clone/type.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 import { IsIntersect, IsUnion, IsTuple } from '../guard/type.mjs';
 // prettier-ignore
-export function RestResolve(T) {
+function RestResolve(T) {
     return (IsIntersect(T) ? [...T.allOf] :
         IsUnion(T) ? [...T.anyOf] :
             IsTuple(T) ? [...(T.items ?? [])] :

package/build/import/type/sets/index.d.mts

@@ -0,0 +1 @@
+export * from './set.mjs';

package/build/import/type/sets/index.mjs

@@ -0,0 +1 @@
+export * from './set.mjs';

package/build/import/type/sets/set.d.mts

@@ -0,0 +1,24 @@
+export type TSetIncludes<T extends PropertyKey[], S extends PropertyKey> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? S extends L ? true : TSetIncludes<R, S> : false);
+/** Returns true if element S is in the set of T */
+export declare function SetIncludes<T extends PropertyKey[], S extends PropertyKey>(T: [...T], S: S): TSetIncludes<T, S>;
+export type SetIsSubset<T extends PropertyKey[], S extends PropertyKey[]> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TSetIncludes<S, L> extends true ? SetIsSubset<R, S> : false : true);
+/** Returns true if T is a subset of S */
+export declare function SetIsSubset<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): SetIsSubset<T, S>;
+export type TSetDistinct<T extends PropertyKey[], Acc extends PropertyKey[] = []> = T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TSetIncludes<Acc, L> extends false ? TSetDistinct<R, [...Acc, L]> : TSetDistinct<R, [...Acc]> : Acc;
+/** Returns a distinct set of elements */
+export declare function SetDistinct<T extends PropertyKey[]>(T: [...T]): TSetDistinct<T>;
+export type TSetIntersect<T extends PropertyKey[], S extends PropertyKey[], Acc extends PropertyKey[] = []> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TSetIncludes<S, L> extends true ? TSetIntersect<R, S, [L, ...Acc]> : TSetIntersect<R, S, [...Acc]> : Acc);
+/** Returns the Intersect of the given sets */
+export declare function SetIntersect<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): TSetIntersect<T, S>;
+export type TSetUnion<T extends PropertyKey[], S extends PropertyKey[], Acc extends PropertyKey[] = S> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TSetUnion<R, S, [...Acc, L]> : Acc);
+/** Returns the Union of the given sets */
+export declare function SetUnion<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): TSetUnion<T, S>;
+export type TSetComplement<T extends PropertyKey[], S extends PropertyKey[], Acc extends PropertyKey[] = []> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TSetIncludes<S, L> extends true ? TSetComplement<R, S, [...Acc]> : TSetComplement<R, S, [...Acc, L]> : Acc);
+/** Returns the Complement by omitting elements in T that are in S */
+export declare function SetComplement<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): TSetComplement<T, S>;
+export type TSetIntersectMany<T extends PropertyKey[][], Acc extends PropertyKey[] = []> = (T extends [infer L extends PropertyKey[]] ? L : T extends [infer L extends PropertyKey[], ...infer R extends PropertyKey[][]] ? TSetIntersectMany<R, TSetIntersect<Acc, L>> : Acc);
+/** Returns the Intersect of multiple sets */
+export declare function SetIntersectMany<T extends PropertyKey[][]>(T: [...T]): TSetIntersectMany<T>;
+export type TSetUnionMany<T extends PropertyKey[][], Acc extends PropertyKey[] = []> = (T extends [infer L extends PropertyKey[], ...infer R extends PropertyKey[][]] ? TSetUnionMany<R, TSetUnion<Acc, L>> : Acc);
+/** Returns the Union of multiple sets */
+export declare function SetUnionMany<T extends PropertyKey[][]>(T: [...T]): TSetUnionMany<T>;

package/build/import/type/sets/set.mjs

@@ -0,0 +1,35 @@
+/** Returns true if element S is in the set of T */
+// prettier-ignore
+export function SetIncludes(T, S) {
+    return T.includes(S);
+}
+/** Returns true if T is a subset of S */
+export function SetIsSubset(T, S) {
+    return T.every((L) => SetIncludes(S, L));
+}
+/** Returns a distinct set of elements */
+export function SetDistinct(T) {
+    return [...new Set(T)];
+}
+/** Returns the Intersect of the given sets */
+export function SetIntersect(T, S) {
+    return T.filter((L) => S.includes(L));
+}
+/** Returns the Union of the given sets */
+export function SetUnion(T, S) {
+    return [...T, ...S];
+}
+/** Returns the Complement by omitting elements in T that are in S */
+// prettier-ignore
+export function SetComplement(T, S) {
+    return T.filter(L => !S.includes(L));
+}
+/** Returns the Intersect of multiple sets */
+// prettier-ignore
+export function SetIntersectMany(T) {
+    return (T.length === 1 ? T[0] : T.reduce((Acc, L) => [...SetIntersect(Acc, L)], []));
+}
+/** Returns the Union of multiple sets */
+export function SetUnionMany(T) {
+    return T.reduce((Acc, L) => [...Acc, ...L], []);
+}

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

@@ -1,3 +1,3 @@
 import type { TSchema } from '../schema/index.mjs';
-/** `[Json]` Omits compositing symbols from this schema */
+/** `[Json]` Omits compositing symbols from this schema. */
 export declare function Strict<T extends TSchema>(schema: T): T;

package/build/import/type/strict/strict.mjs

@@ -1,4 +1,4 @@
-/** `[Json]` Omits compositing symbols from this schema */
+/** `[Json]` Omits compositing symbols from this schema. */
 export function Strict(schema) {
     return JSON.parse(JSON.stringify(schema));
 }

package/build/import/type/template-literal/syntax.d.mts

@@ -1,5 +1,5 @@
 import type { Assert, Trim } from '../helpers/index.mjs';
-import type { TTemplateLiteralKind, TTemplateLiteral } from './index.mjs';
+import type { TTemplateLiteral, TTemplateLiteralKind } from './index.mjs';
 import { type TLiteral } from '../literal/index.mjs';
 import { type TBoolean } from '../boolean/index.mjs';
 import { type TBigInt } from '../bigint/index.mjs';

package/build/import/type/template-literal/template-literal.d.mts

@@ -9,7 +9,7 @@ import type { TString } from '../string/index.mjs';
 import type { TBoolean } from '../boolean/index.mjs';
 import type { TNever } from '../never/index.mjs';
 import type { Static } from '../static/index.mjs';
-import { TTemplateLiteralSyntax } from './syntax.mjs';
+import { type TTemplateLiteralSyntax } from './syntax.mjs';
 import { EmptyString } from '../helpers/index.mjs';
 import { Kind } from '../symbols/index.mjs';
 type TemplateLiteralStaticKind<T, Acc extends string> = T extends TUnion<infer U> ? {

package/build/import/type/transform/transform.mjs

@@ -1,5 +1,5 @@
-import { CloneType } from '../clone/type.mjs';
 import { TransformKind } from '../symbols/index.mjs';
+import { CloneType } from '../clone/type.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------

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/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 = {}) {