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

package/build/import/value/create/create.mjs

@@ -9,50 +9,13 @@ import { TypeBoxError } from '../../type/error/index.mjs';
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
-export class ValueCreateUnknownTypeError extends TypeBoxError {
+export class ValueCreateError extends TypeBoxError {
     schema;
-    constructor(schema) {
-        super('Unknown type');
+    constructor(schema, message) {
+        super(message);
         this.schema = schema;
     }
 }
-export class ValueCreateNeverTypeError extends TypeBoxError {
-    schema;
-    constructor(schema) {
-        super('Never types cannot be created');
-        this.schema = schema;
-    }
-}
-export class ValueCreateNotTypeError extends TypeBoxError {
-    schema;
-    constructor(schema) {
-        super('Not types must have a default value');
-        this.schema = schema;
-    }
-}
-export class ValueCreateIntersectTypeError extends TypeBoxError {
-    schema;
-    constructor(schema) {
-        super('Intersect produced invalid value. Consider using a default value.');
-        this.schema = schema;
-    }
-}
-export class ValueCreateTempateLiteralTypeError extends TypeBoxError {
-    schema;
-    constructor(schema) {
-        super('Can only create template literal values from patterns that produce finite sequences. Consider using a default value.');
-        this.schema = schema;
-    }
-}
-export class ValueCreateRecursiveInstantiationError extends TypeBoxError {
-    schema;
-    recursiveMaxDepth;
-    constructor(schema, recursiveMaxDepth) {
-        super('Value cannot be created as recursive type may produce value of infinite size. Consider using a default.');
-        this.schema = schema;
-        this.recursiveMaxDepth = recursiveMaxDepth;
-    }
-}
 // ------------------------------------------------------------------
 // Create
 // ------------------------------------------------------------------
@@ -66,10 +29,10 @@ function FromAny(schema, references) {
 }
 function FromArray(schema, references) {
     if (schema.uniqueItems === true && !HasPropertyKey(schema, 'default')) {
-        throw new Error('ValueCreate.Array: Array with the uniqueItems constraint requires a default value');
+        throw new ValueCreateError(schema, 'Array with the uniqueItems constraint requires a default value');
     }
     else if ('contains' in schema && !HasPropertyKey(schema, 'default')) {
-        throw new Error('ValueCreate.Array: Array with the contains constraint requires a default value');
+        throw new ValueCreateError(schema, 'Array with the contains constraint requires a default value');
     }
     else if ('default' in schema) {
         return schema.default;
@@ -176,7 +139,7 @@ function FromIntersect(schema, references) {
             return typeof next === 'object' ? { ...acc, ...next } : next;
         }, {});
         if (!Check(schema, references, value))
-            throw new ValueCreateIntersectTypeError(schema);
+            throw new ValueCreateError(schema, 'Intersect produced invalid value. Consider using a default value.');
         return value;
     }
 }
@@ -197,14 +160,19 @@ function FromLiteral(schema, references) {
     }
 }
 function FromNever(schema, references) {
-    throw new ValueCreateNeverTypeError(schema);
+    if (HasPropertyKey(schema, 'default')) {
+        return schema.default;
+    }
+    else {
+        throw new ValueCreateError(schema, 'Never types cannot be created. Consider using a default value.');
+    }
 }
 function FromNot(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
         return schema.default;
     }
     else {
-        throw new ValueCreateNotTypeError(schema);
+        throw new ValueCreateError(schema, 'Not types must have a default value');
     }
 }
 function FromNull(schema, references) {
@@ -269,10 +237,18 @@ function FromRef(schema, references) {
         return Visit(Deref(schema, references), references);
     }
 }
