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

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

@@ -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/require/type/object/object.js

@@ -7,7 +7,6 @@ const index_1 = require("../symbols/index");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 const type_2 = require("../guard/type");
 /** `[Json]` Creates an Object type */
 function _Object(properties, options = {}) {

package/build/require/type/omit/index.d.ts

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

package/build/require/type/omit/index.js

@@ -16,4 +16,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./omit-from-mapped-key"), exports);
+__exportStar(require("./omit-from-mapped-result"), exports);
 __exportStar(require("./omit"), exports);

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

@@ -11,11 +11,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/require/type/omit/omit-from-mapped-result.d.ts

@@ -0,0 +1,11 @@
+import type { SchemaOptions } from '../schema/index';
+import type { TProperties } from '../object/index';
+import { type TMappedResult } from '../mapped/index';
+import { type TOmit } from './omit';
+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/require/type/omit/omit-from-mapped-result.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OmitFromMappedResult = void 0;
+const index_1 = require("../mapped/index");
+const omit_1 = require("./omit");
+// prettier-ignore
+function FromProperties(P, K, options) {
+    return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
+        return { ...Acc, [K2]: (0, omit_1.Omit)(P[K2], K, options) };
+    }, {});
+}
+// prettier-ignore
+function FromMappedResult(R, K, options) {
+    return FromProperties(R.properties, K, options);
+}
+// prettier-ignore
+function OmitFromMappedResult(R, K, options) {
+    const P = FromMappedResult(R, K, options);
+    return (0, index_1.MappedResult)(P);
+}
+exports.OmitFromMappedResult = OmitFromMappedResult;

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

@@ -1,20 +1,23 @@
 import type { TSchema, SchemaOptions } from '../schema/index';
 import type { TupleToUnion, Evaluate } from '../helpers/index';
 import { type TRecursive } from '../recursive/index';
+import type { TMappedKey, TMappedResult } from '../mapped/index';
 import { type TIntersect } from '../intersect/index';
 import { type TUnion } from '../union/index';
 import { type TObject, type TProperties } from '../object/index';
 import { type TIndexPropertyKeys } from '../indexed/index';
-import { TMappedKey } from '../mapped/index';
 import { type TOmitFromMappedKey } from './omit-from-mapped-key';
+import { type TOmitFromMappedResult } from './omit-from-mapped-result';
 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/require/type/omit/omit.js

@@ -10,6 +10,7 @@ const index_5 = require("../discard/index");
 const index_6 = require("../symbols/index");
 const type_1 = require("../clone/type");
 const omit_from_mapped_key_1 = require("./omit-from-mapped-key");
+const omit_from_mapped_result_1 = require("./omit-from-mapped-result");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
@@ -45,14 +46,15 @@ function OmitResolve(T, K) {
 }
 exports.OmitResolve = OmitResolve;
 function Omit(T, K, options = {}) {
-    if ((0, type_2.IsMappedKey)(K)) {
+    // mapped
+    if ((0, type_2.IsMappedKey)(K))
         return (0, omit_from_mapped_key_1.OmitFromMappedKey)(T, K, options);
-    }
-    else {
-        const I = (0, type_2.IsSchema)(K) ? (0, index_4.IndexPropertyKeys)(K) : K;
-        const D = (0, index_5.Discard)(T, [index_6.TransformKind, '$id', 'required']);
-        const R = (0, type_1.CloneType)(OmitResolve(T, I), options);
-        return { ...D, ...R };
-    }
+    if ((0, type_2.IsMappedResult)(T))
+        return (0, omit_from_mapped_result_1.OmitFromMappedResult)(T, K, options);
+    // non-mapped
+    const I = (0, type_2.IsSchema)(K) ? (0, index_4.IndexPropertyKeys)(K) : K;
+    const D = (0, index_5.Discard)(T, [index_6.TransformKind, '$id', 'required']);
+    const R = (0, type_1.CloneType)(OmitResolve(T, I), options);
+    return { ...D, ...R };
 }
 exports.Omit = Omit;

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

