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

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
@@ -50,6 +53,10 @@ function FromLiteralKey(K, T, options) {
     return RecordCreateFromKeys([K.toString()], T, options);
 }
 // prettier-ignore
+function FromRegExpKey(K, T, options) {
+    return RecordCreateFromPattern(K.source, T, options);
+}
+// prettier-ignore
 function FromStringKey(K, T, options) {
     const pattern = (0, value_1.IsUndefined)(K.pattern) ? index_5.PatternStringExact : K.pattern;
     return RecordCreateFromPattern(pattern, T, options);
@@ -71,9 +78,10 @@ function Record(K, T, options = {}) {
     return ((0, type_2.IsUnion)(K) ? FromUnionKey(K.anyOf, T, options) :
         (0, type_2.IsTemplateLiteral)(K) ? FromTemplateLiteralKey(K, T, options) :
             (0, type_2.IsLiteral)(K) ? FromLiteralKey(K.const, T, options) :
-                (0, type_2.IsString)(K) ? FromStringKey(K, T, options) :
-                    (0, type_2.IsInteger)(K) ? FromIntegerKey(K, T, options) :
-                        (0, type_2.IsNumber)(K) ? FromNumberKey(K, T, options) :
-                            (0, index_2.Never)(options));
+                (0, type_2.IsInteger)(K) ? FromIntegerKey(K, T, options) :
+                    (0, type_2.IsNumber)(K) ? FromNumberKey(K, T, options) :
+                        (0, type_2.IsRegExp)(K) ? FromRegExpKey(K, T, options) :
+                            (0, type_2.IsString)(K) ? FromStringKey(K, T, options) :
+                                (0, index_2.Never)(options));
 }
 exports.Record = Record;

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/regexp/regexp.d.ts

@@ -1,7 +1,14 @@
 import type { SchemaOptions } from '../schema/index';
-import type { TString } from '../string/index';
-export type TRegExp = TString;
-/** `[JavaScript]` Creates a String type from a Regular Expression pattern */
+import type { TSchema } from '../schema/index';
+import { Kind } from '../symbols/index';
+export interface TRegExp extends TSchema {
+    [Kind]: 'RegExp';
+    static: `${string}`;
+    type: 'RegExp';
+    source: string;
+    flags: string;
+}
+/** `[JavaScript]` Creates a RegExp type */
 export declare function RegExp(pattern: string, options?: SchemaOptions): TRegExp;
-/** `[JavaScript]` Creates a String type from a Regular Expression */
+/** `[JavaScript]` Creates a RegExp type */
 export declare function RegExp(regex: RegExp, options?: SchemaOptions): TRegExp;

package/build/require/type/regexp/regexp.js

@@ -4,9 +4,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RegExp = void 0;
 const value_1 = require("../guard/value");
 const index_1 = require("../symbols/index");
-/** `[JavaScript]` Creates a String type */
+/** `[JavaScript]` Creates a RegExp type */
 function RegExp(unresolved, options = {}) {
-    const pattern = (0, value_1.IsString)(unresolved) ? unresolved : unresolved.source;
-    return { ...options, [index_1.Kind]: 'String', type: 'string', pattern };
+    const expr = (0, value_1.IsString)(unresolved) ? new globalThis.RegExp(unresolved) : unresolved;
+    return { ...options, [index_1.Kind]: 'RegExp', type: 'RegExp', source: expr.source, flags: expr.flags };
 }
 exports.RegExp = RegExp;

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 {};

package/build/require/type/rest/rest.js

@@ -1,12 +1,11 @@
 "use strict";
 
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Rest = exports.RestResolve = void 0;
+exports.Rest = void 0;
 const type_1 = require("../clone/type");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 const type_2 = require("../guard/type");
 // prettier-ignore
 function RestResolve(T) {
@@ -15,7 +14,6 @@ function RestResolve(T) {
             (0, type_2.IsTuple)(T) ? [...(T.items ?? [])] :
                 []);
 }
