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

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

@@ -7,9 +7,8 @@ import { type TMappedKey } from '../mapped/index.mjs';
 export type IntrinsicMode = 'Uppercase' | 'Lowercase' | 'Capitalize' | 'Uncapitalize';
 type TFromTemplateLiteral<T extends TTemplateLiteralKind[], M extends IntrinsicMode> = M extends IntrinsicMode ? T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]] ? [TIntrinsic<L, M>, ...TFromTemplateLiteral<R, M>] : T : T;
 type TFromLiteralValue<T, M extends IntrinsicMode> = (T extends string ? M extends 'Uncapitalize' ? Uncapitalize<T> : M extends 'Capitalize' ? Capitalize<T> : M extends 'Uppercase' ? Uppercase<T> : M extends 'Lowercase' ? Lowercase<T> : string : T);
-type FromRest<T extends TSchema[], M extends IntrinsicMode, Acc extends TSchema[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? FromRest<R, M, [...Acc, TIntrinsic<L, M>]> : Acc;
-declare function FromRest<T extends TSchema[], M extends IntrinsicMode>(T: [...T], M: M, Acc?: TSchema[]): FromRest<T, M>;
-export type TIntrinsic<T extends TSchema, M extends IntrinsicMode> = T extends TMappedKey ? TIntrinsicFromMappedKey<T, M> : T extends TTemplateLiteral<infer S> ? TTemplateLiteral<TFromTemplateLiteral<S, M>> : T extends TUnion<infer S> ? TUnion<FromRest<S, M>> : T extends TLiteral<infer S> ? TLiteral<TFromLiteralValue<S, M>> : T;
+type TFromRest<T extends TSchema[], M extends IntrinsicMode, Acc extends TSchema[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, M, [...Acc, TIntrinsic<L, M>]> : Acc;
+export type TIntrinsic<T extends TSchema, M extends IntrinsicMode> = T extends TMappedKey ? TIntrinsicFromMappedKey<T, M> : T extends TTemplateLiteral<infer S> ? TTemplateLiteral<TFromTemplateLiteral<S, M>> : T extends TUnion<infer S> ? TUnion<TFromRest<S, M>> : T extends TLiteral<infer S> ? TLiteral<TFromLiteralValue<S, M>> : T;
 /** Applies an intrinsic string manipulation to the given type. */
 export declare function Intrinsic<T extends TMappedKey, M extends IntrinsicMode>(schema: T, mode: M, options?: SchemaOptions): TIntrinsicFromMappedKey<T, M>;
 /** Applies an intrinsic string manipulation to the given type. */

package/build/import/type/intrinsic/intrinsic.mjs

@@ -45,11 +45,8 @@ function FromLiteralValue(value, mode) {
                     value) : value.toString());
 }
 // prettier-ignore
