@sinclair/typebox 0.34.7 → 0.34.9

package/build/cjs/compiler/compiler.d.ts

@@ -12,6 +12,10 @@ export declare class TypeCheck<T extends TSchema> {
     constructor(schema: T, references: TSchema[], checkFunc: CheckFunction, code: string);
     /** Returns the generated assertion code used to validate this type. */
     Code(): string;
+    /** Returns the schema type used to validate */
+    Schema(): T;
+    /** Returns reference types used to validate */
+    References(): TSchema[];
     /** Returns an iterator for each error in this value. */
     Errors(value: unknown): ValueErrorIterator;
     /** Returns true if the value matches the compiled type. */

package/build/cjs/compiler/compiler.js

@@ -36,6 +36,14 @@ class TypeCheck {
     Code() {
         return this.code;
     }
+    /** Returns the schema type used to validate */
+    Schema() {
+        return this.schema;
+    }
+    /** Returns reference types used to validate */
+    References() {
+        return this.references;
+    }
     /** Returns an iterator for each error in this value. */
     Errors(value) {
         return (0, index_2.Errors)(this.schema, this.references, value);

package/build/cjs/type/module/compute.d.ts

@@ -13,9 +13,11 @@ import { type TIterator } from '../iterator/index';
 import { type TKeyOf } from '../keyof/index';
 import { type TObject, type TProperties } from '../object/index';
 import { type TOmit } from '../omit/index';
+import { type TOptional } from '../optional/index';
 import { type TPick } from '../pick/index';
 import { type TNever } from '../never/index';
 import { TPartial } from '../partial/index';
+import { type TReadonly } from '../readonly/index';
 import { type TRecordOrObject } from '../record/index';
 import { type TRef } from '../ref/index';
 import { TRequired } from '../required/index';
@@ -44,7 +46,7 @@ type TFromArray<ModuleProperties extends TProperties, Type extends TSchema> = (E
 type TFromAsyncIterator<ModuleProperties extends TProperties, Type extends TSchema> = (TAsyncIterator<TFromType<ModuleProperties, Type>>);
 type TFromIterator<ModuleProperties extends TProperties, Type extends TSchema> = (TIterator<TFromType<ModuleProperties, Type>>);
 type TFromRest<ModuleProperties extends TProperties, Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromRest<ModuleProperties, Right, [...Result, TFromType<ModuleProperties, Left>]> : Result);
-export type TFromType<ModuleProperties extends TProperties, Type extends TSchema> = (Type extends TArray<infer Type extends TSchema> ? TFromArray<ModuleProperties, Type> : Type extends TAsyncIterator<infer Type extends TSchema> ? TFromAsyncIterator<ModuleProperties, Type> : Type extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TFromComputed<ModuleProperties, Target, Parameters> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TFromConstructor<ModuleProperties, Parameters, InstanceType> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFromFunction<ModuleProperties, Parameters, ReturnType> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<ModuleProperties, Types> : Type extends TIterator<infer Type extends TSchema> ? TFromIterator<ModuleProperties, Type> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<ModuleProperties, Properties> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<ModuleProperties, Types> : Type extends TEnum<infer _ extends TEnumRecord> ? Type : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<ModuleProperties, Types> : Type);
+export type TFromType<ModuleProperties extends TProperties, Type extends TSchema> = (Type extends TOptional<infer Type extends TSchema> ? TOptional<TFromType<ModuleProperties, Type>> : Type extends TReadonly<infer Type extends TSchema> ? TReadonly<TFromType<ModuleProperties, Type>> : Type extends TArray<infer Type extends TSchema> ? TFromArray<ModuleProperties, Type> : Type extends TAsyncIterator<infer Type extends TSchema> ? TFromAsyncIterator<ModuleProperties, Type> : Type extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TFromComputed<ModuleProperties, Target, Parameters> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TFromConstructor<ModuleProperties, Parameters, InstanceType> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFromFunction<ModuleProperties, Parameters, ReturnType> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<ModuleProperties, Types> : Type extends TIterator<infer Type extends TSchema> ? TFromIterator<ModuleProperties, Type> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<ModuleProperties, Properties> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<ModuleProperties, Types> : Type extends TEnum<infer _ extends TEnumRecord> ? Type : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<ModuleProperties, Types> : Type);
 export declare function FromType<ModuleProperties extends TProperties, Type extends TSchema>(moduleProperties: ModuleProperties, type: Type): TFromType<ModuleProperties, Type>;
 export type TComputeType<ModuleProperties extends TProperties, Key extends PropertyKey> = (Key extends keyof ModuleProperties ? TFromType<ModuleProperties, ModuleProperties[Key]> : TNever);
 export declare function ComputeType<ModuleProperties extends TProperties, Key extends PropertyKey>(moduleProperties: ModuleProperties, key: Key): TComputeType<ModuleProperties, Key>;

package/build/cjs/type/module/compute.js

@@ -5,24 +5,26 @@ exports.FromType = FromType;
 exports.ComputeType = ComputeType;
 exports.ComputeModuleProperties = ComputeModuleProperties;
 const index_1 = require("../create/index");
-const index_2 = require("../array/index");
-const index_3 = require("../awaited/index");
-const index_4 = require("../async-iterator/index");
-const index_5 = require("../constructor/index");
-const index_6 = require("../indexed/index");
-const index_7 = require("../function/index");
-const index_8 = require("../intersect/index");
-const index_9 = require("../iterator/index");
-const index_10 = require("../keyof/index");
-const index_11 = require("../object/index");
-const index_12 = require("../omit/index");
-const index_13 = require("../pick/index");
-const index_14 = require("../never/index");
-const index_15 = require("../partial/index");
-const index_16 = require("../record/index");
-const index_17 = require("../required/index");
-const index_18 = require("../tuple/index");
-const index_19 = require("../union/index");
+const index_2 = require("../discard/index");
+const index_3 = require("../array/index");
+const index_4 = require("../awaited/index");
+const index_5 = require("../async-iterator/index");
+const index_6 = require("../constructor/index");
+const index_7 = require("../indexed/index");
+const index_8 = require("../function/index");
+const index_9 = require("../intersect/index");
+const index_10 = require("../iterator/index");
+const index_11 = require("../keyof/index");
+const index_12 = require("../object/index");
+const index_13 = require("../omit/index");
+const index_14 = require("../pick/index");
+const index_15 = require("../never/index");
+const index_16 = require("../partial/index");
+const index_17 = require("../record/index");
+const index_18 = require("../required/index");
+const index_19 = require("../tuple/index");
+const index_20 = require("../union/index");
+const index_21 = require("../symbols/index");
 // ------------------------------------------------------------------
 // KindGuard
 // ------------------------------------------------------------------
@@ -41,39 +43,39 @@ function Deref(moduleProperties, ref) {
         ? KindGuard.IsRef(moduleProperties[ref])
             ? Deref(moduleProperties, moduleProperties[ref].$ref)
             : FromType(moduleProperties, moduleProperties[ref])
-        : (0, index_14.Never)());
+        : (0, index_15.Never)());
 }
 // prettier-ignore
 function FromAwaited(parameters) {
-    return (0, index_3.Awaited)(parameters[0]);
+    return (0, index_4.Awaited)(parameters[0]);
 }
 // prettier-ignore
 function FromIndex(parameters) {
-    return (0, index_6.Index)(parameters[0], parameters[1]);
+    return (0, index_7.Index)(parameters[0], parameters[1]);
 }
 // prettier-ignore
 function FromKeyOf(parameters) {
-    return (0, index_10.KeyOf)(parameters[0]);
+    return (0, index_11.KeyOf)(parameters[0]);
 }
 // prettier-ignore
 function FromPartial(parameters) {
-    return (0, index_15.Partial)(parameters[0]);
+    return (0, index_16.Partial)(parameters[0]);
 }
 // prettier-ignore
 function FromOmit(parameters) {
-    return (0, index_12.Omit)(parameters[0], parameters[1]);
+    return (0, index_13.Omit)(parameters[0], parameters[1]);
 }
 // prettier-ignore
 function FromPick(parameters) {
-    return (0, index_13.Pick)(parameters[0], parameters[1]);
+    return (0, index_14.Pick)(parameters[0], parameters[1]);
 }
 // prettier-ignore
 function FromRecord(parameters) {
-    return (0, index_16.Record)(parameters[0], parameters[1]);
+    return (0, index_17.Record)(parameters[0], parameters[1]);
 }
 // prettier-ignore
 function FromRequired(parameters) {
-    return (0, index_17.Required)(parameters[0]);
+    return (0, index_18.Required)(parameters[0]);
 }
 // prettier-ignore
 function FromComputed(moduleProperties, target, parameters) {
@@ -86,64 +88,69 @@ function FromComputed(moduleProperties, target, parameters) {
                         target === 'Pick' ? FromPick(dereferenced) :
                             target === 'Record' ? FromRecord(dereferenced) :
                                 target === 'Required' ? FromRequired(dereferenced) :
-                                    (0, index_14.Never)());
+                                    (0, index_15.Never)());
 }
 function FromObject(moduleProperties, properties) {
-    return (0, index_11.Object)(globalThis.Object.keys(properties).reduce((result, key) => {
+    return (0, index_12.Object)(globalThis.Object.keys(properties).reduce((result, key) => {
         return { ...result, [key]: FromType(moduleProperties, properties[key]) };
     }, {}));
 }
 // prettier-ignore
 function FromConstructor(moduleProperties, parameters, instanceType) {
-    return (0, index_5.Constructor)(FromRest(moduleProperties, parameters), FromType(moduleProperties, instanceType));
+    return (0, index_6.Constructor)(FromRest(moduleProperties, parameters), FromType(moduleProperties, instanceType));
 }
 // prettier-ignore
 function FromFunction(moduleProperties, parameters, returnType) {
-    return (0, index_7.Function)(FromRest(moduleProperties, parameters), FromType(moduleProperties, returnType));
+    return (0, index_8.Function)(FromRest(moduleProperties, parameters), FromType(moduleProperties, returnType));
 }
 function FromTuple(moduleProperties, types) {
-    return (0, index_18.Tuple)(FromRest(moduleProperties, types));
+    return (0, index_19.Tuple)(FromRest(moduleProperties, types));
 }
 function FromIntersect(moduleProperties, types) {
-    return (0, index_8.Intersect)(FromRest(moduleProperties, types));
+    return (0, index_9.Intersect)(FromRest(moduleProperties, types));
 }
 function FromUnion(moduleProperties, types) {
-    return (0, index_19.Union)(FromRest(moduleProperties, types));
+    return (0, index_20.Union)(FromRest(moduleProperties, types));
 }
 function FromArray(moduleProperties, type) {
-    return (0, index_2.Array)(FromType(moduleProperties, type));
+    return (0, index_3.Array)(FromType(moduleProperties, type));
 }
 function FromAsyncIterator(moduleProperties, type) {
-    return (0, index_4.AsyncIterator)(FromType(moduleProperties, type));
+    return (0, index_5.AsyncIterator)(FromType(moduleProperties, type));
 }
 function FromIterator(moduleProperties, type) {
-    return (0, index_9.Iterator)(FromType(moduleProperties, type));
+    return (0, index_10.Iterator)(FromType(moduleProperties, type));
 }
 function FromRest(moduleProperties, types) {
     return types.map((type) => FromType(moduleProperties, type));
 }
 // prettier-ignore
 function FromType(moduleProperties, type) {
-    return (KindGuard.IsArray(type) ? (0, index_1.CreateType)(FromArray(moduleProperties, type.items), type) :
-        KindGuard.IsAsyncIterator(type) ? (0, index_1.CreateType)(FromAsyncIterator(moduleProperties, type.items), type) :
-            // Note: The 'as never' is required due to excessive resolution of TIndex. In fact TIndex, TPick, TOmit and
-            // all need re-implementation to remove the PropertyKey[] selector. Reimplementation of these types should
-            // be a priority as there is a potential for the current inference to break on TS compiler changes.
-            KindGuard.IsComputed(type) ? (0, index_1.CreateType)(FromComputed(moduleProperties, type.target, type.parameters)) :
-                KindGuard.IsConstructor(type) ? (0, index_1.CreateType)(FromConstructor(moduleProperties, type.parameters, type.returns), type) :
-                    KindGuard.IsFunction(type) ? (0, index_1.CreateType)(FromFunction(moduleProperties, type.parameters, type.returns), type) :
-                        KindGuard.IsIntersect(type) ? (0, index_1.CreateType)(FromIntersect(moduleProperties, type.allOf), type) :
-                            KindGuard.IsIterator(type) ? (0, index_1.CreateType)(FromIterator(moduleProperties, type.items), type) :
-                                KindGuard.IsObject(type) ? (0, index_1.CreateType)(FromObject(moduleProperties, type.properties), type) :
-                                    KindGuard.IsTuple(type) ? (0, index_1.CreateType)(FromTuple(moduleProperties, type.items || []), type) :
-                                        KindGuard.IsUnion(type) ? (0, index_1.CreateType)(FromUnion(moduleProperties, type.anyOf), type) :
-                                            type);
+    return (
+    // Modifier Unwrap - Reapplied via CreateType Options
+    KindGuard.IsOptional(type) ? (0, index_1.CreateType)(FromType(moduleProperties, (0, index_2.Discard)(type, [index_21.OptionalKind])), type) :
+        KindGuard.IsReadonly(type) ? (0, index_1.CreateType)(FromType(moduleProperties, (0, index_2.Discard)(type, [index_21.ReadonlyKind])), type) :
+            // Traveral
+            KindGuard.IsArray(type) ? (0, index_1.CreateType)(FromArray(moduleProperties, type.items), type) :
+                KindGuard.IsAsyncIterator(type) ? (0, index_1.CreateType)(FromAsyncIterator(moduleProperties, type.items), type) :
+                    // Note: The 'as never' is required due to excessive resolution of TIndex. In fact TIndex, TPick, TOmit and
+                    // all need re-implementation to remove the PropertyKey[] selector. Reimplementation of these types should
+                    // be a priority as there is a potential for the current inference to break on TS compiler changes.
+                    KindGuard.IsComputed(type) ? (0, index_1.CreateType)(FromComputed(moduleProperties, type.target, type.parameters)) :
+                        KindGuard.IsConstructor(type) ? (0, index_1.CreateType)(FromConstructor(moduleProperties, type.parameters, type.returns), type) :
+                            KindGuard.IsFunction(type) ? (0, index_1.CreateType)(FromFunction(moduleProperties, type.parameters, type.returns), type) :
+                                KindGuard.IsIntersect(type) ? (0, index_1.CreateType)(FromIntersect(moduleProperties, type.allOf), type) :
+                                    KindGuard.IsIterator(type) ? (0, index_1.CreateType)(FromIterator(moduleProperties, type.items), type) :
+                                        KindGuard.IsObject(type) ? (0, index_1.CreateType)(FromObject(moduleProperties, type.properties), type) :
+                                            KindGuard.IsTuple(type) ? (0, index_1.CreateType)(FromTuple(moduleProperties, type.items || []), type) :
+                                                KindGuard.IsUnion(type) ? (0, index_1.CreateType)(FromUnion(moduleProperties, type.anyOf), type) :
+                                                    type);
 }
 // prettier-ignore
 function ComputeType(moduleProperties, key) {
     return (key in moduleProperties
         ? FromType(moduleProperties, moduleProperties[key])
-        : (0, index_14.Never)());
+        : (0, index_15.Never)());
 }
 // prettier-ignore
 function ComputeModuleProperties(moduleProperties) {

package/build/cjs/value/parse/parse.d.ts

@@ -1,6 +1,22 @@
+import { TypeBoxError } from '../../type/error/index';
 import { TSchema } from '../../type/schema/index';
 import { StaticDecode } from '../../type/static/index';
-/** Parses a value or throws an `AssertError` if invalid. */
-export declare function Parse<T extends TSchema, R = StaticDecode<T>>(schema: T, references: TSchema[], value: unknown): R;
-/** Parses a value or throws an `AssertError` if invalid. */
-export declare function Parse<T extends TSchema, R = StaticDecode<T>>(schema: T, value: unknown): R;
+export declare class ParseError extends TypeBoxError {
+    constructor(message: string);
+}
+export type TParseOperation = 'Clone' | 'Clean' | 'Default' | 'Convert' | 'Assert' | 'Decode' | ({} & string);
+export type TParseFunction = (type: TSchema, references: TSchema[], value: unknown) => unknown;
+export declare namespace ParseRegistry {
+    function Delete(key: string): void;
+    function Set(key: string, callback: TParseFunction): void;
+    function Get(key: string): TParseFunction | undefined;
+}
+export declare const ParseDefault: readonly ["Clone", "Clean", "Default", "Convert", "Assert", "Decode"];
+/** Parses a value using the default parse pipeline. Will throws an `AssertError` if invalid. */
+export declare function Parse<Type extends TSchema, Output = StaticDecode<Type>, Result extends Output = Output>(schema: Type, references: TSchema[], value: unknown): Result;
+/** Parses a value using the default parse pipeline. Will throws an `AssertError` if invalid. */
+export declare function Parse<Type extends TSchema, Output = StaticDecode<Type>, Result extends Output = Output>(schema: Type, value: unknown): Result;
+/** Parses a value using the specified operations. */
+export declare function Parse<Type extends TSchema>(operations: TParseOperation[], schema: Type, references: TSchema[], value: unknown): unknown;
+/** Parses a value using the specified operations. */
+export declare function Parse<Type extends TSchema>(operations: TParseOperation[], schema: Type, value: unknown): unknown;

package/build/cjs/value/parse/parse.js

@@ -1,29 +1,85 @@
 "use strict";
 
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParseDefault = exports.ParseRegistry = exports.ParseError = void 0;
 exports.Parse = Parse;
-const index_1 = require("../transform/index");
-const assert_1 = require("../assert/assert");
-const default_1 = require("../default/default");
-const convert_1 = require("../convert/convert");
-const clean_1 = require("../clean/clean");
-const index_2 = require("../clone/index");
+const index_1 = require("../../type/error/index");
+const index_2 = require("../transform/index");
+const index_3 = require("../assert/index");
+const index_4 = require("../default/index");
+const index_5 = require("../convert/index");
+const index_6 = require("../clean/index");
+const index_7 = require("../clone/index");
+// ------------------------------------------------------------------
+// Guards
+// ------------------------------------------------------------------
+const index_8 = require("../guard/index");
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+class ParseError extends index_1.TypeBoxError {
+    constructor(message) {
+        super(message);
+    }
+}
+exports.ParseError = ParseError;
+// prettier-ignore
+var ParseRegistry;
+(function (ParseRegistry) {
+    const registry = new Map([
+        ['Clone', (_type, _references, value) => (0, index_7.Clone)(value)],
+        ['Clean', (type, references, value) => (0, index_6.Clean)(type, references, value)],
+        ['Default', (type, references, value) => (0, index_4.Default)(type, references, value)],
+        ['Convert', (type, references, value) => (0, index_5.Convert)(type, references, value)],
+        ['Assert', (type, references, value) => { (0, index_3.Assert)(type, references, value); return value; }],
+        ['Decode', (type, references, value) => ((0, index_2.HasTransform)(type, references) ? (0, index_2.TransformDecode)(type, references, value) : value)],
+        ['Encode', (type, references, value) => ((0, index_2.HasTransform)(type, references) ? (0, index_2.TransformEncode)(type, references, value) : value)],
+    ]);
+    // Deletes an entry from the registry
+    function Delete(key) {
+        registry.delete(key);
+    }
+    ParseRegistry.Delete = Delete;
+    // Sets an entry in the registry
+    function Set(key, callback) {
+        registry.set(key, callback);
+    }
+    ParseRegistry.Set = Set;
+    // Gets an entry in the registry
+    function Get(key) {
+        return registry.get(key);
+    }
+    ParseRegistry.Get = Get;
+})(ParseRegistry || (exports.ParseRegistry = ParseRegistry = {}));
+// ------------------------------------------------------------------
+// Default Parse Sequence
+// ------------------------------------------------------------------
 // prettier-ignore
-const ParseReducer = [
-    (_schema, _references, value) => (0, index_2.Clone)(value),
-    (schema, references, value) => (0, default_1.Default)(schema, references, value),
-    (schema, references, value) => (0, clean_1.Clean)(schema, references, value),
-    (schema, references, value) => (0, convert_1.Convert)(schema, references, value),
-    (schema, references, value) => { (0, assert_1.Assert)(schema, references, value); return value; },
-    (schema, references, value) => ((0, index_1.HasTransform)(schema, references) ? (0, index_1.TransformDecode)(schema, references, value) : value),
+exports.ParseDefault = [
+    'Clone',
+    'Clean',
+    'Default',
+    'Convert',
+    'Assert',
+    'Decode'
 ];
 // ------------------------------------------------------------------
 // ParseValue
 // ------------------------------------------------------------------
-function ParseValue(schema, references, value) {
-    return ParseReducer.reduce((value, reducer) => reducer(schema, references, value), value);
+function ParseValue(operations, type, references, value) {
+    return operations.reduce((value, operationKey) => {
+        const operation = ParseRegistry.Get(operationKey);
+        if ((0, index_8.IsUndefined)(operation))
+            throw new ParseError(`Unable to find Parse operation '${operationKey}'`);
+        return operation(type, references, value);
+    }, value);
 }
-/** Parses a value or throws an `AssertError` if invalid. */
+/** Parses a value */
 function Parse(...args) {
-    return args.length === 3 ? ParseValue(args[0], args[1], args[2]) : ParseValue(args[0], [], args[1]);
+    // prettier-ignore
+    const [operations, schema, references, value] = (args.length === 4 ? [args[0], args[1], args[2], args[3]] :
+        args.length === 3 ? (0, index_8.IsArray)(args[0]) ? [args[0], args[1], [], args[2]] : [exports.ParseDefault, args[0], args[1], args[2]] :
+            args.length === 2 ? [exports.ParseDefault, args[0], [], args[1]] :
+                (() => { throw new ParseError('Invalid Arguments'); })());
+    return ParseValue(operations, schema, references, value);
 }

package/build/esm/compiler/compiler.d.mts

@@ -12,6 +12,10 @@ export declare class TypeCheck<T extends TSchema> {
     constructor(schema: T, references: TSchema[], checkFunc: CheckFunction, code: string);
     /** Returns the generated assertion code used to validate this type. */
     Code(): string;
+    /** Returns the schema type used to validate */
+    Schema(): T;
+    /** Returns reference types used to validate */
+    References(): TSchema[];
     /** Returns an iterator for each error in this value. */
     Errors(value: unknown): ValueErrorIterator;
     /** Returns true if the value matches the compiled type. */

package/build/esm/compiler/compiler.mjs

@@ -32,6 +32,14 @@ export class TypeCheck {
     Code() {
         return this.code;
     }
+    /** Returns the schema type used to validate */
+    Schema() {
+        return this.schema;
+    }
+    /** Returns reference types used to validate */
+    References() {
+        return this.references;
+    }
     /** Returns an iterator for each error in this value. */
     Errors(value) {
         return Errors(this.schema, this.references, value);

package/build/esm/type/module/compute.d.mts

@@ -13,9 +13,11 @@ import { type TIterator } from '../iterator/index.mjs';
 import { type TKeyOf } from '../keyof/index.mjs';
 import { type TObject, type TProperties } from '../object/index.mjs';
 import { type TOmit } from '../omit/index.mjs';
+import { type TOptional } from '../optional/index.mjs';
 import { type TPick } from '../pick/index.mjs';
 import { type TNever } from '../never/index.mjs';
 import { TPartial } from '../partial/index.mjs';
+import { type TReadonly } from '../readonly/index.mjs';
 import { type TRecordOrObject } from '../record/index.mjs';
 import { type TRef } from '../ref/index.mjs';
 import { TRequired } from '../required/index.mjs';
@@ -44,7 +46,7 @@ type TFromArray<ModuleProperties extends TProperties, Type extends TSchema> = (E
 type TFromAsyncIterator<ModuleProperties extends TProperties, Type extends TSchema> = (TAsyncIterator<TFromType<ModuleProperties, Type>>);
 type TFromIterator<ModuleProperties extends TProperties, Type extends TSchema> = (TIterator<TFromType<ModuleProperties, Type>>);
 type TFromRest<ModuleProperties extends TProperties, Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromRest<ModuleProperties, Right, [...Result, TFromType<ModuleProperties, Left>]> : Result);
-export type TFromType<ModuleProperties extends TProperties, Type extends TSchema> = (Type extends TArray<infer Type extends TSchema> ? TFromArray<ModuleProperties, Type> : Type extends TAsyncIterator<infer Type extends TSchema> ? TFromAsyncIterator<ModuleProperties, Type> : Type extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TFromComputed<ModuleProperties, Target, Parameters> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TFromConstructor<ModuleProperties, Parameters, InstanceType> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFromFunction<ModuleProperties, Parameters, ReturnType> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<ModuleProperties, Types> : Type extends TIterator<infer Type extends TSchema> ? TFromIterator<ModuleProperties, Type> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<ModuleProperties, Properties> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<ModuleProperties, Types> : Type extends TEnum<infer _ extends TEnumRecord> ? Type : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<ModuleProperties, Types> : Type);
+export type TFromType<ModuleProperties extends TProperties, Type extends TSchema> = (Type extends TOptional<infer Type extends TSchema> ? TOptional<TFromType<ModuleProperties, Type>> : Type extends TReadonly<infer Type extends TSchema> ? TReadonly<TFromType<ModuleProperties, Type>> : Type extends TArray<infer Type extends TSchema> ? TFromArray<ModuleProperties, Type> : Type extends TAsyncIterator<infer Type extends TSchema> ? TFromAsyncIterator<ModuleProperties, Type> : Type extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TFromComputed<ModuleProperties, Target, Parameters> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TFromConstructor<ModuleProperties, Parameters, InstanceType> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFromFunction<ModuleProperties, Parameters, ReturnType> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<ModuleProperties, Types> : Type extends TIterator<infer Type extends TSchema> ? TFromIterator<ModuleProperties, Type> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<ModuleProperties, Properties> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<ModuleProperties, Types> : Type extends TEnum<infer _ extends TEnumRecord> ? Type : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<ModuleProperties, Types> : Type);
 export declare function FromType<ModuleProperties extends TProperties, Type extends TSchema>(moduleProperties: ModuleProperties, type: Type): TFromType<ModuleProperties, Type>;
 export type TComputeType<ModuleProperties extends TProperties, Key extends PropertyKey> = (Key extends keyof ModuleProperties ? TFromType<ModuleProperties, ModuleProperties[Key]> : TNever);
 export declare function ComputeType<ModuleProperties extends TProperties, Key extends PropertyKey>(moduleProperties: ModuleProperties, key: Key): TComputeType<ModuleProperties, Key>;

package/build/esm/type/module/compute.mjs

@@ -1,4 +1,5 @@
 import { CreateType } from '../create/index.mjs';
+import { Discard } from '../discard/index.mjs';
 import { Array } from '../array/index.mjs';
 import { Awaited } from '../awaited/index.mjs';
 import { AsyncIterator } from '../async-iterator/index.mjs';
@@ -17,6 +18,7 @@ import { Record } from '../record/index.mjs';
 import { Required } from '../required/index.mjs';
 import { Tuple } from '../tuple/index.mjs';
 import { Union } from '../union/index.mjs';
+import { OptionalKind, ReadonlyKind } from '../symbols/index.mjs';
 // ------------------------------------------------------------------
 // KindGuard
 // ------------------------------------------------------------------
@@ -118,20 +120,25 @@ function FromRest(moduleProperties, types) {
 }
 // prettier-ignore
 export function FromType(moduleProperties, type) {
-    return (KindGuard.IsArray(type) ? CreateType(FromArray(moduleProperties, type.items), type) :
-        KindGuard.IsAsyncIterator(type) ? CreateType(FromAsyncIterator(moduleProperties, type.items), type) :
-            // Note: The 'as never' is required due to excessive resolution of TIndex. In fact TIndex, TPick, TOmit and
-            // all need re-implementation to remove the PropertyKey[] selector. Reimplementation of these types should
-            // be a priority as there is a potential for the current inference to break on TS compiler changes.
-            KindGuard.IsComputed(type) ? CreateType(FromComputed(moduleProperties, type.target, type.parameters)) :
-                KindGuard.IsConstructor(type) ? CreateType(FromConstructor(moduleProperties, type.parameters, type.returns), type) :
-                    KindGuard.IsFunction(type) ? CreateType(FromFunction(moduleProperties, type.parameters, type.returns), type) :
-                        KindGuard.IsIntersect(type) ? CreateType(FromIntersect(moduleProperties, type.allOf), type) :
-                            KindGuard.IsIterator(type) ? CreateType(FromIterator(moduleProperties, type.items), type) :
-                                KindGuard.IsObject(type) ? CreateType(FromObject(moduleProperties, type.properties), type) :
-                                    KindGuard.IsTuple(type) ? CreateType(FromTuple(moduleProperties, type.items || []), type) :
-                                        KindGuard.IsUnion(type) ? CreateType(FromUnion(moduleProperties, type.anyOf), type) :
-                                            type);
+    return (
+    // Modifier Unwrap - Reapplied via CreateType Options
+    KindGuard.IsOptional(type) ? CreateType(FromType(moduleProperties, Discard(type, [OptionalKind])), type) :
+        KindGuard.IsReadonly(type) ? CreateType(FromType(moduleProperties, Discard(type, [ReadonlyKind])), type) :
+            // Traveral
+            KindGuard.IsArray(type) ? CreateType(FromArray(moduleProperties, type.items), type) :
+                KindGuard.IsAsyncIterator(type) ? CreateType(FromAsyncIterator(moduleProperties, type.items), type) :
+                    // Note: The 'as never' is required due to excessive resolution of TIndex. In fact TIndex, TPick, TOmit and
+                    // all need re-implementation to remove the PropertyKey[] selector. Reimplementation of these types should
+                    // be a priority as there is a potential for the current inference to break on TS compiler changes.
+                    KindGuard.IsComputed(type) ? CreateType(FromComputed(moduleProperties, type.target, type.parameters)) :
+                        KindGuard.IsConstructor(type) ? CreateType(FromConstructor(moduleProperties, type.parameters, type.returns), type) :
+                            KindGuard.IsFunction(type) ? CreateType(FromFunction(moduleProperties, type.parameters, type.returns), type) :
+                                KindGuard.IsIntersect(type) ? CreateType(FromIntersect(moduleProperties, type.allOf), type) :
+                                    KindGuard.IsIterator(type) ? CreateType(FromIterator(moduleProperties, type.items), type) :
+                                        KindGuard.IsObject(type) ? CreateType(FromObject(moduleProperties, type.properties), type) :
+                                            KindGuard.IsTuple(type) ? CreateType(FromTuple(moduleProperties, type.items || []), type) :
+                                                KindGuard.IsUnion(type) ? CreateType(FromUnion(moduleProperties, type.anyOf), type) :
+                                                    type);
 }
 // prettier-ignore
 export function ComputeType(moduleProperties, key) {

package/build/esm/value/parse/parse.d.mts

@@ -1,6 +1,22 @@
+import { TypeBoxError } from '../../type/error/index.mjs';
 import { TSchema } from '../../type/schema/index.mjs';
 import { StaticDecode } from '../../type/static/index.mjs';
-/** Parses a value or throws an `AssertError` if invalid. */
-export declare function Parse<T extends TSchema, R = StaticDecode<T>>(schema: T, references: TSchema[], value: unknown): R;
-/** Parses a value or throws an `AssertError` if invalid. */
-export declare function Parse<T extends TSchema, R = StaticDecode<T>>(schema: T, value: unknown): R;
+export declare class ParseError extends TypeBoxError {
+    constructor(message: string);
+}
+export type TParseOperation = 'Clone' | 'Clean' | 'Default' | 'Convert' | 'Assert' | 'Decode' | ({} & string);
+export type TParseFunction = (type: TSchema, references: TSchema[], value: unknown) => unknown;
+export declare namespace ParseRegistry {
+    function Delete(key: string): void;
+    function Set(key: string, callback: TParseFunction): void;
+    function Get(key: string): TParseFunction | undefined;
+}
+export declare const ParseDefault: readonly ["Clone", "Clean", "Default", "Convert", "Assert", "Decode"];
+/** Parses a value using the default parse pipeline. Will throws an `AssertError` if invalid. */
+export declare function Parse<Type extends TSchema, Output = StaticDecode<Type>, Result extends Output = Output>(schema: Type, references: TSchema[], value: unknown): Result;
+/** Parses a value using the default parse pipeline. Will throws an `AssertError` if invalid. */
+export declare function Parse<Type extends TSchema, Output = StaticDecode<Type>, Result extends Output = Output>(schema: Type, value: unknown): Result;
+/** Parses a value using the specified operations. */
+export declare function Parse<Type extends TSchema>(operations: TParseOperation[], schema: Type, references: TSchema[], value: unknown): unknown;
+/** Parses a value using the specified operations. */
+export declare function Parse<Type extends TSchema>(operations: TParseOperation[], schema: Type, value: unknown): unknown;

package/build/esm/value/parse/parse.mjs

@@ -1,25 +1,79 @@
-import { TransformDecode, HasTransform } from '../transform/index.mjs';
-import { Assert } from '../assert/assert.mjs';
-import { Default } from '../default/default.mjs';
-import { Convert } from '../convert/convert.mjs';
-import { Clean } from '../clean/clean.mjs';
+import { TypeBoxError } from '../../type/error/index.mjs';
+import { TransformDecode, TransformEncode, HasTransform } from '../transform/index.mjs';
+import { Assert } from '../assert/index.mjs';
+import { Default } from '../default/index.mjs';
+import { Convert } from '../convert/index.mjs';
+import { Clean } from '../clean/index.mjs';
 import { Clone } from '../clone/index.mjs';
+// ------------------------------------------------------------------
+// Guards
+// ------------------------------------------------------------------
+import { IsArray, IsUndefined } from '../guard/index.mjs';
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export class ParseError extends TypeBoxError {
+    constructor(message) {
+        super(message);
+    }
+}
+// prettier-ignore
+export var ParseRegistry;
+(function (ParseRegistry) {
+    const registry = new Map([
+        ['Clone', (_type, _references, value) => Clone(value)],
+        ['Clean', (type, references, value) => Clean(type, references, value)],
+        ['Default', (type, references, value) => Default(type, references, value)],
+        ['Convert', (type, references, value) => Convert(type, references, value)],
+        ['Assert', (type, references, value) => { Assert(type, references, value); return value; }],
+        ['Decode', (type, references, value) => (HasTransform(type, references) ? TransformDecode(type, references, value) : value)],
+        ['Encode', (type, references, value) => (HasTransform(type, references) ? TransformEncode(type, references, value) : value)],
+    ]);
+    // Deletes an entry from the registry
+    function Delete(key) {
+        registry.delete(key);
+    }
+    ParseRegistry.Delete = Delete;
+    // Sets an entry in the registry
+    function Set(key, callback) {
+        registry.set(key, callback);
+    }
+    ParseRegistry.Set = Set;
+    // Gets an entry in the registry
+    function Get(key) {
+        return registry.get(key);
+    }
+    ParseRegistry.Get = Get;
+})(ParseRegistry || (ParseRegistry = {}));
+// ------------------------------------------------------------------
+// Default Parse Sequence
+// ------------------------------------------------------------------
 // prettier-ignore
-const ParseReducer = [
-    (_schema, _references, value) => Clone(value),
-    (schema, references, value) => Default(schema, references, value),
-    (schema, references, value) => Clean(schema, references, value),
-    (schema, references, value) => Convert(schema, references, value),
-    (schema, references, value) => { Assert(schema, references, value); return value; },
-    (schema, references, value) => (HasTransform(schema, references) ? TransformDecode(schema, references, value) : value),
+export const ParseDefault = [
+    'Clone',
+    'Clean',
+    'Default',
+    'Convert',
+    'Assert',
+    'Decode'
 ];
 // ------------------------------------------------------------------
 // ParseValue
 // ------------------------------------------------------------------
-function ParseValue(schema, references, value) {
-    return ParseReducer.reduce((value, reducer) => reducer(schema, references, value), value);
+function ParseValue(operations, type, references, value) {
+    return operations.reduce((value, operationKey) => {
+        const operation = ParseRegistry.Get(operationKey);
+        if (IsUndefined(operation))
+            throw new ParseError(`Unable to find Parse operation '${operationKey}'`);
+        return operation(type, references, value);
+    }, value);
 }
-/** Parses a value or throws an `AssertError` if invalid. */
+/** Parses a value */
 export function Parse(...args) {
-    return args.length === 3 ? ParseValue(args[0], args[1], args[2]) : ParseValue(args[0], [], args[1]);
+    // prettier-ignore
+    const [operations, schema, references, value] = (args.length === 4 ? [args[0], args[1], args[2], args[3]] :
+        args.length === 3 ? IsArray(args[0]) ? [args[0], args[1], [], args[2]] : [ParseDefault, args[0], args[1], args[2]] :
+            args.length === 2 ? [ParseDefault, args[0], [], args[1]] :
+                (() => { throw new ParseError('Invalid Arguments'); })());
+    return ParseValue(operations, schema, references, value);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.7",
+  "version": "0.34.9",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",

package/readme.md

@@ -78,9 +78,6 @@ License MIT
   - [Unsafe](#types-unsafe)
 - [Syntax](#syntax)
   - [Parse](#syntax-parse)
-  - [Compose](#syntax-compose)
-  - [Context](#syntax-context)
-  - [Module](#syntax-module)
   - [Static](#syntax-static)
   - [Limits](#syntax-limits)
 - [Values](#values)
@@ -1025,9 +1022,9 @@ if(TypeGuard.IsString(T)) {
 
 ## Syntax Types
 
-TypeBox provides support for parsing TypeScript syntax directly into TypeBox Json Schema schematics. Syntax Types offer a string based DSL frontend to TypeBox's Type Builder system and can be useful for converting existing TypeScript type definitions into Json Schema schematics without reimplementation via the Type Builder.
+Syntax Types is a feature that enables TypeBox to parse TypeScript type annotations directly into Json Schema. This feature works both at runtime and statically within the type system. Syntax Types use Json Schema as the Abstract Syntax Tree (AST) parse target for TypeScript types. Syntax Types are designed to offer a syntactical frontend to the standard Type Builder API.
 
-Syntax Types are provided via optional import.
+This feature is available via optional import.
 
 ```typescript
 import { Parse } from '@sinclair/typebox/syntax'
@@ -1037,7 +1034,7 @@ import { Parse } from '@sinclair/typebox/syntax'
 
 ### Parse
 
-Use the Parse function to convert a TypeScript string into a TypeBox type. TypeBox will infer the appropriate TSchema type or return undefined if there is a syntax error.
+Use the Parse function to transform a TypeScript type annotation into a TypeBox type. This function will return the parsed TypeBox type or undefined on error.
 
 ```typescript
 const A = Parse('string')                           // const A: TString
@@ -1054,45 +1051,46 @@ const C = Parse(`{ x: number, y: number }`)         // const C: TObject<{
                                                     // }>
 ```
 
-
-
-<a name='syntax-compose'></a>
-
-### Compose
-
-Syntax Types are designed to be interchangeable with standard Types.
+Syntax Types can be composed with Standard Types. 
 
 ```typescript
 const T = Type.Object({                             // const T: TObject<{
   x: Parse('number'),                               //   x: TNumber,
-  y: Parse('number'),                               //   y: TNumber,
-  z: Parse('number')                                //   z: TNumber
+  y: Parse('string'),                               //   y: TString,
+  z: Parse('boolean')                               //   z: TBoolean
 })                                                  // }>
 ```
 
-<a name='syntax-module'></a>
+It is also possible to pass Standard Types to Syntax Types in the following way.
 
-### Module
+```typescript
+const X = Type.Number()
+const Y = Type.String()
+const Z = Type.Boolean()
+
+const T = Parse({ X, Y, Z }, `{ 
+  x: X, 
+  y: Y, 
+  z: Z 
+}`)
+```
 
-Syntax Types also support Module parsing. This can provide a more terse syntax for creating Module definitions, but comes with an inference performance cost. Module parsing supports interface and type alias definitions. Generics types are currently unsupported. 
+Syntax Types can also be used to parse Module types.
 
 ```typescript
-const Module = Parse(`module {
-  
+const Foo = Parse(`module Foo {
+
+  export type PartialUser = Pick<User, 'id'> & Partial<Omit<User, 'id'>>
+
   export interface User {
     id: string
     name: string
     email: string
   }
- 
-  export type PartialUser = (
-    Pick<User, 'id'> &
-    Partial<Omit<User, 'id'>>
-  )
 
 }`)
 
-const PartialUser = Module.Import('PartialUser')    // TImport<{...}, 'PartialUser'>
+const PartialUser = Foo.Import('PartialUser')       // TImport<{...}, 'PartialUser'>
 
 type PartialUser = Static<typeof PartialUser>       // type PartialUser = {
                                                     //   id: string,
@@ -1102,45 +1100,11 @@ type PartialUser = Static<typeof PartialUser>       // type PartialUser = {
                                                     // }
 ```
 
-<a name='syntax-context'></a>
-
-### Context
-
-The Parse function takes an optional leading Context object that contains external types. This Context allows the syntax to reference these external types using the property identifiers provided by the Context. The following passes the external type `T` to Parse.
-
-```typescript
-const T = Type.Object({                             // const T: TObject<{
-  x: Type.Number(),                                 //   x: TNumber,
-  y: Type.Number(),                                 //   y: TNumber,
-  z: Type.Number()                                  //   z: TNumber
-})                                                  // }>
-
-const A = Parse({ T }, 'Partial<T>')                // const A: TObject<{
-                                                    //   x: TOptional<TNumber>,
-                                                    //   y: TOptional<TNumber>,
-                                                    //   z: TOptional<TNumber>
-                                                    // }>
-
-const B = Parse({ T }, 'keyof T')                   // const B: TUnion<[
-                                                    //   TLiteral<'x'>,
-                                                    //   TLiteral<'y'>,
-                                                    //   TLiteral<'z'>
-                                                    // ]>
-
-const C = Parse({ T }, 'T & { w: number }')         // const C: TIntersect<[TObject<{
-                                                    //    x: TNumber;
-                                                    //    y: TNumber;
-                                                    //    z: TNumber;
-                                                    // }>, TObject<{
-                                                    //    w: TNumber;
-                                                    // }>]>
-```
-
 <a name='syntax-static'></a>
 
 ### Static
 
-Syntax Types provide two Static types for inferring TypeScript types and TypeBox schematics from strings.
+Syntax Types provide two Static types specific to inferring TypeBox and TypeScript types from strings.
 
 ```typescript
 import { StaticParseAsSchema, StaticParseAsType } from '@sinclair/typebox/syntax' 
@@ -1154,8 +1118,8 @@ type S = StaticParseAsSchema<{}, '{ x: number }'>   // type S: TObject<{
 // Will infer as a type
 
 type T = StaticParseAsType<{}, '{ x: number }'>     // type T = {
-                                                    //  x: number
-                                                    //                       
+                                                    //   x: number
+                                                    // }                      
 ```
 
 
@@ -1361,26 +1325,28 @@ const B = Value.Encode(Type.String(), 42)             // throw
 
 ### Parse
 
-Use the Parse function to parse a value or throw if invalid. This function internally uses Default, Clean, Convert and Decode to make a best effort attempt to parse the value into the expected type. This function should not be used in performance critical code paths.
+Use the Parse function to parse a value. This function calls the `Clone` `Clean`, `Default`, `Convert`, `Assert` and `Decode` Value functions in this exact order to process a value.
 
 ```typescript
-const T = Type.Object({ x: Type.Number({ default: 0 }), y: Type.Number({ default: 0 }) })
+const R = Value.Parse(Type.String(), 'hello')      // const R: string = "hello"
 
-// Default
+const E = Value.Parse(Type.String(), undefined)    // throws AssertError 
+```
 
-const A = Value.Parse(T, { })                                 // const A = { x: 0, y: 0 }
+You can override the order in which functions are are run, or omit functions entirely in the following way.
 
-// Convert
+```typescript
+// Runs no functions.
 
-const B = Value.Parse(T, { x: '1', y: '2' })                  // const B = { x: 1, y: 2 }
+const R = Value.Parse([], Type.String(), 12345)
 
-// Clean
+// Runs the Assert() function.
 
-const C = Value.Parse(T, { x: 1, y: 2, z: 3 })                // const C = { x: 1, y: 2 }
+const E = Value.Parse(['Assert'], Type.String(), 12345)
 
-// Assert
+// Runs the Convert() function followed by the Assert() function.
 
-const D = Value.Parse(T, undefined)                           // throws AssertError
+const S = Value.Parse(['Convert', 'Assert'], Type.String(), 12345)
 ```
 
 <a name='values-equal'></a>