typebox 1.1.37 → 1.1.39

package/build/compile/code.mjs

@@ -45,8 +45,8 @@ function FunctionSection(build) {
 // ------------------------------------------------------------------
 function ExportSection(build) {
     const body = build.UseUnevaluated()
-        ? `const context = new CheckContext({}, {}); return ${build.Call()}`
-        : `return ${build.Call()}`;
+        ? `const context = new CheckContext({}, {}); return ${build.Entry()}`
+        : `return ${build.Entry()}`;
     return [
         Separator(),
         TsIgnore(),

package/build/compile/validator.d.mts

@@ -1,16 +1,14 @@
 import { type TLocalizedValidationError } from '../error/index.mjs';
 import { type StaticDecode, type StaticEncode, type TProperties, type TSchema, Base } from '../type/index.mjs';
+import { BuildResult, EvaluateResult } from '../schema/index.mjs';
 export declare class Validator<Context extends TProperties = TProperties, Type extends TSchema = TSchema, Encode extends unknown = StaticEncode<Type, Context>, Decode extends unknown = StaticDecode<Type, Context>> extends Base<Encode> {
-    private readonly context;
-    private readonly type;
-    private readonly isAccelerated;
     private readonly hasCodec;
-    private readonly code;
-    private readonly check;
+    private readonly buildResult;
+    private readonly evaluateResult;
     /** Constructs a Validator with the given Context and Type. */
     constructor(context: Context, type: Type);
     /** Constructs a Validator with the given arguments. */
-    constructor(context: Context, type: Type, isEvaluated: boolean, hasCodec: boolean, code: string, check: (value: unknown) => boolean);
+    constructor(hasCodec: boolean, buildResult: BuildResult, evaluateResult: EvaluateResult);
     /** Returns true if this Validator is using JIT acceleration. */
     IsAccelerated(): boolean;
     /** Returns the Context for this validator. */
@@ -21,6 +19,8 @@ export declare class Validator<Context extends TProperties = TProperties, Type e
     Code(): string;
     /** Performs a type-guard check on the provided value. */
     Check(value: unknown): value is Encode;
+    /** Validates a value and returns it. Will throw if invalid. */
+    Parse(value: unknown): Encode;
     /** Inspects a value and returns a detailed list of validation errors. */
     Errors(value: unknown): TLocalizedValidationError[];
     /** Cleans a value using the Validator type. */
@@ -31,12 +31,13 @@ export declare class Validator<Context extends TProperties = TProperties, Type e
     Create(): Encode;
     /** Creates defaults using the Validator type. */
     Default(value: unknown): unknown;
-    /** Clones this validator. */
-    Clone(): Validator<Context, Type>;
-    /** Validates a value and returns it. Will throw if invalid. */
-    Parse(value: unknown): Encode;
     /** Decodes a value */
     Decode(value: unknown): Decode;
     /** Encodes a value */
     Encode(value: unknown): Encode;
+    /**
+     * @deprecated Validator instances should not support Clone because they are owners of JIT evaluated functions. This function will be
+     * removed in the next version of TypeBox (relates to Type.Base deprecation)
+     */
+    Clone(): Validator<Context, Type>;
 }

package/build/compile/validator.mjs

@@ -1,10 +1,9 @@
 // deno-fmt-ignore-file
 import { Settings } from '../system/settings/index.mjs';
 import { Arguments } from '../system/arguments/index.mjs';
-import { Environment } from '../system/environment/index.mjs';
 import { Base } from '../type/index.mjs';
 import { Errors, Clean, Convert, Create, Default, Decode, Encode, HasCodec, Parser, ParseError } from '../value/index.mjs';
-import { Build } from '../schema/index.mjs';
+import { Build, BuildResult, EvaluateResult } from '../schema/index.mjs';
 // ------------------------------------------------------------------
 // Validator<...>
 // ------------------------------------------------------------------
@@ -13,27 +12,24 @@ export class Validator extends Base {
     constructor(...args) {
         super();
         const matched = Arguments.Match(args, {
-            6: (context, type, isEvalulated, hasCodec, code, check) => [context, type, isEvalulated, hasCodec, code, check],
+            3: (hasCodec, buildResult, evaluateResult) => [hasCodec, buildResult, evaluateResult],
             2: (context, type) => [context, type]
         });
-        if (matched.length === 6) {
-            const [context, type, isEvaluated, hasCodec, code, check] = matched;
-            this.context = context;
-            this.type = type;
-            this.isAccelerated = isEvaluated;
+        // Note: The Base type requires this Validator to be Clone, but where we cannot safely clone
+        // the BuildResult or the EvaluateResult. For now we pass the Validator constructor a shared 
+        // reference of BuildResult and EvaluateResult to mitigate re-compile on Clone. We must remove 
+        // this overload when Base is removed (memory-gc-ref)
+        if (matched.length === 3 && matched[1] instanceof BuildResult && matched[2] instanceof EvaluateResult) {
+            const [hasCodec, buildResult, evaluateResult] = matched;
             this.hasCodec = hasCodec;
-            this.code = code;
-            this.check = check;
+            this.buildResult = buildResult;
+            this.evaluateResult = evaluateResult;
         }
         else {
             const [context, type] = matched;
-            const result = Build(context, type).Evaluate();
             this.hasCodec = HasCodec(context, type);
-            this.context = context;
-            this.type = type;
-            this.isAccelerated = result.IsAccelerated;
-            this.code = result.Code;
-            this.check = result.Check;
+            this.buildResult = Build(context, type);
+            this.evaluateResult = this.buildResult.Evaluate();
         }
     }
     // ----------------------------------------------------------------
@@ -41,76 +37,85 @@ export class Validator extends Base {
     // ----------------------------------------------------------------
     /** Returns true if this Validator is using JIT acceleration. */
     IsAccelerated() {
-        return this.isAccelerated;
+        return this.evaluateResult.IsAccelerated();
     }
     // ----------------------------------------------------------------
-    // Context | Type
+    // Context & Type
     // ----------------------------------------------------------------
     /** Returns the Context for this validator. */
     Context() {
-        return this.context;
+        return this.buildResult.Context();
     }
     /** Returns the underlying Type used to construct this Validator. */
     Type() {
-        return this.type;
+        return this.buildResult.Schema();
     }
     // ----------------------------------------------------------------
     // Code
     // ----------------------------------------------------------------
     /** Returns the generated code for this validator. */
     Code() {
-        return this.code;
+        return this.evaluateResult.Code();
     }
     // ----------------------------------------------------------------
-    // Base<...>
+    // Standard Validator
     // ----------------------------------------------------------------
     /** Performs a type-guard check on the provided value. */
     Check(value) {
-        return this.check(value);
+        return this.evaluateResult.Check(value);
+    }
+    /** Validates a value and returns it. Will throw if invalid. */
+    Parse(value) {
+        const checked = this.Check(value);
+        if (checked)
+            return value;
+        if (Settings.Get().correctiveParse)
+            return Parser(this.Context(), this.Type(), value);
+        throw new ParseError(value, this.Errors(value));
     }
     /** Inspects a value and returns a detailed list of validation errors. */
     Errors(value) {
-        if (Environment.CanEvaluate() && this.check(value))
+        if (this.IsAccelerated() && this.Check(value))
             return [];
-        return Errors(this.context, this.type, value);
+        return Errors(this.Context(), this.Type(), value);
     }
+    // ----------------------------------------------------------------
+    // Value.* Operations
+    // ----------------------------------------------------------------
     /** Cleans a value using the Validator type. */
     Clean(value) {
-        return Clean(this.context, this.type, value);
+        return Clean(this.Context(), this.Type(), value);
     }
     /** Converts a value using the Validator type. */
     Convert(value) {
-        return Convert(this.context, this.type, value);
+        return Convert(this.Context(), this.Type(), value);
     }
     /** Creates a value using the Validator type. */
     Create() {
-        return Create(this.context, this.type);
+        return Create(this.Context(), this.Type());
     }
     /** Creates defaults using the Validator type. */
     Default(value) {
-        return Default(this.context, this.type, value);
-    }
-    /** Clones this validator. */
-    Clone() {
-        return new Validator(this.context, this.type, this.isAccelerated, this.hasCodec, this.code, this.check);
-    }
-    /** Validates a value and returns it. Will throw if invalid. */
-    Parse(value) {
-        const checked = this.Check(value);
-        if (checked)
-            return value;
-        if (Settings.Get().correctiveParse)
-            return Parser(this.context, this.type, value);
-        throw new ParseError(value, this.Errors(value));
+        return Default(this.Context(), this.Type(), value);
     }
     /** Decodes a value */
     Decode(value) {
-        const result = this.hasCodec ? Decode(this.context, this.type, value) : this.Parse(value);
+        const result = this.hasCodec ? Decode(this.Context(), this.Type(), value) : this.Parse(value);
         return result;
     }
     /** Encodes a value */
     Encode(value) {
-        const result = this.hasCodec ? Encode(this.context, this.type, value) : this.Parse(value);
+        const result = this.hasCodec ? Encode(this.Context(), this.Type(), value) : this.Parse(value);
         return result;
     }
+    // ----------------------------------------------------------------
+    // Deprecations
+    // ----------------------------------------------------------------
+    /**
+     * @deprecated Validator instances should not support Clone because they are owners of JIT evaluated functions. This function will be
+     * removed in the next version of TypeBox (relates to Type.Base deprecation)
+     */
+    Clone() {
+        return new Validator(this.hasCodec, this.buildResult, this.evaluateResult);
+    }
 }

package/build/schema/build.d.mts

@@ -1,19 +1,23 @@
 import * as Engine from './engine/index.mjs';
 import * as Schema from './types/index.mjs';
 export type CheckFunction = (value: unknown) => boolean;
-export interface EvaluateResult {
-    IsAccelerated: boolean;
-    Code: string;
-    Check: CheckFunction;
+export declare class EvaluateResult {
+    private readonly isAccelerated;
+    private readonly code;
+    private readonly check;
+    constructor(isAccelerated: boolean, code: string, check: CheckFunction);
+    IsAccelerated(): boolean;
+    Code(): string;
+    Check(value: unknown): boolean;
 }
 export declare class BuildResult {
     private readonly context;
     private readonly schema;
     private readonly external;
     private readonly functions;
-    private readonly call;
+    private readonly entry;
     private readonly useUnevaluated;
-    constructor(context: Record<PropertyKey, Schema.XSchema>, schema: Schema.XSchema, external: Engine.TExternal, functions: string[], call: string, useUnevaluated: boolean);
+    constructor(context: Record<PropertyKey, Schema.XSchema>, schema: Schema.XSchema, external: Engine.TExternal, functions: string[], entry: string, useUnevaluated: boolean);
     /** Returns the Context used for this build */
     Context(): Record<PropertyKey, Schema.XSchema>;
     /** Returns the Schema used for this build */
@@ -25,7 +29,7 @@ export declare class BuildResult {
     /** Returns check functions */
     Functions(): string[];
     /** Return entry function call. */
-    Call(): string;
+    Entry(): string;
     /** Evaluates the build into a validation function */
     Evaluate(): EvaluateResult;
 }

package/build/schema/build.mjs

@@ -12,8 +12,8 @@ import * as Engine from './engine/index.mjs';
 function CreateCode(build) {
     const functions = build.Functions().join(';\n');
     const statements = build.UseUnevaluated()
-        ? ['const context = new CheckContext({}, {})', `return ${build.Call()}`]
-        : [`return ${build.Call()}`];
+        ? ['const context = new CheckContext({}, {})', `return ${build.Entry()}`]
+        : [`return ${build.Entry()}`];
     return `${functions}; return (value) => { ${statements.join('; ')} }`;
 }
 // ------------------------------------------------------------------
@@ -40,15 +40,34 @@ function CreateCheck(build, code) {
         : CreateDynamicCheck(build);
 }
 // ------------------------------------------------------------------
+// EvaluateResult
+// ------------------------------------------------------------------
+export class EvaluateResult {
+    constructor(isAccelerated, code, check) {
+        this.isAccelerated = isAccelerated;
+        this.code = code;
+        this.check = check;
+    }
+    IsAccelerated() {
+        return this.isAccelerated;
+    }
+    Code() {
+        return this.code;
+    }
+    Check(value) {
+        return this.check(value);
+    }
+}
+// ------------------------------------------------------------------
 // BuildResult
 // ------------------------------------------------------------------
 export class BuildResult {
-    constructor(context, schema, external, functions, call, useUnevaluated) {
+    constructor(context, schema, external, functions, entry, useUnevaluated) {
         this.context = context;
         this.schema = schema;
         this.external = external;
         this.functions = functions;
-        this.call = call;
+        this.entry = entry;
         this.useUnevaluated = useUnevaluated;
     }
     /** Returns the Context used for this build */
@@ -72,14 +91,14 @@ export class BuildResult {
         return this.functions;
     }
     /** Return entry function call. */
-    Call() {
-        return this.call;
+    Entry() {
+        return this.entry;
     }
     /** Evaluates the build into a validation function */
     Evaluate() {
-        const Code = CreateCode(this);
-        const Check = CreateCheck(this, Code);
-        return { IsAccelerated: Environment.CanEvaluate(), Code, Check };
+        const code = CreateCode(this);
+        const check = CreateCheck(this, code);
+        return new EvaluateResult(Environment.CanEvaluate(), code, check);
     }
 }
 /** Builds a schema into a optimized runtime validator */

package/build/schema/compile.d.mts

@@ -2,8 +2,8 @@ import { type TLocalizedValidationError } from '../error/index.mjs';
 import { type Static } from '../type/types/static.mjs';
 import * as Schema from './types/index.mjs';
 export declare class Validator<const Schema extends Schema.XSchema = Schema.XSchema, Value extends unknown = Static<Schema>> {
-    private readonly build;
-    private readonly result;
+    private readonly buildResult;
+    private readonly evaluateResult;
     constructor(context: Record<string, Schema.XSchema>, schema: Schema);
     /** Returns true if this Validator is using JIT acceleration. */
     IsAccelerated(): boolean;

package/build/schema/compile.mjs

@@ -9,31 +9,31 @@ import { ParseError } from './parse.mjs';
 // ------------------------------------------------------------------
 export class Validator {
     constructor(context, schema) {
-        this.build = Build.Build(context, schema);
-        this.result = this.build.Evaluate();
+        this.buildResult = Build.Build(context, schema);
+        this.evaluateResult = this.buildResult.Evaluate();
     }
     /** Returns true if this Validator is using JIT acceleration. */
     IsAccelerated() {
-        return this.result.IsAccelerated;
+        return this.evaluateResult.IsAccelerated();
     }
     /** Returns the underlying Schema used to construct this Validator. */
     Schema() {
-        return this.build.Schema();
+        return this.buildResult.Schema();
     }
     /** Performs a type-guard check on the provided value. */
     Check(value) {
-        return this.result.Check(value);
+        return this.evaluateResult.Check(value);
     }
     /** Validates a value and returns it. Will throw if invalid. */
     Parse(value) {
-        if (this.result.Check(value))
+        if (this.evaluateResult.Check(value))
             return value;
-        const [_result, errors] = Errors(this.build.Context(), this.build.Schema(), value);
-        throw new ParseError(this.build.Schema(), value, errors);
+        const [_result, errors] = Errors(this.buildResult.Context(), this.buildResult.Schema(), value);
+        throw new ParseError(this.buildResult.Schema(), value, errors);
     }
     /** Inspects a value and returns a detailed list of validation errors. */
     Errors(value) {
-        return Errors(this.build.Context(), this.build.Schema(), value);
+        return Errors(this.buildResult.Context(), this.buildResult.Schema(), value);
     }
 }
 /** Compiles this schema into a high performance Validator */

package/build/schema/engine/additionalProperties.mjs

@@ -104,7 +104,7 @@ export function ErrorAdditionalProperties(stack, context, schemaPath, instancePa
     return isAdditionalProperties || context.AddError({
         keyword: 'additionalProperties',
         schemaPath,
-        instancePath: instancePath,
+        instancePath,
         params: { additionalProperties },
     });
 }

package/build/type/script/mapping.d.mts

@@ -164,10 +164,13 @@ export type TExtendsMapping<Input extends [unknown, unknown, unknown, unknown, u
 export declare function ExtendsMapping(input: [unknown, unknown, unknown, unknown, unknown, unknown] | []): unknown;
 export type TBaseMapping<Input extends [unknown, unknown, unknown] | unknown> = (Input extends ['(', infer Type extends T.TSchema, ')'] ? Type : Input extends infer Type extends T.TSchema ? Type : never);
 export declare function BaseMapping(input: [unknown, unknown, unknown] | unknown): unknown;
+export type TWithMapping<Input extends [unknown, unknown] | []> = (Input extends ['with', infer Options extends Record<PropertyKey, unknown>] ? Options : []);
+export declare function WithMapping(input: [unknown, unknown] | []): unknown;
 type TFactorIndexArray<Type extends T.TSchema, IndexArray extends unknown[]> = (IndexArray extends [infer Left extends T.TSchema[], ...infer Right extends unknown[]] ? (Left extends [infer Indexer extends T.TSchema] ? TFactorIndexArray<C.TIndexDeferred<Type, Indexer>, Right> : Left extends [] ? TFactorIndexArray<T.TArray<Type>, Right> : T.TNever) : Type);
 type TFactorExtends<Type extends T.TSchema, Extends extends unknown[]> = (Extends extends [infer Right extends T.TSchema, infer True extends T.TSchema, infer False extends T.TSchema] ? C.TConditionalDeferred<Type, Right, True, False> : Type);
-export type TFactorMapping<Input extends [unknown, unknown, unknown, unknown]> = (Input extends [infer KeyOf extends boolean, infer Type extends T.TSchema, infer IndexArray extends unknown[], infer Extend extends unknown[]] ? KeyOf extends true ? TFactorExtends<C.TKeyOfDeferred<TFactorIndexArray<Type, IndexArray>>, Extend> : TFactorExtends<TFactorIndexArray<Type, IndexArray>, Extend> : never);
-export declare function FactorMapping(input: [unknown, unknown, unknown, unknown]): unknown;
+type TFactorWith<Type extends T.TSchema, With extends unknown> = (With extends Record<PropertyKey, unknown> ? C.TOptionsDeferred<Type, With> : Type);
+export type TFactorMapping<Input extends [unknown, unknown, unknown, unknown, unknown]> = (Input extends [infer KeyOf extends boolean, infer Type extends T.TSchema, infer IndexArray extends unknown[], infer Extend extends unknown[], infer WithClause extends unknown] ? TFactorWith<KeyOf extends true ? TFactorExtends<C.TKeyOfDeferred<TFactorIndexArray<Type, IndexArray>>, Extend> : TFactorExtends<TFactorIndexArray<Type, IndexArray>, Extend>, WithClause> : never);
+export declare function FactorMapping(input: [unknown, unknown, unknown, unknown, unknown]): unknown;
 type TExprBinaryMapping<Left extends T.TSchema, Rest extends unknown[]> = (Rest extends [infer Operator extends unknown, infer Right extends T.TSchema, infer Next extends unknown[]] ? (TExprBinaryMapping<Right, Next> extends infer Schema extends T.TSchema ? (Operator extends '&' ? (Schema extends T.TIntersect<infer Types extends T.TSchema[]> ? T.TIntersect<[Left, ...Types]> : T.TIntersect<[Left, Schema]>) : Operator extends '|' ? (Schema extends T.TUnion<infer Types extends T.TSchema[]> ? T.TUnion<[Left, ...Types]> : T.TUnion<[Left, Schema]>) : never) : never) : Left);
 export type TExprTermTailMapping<Input extends [unknown, unknown, unknown] | []> = (Input);
 export declare function ExprTermTailMapping(input: [unknown, unknown, unknown] | []): unknown;

package/build/type/script/mapping.mjs

@@ -185,27 +185,34 @@ export function BaseMapping(input) {
         ? input[1]
         : input;
 }
+export function WithMapping(input) {
+    return Guard.IsEqual(input.length, 2) ? input[1] : [];
+}
 // deno-coverage-ignore-start
-// ...
-const FactorIndexArray = (Type, indexArray) => {
+function FactorIndexArray(Type, indexArray) {
     return indexArray.reduce((result, left) => {
         const _left = left;
         return (Guard.IsEqual(_left.length, 1) ? C.IndexDeferred(result, _left[0]) :
             Guard.IsEqual(_left.length, 0) ? T.Array(result) :
                 Unreachable());
     }, Type);
-};
+}
 // deno-coverage-ignore-stop
-const FactorExtends = (type, extend) => {
+function FactorExtends(type, extend) {
     return Guard.IsEqual(extend.length, 3)
         ? C.ConditionalDeferred(type, extend[0], extend[1], extend[2])
         : type;
-};
+}
+function FactorWith(type, withClause) {
+    return Guard.IsArray(withClause) && Guard.IsEqual(withClause.length, 0)
+        ? type
+        : C.OptionsDeferred(type, withClause);
+}
 export function FactorMapping(input) {
-    const [keyOf, type, indexArray, extend] = input;
-    return keyOf
+    const [keyOf, type, indexArray, extend, withClause] = input;
+    return FactorWith(keyOf
         ? FactorExtends(C.KeyOfDeferred(FactorIndexArray(type, indexArray)), extend)
-        : FactorExtends(FactorIndexArray(type, indexArray), extend);
+        : FactorExtends(FactorIndexArray(type, indexArray), extend), withClause);
 }
 // deno-coverage-ignore-start
 function ExprBinaryMapping(left, rest) {

package/build/type/script/parser.d.mts

@@ -43,7 +43,8 @@ export type TIndexArray_0<Input extends string, Result extends unknown[] = []> =
 export type TIndexArray<Input extends string> = TIndexArray_0<Input> extends [infer _0 extends ([unknown, unknown, unknown] | [unknown, unknown])[], infer Input extends string] ? [S.TIndexArrayMapping<_0>, Input] : [];
 export type TExtends<Input extends string> = ((Token.TConst<'extends', Input> extends [infer _0, infer Input extends string] ? (TType<Input> extends [infer _1, infer Input extends string] ? (Token.TConst<'?', Input> extends [infer _2, infer Input extends string] ? (TType<Input> extends [infer _3, infer Input extends string] ? (Token.TConst<':', Input> extends [infer _4, infer Input extends string] ? (TType<Input> extends [infer _5, infer Input extends string] ? [[_0, _1, _2, _3, _4, _5], Input] : []) : []) : []) : []) : []) : []) extends [infer _0, infer Input extends string] ? [_0, Input] : [[], Input] extends [infer _0, infer Input extends string] ? [_0, Input] : []) extends [infer _0 extends [unknown, unknown, unknown, unknown, unknown, unknown] | [], infer Input extends string] ? [S.TExtendsMapping<_0>, Input] : [];
 export type TBase<Input extends string> = ((Token.TConst<'(', Input> extends [infer _0, infer Input extends string] ? (TType<Input> extends [infer _1, infer Input extends string] ? (Token.TConst<')', Input> extends [infer _2, infer Input extends string] ? [[_0, _1, _2], Input] : []) : []) : []) extends [infer _0, infer Input extends string] ? [_0, Input] : TKeyword<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : T_Object_<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : TTuple<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : TTemplateLiteral<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : TLiteral<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : TConstructor<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : T_Function_<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : TMapped<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : TOptions<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : TGenericCall<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : TReference<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : []) extends [infer _0 extends [unknown, unknown, unknown] | unknown, infer Input extends string] ? [S.TBaseMapping<_0>, Input] : [];
-export type TFactor<Input extends string> = (TKeyOf<Input> extends [infer _0, infer Input extends string] ? (TBase<Input> extends [infer _1, infer Input extends string] ? (TIndexArray<Input> extends [infer _2, infer Input extends string] ? (TExtends<Input> extends [infer _3, infer Input extends string] ? [[_0, _1, _2, _3], Input] : []) : []) : []) : []) extends [infer _0 extends [unknown, unknown, unknown, unknown], infer Input extends string] ? [S.TFactorMapping<_0>, Input] : [];
+export type TWith<Input extends string> = ((Token.TConst<'with', Input> extends [infer _0, infer Input extends string] ? (TJsonObject<Input> extends [infer _1, infer Input extends string] ? [[_0, _1], Input] : []) : []) extends [infer _0, infer Input extends string] ? [_0, Input] : [[], Input] extends [infer _0, infer Input extends string] ? [_0, Input] : []) extends [infer _0 extends [unknown, unknown] | [], infer Input extends string] ? [S.TWithMapping<_0>, Input] : [];
+export type TFactor<Input extends string> = (TKeyOf<Input> extends [infer _0, infer Input extends string] ? (TBase<Input> extends [infer _1, infer Input extends string] ? (TIndexArray<Input> extends [infer _2, infer Input extends string] ? (TExtends<Input> extends [infer _3, infer Input extends string] ? (TWith<Input> extends [infer _4, infer Input extends string] ? [[_0, _1, _2, _3, _4], Input] : []) : []) : []) : []) : []) extends [infer _0 extends [unknown, unknown, unknown, unknown, unknown], infer Input extends string] ? [S.TFactorMapping<_0>, Input] : [];
 export type TExprTermTail<Input extends string> = ((Token.TConst<'&', Input> extends [infer _0, infer Input extends string] ? (TFactor<Input> extends [infer _1, infer Input extends string] ? (TExprTermTail<Input> extends [infer _2, infer Input extends string] ? [[_0, _1, _2], Input] : []) : []) : []) extends [infer _0, infer Input extends string] ? [_0, Input] : [[], Input] extends [infer _0, infer Input extends string] ? [_0, Input] : []) extends [infer _0 extends [unknown, unknown, unknown] | [], infer Input extends string] ? [S.TExprTermTailMapping<_0>, Input] : [];
 export type TExprTerm<Input extends string> = (TFactor<Input> extends [infer _0, infer Input extends string] ? (TExprTermTail<Input> extends [infer _1, infer Input extends string] ? [[_0, _1], Input] : []) : []) extends [infer _0 extends [unknown, unknown], infer Input extends string] ? [S.TExprTermMapping<_0>, Input] : [];
 export type TExprTail<Input extends string> = ((Token.TConst<'|', Input> extends [infer _0, infer Input extends string] ? (TExprTerm<Input> extends [infer _1, infer Input extends string] ? (TExprTail<Input> extends [infer _2, infer Input extends string] ? [[_0, _1, _2], Input] : []) : []) : []) extends [infer _0, infer Input extends string] ? [_0, Input] : [[], Input] extends [infer _0, infer Input extends string] ? [_0, Input] : []) extends [infer _0 extends [unknown, unknown, unknown] | [], infer Input extends string] ? [S.TExprTailMapping<_0>, Input] : [];
@@ -172,6 +173,7 @@ export declare const IndexArray_0: (input: string, result?: unknown[]) => [unkno
 export declare const IndexArray: (input: string) => [unknown, string] | [];
 export declare const Extends: (input: string) => [unknown, string] | [];
 export declare const Base: (input: string) => [unknown, string] | [];
+export declare const With: (input: string) => [unknown, string] | [];
 export declare const Factor: (input: string) => [unknown, string] | [];
 export declare const ExprTermTail: (input: string) => [unknown, string] | [];
 export declare const ExprTerm: (input: string) => [unknown, string] | [];

package/build/type/script/parser.mjs

@@ -47,7 +47,8 @@ export const IndexArray_0 = (input, result = []) => If(If(If(Token.Const('[', in
 export const IndexArray = (input) => If(IndexArray_0(input), ([_0, input]) => [S.IndexArrayMapping(_0), input]);
 export const Extends = (input) => If(If(If(Token.Const('extends', input), ([_0, input]) => If(Type(input), ([_1, input]) => If(Token.Const('?', input), ([_2, input]) => If(Type(input), ([_3, input]) => If(Token.Const(':', input), ([_4, input]) => If(Type(input), ([_5, input]) => [[_0, _1, _2, _3, _4, _5], input])))))), ([_0, input]) => [_0, input], () => If([[], input], ([_0, input]) => [_0, input], () => [])), ([_0, input]) => [S.ExtendsMapping(_0), input]);
 export const Base = (input) => If(If(If(Token.Const('(', input), ([_0, input]) => If(Type(input), ([_1, input]) => If(Token.Const(')', input), ([_2, input]) => [[_0, _1, _2], input]))), ([_0, input]) => [_0, input], () => If(Keyword(input), ([_0, input]) => [_0, input], () => If(_Object_(input), ([_0, input]) => [_0, input], () => If(Tuple(input), ([_0, input]) => [_0, input], () => If(TemplateLiteral(input), ([_0, input]) => [_0, input], () => If(Literal(input), ([_0, input]) => [_0, input], () => If(Constructor(input), ([_0, input]) => [_0, input], () => If(_Function_(input), ([_0, input]) => [_0, input], () => If(Mapped(input), ([_0, input]) => [_0, input], () => If(Options(input), ([_0, input]) => [_0, input], () => If(GenericCall(input), ([_0, input]) => [_0, input], () => If(Reference(input), ([_0, input]) => [_0, input], () => [])))))))))))), ([_0, input]) => [S.BaseMapping(_0), input]);
-export const Factor = (input) => If(If(KeyOf(input), ([_0, input]) => If(Base(input), ([_1, input]) => If(IndexArray(input), ([_2, input]) => If(Extends(input), ([_3, input]) => [[_0, _1, _2, _3], input])))), ([_0, input]) => [S.FactorMapping(_0), input]);
+export const With = (input) => If(If(If(Token.Const('with', input), ([_0, input]) => If(JsonObject(input), ([_1, input]) => [[_0, _1], input])), ([_0, input]) => [_0, input], () => If([[], input], ([_0, input]) => [_0, input], () => [])), ([_0, input]) => [S.WithMapping(_0), input]);
+export const Factor = (input) => If(If(KeyOf(input), ([_0, input]) => If(Base(input), ([_1, input]) => If(IndexArray(input), ([_2, input]) => If(Extends(input), ([_3, input]) => If(With(input), ([_4, input]) => [[_0, _1, _2, _3, _4], input]))))), ([_0, input]) => [S.FactorMapping(_0), input]);
 export const ExprTermTail = (input) => If(If(If(Token.Const('&', input), ([_0, input]) => If(Factor(input), ([_1, input]) => If(ExprTermTail(input), ([_2, input]) => [[_0, _1, _2], input]))), ([_0, input]) => [_0, input], () => If([[], input], ([_0, input]) => [_0, input], () => [])), ([_0, input]) => [S.ExprTermTailMapping(_0), input]);
 export const ExprTerm = (input) => If(If(Factor(input), ([_0, input]) => If(ExprTermTail(input), ([_1, input]) => [[_0, _1], input])), ([_0, input]) => [S.ExprTermMapping(_0), input]);
 export const ExprTail = (input) => If(If(If(Token.Const('|', input), ([_0, input]) => If(ExprTerm(input), ([_1, input]) => If(ExprTail(input), ([_2, input]) => [[_0, _1, _2], input]))), ([_0, input]) => [_0, input], () => If([[], input], ([_0, input]) => [_0, input], () => [])), ([_0, input]) => [S.ExprTailMapping(_0), input]);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typebox",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
-  "version": "1.1.37",
+  "version": "1.1.39",
   "keywords": [
     "typescript",
     "jsonschema"
@@ -16,22 +16,6 @@
   "types": "./build/index.d.mts",
   "module": "./build/index.mjs",
   "exports": {
-    "./guard": {
-      "import": "./build/guard/index.mjs",
-      "default": "./build/guard/index.mjs"
-    },
-    "./error": {
-      "import": "./build/error/index.mjs",
-      "default": "./build/error/index.mjs"
-    },
-    "./compile": {
-      "import": "./build/compile/index.mjs",
-      "default": "./build/compile/index.mjs"
-    },
-    "./system": {
-      "import": "./build/system/index.mjs",
-      "default": "./build/system/index.mjs"
-    },
     "./format": {
       "import": "./build/format/index.mjs",
       "default": "./build/format/index.mjs"
@@ -44,10 +28,26 @@
       "import": "./build/schema/index.mjs",
       "default": "./build/schema/index.mjs"
     },
+    "./compile": {
+      "import": "./build/compile/index.mjs",
+      "default": "./build/compile/index.mjs"
+    },
     "./value": {
       "import": "./build/value/index.mjs",
       "default": "./build/value/index.mjs"
     },
+    "./guard": {
+      "import": "./build/guard/index.mjs",
+      "default": "./build/guard/index.mjs"
+    },
+    "./system": {
+      "import": "./build/system/index.mjs",
+      "default": "./build/system/index.mjs"
+    },
+    "./error": {
+      "import": "./build/error/index.mjs",
+      "default": "./build/error/index.mjs"
+    },
     ".": {
       "import": "./build/index.mjs",
       "default": "./build/index.mjs"
@@ -55,18 +55,6 @@
   },
   "typesVersions": {
     "*": {
-      "guard": [
-        "./build/guard/index.d.mts"
-      ],
-      "error": [
-        "./build/error/index.d.mts"
-      ],
-      "compile": [
-        "./build/compile/index.d.mts"
-      ],
-      "system": [
-        "./build/system/index.d.mts"
-      ],
       "format": [
         "./build/format/index.d.mts"
       ],
@@ -76,9 +64,21 @@
       "schema": [
         "./build/schema/index.d.mts"
       ],
+      "compile": [
+        "./build/compile/index.d.mts"
+      ],
       "value": [
         "./build/value/index.d.mts"
       ],
+      "guard": [
+        "./build/guard/index.d.mts"
+      ],
+      "system": [
+        "./build/system/index.d.mts"
+      ],
+      "error": [
+        "./build/error/index.d.mts"
+      ],
       ".": [
         "./build/index.d.mts"
       ]

package/readme.md

@@ -52,7 +52,7 @@ type T = Type.Static<typeof T>              // type T = {
 
 TypeBox is a runtime type system that creates in-memory JSON Schema objects that infer as TypeScript types. The schematics produced by this library are designed to match the static type checking rules of the TypeScript compiler. TypeBox offers a unified type system that can be statically checked by TypeScript and validated at runtime using standard JSON Schema.
 
-This library is designed to allow JSON Schema to compose similar to how types compose within TypeScript's type system. It can be used as a simple tool to build up complex schematics or integrated into REST, RPC and MCP services to help validate data received over the wire.
+This library is designed to allow JSON Schema to compose similar to how types compose within TypeScript's type system. It can be used as a simple tool to build up complex schematics or integrated into REST and RPC services to help validate data received over the wire.
 
 License: MIT
 
@@ -281,29 +281,29 @@ The following table shows compile performance for various JSON Schema structures
 ┌──────────────────────┬─────────────┬─────────────┐
 │ Compile              │ TB1X        │ AJV8        │
 ├──────────────────────┼─────────────┼─────────────┤
-│ Boolean              │ 28.4K ops/s │    7K ops/s │
-│ Number               │ 21.8K ops/s │  7.7K ops/s │
-│ String               │ 47.8K ops/s │  7.3K ops/s │
-│ Null                 │ 35.6K ops/s │  7.8K ops/s │
-│ Literal_String       │ 28.6K ops/s │  6.3K ops/s │
-│ Literal_Number       │ 46.6K ops/s │  6.2K ops/s │
-│ Literal_Boolean      │ 40.8K ops/s │  6.6K ops/s │
-│ Pattern              │ 29.7K ops/s │  4.9K ops/s │
-│ Object_Open          │  6.8K ops/s │  1.1K ops/s │
-│ Object_Close         │  7.4K ops/s │   833 ops/s │
-│ Object_Vector3       │ 19.4K ops/s │  2.1K ops/s │
-│ Object_Basis3        │    6K ops/s │   895 ops/s │
-│ Intersect_And        │   12K ops/s │  3.5K ops/s │
-│ Intersect_Structural │  8.4K ops/s │  1.1K ops/s │
-│ Union_Or             │ 18.2K ops/s │  2.5K ops/s │
-│ Union_Structural     │ 10.9K ops/s │  1.3K ops/s │
-│ Tuple_Values         │  7.3K ops/s │  1.6K ops/s │
-│ Tuple_Objects        │  1.9K ops/s │   339 ops/s │
-│ Array_Numbers_4      │ 29.9K ops/s │  3.4K ops/s │
-│ Array_Numbers_8      │ 20.3K ops/s │  3.4K ops/s │
-│ Array_Numbers_16     │ 29.4K ops/s │  3.3K ops/s │
-│ Array_Objects_Open   │  6.3K ops/s │   684 ops/s │
-│ Array_Objects_Close  │  7.3K ops/s │   762 ops/s │
+│ Boolean              │ 29.2K ops/s │  7.1K ops/s │
+│ Number               │ 34.5K ops/s │  7.6K ops/s │
+│ String               │ 48.9K ops/s │  8.7K ops/s │
+│ Null                 │ 39.6K ops/s │  7.6K ops/s │
+│ Literal_String       │ 46.8K ops/s │  6.8K ops/s │
+│ Literal_Number       │ 48.3K ops/s │  7.4K ops/s │
+│ Literal_Boolean      │ 48.8K ops/s │  7.3K ops/s │
+│ Pattern              │ 32.5K ops/s │  6.1K ops/s │
+│ Object_Open          │  6.6K ops/s │  1.4K ops/s │
+│ Object_Close         │  7.6K ops/s │    1K ops/s │
+│ Object_Vector3       │ 20.8K ops/s │  2.8K ops/s │
+│ Object_Basis3        │  7.5K ops/s │    1K ops/s │
+│ Intersect_And        │   23K ops/s │  3.9K ops/s │
+│ Intersect_Structural │  8.7K ops/s │  1.2K ops/s │
+│ Union_Or             │ 17.9K ops/s │  3.4K ops/s │
+│ Union_Structural     │ 11.3K ops/s │  2.1K ops/s │
+│ Tuple_Values         │  9.6K ops/s │  2.1K ops/s │
+│ Tuple_Objects        │  2.1K ops/s │   350 ops/s │
+│ Array_Numbers_4      │ 33.6K ops/s │  4.2K ops/s │
+│ Array_Numbers_8      │   39K ops/s │  3.7K ops/s │
+│ Array_Numbers_16     │ 29.6K ops/s │  3.8K ops/s │
+│ Array_Objects_Open   │  7.7K ops/s │   833 ops/s │
+│ Array_Objects_Close  │  7.6K ops/s │   860 ops/s │
 └──────────────────────┴─────────────┴─────────────┘
 ```
 
@@ -314,29 +314,29 @@ The following tables shows validation performance for various JSON Schema struct
 ┌──────────────────────┬──────────────┬──────────────┐
 │ Validate             │ TB1X         │ AJV8         │
 ├──────────────────────┼──────────────┼──────────────┤
-│ Boolean              │ 164.1M ops/s │ 181.5M ops/s │
-│ Number               │   107M ops/s │  50.2M ops/s │
-│ String               │ 102.2M ops/s │  61.9M ops/s │
-│ Null                 │ 112.1M ops/s │  48.2M ops/s │
-│ Literal_String       │ 102.8M ops/s │  61.5M ops/s │
-│ Literal_Number       │ 109.1M ops/s │  46.4M ops/s │
-│ Literal_Boolean      │ 109.6M ops/s │  63.3M ops/s │
-│ Pattern              │  24.7M ops/s │  20.3M ops/s │
-│ Object_Open          │  75.4M ops/s │  37.3M ops/s │
-│ Object_Close         │  35.9M ops/s │  21.9M ops/s │
-│ Object_Vector3       │  77.6M ops/s │  47.4M ops/s │
-│ Object_Basis3        │    37M ops/s │  24.3M ops/s │
-│ Intersect_And        │  93.3M ops/s │  61.1M ops/s │
-│ Intersect_Structural │    83M ops/s │  36.4M ops/s │
-│ Union_Or             │  99.7M ops/s │   8.6M ops/s │
-│ Union_Structural     │  81.3M ops/s │  43.5M ops/s │
-│ Tuple_Values         │  72.4M ops/s │  41.7M ops/s │
-│ Tuple_Objects        │  32.6M ops/s │  22.4M ops/s │
-│ Array_Numbers_4      │  94.1M ops/s │  42.8M ops/s │
-│ Array_Numbers_8      │  90.6M ops/s │  42.3M ops/s │
-│ Array_Numbers_16     │  77.5M ops/s │  40.2M ops/s │
-│ Array_Objects_Open   │  26.3M ops/s │  19.6M ops/s │
-│ Array_Objects_Close  │   9.1M ops/s │    10M ops/s │
+│ Boolean              │ 192.2M ops/s │ 189.5M ops/s │
+│ Number               │ 112.4M ops/s │    61M ops/s │
+│ String               │ 113.7M ops/s │  64.1M ops/s │
+│ Null                 │ 112.8M ops/s │  64.9M ops/s │
+│ Literal_String       │   108M ops/s │  62.9M ops/s │
+│ Literal_Number       │ 113.5M ops/s │  63.2M ops/s │
+│ Literal_Boolean      │ 109.2M ops/s │  64.1M ops/s │
+│ Pattern              │  26.5M ops/s │  22.4M ops/s │
+│ Object_Open          │    78M ops/s │  47.2M ops/s │
+│ Object_Close         │  38.6M ops/s │  27.6M ops/s │
+│ Object_Vector3       │    91M ops/s │  51.3M ops/s │
+│ Object_Basis3        │  41.1M ops/s │  27.4M ops/s │
+│ Intersect_And        │ 107.6M ops/s │  59.9M ops/s │
+│ Intersect_Structural │  83.6M ops/s │  46.3M ops/s │
+│ Union_Or             │    95M ops/s │   7.9M ops/s │
+│ Union_Structural     │  84.5M ops/s │  52.3M ops/s │
+│ Tuple_Values         │  74.7M ops/s │    53M ops/s │
+│ Tuple_Objects        │  32.9M ops/s │  22.3M ops/s │
+│ Array_Numbers_4      │  93.3M ops/s │  55.1M ops/s │
+│ Array_Numbers_8      │  90.3M ops/s │  50.8M ops/s │
+│ Array_Numbers_16     │  76.8M ops/s │  39.6M ops/s │
+│ Array_Objects_Open   │  28.7M ops/s │  20.4M ops/s │
+│ Array_Objects_Close  │  10.3M ops/s │  10.8M ops/s │
 └──────────────────────┴──────────────┴──────────────┘
 ```