-function FromRest(T, M, Acc = []) {
-    const [L, ...R] = T;
-    return (T.length > 0
-        ? FromRest(R, M, [...Acc, Intrinsic(L, M)])
-        : Acc);
+function FromRest(T, M) {
+    return T.map(L => Intrinsic(L, M));
 }
 /** Applies an intrinsic string manipulation to the given type. */
 export function Intrinsic(schema, mode, options = {}) {

package/build/import/type/intrinsic/lowercase.d.mts

@@ -1,5 +1,5 @@
-import { TSchema, SchemaOptions } from '../schema/index.mjs';
-import { TIntrinsic } from './intrinsic.mjs';
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import { type TIntrinsic } from './intrinsic.mjs';
 export type TLowercase<T extends TSchema> = TIntrinsic<T, 'Lowercase'>;
 /** `[Json]` Intrinsic function to Lowercase LiteralString types */
 export declare function Lowercase<T extends TSchema>(T: T, options?: SchemaOptions): TLowercase<T>;

package/build/import/type/intrinsic/uncapitalize.d.mts

@@ -1,5 +1,5 @@
-import { TSchema, SchemaOptions } from '../schema/index.mjs';
-import { TIntrinsic } from './intrinsic.mjs';
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import { type TIntrinsic } from './intrinsic.mjs';
 export type TUncapitalize<T extends TSchema> = TIntrinsic<T, 'Uncapitalize'>;
 /** `[Json]` Intrinsic function to Uncapitalize LiteralString types */
 export declare function Uncapitalize<T extends TSchema>(T: T, options?: SchemaOptions): TUncapitalize<T>;

package/build/import/type/intrinsic/uppercase.d.mts

@@ -1,5 +1,5 @@
-import { TSchema, SchemaOptions } from '../schema/index.mjs';
-import { TIntrinsic } from './intrinsic.mjs';
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import { type TIntrinsic } from './intrinsic.mjs';
 export type TUppercase<T extends TSchema> = TIntrinsic<T, 'Uppercase'>;
 /** `[Json]` Intrinsic function to Uppercase LiteralString types */
 export declare function Uppercase<T extends TSchema>(T: T, options?: SchemaOptions): TUppercase<T>;

package/build/import/type/iterator/iterator.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 an Iterator type */
 export function Iterator(items, options = {}) {
     return {

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

@@ -5,7 +5,7 @@ import { type TKeyOf } from './keyof.mjs';
 type TFromProperties<K extends TProperties> = ({
     [K2 in keyof K]: TKeyOf<K[K2]>;
 });
-type TFromMappedResult<K extends TMappedResult> = (TFromProperties<K['properties']>);
-export type TKeyOfFromMappedResult<T extends TMappedResult, P extends TProperties = TFromMappedResult<T>> = (TMappedResult<P>);
-export declare function KeyOfFromMappedResult<T extends TMappedResult, P extends TProperties = TFromMappedResult<T>>(T: T, options: SchemaOptions): TMappedResult<P>;
+type TFromMappedResult<R extends TMappedResult> = (TFromProperties<R['properties']>);
+export type TKeyOfFromMappedResult<R extends TMappedResult, P extends TProperties = TFromMappedResult<R>> = (TMappedResult<P>);
+export declare function KeyOfFromMappedResult<R extends TMappedResult, P extends TProperties = TFromMappedResult<R>>(R: R, options: SchemaOptions): TMappedResult<P>;
 export {};

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

@@ -7,11 +7,11 @@ function FromProperties(K, 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 KeyOfFromMappedResult(T, options) {
-    const P = FromMappedResult(T, options);
+export function KeyOfFromMappedResult(R, options) {
+    const P = FromMappedResult(R, options);
     return MappedResult(P);
 }

package/build/import/type/keyof/keyof-property-keys.d.mts

@@ -6,11 +6,11 @@ import type { TUnion } from '../union/index.mjs';
 import type { TTuple } from '../tuple/index.mjs';
 import type { TArray } from '../array/index.mjs';
 import type { TObject, TProperties } from '../object/index.mjs';
-import { OperatorUnionMany, OperatorIntersectMany } from '../operators/index.mjs';
+import { type TSetUnionMany, type TSetIntersectMany } from '../sets/index.mjs';
 type TFromRest<T extends TSchema[], Acc extends PropertyKey[][] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Acc, TKeyOfPropertyKeys<L>]> : Acc);
-type FromIntersect<T extends TSchema[], C extends PropertyKey[][] = TFromRest<T>, R extends PropertyKey[] = OperatorUnionMany<C>> = R;
+type FromIntersect<T extends TSchema[], C extends PropertyKey[][] = TFromRest<T>, R extends PropertyKey[] = TSetUnionMany<C>> = R;
 declare function FromIntersect<T extends TSchema[]>(T: [...T]): FromIntersect<T>;
-type FromUnion<T extends TSchema[], C extends PropertyKey[][] = TFromRest<T>, R extends PropertyKey[] = OperatorIntersectMany<C>> = R;
+type FromUnion<T extends TSchema[], C extends PropertyKey[][] = TFromRest<T>, R extends PropertyKey[] = TSetIntersectMany<C>> = R;
 declare function FromUnion<T extends TSchema[]>(T: [...T]): FromUnion<T>;
 type TFromTuple<T extends TSchema[], I extends string = ZeroString, Acc extends PropertyKey[] = []> = T extends [infer _ extends TSchema, ...infer R extends TSchema[]] ? TFromTuple<R, Increment<I>, [...Acc, I]> : Acc;
 type TFromArray<_ extends TSchema> = ([

package/build/import/type/keyof/keyof-property-keys.mjs

@@ -1,35 +1,29 @@
-import { Increment } from '../helpers/index.mjs';
-import { OperatorUnionMany, OperatorIntersectMany } from '../operators/index.mjs';
+import { SetUnionMany, SetIntersectMany } from '../sets/index.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 import { IsIntersect, IsUnion, IsTuple, IsArray, IsObject, IsRecord } from '../guard/type.mjs';
 // prettier-ignore
-function FromRest(T, Acc = []) {
-    const [L, ...R] = T;
-    return (T.length > 0
-        ? FromRest(R, [...Acc, KeyOfPropertyKeys(L)])
-        : Acc);
+function FromRest(T) {
+    return T.reduce((Acc, L) => {
+        return [...Acc, KeyOfPropertyKeys(L)];
+    }, []);
 }
 // prettier-ignore
 function FromIntersect(T) {
     const C = FromRest(T);
-    const R = OperatorUnionMany(C);
+    const R = SetUnionMany(C);
     return R;
 }
 // prettier-ignore
 function FromUnion(T) {
     const C = FromRest(T);
-    const R = OperatorIntersectMany(C);
+    const R = SetIntersectMany(C);
     return R;
 }
 // prettier-ignore
-function FromTuple(T, I = '0', Acc = []) {
-    const [_, ...R] = T;
-    return (T.length > 0
-        ? FromTuple(R, Increment(I), [...Acc, I])
-        : Acc);
+function FromTuple(T) {
+    return T.map((_, I) => I.toString());
 }
 // prettier-ignore
 function FromArray(_) {

package/build/import/type/keyof/keyof.mjs

@@ -7,16 +7,10 @@ import { KeyOfFromMappedResult } from './keyof-from-mapped-result.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 import { IsMappedResult } from '../guard/type.mjs';
 // prettier-ignore
-function FromPropertyKeys(T, Acc = []) {
-    const [L, ...R] = T;
-    return (T.length > 0
-        ? L === '[number]'
-            ? FromPropertyKeys(R, [...Acc, Number()])
-            : FromPropertyKeys(R, [...Acc, Literal(L)])
-        : Acc);
+function FromPropertyKeys(T) {
+    return T.map(L => L === '[number]' ? Number() : Literal(L));
 }
 /** `[Json]` Creates a KeyOf type */
 export function KeyOf(T, options = {}) {

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

@@ -14,12 +14,17 @@ import { type TPromise } from '../promise/index.mjs';
 import { type TReadonly } from '../readonly/index.mjs';
 import { type TTuple } from '../tuple/index.mjs';
 import { type TUnion } from '../union/index.mjs';
+import { type TSetIncludes } from '../sets/index.mjs';
 import { type TMappedResult } from './mapped-result.mjs';
 import type { TMappedKey } from './mapped-key.mjs';
 type TFromMappedResult<K extends PropertyKey, P extends TProperties> = (K extends keyof P ? FromSchemaType<K, P[K]> : TMappedResult<P>);
-type TMappedKeyToMappedResultProperties<K extends PropertyKey, P extends PropertyKey[], Acc extends TProperties = {}> = (P extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TMappedKeyToMappedResultProperties<K, R, Acc & {
+type TMappedKeyToKnownMappedResultProperties<K extends PropertyKey> = {
+    [_ in K]: TLiteral<Assert<K, TLiteralValue>>;
+};
+type TMappedKeyToUnknownMappedResultProperties<P extends PropertyKey[], Acc extends TProperties = {}> = (P extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TMappedKeyToUnknownMappedResultProperties<R, Acc & {
     [_ in L]: TLiteral<Assert<L, TLiteralValue>>;
 }> : Acc);
+type TMappedKeyToMappedResultProperties<K extends PropertyKey, P extends PropertyKey[]> = (TSetIncludes<P, K> extends true ? TMappedKeyToKnownMappedResultProperties<K> : TMappedKeyToUnknownMappedResultProperties<P>);
 type TFromMappedKey<K extends PropertyKey, P extends PropertyKey[], R extends TProperties = TMappedKeyToMappedResultProperties<K, P>> = (TFromMappedResult<K, R>);
 type TFromRest<K extends PropertyKey, T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<K, R, [...Acc, FromSchemaType<K, L>]> : Acc);
 type FromProperties<K extends PropertyKey, T extends TProperties, R extends TProperties = Evaluate<{

package/build/import/type/mapped/mapped.mjs

@@ -16,6 +16,8 @@ import { Promise } from '../promise/index.mjs';
 import { Readonly } from '../readonly/index.mjs';
 import { Tuple } from '../tuple/index.mjs';
 import { Union } from '../union/index.mjs';
+// operator
+import { SetIncludes } from '../sets/index.mjs';
 // mapping types
 import { MappedResult } from './mapped-result.mjs';
 // ------------------------------------------------------------------
@@ -30,11 +32,20 @@ function FromMappedResult(K, P) {
         : MappedResult(P));
 }
 // prettier-ignore
-function MappedKeyToMappedResultProperties(K, P, Acc = {}) {
-    const [L, ...R] = P;
-    return (P.length > 0
-        ? MappedKeyToMappedResultProperties(K, R, { ...Acc, [L]: Literal(L) })
-        : Acc);
+function MappedKeyToKnownMappedResultProperties(K) {
+    return { [K]: Literal(K) };
+}
+// prettier-ignore
+function MappedKeyToUnknownMappedResultProperties(P) {
+    return P.reduce((Acc, L) => {
+        return { ...Acc, [L]: Literal(L) };
+    }, {});
+}
+// prettier-ignore
+function MappedKeyToMappedResultProperties(K, P) {
+    return (SetIncludes(P, K)
+        ? MappedKeyToKnownMappedResultProperties(K)
+        : MappedKeyToUnknownMappedResultProperties(P));
 }
 // prettier-ignore
 function FromMappedKey(K, P) {
@@ -42,11 +53,8 @@ function FromMappedKey(K, P) {
     return FromMappedResult(K, R);
 }
 // prettier-ignore
-function FromRest(K, T, Acc = []) {
-    const [L, ...R] = T;
-    return (T.length > 0
-        ? FromRest(K, R, [...Acc, FromSchemaType(K, L)])
-        : Acc);
+function FromRest(K, T) {
+    return T.map(L => FromSchemaType(K, L));
 }
 // prettier-ignore
 function FromProperties(K, T) {
@@ -78,10 +86,9 @@ function FromSchemaType(K, T) {
 }
 // prettier-ignore
 function FromMappedFunctionReturnType(K, T, Acc = {}) {
-    const [L, ...R] = K;
-    return (K.length > 0
-        ? FromMappedFunctionReturnType(R, T, { ...Acc, [L]: FromSchemaType(L, T) })
-        : Acc);
+    return K.reduce((Acc, L) => {
+        return { ...Acc, [L]: FromSchemaType(L, T) };
+    }, {});
 }
 /** `[Json]` Creates a Mapped object type */
 export function Mapped(key, map, options = {}) {

package/build/import/type/not/not.mjs

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

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

@@ -15,7 +15,7 @@ type OptionalPropertyKeys<T extends TProperties> = {
 }[keyof T];
 type RequiredPropertyKeys<T extends TProperties> = keyof Omit<T, ReadonlyOptionalPropertyKeys<T> | ReadonlyPropertyKeys<T> | OptionalPropertyKeys<T>>;
 type ObjectStaticProperties<T extends TProperties, R extends Record<keyof any, unknown>> = Evaluate<(Readonly<Partial<Pick<R, ReadonlyOptionalPropertyKeys<T>>>> & Readonly<Pick<R, ReadonlyPropertyKeys<T>>> & Partial<Pick<R, OptionalPropertyKeys<T>>> & Required<Pick<R, RequiredPropertyKeys<T>>>)>;
-export type ObjectStatic<T extends TProperties, P extends unknown[]> = ObjectStaticProperties<T, {
+type ObjectStatic<T extends TProperties, P extends unknown[]> = ObjectStaticProperties<T, {
     [K in keyof T]: Static<T[K], P>;
 }>;
 export type TPropertyKey = string | number;

package/build/import/type/object/object.mjs

@@ -3,7 +3,6 @@ import { Kind } from '../symbols/index.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 import { IsOptional, IsSchema } from '../guard/type.mjs';
 /** `[Json]` Creates an Object type */
 export function _Object(properties, options = {}) {

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

@@ -1,2 +1,3 @@
 export * from './omit-from-mapped-key.mjs';
+export * from './omit-from-mapped-result.mjs';
 export * from './omit.mjs';

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

@@ -1,2 +1,3 @@
 export * from './omit-from-mapped-key.mjs';
+export * from './omit-from-mapped-result.mjs';
 export * from './omit.mjs';

package/build/import/type/omit/omit-from-mapped-key.mjs

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

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

@@ -0,0 +1,11 @@
+import type { SchemaOptions } from '../schema/index.mjs';
+import type { TProperties } from '../object/index.mjs';
+import { type TMappedResult } from '../mapped/index.mjs';
+import { type TOmit } from './omit.mjs';
+type TFromProperties<P extends TProperties, K extends PropertyKey[]> = ({
+    [K2 in keyof P]: TOmit<P[K2], K>;
+});
+type TFromMappedResult<R extends TMappedResult, K extends PropertyKey[]> = (TFromProperties<R['properties'], K>);
+export type TOmitFromMappedResult<T extends TMappedResult, K extends PropertyKey[], P extends TProperties = TFromMappedResult<T, K>> = (TMappedResult<P>);
+export declare function OmitFromMappedResult<R extends TMappedResult, K extends PropertyKey[], P extends TProperties = TFromMappedResult<R, K>>(R: R, K: [...K], options: SchemaOptions): TMappedResult<P>;
+export {};

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

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

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

@@ -1,20 +1,23 @@
 import type { TSchema, SchemaOptions } from '../schema/index.mjs';
 import type { TupleToUnion, Evaluate } from '../helpers/index.mjs';
 import { type TRecursive } from '../recursive/index.mjs';
+import type { TMappedKey, TMappedResult } from '../mapped/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 TIndexPropertyKeys } from '../indexed/index.mjs';
-import { TMappedKey } from '../mapped/index.mjs';
 import { type TOmitFromMappedKey } from './omit-from-mapped-key.mjs';
+import { type TOmitFromMappedResult } from './omit-from-mapped-result.mjs';
 type TFromIntersect<T extends TSchema[], K extends PropertyKey[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromIntersect<R, K, [...Acc, TOmitResolve<L, K>]> : Acc);
 type TFromUnion<T extends TSchema[], K extends PropertyKey[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromUnion<R, K, [...Acc, TOmitResolve<L, K>]> : Acc);
 type TFromProperties<T extends TProperties, K extends PropertyKey[], I extends PropertyKey = TupleToUnion<K>> = Evaluate<Omit<T, I>>;
 export type TOmitResolve<T extends TProperties, K extends PropertyKey[]> = T extends TRecursive<infer S> ? TRecursive<TOmitResolve<S, K>> : T extends TIntersect<infer S> ? TIntersect<TFromIntersect<S, K>> : T extends TUnion<infer S> ? TUnion<TFromUnion<S, K>> : T extends TObject<infer S> ? TObject<TFromProperties<S, K>> : TObject<{}>;
 export declare function OmitResolve<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): TOmitResolve<T, K>;
 export type TOmit<T extends TSchema, K extends PropertyKey[]> = TOmitResolve<T, K>;
-/** `[Json]` Constructs a type whose keys are picked from the given type */
-export declare function 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 */
+export declare function 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 */
+export declare function Omit<T extends TSchema, K extends TMappedKey>(T: T, K: K, options?: SchemaOptions): TOmitFromMappedKey<T, K>;
 /** `[Json]` Constructs a type whose keys are omitted from the given type */
 export declare function Omit<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TOmit<T, I>;
 /** `[Json]` Constructs a type whose keys are omitted from the given type */

package/build/import/type/omit/omit.mjs

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

package/build/import/type/optional/optional-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 TOptionalWithFlag } from './optional.mjs';
-type TFromProperties<K extends TProperties, F extends boolean> = ({
-    [K2 in keyof K]: TOptionalWithFlag<K[K2], F>;
+type TFromProperties<P extends TProperties, F extends boolean> = ({
+    [K2 in keyof P]: TOptionalWithFlag<P[K2], F>;
 });
-type TFromMappedResult<K extends TMappedResult, F extends boolean> = (TFromProperties<K['properties'], F>);
-export type TOptionalFromMappedResult<T extends TMappedResult, F extends boolean, P extends TProperties = TFromMappedResult<T, F>> = (TMappedResult<P>);
-export declare function OptionalFromMappedResult<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 TOptionalFromMappedResult<R extends TMappedResult, F extends boolean, P extends TProperties = TFromMappedResult<R, F>> = (TMappedResult<P>);
+export declare function OptionalFromMappedResult<R extends TMappedResult, F extends boolean, P extends TProperties = TFromMappedResult<R, F>>(R: R, F: F): TMappedResult<P>;
 export {};

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

@@ -1,17 +1,17 @@
 import { MappedResult } from '../mapped/index.mjs';
 import { Optional } from './optional.mjs';
 // prettier-ignore
-function FromProperties(K, F) {
-    return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
-        return { ...Acc, [K2]: Optional(K[K2], F) };
+function FromProperties(P, F) {
+    return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
+        return { ...Acc, [K2]: Optional(P[K2], 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 OptionalFromMappedResult(T, F) {
-    const P = FromMappedResult(T, F);
+export function OptionalFromMappedResult(R, F) {
+    const P = FromMappedResult(R, F);
     return MappedResult(P);
 }

package/build/import/type/partial/partial-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 TPartial } from './partial.mjs';
-type TFromProperties<K extends TProperties> = ({
-    [K2 in keyof K]: TPartial<K[K2]>;
+type TFromProperties<P extends TProperties> = ({
+    [K2 in keyof P]: TPartial<P[K2]>;
 });
-type TFromMappedResult<K extends TMappedResult> = (TFromProperties<K['properties']>);
-export type TPartialFromMappedResult<T extends TMappedResult, P extends TProperties = TFromMappedResult<T>> = (TMappedResult<P>);
-export declare function PartialFromMappedResult<T extends TMappedResult, P extends TProperties = TFromMappedResult<T>>(T: T, options: SchemaOptions): TMappedResult<P>;
+type TFromMappedResult<R extends TMappedResult> = (TFromProperties<R['properties']>);
+export type TPartialFromMappedResult<R extends TMappedResult, P extends TProperties = TFromMappedResult<R>> = (TMappedResult<P>);
+export declare function PartialFromMappedResult<R extends TMappedResult, P extends TProperties = TFromMappedResult<R>>(R: R, options: SchemaOptions): TMappedResult<P>;
 export {};

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

@@ -7,11 +7,11 @@ function FromProperties(K, 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 PartialFromMappedResult(T, options) {
-    const P = FromMappedResult(T, options);
+export function PartialFromMappedResult(R, options) {
+    const P = FromMappedResult(R, options);
     return MappedResult(P);
 }

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

@@ -9,12 +9,11 @@ import { type TObject, type TProperties } from '../object/index.mjs';
 import { type TIntersect } from '../intersect/index.mjs';
 import { type TUnion } from '../union/index.mjs';
 import { type TPartialFromMappedResult } from './partial-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, PartialResolve<L>]> : Acc);
-type TFromUnion<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromUnion<R, [...Acc, PartialResolve<L>]> : Acc);
+type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Acc, PartialResolve<L>]> : Acc);
 type TFromProperties<T extends TProperties> = Evaluate<{
     [K in keyof T]: T[K] extends (TReadonlyOptional<infer S>) ? TReadonlyOptional<S> : T[K] extends (TReadonly<infer S>) ? TReadonlyOptional<S> : T[K] extends (TOptional<infer S>) ? TOptional<S> : TOptional<T[K]>;
 }>;
-type PartialResolve<T extends TSchema> = (T extends TRecursive<infer S> ? TRecursive<PartialResolve<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 PartialResolve<T extends TSchema> = (T extends TRecursive<infer S> ? TRecursive<PartialResolve<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<{}>);
 declare function PartialResolve<T extends TSchema>(T: T): PartialResolve<T>;
 export type TPartial<T extends TSchema> = PartialResolve<T>;
 /** `[Json]` Constructs a type where all properties are optional */

package/build/import/type/partial/partial.mjs

@@ -11,18 +11,8 @@ import { PartialFromMappedResult } from './partial-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, PartialResolve(L)])
-        : Acc);
-}
-// prettier-ignore
-function FromUnion(T, Acc = []) {
-    const [L, ...R] = T;
-    return (T.length > 0
-        ? FromUnion(R, [...Acc, PartialResolve(L)])
-        : Acc);
+function FromRest(T) {
+    return T.map(L => PartialResolve(L));
 }
 // prettier-ignore
 function FromProperties(T) {
@@ -32,19 +22,16 @@ function FromProperties(T) {
 }
 // prettier-ignore
 function PartialResolve(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({}));
 }
 /** `[Json]` Constructs a type where all properties are optional */
 export function Partial(T, options = {}) {
-    if (IsMappedResult(T)) {
+    if (IsMappedResult(T))
         return PartialFromMappedResult(T, options);
-    }
-    else {
-        const D = Discard(T, [TransformKind, '$id', 'required']);
-        const R = CloneType(PartialResolve(T), options);
-        return { ...D, ...R };
-    }
+    const D = Discard(T, [TransformKind, '$id', 'required']);
+    const R = CloneType(PartialResolve(T), options);
+    return { ...D, ...R };
 }

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

@@ -1,2 +1,3 @@
 export * from './pick-from-mapped-key.mjs';
+export * from './pick-from-mapped-result.mjs';
 export * from './pick.mjs';

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

@@ -1,2 +1,3 @@
 export * from './pick-from-mapped-key.mjs';
+export * from './pick-from-mapped-result.mjs';
 export * from './pick.mjs';

package/build/import/type/pick/pick-from-mapped-key.mjs

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

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

@@ -0,0 +1,11 @@
+import type { SchemaOptions } from '../schema/index.mjs';
+import type { TProperties } from '../object/index.mjs';
+import { type TMappedResult } from '../mapped/index.mjs';
+import { type TPick } from './pick.mjs';
+type TFromProperties<P extends TProperties, K extends PropertyKey[]> = ({
+    [K2 in keyof P]: TPick<P[K2], K>;
+});
+type TFromMappedResult<R extends TMappedResult, K extends PropertyKey[]> = (TFromProperties<R['properties'], K>);
+export type TPickFromMappedResult<T extends TMappedResult, K extends PropertyKey[], P extends TProperties = TFromMappedResult<T, K>> = (TMappedResult<P>);
+export declare function PickFromMappedResult<R extends TMappedResult, K extends PropertyKey[], P extends TProperties = TFromMappedResult<R, K>>(R: R, K: [...K], options: SchemaOptions): TMappedResult<P>;
+export {};

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

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