-exports.RestResolve = RestResolve;
 /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
 function Rest(T) {
     return (0, type_1.CloneRest)(RestResolve(T));

package/build/require/type/schema/anyschema.d.ts

@@ -19,6 +19,7 @@ import type { TPromise } from '../promise/index';
 import type { TRecord } from '../record/index';
 import type { TThis } from '../recursive/index';
 import type { TRef } from '../ref/index';
+import type { TRegExp } from '../regexp/index';
 import type { TString } from '../string/index';
 import type { TSymbol } from '../symbol/index';
 import type { TTemplateLiteral } from '../template-literal/index';
@@ -29,4 +30,4 @@ import type { TUnion } from '../union/index';
 import type { TUnknown } from '../unknown/index';
 import type { TVoid } from '../void/index';
 import type { TSchema } from './schema';
-export type TAnySchema = TSchema | TAny | TArray | TAsyncIterator | TBigInt | TBoolean | TConstructor | TDate | TEnum | TFunction | TInteger | TIntersect | TIterator | TLiteral | TNot | TNull | TNumber | TObject | TPromise | TRecord | TRef | TString | TSymbol | TTemplateLiteral | TThis | TTuple | TUndefined | TUnion | TUint8Array | TUnknown | TVoid;
+export type TAnySchema = TSchema | TAny | TArray | TAsyncIterator | TBigInt | TBoolean | TConstructor | TDate | TEnum | TFunction | TInteger | TIntersect | TIterator | TLiteral | TNot | TNull | TNumber | TObject | TPromise | TRecord | TRef | TRegExp | TString | TSymbol | TTemplateLiteral | TThis | TTuple | TUndefined | TUnion | TUint8Array | TUnknown | TVoid;

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

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

package/build/require/type/{operators → sets}/index.js

@@ -15,4 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./operators"), exports);
+__exportStar(require("./set"), exports);

package/build/require/type/sets/set.d.ts

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

package/build/require/type/sets/set.js

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

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

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

package/build/require/type/strict/strict.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Strict = void 0;
-/** `[Json]` Omits compositing symbols from this schema */
+/** `[Json]` Omits compositing symbols from this schema. */
 function Strict(schema) {
     return JSON.parse(JSON.stringify(schema));
 }

package/build/require/type/template-literal/parse.js

@@ -1,7 +1,7 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TemplateLiteralParseExact = exports.TemplateLiteralParse = exports.TemplateLiteralParserError = void 0;
-
 const index_1 = require("../error/index");
 // ------------------------------------------------------------------
 // TemplateLiteralParserError

package/build/require/type/template-literal/syntax.d.ts

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

package/build/require/type/template-literal/template-literal.d.ts

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

package/build/require/type/transform/transform.js

@@ -2,8 +2,8 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Transform = exports.TransformEncodeBuilder = exports.TransformDecodeBuilder = void 0;
-const type_1 = require("../clone/type");
 const index_1 = require("../symbols/index");
+const type_1 = require("../clone/type");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------

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

@@ -41,9 +41,9 @@ export declare class JavaScriptTypeBuilder extends JsonTypeBuilder {
     Parameters<T extends TFunction<TSchema[], TSchema>>(schema: T, options?: SchemaOptions): TParameters<T>;
     /** `[JavaScript]` Creates a Promise type */
     Promise<T extends TSchema>(item: T, options?: SchemaOptions): TPromise<T>;
-    /** `[JavaScript]` Creates a String type from a Regular Expression pattern */
+    /** `[JavaScript]` Creates a RegExp type */
     RegExp(pattern: string, options?: SchemaOptions): TRegExp;
-    /** `[JavaScript]` Creates a String type from a Regular Expression */
+    /** `[JavaScript]` Creates a RegExp type */
     RegExp(regex: RegExp, options?: SchemaOptions): TRegExp;
     /** `[JavaScript]` Extracts the ReturnType from the given Function type */
     ReturnType<T extends TFunction<any[], any>>(schema: T, options?: SchemaOptions): TReturnType<T>;

package/build/require/type/type/javascript.js

@@ -66,7 +66,7 @@ class JavaScriptTypeBuilder extends json_1.JsonTypeBuilder {
     Promise(item, options = {}) {
         return (0, index_11.Promise)(item, options);
     }
-    /** `[JavaScript]` Creates a String type */
+    /** `[JavaScript]` Creates a RegExp type */
     RegExp(unresolved, options = {}) {
         return (0, index_12.RegExp)(unresolved, options);
     }

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

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

package/build/require/type/union/union-evaluated.js

@@ -11,25 +11,14 @@ const union_create_1 = require("./union-create");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 const type_2 = require("../guard/type");
 // prettier-ignore
 function IsUnionOptional(T) {
-    const [L, ...R] = T;
-    return (T.length > 0
-        ? (0, type_2.IsOptional)(L)
-            ? true
-            : IsUnionOptional(R)
-        : false);
+    return T.some(L => (0, type_2.IsOptional)(L));
 }
 // prettier-ignore
-function RemoveOptionalFromRest(T, Acc = []) {
-    const [L, ...R] = T;
-    return (T.length > 0
-        ? (0, type_2.IsOptional)(L)
-            ? RemoveOptionalFromRest(R, [...Acc, RemoveOptionalFromType(L)])
-            : RemoveOptionalFromRest(R, [...Acc, L])
-        : Acc);
+function RemoveOptionalFromRest(T) {
+    return T.map(L => (0, type_2.IsOptional)(L) ? RemoveOptionalFromType(L) : L);
 }
 // prettier-ignore
 function RemoveOptionalFromType(T) {

package/build/require/value/cast/cast.d.ts

@@ -1,22 +1,9 @@
 import { TypeBoxError } from '../../type/error/index';
 import type { TSchema } from '../../type/schema/index';
 import type { Static } from '../../type/static/index';
-export declare class ValueCastArrayUniqueItemsTypeError extends TypeBoxError {
+export declare class ValueCastError extends TypeBoxError {
     readonly schema: TSchema;
-    readonly value: unknown;
-    constructor(schema: TSchema, value: unknown);
-}
-export declare class ValueCastNeverTypeError extends TypeBoxError {
-    readonly schema: TSchema;
-    constructor(schema: TSchema);
-}
-export declare class ValueCastRecursiveTypeError extends TypeBoxError {
-    readonly schema: TSchema;
-    constructor(schema: TSchema);
-}
-export declare class ValueCastUnknownTypeError extends TypeBoxError {
-    readonly schema: TSchema;
-    constructor(schema: TSchema);
+    constructor(schema: TSchema, message: string);
 }
 /** Casts a value into a given type and references. The return value will retain as much information of the original value as possible. */
 export declare function Cast<T extends TSchema>(schema: T, references: TSchema[], value: unknown): Static<T>;

package/build/require/value/cast/cast.js

@@ -1,7 +1,7 @@
 "use strict";
 
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Cast = exports.ValueCastUnknownTypeError = exports.ValueCastRecursiveTypeError = exports.ValueCastNeverTypeError = exports.ValueCastArrayUniqueItemsTypeError = void 0;
+exports.Cast = exports.ValueCastError = void 0;
 const index_1 = require("../guard/index");
 const index_2 = require("../../type/error/index");
 const index_3 = require("../../type/symbols/index");
@@ -12,35 +12,13 @@ const index_7 = require("../deref/index");
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
-class ValueCastArrayUniqueItemsTypeError extends index_2.TypeBoxError {
-    constructor(schema, value) {
-        super('Array cast produced invalid data due to uniqueItems constraint');
+class ValueCastError extends index_2.TypeBoxError {
+    constructor(schema, message) {
+        super(message);
         this.schema = schema;
-        this.value = value;
     }
 }
-exports.ValueCastArrayUniqueItemsTypeError = ValueCastArrayUniqueItemsTypeError;
-class ValueCastNeverTypeError extends index_2.TypeBoxError {
-    constructor(schema) {
-        super('Never types cannot be cast');
-        this.schema = schema;
-    }
-}
-exports.ValueCastNeverTypeError = ValueCastNeverTypeError;
-class ValueCastRecursiveTypeError extends index_2.TypeBoxError {
-    constructor(schema) {
-        super('Cannot cast recursive schemas');
-        this.schema = schema;
-    }
-}
-exports.ValueCastRecursiveTypeError = ValueCastRecursiveTypeError;
-class ValueCastUnknownTypeError extends index_2.TypeBoxError {
-    constructor(schema) {
-        super('Unknown type');
-        this.schema = schema;
-    }
-}
-exports.ValueCastUnknownTypeError = ValueCastUnknownTypeError;
+exports.ValueCastError = ValueCastError;
 // ------------------------------------------------------------------
 // The following will score a schema against a value. For objects,
 // the score is the tally of points awarded for each property of
@@ -109,7 +87,7 @@ function FromArray(schema, references, value) {
         return casted;
     const unique = [...new Set(casted)];
     if (!(0, index_5.Check)(schema, references, unique))
-        throw new ValueCastArrayUniqueItemsTypeError(schema, unique);
+        throw new ValueCastError(schema, 'Array cast produced invalid data due to uniqueItems constraint');
     return unique;
 }
 function FromConstructor(schema, references, value) {
@@ -130,7 +108,7 @@ function FromIntersect(schema, references, value) {
     return (0, index_5.Check)(schema, references, mapped) ? mapped : (0, index_4.Create)(schema, references);
 }
 function FromNever(schema, references, value) {
-    throw new ValueCastNeverTypeError(schema);
+    throw new ValueCastError(schema, 'Never types cannot be cast');
 }
 function FromObject(schema, references, value) {
     if ((0, index_5.Check)(schema, references, value))

package/build/require/value/check/check.js

@@ -14,7 +14,6 @@ const index_9 = require("../../type/never/index");
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 const index_10 = require("../guard/index");
 // ------------------------------------------------------------------
 // TypeGuard
@@ -290,6 +289,10 @@ function FromRecord(schema, references, value) {
 function FromRef(schema, references, value) {
     return Visit((0, index_2.Deref)(schema, references), references, value);
 }
+function FromRegExp(schema, references, value) {
+    const regex = new RegExp(schema.source, schema.flags);
+    return regex.test(value);
+}
 function FromString(schema, references, value) {
     if (!(0, index_10.IsString)(value)) {
         return false;
@@ -417,6 +420,8 @@ function Visit(schema, references, value) {
             return FromRecord(schema_, references_, value);
         case 'Ref':
             return FromRef(schema_, references_, value);
+        case 'RegExp':
+            return FromRegExp(schema_, references_, value);
         case 'String':
             return FromString(schema_, references_, value);
         case 'Symbol':

package/build/require/value/convert/convert.d.ts

@@ -1,9 +1,4 @@
-import { TypeBoxError } from '../../type/error/index';
 import type { TSchema } from '../../type/schema/index';
-export declare class ValueConvertUnknownTypeError extends TypeBoxError {
-    readonly schema: TSchema;
-    constructor(schema: TSchema);
-}
 /** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
 export declare function Convert<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown;
 /** Converts any type mismatched values to their target type if a reasonable conversion is possible. */