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

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

@@ -14,12 +14,17 @@ import { type TPromise } from '../promise/index';
 import { type TReadonly } from '../readonly/index';
 import { type TTuple } from '../tuple/index';
 import { type TUnion } from '../union/index';
+import { type TSetIncludes } from '../sets/index';
 import { type TMappedResult } from './mapped-result';
 import type { TMappedKey } from './mapped-key';
 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/require/type/mapped/mapped.js

@@ -20,6 +20,8 @@ const index_13 = require("../promise/index");
 const index_14 = require("../readonly/index");
 const index_15 = require("../tuple/index");
 const index_16 = require("../union/index");
+// operator
+const index_17 = require("../sets/index");
 // mapping types
 const mapped_result_1 = require("./mapped-result");
 // ------------------------------------------------------------------
@@ -34,11 +36,20 @@ function FromMappedResult(K, P) {
         : (0, mapped_result_1.MappedResult)(P));
 }
 // prettier-ignore
-function MappedKeyToMappedResultProperties(K, P, Acc = {}) {
-    const [L, ...R] = P;
-    return (P.length > 0
-        ? MappedKeyToMappedResultProperties(K, R, { ...Acc, [L]: (0, index_10.Literal)(L) })
-        : Acc);
+function MappedKeyToKnownMappedResultProperties(K) {
+    return { [K]: (0, index_10.Literal)(K) };
+}
+// prettier-ignore
+function MappedKeyToUnknownMappedResultProperties(P) {
+    return P.reduce((Acc, L) => {
+        return { ...Acc, [L]: (0, index_10.Literal)(L) };
+    }, {});
+}
+// prettier-ignore
+function MappedKeyToMappedResultProperties(K, P) {
+    return ((0, index_17.SetIncludes)(P, K)
+        ? MappedKeyToKnownMappedResultProperties(K)
+        : MappedKeyToUnknownMappedResultProperties(P));
 }
 // prettier-ignore
 function FromMappedKey(K, P) {
@@ -46,11 +57,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) {
@@ -82,10 +90,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 */
 function Mapped(key, map, options = {}) {

package/build/require/type/not/not.js

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

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,15 @@ 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 TRegExp } from '../regexp/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<{
@@ -30,6 +31,7 @@ type TFromUnionKey<K extends TSchema[], T extends TSchema, P extends TProperties
 type TFromLiteralKey<K extends TLiteralValue, T extends TSchema> = (Ensure<TObject<{
     [_ in Assert<K, PropertyKey>]: T;
 }>>);
+type TFromRegExpKey<_ extends TRegExp, T extends TSchema> = (Ensure<TRecord<TRegExp, T>>);
 type TFromStringKey<_ extends TString, T extends TSchema> = (Ensure<TRecord<TString, T>>);
 type TFromIntegerKey<_ extends TSchema, T extends TSchema> = (Ensure<TRecord<TNumber, T>>);
 type TFromNumberKey<_ extends TSchema, T extends TSchema> = (Ensure<TRecord<TNumber, T>>);
@@ -43,7 +45,7 @@ export interface TRecord<K extends TSchema = TSchema, T extends TSchema = TSchem
     };
     additionalProperties: TAdditionalProperties;
 }
-export type TRecordOrObject<K extends TSchema, T extends TSchema> = K extends TTemplateLiteral ? TFromTemplateLiteralKey<K, T> : K extends TEnum<infer S> ? TFromEnumKey<S, T> : K extends TUnion<infer S> ? TFromUnionKey<S, T> : K extends TLiteral<infer S> ? TFromLiteralKey<S, T> : K extends TInteger ? TFromIntegerKey<K, T> : K extends TNumber ? TFromNumberKey<K, T> : K extends TString ? TFromStringKey<K, T> : TNever;
+export type TRecordOrObject<K extends TSchema, T extends TSchema> = K extends TTemplateLiteral ? TFromTemplateLiteralKey<K, T> : K extends TEnum<infer S> ? TFromEnumKey<S, T> : K extends TUnion<infer S> ? TFromUnionKey<S, T> : K extends TLiteral<infer S> ? TFromLiteralKey<S, T> : K extends TInteger ? TFromIntegerKey<K, T> : K extends TNumber ? TFromNumberKey<K, T> : K extends TRegExp ? TFromRegExpKey<K, T> : K extends TString ? TFromStringKey<K, T> : TNever;
 /** `[Json]` Creates a Record type */
 export declare function Record<K extends TSchema, T extends TSchema>(K: K, T: T, options?: ObjectOptions): TRecordOrObject<K, T>;
 export {};