@@ -1,10 +1,10 @@
 import type { TProperties } from '../object/index';
 import { type TMappedResult } from '../mapped/index';
 import { type TOptionalWithFlag } from './optional';
-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/require/type/optional/optional-from-mapped-result.js

@@ -5,18 +5,18 @@ exports.OptionalFromMappedResult = void 0;
 const index_1 = require("../mapped/index");
 const optional_1 = require("./optional");
 // prettier-ignore
-function FromProperties(K, F) {
-    return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
-        return { ...Acc, [K2]: (0, optional_1.Optional)(K[K2], F) };
+function FromProperties(P, F) {
+    return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
+        return { ...Acc, [K2]: (0, optional_1.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
-function OptionalFromMappedResult(T, F) {
-    const P = FromMappedResult(T, F);
+function OptionalFromMappedResult(R, F) {
+    const P = FromMappedResult(R, F);
     return (0, index_1.MappedResult)(P);
 }
 exports.OptionalFromMappedResult = OptionalFromMappedResult;

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

@@ -2,10 +2,10 @@ import type { SchemaOptions } from '../schema/index';
 import type { TProperties } from '../object/index';
 import { type TMappedResult } from '../mapped/index';
 import { type TPartial } from './partial';
-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/require/type/partial/partial-from-mapped-result.js

@@ -11,12 +11,12 @@ 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
-function PartialFromMappedResult(T, options) {
-    const P = FromMappedResult(T, options);
+function PartialFromMappedResult(R, options) {
+    const P = FromMappedResult(R, options);
     return (0, index_1.MappedResult)(P);
 }
 exports.PartialFromMappedResult = PartialFromMappedResult;

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

@@ -9,12 +9,11 @@ import { type TObject, type TProperties } from '../object/index';
 import { type TIntersect } from '../intersect/index';
 import { type TUnion } from '../union/index';
 import { type TPartialFromMappedResult } from './partial-from-mapped-result';
-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/require/type/partial/partial.js

@@ -15,18 +15,8 @@ const partial_from_mapped_result_1 = require("./partial-from-mapped-result");
 // ------------------------------------------------------------------
 const type_2 = require("../guard/type");
 // 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) {
@@ -36,20 +26,17 @@ function FromProperties(T) {
 }
 // prettier-ignore
 function PartialResolve(T) {
-    return ((0, type_2.IsIntersect)(T) ? (0, index_3.Intersect)(FromIntersect(T.allOf)) :
-        (0, type_2.IsUnion)(T) ? (0, index_4.Union)(FromUnion(T.anyOf)) :
+    return ((0, type_2.IsIntersect)(T) ? (0, index_3.Intersect)(FromRest(T.allOf)) :
+        (0, type_2.IsUnion)(T) ? (0, index_4.Union)(FromRest(T.anyOf)) :
             (0, type_2.IsObject)(T) ? (0, index_2.Object)(FromProperties(T.properties)) :
                 (0, index_2.Object)({}));
 }
 /** `[Json]` Constructs a type where all properties are optional */
 function Partial(T, options = {}) {
-    if ((0, type_2.IsMappedResult)(T)) {
+    if ((0, type_2.IsMappedResult)(T))
         return (0, partial_from_mapped_result_1.PartialFromMappedResult)(T, options);
-    }
-    else {
-        const D = (0, index_5.Discard)(T, [index_6.TransformKind, '$id', 'required']);
-        const R = (0, type_1.CloneType)(PartialResolve(T), options);
-        return { ...D, ...R };
-    }
+    const D = (0, index_5.Discard)(T, [index_6.TransformKind, '$id', 'required']);
+    const R = (0, type_1.CloneType)(PartialResolve(T), options);
+    return { ...D, ...R };
 }
 exports.Partial = Partial;

package/build/require/type/pick/index.d.ts

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

package/build/require/type/pick/index.js

@@ -16,4 +16,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./pick-from-mapped-key"), exports);
+__exportStar(require("./pick-from-mapped-result"), exports);
 __exportStar(require("./pick"), exports);

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

@@ -11,11 +11,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/require/type/pick/pick-from-mapped-result.d.ts

@@ -0,0 +1,11 @@
+import type { SchemaOptions } from '../schema/index';
+import type { TProperties } from '../object/index';
+import { type TMappedResult } from '../mapped/index';
+import { type TPick } from './pick';
+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/require/type/pick/pick-from-mapped-result.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PickFromMappedResult = void 0;
+const index_1 = require("../mapped/index");
+const pick_1 = require("./pick");
+// prettier-ignore
+function FromProperties(P, K, options) {
+    return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
+        return { ...Acc, [K2]: (0, pick_1.Pick)(P[K2], K, options) };
+    }, {});
+}
+// prettier-ignore
+function FromMappedResult(R, K, options) {
+    return FromProperties(R.properties, K, options);
+}
+// prettier-ignore
+function PickFromMappedResult(R, K, options) {
+    const P = FromMappedResult(R, K, options);
+    return (0, index_1.MappedResult)(P);
+}
+exports.PickFromMappedResult = PickFromMappedResult;

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

@@ -4,9 +4,10 @@ import { type TRecursive } from '../recursive/index';
 import { type TIntersect } from '../intersect/index';
 import { type TUnion } from '../union/index';
 import { type TObject, type TProperties } from '../object/index';
+import type { TMappedKey, TMappedResult } from '../mapped/index';
 import { type TIndexPropertyKeys } from '../indexed/index';
-import { TMappedKey } from '../mapped/index';
 import { type TPickFromMappedKey } from './pick-from-mapped-key';
+import { type TPickFromMappedResult } from './pick-from-mapped-result';
 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/require/type/pick/pick.js

@@ -10,10 +10,10 @@ const index_5 = require("../discard/index");
 const index_6 = require("../symbols/index");
 const type_1 = require("../clone/type");
 const pick_from_mapped_key_1 = require("./pick-from-mapped-key");
+const pick_from_mapped_result_1 = require("./pick-from-mapped-result");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 const type_2 = require("../guard/type");
 function FromIntersect(T, K) {
     return T.map((T) => PickResolve(T, K));
@@ -37,14 +37,15 @@ function PickResolve(T, K) {
 }
 exports.PickResolve = PickResolve;
 function Pick(T, K, options = {}) {
-    if ((0, type_2.IsMappedKey)(K)) {
+    // mapped
+    if ((0, type_2.IsMappedKey)(K))
         return (0, pick_from_mapped_key_1.PickFromMappedKey)(T, K, options);
-    }
-    else {
-        const I = (0, type_2.IsSchema)(K) ? (0, index_4.IndexPropertyKeys)(K) : K;
-        const D = (0, index_5.Discard)(T, [index_6.TransformKind, '$id', 'required']);
-        const R = (0, type_1.CloneType)(PickResolve(T, I), options);
-        return { ...D, ...R };
-    }
+    if ((0, type_2.IsMappedResult)(T))
+        return (0, pick_from_mapped_result_1.PickFromMappedResult)(T, K, options);
+    // non-mapped
+    const I = (0, type_2.IsSchema)(K) ? (0, index_4.IndexPropertyKeys)(K) : K;
+    const D = (0, index_5.Discard)(T, [index_6.TransformKind, '$id', 'required']);
+    const R = (0, type_1.CloneType)(PickResolve(T, I), options);
+    return { ...D, ...R };
 }
 exports.Pick = Pick;

package/build/require/type/promise/promise.js

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

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

@@ -1,10 +1,10 @@
 import type { TProperties } from '../object/index';
 import { type TMappedResult } from '../mapped/index';
 import { type TReadonlyWithFlag } from './readonly';
-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/require/type/readonly/readonly-from-mapped-result.js

@@ -11,12 +11,12 @@ 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
-function ReadonlyFromMappedResult(T, F) {
-    const P = FromMappedResult(T, F);
+function ReadonlyFromMappedResult(R, F) {
+    const P = FromMappedResult(R, F);
     return (0, index_1.MappedResult)(P);
 }
 exports.ReadonlyFromMappedResult = ReadonlyFromMappedResult;

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

@@ -2,14 +2,14 @@ import type { TSchema } from '../schema/index';
 import type { Static } from '../static/index';
 import type { Evaluate, Ensure, Assert } from '../helpers/index';
 import { type TObject, type TProperties, type TAdditionalProperties, type ObjectOptions } from '../object/index';
-import { type TLiteral, TLiteralValue } from '../literal/index';
+import { type TLiteral, type TLiteralValue } from '../literal/index';
 import { type TNever } from '../never/index';
 import { type TUnion } from '../union/index';
 import { type TString } from '../string/index';
 import { type TInteger } from '../integer/index';
 import { type TNumber } from '../number/index';
 import { type TEnum } from '../enum/index';
-import { TTemplateLiteral, TIsTemplateLiteralFinite } from '../template-literal/index';
+import { TIsTemplateLiteralFinite, type TTemplateLiteral } from '../template-literal/index';
 import { Kind } from '../symbols/index';
 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/require/type/record/record.js

@@ -10,6 +10,9 @@ const index_5 = require("../patterns/index");
 const index_6 = require("../indexed/index");
 const index_7 = require("../symbols/index");
 const type_1 = require("../clone/type");
+// ------------------------------------------------------------------
+// ValueGuard
+// ------------------------------------------------------------------
 const value_1 = require("../guard/value");
 // ------------------------------------------------------------------
 // TypeGuard

package/build/require/type/ref/ref.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Ref = void 0;
 const index_1 = require("../symbols/index");
 // ------------------------------------------------------------------
-// TypeGuard
+// ValueGuard
 // ------------------------------------------------------------------
 const value_1 = require("../guard/value");
 /** `[Json]` Creates a Ref type. */

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

@@ -2,10 +2,10 @@ import type { SchemaOptions } from '../schema/index';
 import type { TProperties } from '../object/index';
 import { type TMappedResult } from '../mapped/index';
 import { type TRequired } from './required';
-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/require/type/required/required-from-mapped-result.js

@@ -5,18 +5,18 @@ exports.RequiredFromMappedResult = void 0;
 const index_1 = require("../mapped/index");
 const required_1 = require("./required");
 // prettier-ignore
-function FromProperties(K, options) {
-    return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
-        return { ...Acc, [K2]: (0, required_1.Required)(K[K2], options) };
+function FromProperties(P, options) {
+    return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
+        return { ...Acc, [K2]: (0, required_1.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
-function RequiredFromMappedResult(T, options) {
-    const P = FromMappedResult(T, options);
+function RequiredFromMappedResult(R, options) {
+    const P = FromMappedResult(R, options);
     return (0, index_1.MappedResult)(P);
 }
 exports.RequiredFromMappedResult = RequiredFromMappedResult;

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

@@ -9,12 +9,11 @@ import { type TIntersect } from '../intersect/index';
 import { type TUnion } from '../union/index';
 import { type TObject, type TProperties } from '../object/index';
 import { type TRequiredFromMappedResult } from './required-from-mapped-result';
-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/require/type/required/required.js

@@ -14,18 +14,8 @@ const required_from_mapped_result_1 = require("./required-from-mapped-result");
 // ------------------------------------------------------------------
 const type_2 = require("../guard/type");
 // 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) {
@@ -35,8 +25,8 @@ function FromProperties(T) {
 }
 // prettier-ignore
 function RequiredResolve(T) {
-    return ((0, type_2.IsIntersect)(T) ? (0, index_1.Intersect)(FromIntersect(T.allOf)) :
-        (0, type_2.IsUnion)(T) ? (0, index_2.Union)(FromUnion(T.anyOf)) :
+    return ((0, type_2.IsIntersect)(T) ? (0, index_1.Intersect)(FromRest(T.allOf)) :
+        (0, type_2.IsUnion)(T) ? (0, index_2.Union)(FromRest(T.anyOf)) :
             (0, type_2.IsObject)(T) ? (0, index_3.Object)(FromProperties(T.properties)) :
                 (0, index_3.Object)({}));
 }

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

@@ -2,9 +2,9 @@ import type { TSchema } from '../schema/index';
 import type { TIntersect } from '../intersect/index';
 import type { TUnion } from '../union/index';
 import type { TTuple } from '../tuple/index';
-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 {};