+function FromRegExp(schema, references) {
+    if (HasPropertyKey(schema, 'default')) {
+        return schema.default;
+    }
+    else {
+        throw new ValueCreateError(schema, 'RegExp types cannot be created. Consider using a default value.');
+    }
+}
 function FromString(schema, references) {
     if (schema.pattern !== undefined) {
         if (!HasPropertyKey(schema, 'default')) {
-            throw new Error('ValueCreate.String: String types with patterns must specify a default value');
+            throw new ValueCreateError(schema, 'String types with patterns must specify a default value');
         }
         else {
             return schema.default;
@@ -280,7 +256,7 @@ function FromString(schema, references) {
     }
     else if (schema.format !== undefined) {
         if (!HasPropertyKey(schema, 'default')) {
-            throw new Error('ValueCreate.String: String types with formats must specify a default value');
+            throw new ValueCreateError(schema, 'String types with formats must specify a default value');
         }
         else {
             return schema.default;
@@ -291,9 +267,8 @@ function FromString(schema, references) {
             return schema.default;
         }
         else if (schema.minLength !== undefined) {
-            return Array.from({ length: schema.minLength })
-                .map(() => '.')
-                .join('');
+            // prettier-ignore
+            return Array.from({ length: schema.minLength }).map(() => ' ').join('');
         }
         else {
             return '';
@@ -316,13 +291,13 @@ function FromTemplateLiteral(schema, references) {
         return schema.default;
     }
     if (!IsTemplateLiteralFinite(schema))
-        throw new ValueCreateTempateLiteralTypeError(schema);
+        throw new ValueCreateError(schema, 'Can only create template literals that produce a finite variants. Consider using a default value.');
     const generated = TemplateLiteralGenerate(schema);
     return generated[0];
 }
 function FromThis(schema, references) {
     if (recursiveDepth++ > recursiveMaxDepth)
-        throw new ValueCreateRecursiveInstantiationError(schema, recursiveMaxDepth);
+        throw new ValueCreateError(schema, 'Cannot create recursive type as it appears possibly infinite. Consider using a default.');
     if (HasPropertyKey(schema, 'default')) {
         return schema.default;
     }
@@ -439,6 +414,8 @@ function Visit(schema, references) {
             return FromRecord(schema_, references_);
         case 'Ref':
             return FromRef(schema_, references_);
+        case 'RegExp':
+            return FromRegExp(schema_, references_);
         case 'String':
             return FromString(schema_, references_);
         case 'Symbol':
@@ -461,7 +438,7 @@ function Visit(schema, references) {
             return FromVoid(schema_, references_);
         default:
             if (!TypeRegistry.Has(schema_[Kind]))
-                throw new ValueCreateUnknownTypeError(schema_);
+                throw new ValueCreateError(schema_, 'Unknown type');
             return FromKind(schema_, references_);
     }
 }

package/build/import/value/default/default.mjs

@@ -4,12 +4,10 @@ import { Kind } from '../../type/symbols/index.mjs';
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 import { IsString, IsObject, IsArray, IsUndefined } from '../guard/index.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 import { IsSchema } from '../../type/guard/type.mjs';
 // ------------------------------------------------------------------
 // ValueOrDefault

package/build/import/value/delta/delta.d.mts

@@ -30,11 +30,11 @@ export declare const Edit: import("../../type/union/union-type.mjs").TUnion<[imp
     type: import("../../type/literal/literal.mjs").TLiteral<"delete">;
     path: import("../../type/string/string.mjs").TString;
 }>]>;
-export declare class ValueDeltaObjectWithSymbolKeyError extends TypeBoxError {
-    readonly key: unknown;
-    constructor(key: unknown);
+export declare class ValueDeltaError extends TypeBoxError {
+    readonly value: unknown;
+    constructor(value: unknown, message: string);
 }
-export declare class ValueDeltaUnableToDiffUnknownValue extends TypeBoxError {
+export declare class ValueDeltaSymbolError extends ValueDeltaError {
     readonly value: unknown;
     constructor(value: unknown);
 }

package/build/import/value/delta/delta.mjs

@@ -25,17 +25,17 @@ export const Edit = CreateUnion([Insert, Update, Delete]);
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
-export class ValueDeltaObjectWithSymbolKeyError extends TypeBoxError {
-    key;
-    constructor(key) {
-        super('Cannot diff objects with symbol keys');
-        this.key = key;
+export class ValueDeltaError extends TypeBoxError {
+    value;
+    constructor(value, message) {
+        super(message);
+        this.value = value;
     }
 }
-export class ValueDeltaUnableToDiffUnknownValue extends TypeBoxError {
+export class ValueDeltaSymbolError extends ValueDeltaError {
     value;
     constructor(value) {
-        super('Unable to create diff edits for unknown value');
+        super(value, 'Cannot diff objects with symbol keys');
         this.value = value;
     }
 }
@@ -61,7 +61,7 @@ function* ObjectType(path, current, next) {
     const nextKeys = [...globalThis.Object.keys(next), ...globalThis.Object.getOwnPropertySymbols(next)];
     for (const key of currentKeys) {
         if (IsSymbol(key))
-            throw new ValueDeltaObjectWithSymbolKeyError(key);
+            throw new ValueDeltaSymbolError(key);
         if (IsUndefined(next[key]) && nextKeys.includes(key))
             yield CreateUpdate(`${path}/${globalThis.String(key)}`, undefined);
     }
@@ -69,18 +69,18 @@ function* ObjectType(path, current, next) {
         if (IsUndefined(current[key]) || IsUndefined(next[key]))
             continue;
         if (IsSymbol(key))
-            throw new ValueDeltaObjectWithSymbolKeyError(key);
+            throw new ValueDeltaSymbolError(key);
         yield* Visit(`${path}/${globalThis.String(key)}`, current[key], next[key]);
     }
     for (const key of nextKeys) {
         if (IsSymbol(key))
-            throw new ValueDeltaObjectWithSymbolKeyError(key);
+            throw new ValueDeltaSymbolError(key);
         if (IsUndefined(current[key]))
             yield CreateInsert(`${path}/${globalThis.String(key)}`, next[key]);
     }
     for (const key of currentKeys.reverse()) {
         if (IsSymbol(key))
-            throw new ValueDeltaObjectWithSymbolKeyError(key);
+            throw new ValueDeltaSymbolError(key);
         if (IsUndefined(next[key]) && !nextKeys.includes(key))
             yield CreateDelete(`${path}/${globalThis.String(key)}`);
     }
@@ -123,7 +123,7 @@ function* Visit(path, current, next) {
         return yield* TypedArrayType(path, current, next);
     if (IsValueType(current))
         return yield* ValueType(path, current, next);
-    throw new ValueDeltaUnableToDiffUnknownValue(current);
+    throw new ValueDeltaError(current, 'Unable to create diff edits for unknown value');
 }
 // ------------------------------------------------------------------
 // Diff

package/build/import/value/index.d.mts

@@ -1,16 +1,16 @@
 export { ValueError, ValueErrorType, ValueErrorIterator } from '../errors/index.mjs';
-export { Cast, ValueCastArrayUniqueItemsTypeError, ValueCastNeverTypeError, ValueCastRecursiveTypeError, ValueCastUnknownTypeError } from './cast/index.mjs';
+export { Cast, ValueCastError } from './cast/index.mjs';
 export { Check } from './check/index.mjs';
 export { Clean } from './clean/index.mjs';
 export { Clone } from './clone/index.mjs';
-export { Convert, ValueConvertUnknownTypeError } from './convert/index.mjs';
-export { Create, ValueCreateIntersectTypeError, ValueCreateNeverTypeError, ValueCreateNotTypeError, ValueCreateRecursiveInstantiationError, ValueCreateTempateLiteralTypeError, ValueCreateUnknownTypeError } from './create/index.mjs';
+export { Convert } from './convert/index.mjs';
+export { Create, ValueCreateError } from './create/index.mjs';
 export { Default } from './default/index.mjs';
-export { Diff, Patch, Edit, Delete, Insert, Update, ValueDeltaObjectWithSymbolKeyError, ValueDeltaUnableToDiffUnknownValue } from './delta/index.mjs';
+export { Diff, Patch, Edit, Delete, Insert, Update, ValueDeltaError } from './delta/index.mjs';
 export { Equal } from './equal/index.mjs';
 export { Hash, ValueHashError } from './hash/index.mjs';
-export { Mutate, type Mutable, ValueMutateInvalidRootMutationError, ValueMutateTypeMismatchError } from './mutate/index.mjs';
+export { Mutate, ValueMutateError, type Mutable } from './mutate/index.mjs';
 export { ValuePointer } from './pointer/index.mjs';
-export { TransformDecode as DecodeTransform, TransformEncode as EncodeTransform, HasTransform, TransformDecodeCheckError, TransformDecodeError, TransformEncodeCheckError, TransformEncodeError } from './transform/index.mjs';
-export { ArrayType, HasPropertyKey, IsArray, IsAsyncIterator, IsBigInt, IsBoolean, IsDate, IsFunction, IsInteger, IsIterator, IsNull, IsNumber, IsObject, IsPlainObject, IsPromise, IsString, IsSymbol, IsTypedArray, IsUint8Array, IsUndefined, IsValueType, ObjectType, TypedArrayType, ValueType, } from './guard/index.mjs';
+export { TransformDecode, TransformEncode, HasTransform, TransformDecodeCheckError, TransformDecodeError, TransformEncodeCheckError, TransformEncodeError } from './transform/index.mjs';
+export { ArrayType, HasPropertyKey, IsArray, IsAsyncIterator, IsBigInt, IsBoolean, IsDate, IsFunction, IsInteger, IsIterator, IsNull, IsNumber, IsObject, IsPlainObject, IsPromise, IsString, IsSymbol, IsTypedArray, IsUint8Array, IsUndefined, IsValueType, type ObjectType, type TypedArrayType, type ValueType, } from './guard/index.mjs';
 export { Value } from './value/index.mjs';

package/build/import/value/index.mjs

@@ -5,19 +5,19 @@ export { ValueErrorType, ValueErrorIterator } from '../errors/index.mjs';
 // ------------------------------------------------------------------
 // Value Operators
 // ------------------------------------------------------------------
-export { Cast, ValueCastArrayUniqueItemsTypeError, ValueCastNeverTypeError, ValueCastRecursiveTypeError, ValueCastUnknownTypeError } from './cast/index.mjs';
+export { Cast, ValueCastError } from './cast/index.mjs';
 export { Check } from './check/index.mjs';
 export { Clean } from './clean/index.mjs';
 export { Clone } from './clone/index.mjs';
-export { Convert, ValueConvertUnknownTypeError } from './convert/index.mjs';
-export { Create, ValueCreateIntersectTypeError, ValueCreateNeverTypeError, ValueCreateNotTypeError, ValueCreateRecursiveInstantiationError, ValueCreateTempateLiteralTypeError, ValueCreateUnknownTypeError } from './create/index.mjs';
+export { Convert } from './convert/index.mjs';
+export { Create, ValueCreateError } from './create/index.mjs';
 export { Default } from './default/index.mjs';
-export { Diff, Patch, Edit, Delete, Insert, Update, ValueDeltaObjectWithSymbolKeyError, ValueDeltaUnableToDiffUnknownValue } from './delta/index.mjs';
+export { Diff, Patch, Edit, Delete, Insert, Update, ValueDeltaError } from './delta/index.mjs';
 export { Equal } from './equal/index.mjs';
 export { Hash, ValueHashError } from './hash/index.mjs';
-export { Mutate, ValueMutateInvalidRootMutationError, ValueMutateTypeMismatchError } from './mutate/index.mjs';
+export { Mutate, ValueMutateError } from './mutate/index.mjs';
 export { ValuePointer } from './pointer/index.mjs';
-export { TransformDecode as DecodeTransform, TransformEncode as EncodeTransform, HasTransform, TransformDecodeCheckError, TransformDecodeError, TransformEncodeCheckError, TransformEncodeError } from './transform/index.mjs';
+export { TransformDecode, TransformEncode, HasTransform, TransformDecodeCheckError, TransformDecodeError, TransformEncodeCheckError, TransformEncodeError } from './transform/index.mjs';
 // ------------------------------------------------------------------
 // Value Guards
 // ------------------------------------------------------------------

package/build/import/value/mutate/mutate.d.mts

@@ -1,9 +1,6 @@
 import { TypeBoxError } from '../../type/error/index.mjs';
-export declare class ValueMutateTypeMismatchError extends TypeBoxError {
-    constructor();
-}
-export declare class ValueMutateInvalidRootMutationError extends TypeBoxError {
-    constructor();
+export declare class ValueMutateError extends TypeBoxError {
+    constructor(message: string);
 }
 export type Mutable = {
     [key: string]: unknown;

package/build/import/value/mutate/mutate.mjs

@@ -5,14 +5,9 @@ import { TypeBoxError } from '../../type/error/index.mjs';
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
-export class ValueMutateTypeMismatchError extends TypeBoxError {
-    constructor() {
-        super('Cannot assign due type mismatch of assignable values');
-    }
-}
-export class ValueMutateInvalidRootMutationError extends TypeBoxError {
-    constructor() {
-        super('Only object and array types can be mutated at the root level');
+export class ValueMutateError extends TypeBoxError {
+    constructor(message) {
+        super(message);
     }
 }
 function ObjectType(root, path, current, next) {
@@ -90,8 +85,8 @@ function IsMismatchedValue(current, next) {
 /** `[Mutable]` Performs a deep mutable value assignment while retaining internal references */
 export function Mutate(current, next) {
     if (IsNonMutableValue(current) || IsNonMutableValue(next))
-        throw new ValueMutateInvalidRootMutationError();
+        throw new ValueMutateError('Only object and array types can be mutated at the root level');
     if (IsMismatchedValue(current, next))
-        throw new ValueMutateTypeMismatchError();
+        throw new ValueMutateError('Cannot assign due type mismatch of assignable values');
     Visit(current, '', current, next);
 }

package/build/require/compiler/compiler.js

@@ -384,6 +384,11 @@ var TypeCompiler;
             return yield `${CreateFunctionName(schema.$ref)}(${value})`;
         yield* Visit(target, references, value);
     }
+    function* FromRegExp(schema, references, value) {
+        const variable = CreateVariable(`${new RegExp(schema.source, schema.flags)};`);
+        yield `(typeof ${value} === 'string')`;
+        yield `${variable}.test(${value})`;
+    }
     function* FromString(schema, references, value) {
         yield `(typeof ${value} === 'string')`;
         if ((0, index_11.IsNumber)(schema.maxLength))
@@ -503,6 +508,8 @@ var TypeCompiler;
                 return yield* FromRecord(schema_, references_, value);
             case 'Ref':
                 return yield* FromRef(schema_, references_, value);
+            case 'RegExp':
+                return yield* FromRegExp(schema_, references_, value);
             case 'String':
                 return yield* FromString(schema_, references_, value);
             case 'Symbol':

package/build/require/errors/errors.d.ts

@@ -49,21 +49,22 @@ export declare enum ValueErrorType {
     ObjectRequiredProperty = 45,
     Object = 46,
     Promise = 47,
-    StringFormatUnknown = 48,
-    StringFormat = 49,
-    StringMaxLength = 50,
-    StringMinLength = 51,
-    StringPattern = 52,
-    String = 53,
-    Symbol = 54,
-    TupleLength = 55,
-    Tuple = 56,
-    Uint8ArrayMaxByteLength = 57,
-    Uint8ArrayMinByteLength = 58,
-    Uint8Array = 59,
-    Undefined = 60,
-    Union = 61,
-    Void = 62
+    RegExp = 48,
+    StringFormatUnknown = 49,
+    StringFormat = 50,
+    StringMaxLength = 51,
+    StringMinLength = 52,
+    StringPattern = 53,
+    String = 54,
+    Symbol = 55,
+    TupleLength = 56,
+    Tuple = 57,
+    Uint8ArrayMaxByteLength = 58,
+    Uint8ArrayMinByteLength = 59,
+    Uint8Array = 60,
+    Undefined = 61,
+    Union = 62,
+    Void = 63
 }
 export interface ValueError {
     type: ValueErrorType;

package/build/require/errors/errors.js

@@ -70,21 +70,22 @@ var ValueErrorType;
     ValueErrorType[ValueErrorType["ObjectRequiredProperty"] = 45] = "ObjectRequiredProperty";
     ValueErrorType[ValueErrorType["Object"] = 46] = "Object";
     ValueErrorType[ValueErrorType["Promise"] = 47] = "Promise";
-    ValueErrorType[ValueErrorType["StringFormatUnknown"] = 48] = "StringFormatUnknown";
-    ValueErrorType[ValueErrorType["StringFormat"] = 49] = "StringFormat";
-    ValueErrorType[ValueErrorType["StringMaxLength"] = 50] = "StringMaxLength";
-    ValueErrorType[ValueErrorType["StringMinLength"] = 51] = "StringMinLength";
-    ValueErrorType[ValueErrorType["StringPattern"] = 52] = "StringPattern";
-    ValueErrorType[ValueErrorType["String"] = 53] = "String";
-    ValueErrorType[ValueErrorType["Symbol"] = 54] = "Symbol";
-    ValueErrorType[ValueErrorType["TupleLength"] = 55] = "TupleLength";
-    ValueErrorType[ValueErrorType["Tuple"] = 56] = "Tuple";
-    ValueErrorType[ValueErrorType["Uint8ArrayMaxByteLength"] = 57] = "Uint8ArrayMaxByteLength";
-    ValueErrorType[ValueErrorType["Uint8ArrayMinByteLength"] = 58] = "Uint8ArrayMinByteLength";
-    ValueErrorType[ValueErrorType["Uint8Array"] = 59] = "Uint8Array";
-    ValueErrorType[ValueErrorType["Undefined"] = 60] = "Undefined";
-    ValueErrorType[ValueErrorType["Union"] = 61] = "Union";
-    ValueErrorType[ValueErrorType["Void"] = 62] = "Void";
+    ValueErrorType[ValueErrorType["RegExp"] = 48] = "RegExp";
+    ValueErrorType[ValueErrorType["StringFormatUnknown"] = 49] = "StringFormatUnknown";
+    ValueErrorType[ValueErrorType["StringFormat"] = 50] = "StringFormat";
+    ValueErrorType[ValueErrorType["StringMaxLength"] = 51] = "StringMaxLength";
+    ValueErrorType[ValueErrorType["StringMinLength"] = 52] = "StringMinLength";
+    ValueErrorType[ValueErrorType["StringPattern"] = 53] = "StringPattern";
+    ValueErrorType[ValueErrorType["String"] = 54] = "String";
+    ValueErrorType[ValueErrorType["Symbol"] = 55] = "Symbol";
+    ValueErrorType[ValueErrorType["TupleLength"] = 56] = "TupleLength";
+    ValueErrorType[ValueErrorType["Tuple"] = 57] = "Tuple";
+    ValueErrorType[ValueErrorType["Uint8ArrayMaxByteLength"] = 58] = "Uint8ArrayMaxByteLength";
+    ValueErrorType[ValueErrorType["Uint8ArrayMinByteLength"] = 59] = "Uint8ArrayMinByteLength";
+    ValueErrorType[ValueErrorType["Uint8Array"] = 60] = "Uint8Array";
+    ValueErrorType[ValueErrorType["Undefined"] = 61] = "Undefined";
+    ValueErrorType[ValueErrorType["Union"] = 62] = "Union";
+    ValueErrorType[ValueErrorType["Void"] = 63] = "Void";
 })(ValueErrorType || (exports.ValueErrorType = ValueErrorType = {}));
 // ------------------------------------------------------------------
 // ValueErrors
@@ -395,6 +396,12 @@ function* FromRecord(schema, references, path, value) {
 function* FromRef(schema, references, path, value) {
     yield* Visit((0, index_5.Deref)(schema, references), references, path, value);
 }
+function* FromRegExp(schema, references, path, value) {
+    const regex = new RegExp(schema.source, schema.flags);
+    if (!regex.test(value)) {
+        return yield Create(ValueErrorType.RegExp, schema, path, value);
+    }
+}
 function* FromString(schema, references, path, value) {
     if (!(0, index_9.IsString)(value))
         return yield Create(ValueErrorType.String, schema, path, value);
@@ -533,6 +540,8 @@ function* Visit(schema, references, path, value) {
             return yield* FromRecord(schema_, references_, path, value);
         case 'Ref':
             return yield* FromRef(schema_, references_, path, value);
+        case 'RegExp':
+            return yield* FromRegExp(schema_, references_, path, value);
         case 'String':
             return yield* FromString(schema_, references_, path, value);
         case 'Symbol':

package/build/require/errors/function.js

@@ -101,6 +101,8 @@ function DefaultErrorFunction(error) {
             return 'Required property';
         case errors_1.ValueErrorType.Promise:
             return 'Expected Promise';
+        case errors_1.ValueErrorType.RegExp:
+            return 'Expected string to match regular expression';
         case errors_1.ValueErrorType.StringFormatUnknown:
             return `Unknown format '${error.schema.format}'`;
         case errors_1.ValueErrorType.StringFormat:

package/build/require/index.d.ts

@@ -36,11 +36,11 @@ export { Not, type TNot } from './type/not/index';
 export { Null, type TNull } from './type/null/index';
 export { Number, type TNumber, type NumberOptions } from './type/number/index';
 export { Object, type TObject, type TProperties, type ObjectOptions } from './type/object/index';
-export { Omit, type TOmit, type TOmitFromMappedKey } from './type/omit/index';
+export { Omit, type TOmit, type TOmitFromMappedKey, type TOmitFromMappedResult } from './type/omit/index';
 export { Optional, OptionalFromMappedResult, type TOptional, type TOptionalWithFlag, type TOptionalFromMappedResult } from './type/optional/index';
 export { Parameters, type TParameters } from './type/parameters/index';
 export { Partial, PartialFromMappedResult, type TPartial, type TPartialFromMappedResult } from './type/partial/index';
-export { Pick, type TPick, type TPickFromMappedKey } from './type/pick/index';
+export { Pick, type TPick, type TPickFromMappedKey, type TPickFromMappedResult } from './type/pick/index';
 export { Promise, type TPromise } from './type/promise/index';
 export { Readonly, ReadonlyFromMappedResult, type TReadonly, type TReadonlyWithFlag, type TReadonlyFromMappedResult } from './type/readonly/index';
 export { ReadonlyOptional, type TReadonlyOptional } from './type/readonly-optional/index';

package/build/require/type/awaited/awaited.js

@@ -8,14 +8,10 @@ const type_1 = require("../clone/type");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 const type_2 = require("../guard/type");
 // prettier-ignore
-function FromRest(T, Acc = []) {
-    const [L, ...R] = T;
-    return (T.length > 0
-        ? FromRest(R, [...Acc, FromSchema(L)])
-        : Acc);
+function FromRest(T) {
+    return T.map(L => FromSchema(L));
 }
 // prettier-ignore
 function FromIntersect(T) {

package/build/require/type/clone/value.js

@@ -12,6 +12,9 @@ function DateType(value) {
 function Uint8ArrayType(value) {
     return new Uint8Array(value);
 }
+function RegExpType(value) {
+    return new RegExp(value.source, value.flags);
+}
 function ObjectType(value) {
     const clonedProperties = Object.getOwnPropertyNames(value).reduce((acc, key) => ({ ...acc, [key]: Visit(value[key]) }), {});
     const clonedSymbols = Object.getOwnPropertySymbols(value).reduce((acc, key) => ({ ...acc, [key]: Visit(value[key]) }), {});
@@ -22,8 +25,9 @@ function Visit(value) {
     return (ValueGuard.IsArray(value) ? ArrayType(value) :
         ValueGuard.IsDate(value) ? DateType(value) :
             ValueGuard.IsUint8Array(value) ? Uint8ArrayType(value) :
-                ValueGuard.IsObject(value) ? ObjectType(value) :
-                    value);
+                ValueGuard.IsRegExp(value) ? RegExpType(value) :
+                    ValueGuard.IsObject(value) ? ObjectType(value) :
+                        value);
 }
 /** Clones a value */
 function Clone(value) {

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

@@ -7,8 +7,7 @@ type TCompositeIndex<T extends TIntersect<TObject[]>, K extends string[], Acc ex
     [_ in L]: TIndex<T, [L]>;
 }> : Acc;
 type TCompositeReduce<T extends TObject[]> = UnionToTuple<TCompositeKeys<T>> extends infer K ? Evaluate<TCompositeIndex<TIntersect<T>, Assert<K, string[]>>> : {};
-export type TCompositeResolve<T extends TObject[]> = TIntersect<T> extends TIntersect ? TObject<TCompositeReduce<T>> : TObject<{}>;
-export declare function CompositeResolve<T extends TObject[]>(T: [...T]): TCompositeResolve<T>;
+type TCompositeResolve<T extends TObject[]> = TIntersect<T> extends TIntersect ? TObject<TCompositeReduce<T>> : TObject<{}>;
 export type TComposite<T extends TObject[]> = TCompositeResolve<T>;
 /** `[Json]` Creates a Composite object type */
 export declare function Composite<T extends TObject[]>(T: [...T], options?: ObjectOptions): TComposite<T>;

package/build/require/type/composite/composite.js

@@ -1,19 +1,18 @@
 "use strict";
 
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Composite = exports.CompositeResolve = void 0;
+exports.Composite = void 0;
 const index_1 = require("../object/index");
 const index_2 = require("../intersect/index");
-const index_3 = require("../keyof/index");
-const index_4 = require("../indexed/index");
+const index_3 = require("../indexed/index");
+const index_4 = require("../keyof/index");
 const type_1 = require("../clone/type");
 function CompositeResolve(T) {
     const intersect = (0, index_2.Intersect)(T, {});
-    const keys = (0, index_3.KeyOfPropertyKeys)(intersect);
-    const properties = keys.reduce((acc, key) => ({ ...acc, [key]: (0, index_4.Index)(intersect, [key]) }), {});
+    const keys = (0, index_4.KeyOfPropertyKeys)(intersect);
+    const properties = keys.reduce((acc, key) => ({ ...acc, [key]: (0, index_3.Index)(intersect, [key]) }), {});
     return (0, index_1.Object)(properties);
 }
-exports.CompositeResolve = CompositeResolve;
 /** `[Json]` Creates a Composite object type */
 function Composite(T, options) {
     return (0, type_1.CloneType)(CompositeResolve(T), options);

package/build/require/type/const/const.js

@@ -2,7 +2,6 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Const = void 0;
-const value_1 = require("../guard/value");
 const index_1 = require("../any/index");
 const index_2 = require("../bigint/index");
 const index_3 = require("../date/index");
@@ -17,12 +16,13 @@ const index_11 = require("../undefined/index");
 const index_12 = require("../uint8array/index");
 const index_13 = require("../unknown/index");
 const index_14 = require("../clone/index");
+// ------------------------------------------------------------------
+// ValueGuard
+// ------------------------------------------------------------------
+const value_1 = require("../guard/value");
 // prettier-ignore
 function FromArray(T) {
-    const [L, ...R] = T;
-    return (T.length > 0
-        ? [FromValue(L, false), ...FromArray(R)]
-        : []);
+    return T.map(L => FromValue(L, false));
 }
 // prettier-ignore
 function FromProperties(value) {
@@ -37,7 +37,7 @@ function ConditionalReadonly(T, root) {
 function FromValue(value, root) {
     return ((0, value_1.IsAsyncIterator)(value) ? ConditionalReadonly((0, index_1.Any)(), root) :
         (0, value_1.IsIterator)(value) ? ConditionalReadonly((0, index_1.Any)(), root) :
-            (0, value_1.IsArray)(value) ? (0, index_10.Readonly)((0, index_9.Tuple)(FromArray(value))) : // Always Readonly
+            (0, value_1.IsArray)(value) ? (0, index_10.Readonly)((0, index_9.Tuple)(FromArray(value))) :
                 (0, value_1.IsUint8Array)(value) ? (0, index_12.Uint8Array)() :
                     (0, value_1.IsDate)(value) ? (0, index_3.Date)() :
                         (0, value_1.IsObject)(value) ? ConditionalReadonly((0, index_7.Object)(FromProperties(value)), root) :

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

@@ -4,7 +4,7 @@ import type { Ensure } from '../helpers/index';
 import { Kind } from '../symbols/index';
 type ConstructorStaticReturnType<T extends TSchema, P extends unknown[]> = Static<T, P>;
 type ConstructorStaticParameters<T extends TSchema[], P extends unknown[], Acc extends unknown[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? ConstructorStaticParameters<R, P, [...Acc, Static<L, P>]> : Acc;
-export type ConstructorStatic<T extends TSchema[], U extends TSchema, P extends unknown[]> = (Ensure<new (...param: ConstructorStaticParameters<T, P>) => ConstructorStaticReturnType<U, P>>);
+type ConstructorStatic<T extends TSchema[], U extends TSchema, P extends unknown[]> = (Ensure<new (...param: ConstructorStaticParameters<T, P>) => ConstructorStaticReturnType<U, P>>);
 export interface TConstructor<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Constructor';
     static: ConstructorStatic<T, U, this['params']>;