@sinclair/typebox 0.34.24 → 0.34.26

package/build/esm/parser/runtime/types.d.mts

@@ -1,4 +1,6 @@
 export type IModuleProperties = Record<PropertyKey, IParser>;
+/** Force output static type evaluation for Arrays */
+export type StaticEnsure<T> = T extends infer R ? R : never;
 /** Infers the Output Parameter for a Parser */
 export type StaticParser<Parser extends IParser> = Parser extends IParser<infer Output extends unknown> ? Output : unknown;
 export type IMapping<Input extends unknown = any, Output extends unknown = unknown> = (input: Input, context: any) => Output;
@@ -10,59 +12,87 @@ export interface IParser<Output extends unknown = unknown> {
     type: string;
     mapping: IMapping<any, Output>;
 }
-export type TupleParameter<Parsers extends IParser[], Result extends unknown[] = []> = Parsers extends [infer L extends IParser, ...infer R extends IParser[]] ? TupleParameter<R, [...Result, StaticParser<L>]> : Result;
-export interface ITuple<Output extends unknown = unknown> extends IParser<Output> {
-    type: 'Tuple';
-    parsers: IParser[];
+export type ContextParameter<_Left extends IParser, Right extends IParser> = (StaticParser<Right>);
+export interface IContext<Output extends unknown = unknown> extends IParser<Output> {
+    type: 'Context';
+    left: IParser;
+    right: IParser;
 }
-/** Creates a Tuple parser */
-export declare function Tuple<Parsers extends IParser[], Mapping extends IMapping = IMapping<TupleParameter<Parsers>>>(parsers: [...Parsers], mapping: Mapping): ITuple<ReturnType<Mapping>>;
-/** Creates a Tuple parser */
-export declare function Tuple<Parsers extends IParser[]>(parsers: [...Parsers]): ITuple<TupleParameter<Parsers>>;
-export type UnionParameter<Parsers extends IParser[], Result extends unknown = never> = Parsers extends [infer L extends IParser, ...infer R extends IParser[]] ? UnionParameter<R, Result | StaticParser<L>> : Result;
-export interface IUnion<Output extends unknown = unknown> extends IParser<Output> {
-    type: 'Union';
-    parsers: IParser[];
+/** `[Context]` Creates a Context Parser */
+export declare function Context<Left extends IParser, Right extends IParser, Mapping extends IMapping = IMapping<ContextParameter<Left, Right>>>(left: Left, right: Right, mapping: Mapping): IContext<ReturnType<Mapping>>;
+/** `[Context]` Creates a Context Parser */
+export declare function Context<Left extends IParser, Right extends IParser>(left: Left, right: Right): IContext<ContextParameter<Left, Right>>;
+export type ArrayParameter<Parser extends IParser> = StaticEnsure<StaticParser<Parser>[]>;
+export interface IArray<Output extends unknown = unknown> extends IParser<Output> {
+    type: 'Array';
+    parser: IParser;
 }
-/** Creates a Union parser */
-export declare function Union<Parsers extends IParser[], Mapping extends IMapping = IMapping<UnionParameter<Parsers>>>(parsers: [...Parsers], mapping: Mapping): IUnion<ReturnType<Mapping>>;
-/** Creates a Union parser */
-export declare function Union<Parsers extends IParser[]>(parsers: [...Parsers]): IUnion<UnionParameter<Parsers>>;
+/** `[EBNF]` Creates an Array Parser */
+export declare function Array<Parser extends IParser, Mapping extends IMapping = IMapping<ArrayParameter<Parser>>>(parser: Parser, mapping: Mapping): IArray<ReturnType<Mapping>>;
+/** `[EBNF]` Creates an Array Parser */
+export declare function Array<Parser extends IParser>(parser: Parser): IArray<ArrayParameter<Parser>>;
 export interface IConst<Output extends unknown = unknown> extends IParser<Output> {
     type: 'Const';
     value: string;
 }
-/** Creates a Const parser */
+/** `[TERM]` Creates a Const Parser */
 export declare function Const<Value extends string, Mapping extends IMapping<Value>>(value: Value, mapping: Mapping): IConst<ReturnType<Mapping>>;
-/** Creates a Const parser */
+/** `[TERM]` Creates a Const Parser */
 export declare function Const<Value extends string>(value: Value): IConst<Value>;
 export interface IRef<Output extends unknown = unknown> extends IParser<Output> {
     type: 'Ref';
     ref: string;
 }
-/** Creates a Ref parser */
+/** `[BNF]` Creates a Ref Parser. This Parser can only be used in the context of a Module */
 export declare function Ref<Type extends unknown, Mapping extends IMapping<Type>>(ref: string, mapping: Mapping): IRef<ReturnType<Mapping>>;
-/** Creates a Ref parser */
+/** `[BNF]` Creates a Ref Parser. This Parser can only be used in the context of a Module */
 export declare function Ref<Type extends unknown>(ref: string): IRef<Type>;
 export interface IString<Output extends unknown = unknown> extends IParser<Output> {
     type: 'String';
     options: string[];
 }
-/** Creates a String Parser. Options are an array of permissable quote characters */
+/** `[TERM]` Creates a String Parser. Options are an array of permissable quote characters */
 export declare function String<Mapping extends IMapping<string>>(options: string[], mapping: Mapping): IString<ReturnType<Mapping>>;
-/** Creates a String Parser. Options are an array of permissable quote characters */
+/** `[TERM]` Creates a String Parser. Options are an array of permissable quote characters */
 export declare function String(options: string[]): IString<string>;
 export interface IIdent<Output extends unknown = unknown> extends IParser<Output> {
     type: 'Ident';
 }
-/** Creates an Ident parser */
+/** `[TERM]` Creates an Ident Parser where Ident matches any valid JavaScript identifier */
 export declare function Ident<Mapping extends IMapping<string>>(mapping: Mapping): IIdent<ReturnType<Mapping>>;
-/** Creates an Ident parser */
+/** `[TERM]` Creates an Ident Parser where Ident matches any valid JavaScript identifier */
 export declare function Ident(): IIdent<string>;
 export interface INumber<Output extends unknown = unknown> extends IParser<Output> {
     type: 'Number';
 }
-/** Creates a Number parser */
+/** `[TERM]` Creates an Number Parser */
 export declare function Number<Mapping extends IMapping<string>>(mapping: Mapping): INumber<ReturnType<Mapping>>;
-/** Creates a Number parser */
+/** `[TERM]` Creates an Number Parser */
 export declare function Number(): INumber<string>;
+export type OptionalParameter<Parser extends IParser, Result extends unknown = [StaticParser<Parser>] | []> = (Result);
+export interface IOptional<Output extends unknown = unknown> extends IParser<Output> {
+    type: 'Optional';
+    parser: IParser;
+}
+/** `[EBNF]` Creates an Optional Parser */
+export declare function Optional<Parser extends IParser, Mapping extends IMapping = IMapping<OptionalParameter<Parser>>>(parser: Parser, mapping: Mapping): IOptional<ReturnType<Mapping>>;
+/** `[EBNF]` Creates an Optional Parser */
+export declare function Optional<Parser extends IParser>(parser: Parser): IOptional<OptionalParameter<Parser>>;
+export type TupleParameter<Parsers extends IParser[], Result extends unknown[] = []> = StaticEnsure<Parsers extends [infer Left extends IParser, ...infer Right extends IParser[]] ? TupleParameter<Right, [...Result, StaticEnsure<StaticParser<Left>>]> : Result>;
+export interface ITuple<Output extends unknown = unknown> extends IParser<Output> {
+    type: 'Tuple';
+    parsers: IParser[];
+}
+/** `[BNF]` Creates a Tuple Parser */
+export declare function Tuple<Parsers extends IParser[], Mapping extends IMapping = IMapping<TupleParameter<Parsers>>>(parsers: [...Parsers], mapping: Mapping): ITuple<ReturnType<Mapping>>;
+/** `[BNF]` Creates a Tuple Parser */
+export declare function Tuple<Parsers extends IParser[]>(parsers: [...Parsers]): ITuple<TupleParameter<Parsers>>;
+export type UnionParameter<Parsers extends IParser[], Result extends unknown = never> = StaticEnsure<Parsers extends [infer Left extends IParser, ...infer Right extends IParser[]] ? UnionParameter<Right, Result | StaticParser<Left>> : Result>;
+export interface IUnion<Output extends unknown = unknown> extends IParser<Output> {
+    type: 'Union';
+    parsers: IParser[];
+}
+/** `[BNF]` Creates a Union parser */
+export declare function Union<Parsers extends IParser[], Mapping extends IMapping = IMapping<UnionParameter<Parsers>>>(parsers: [...Parsers], mapping: Mapping): IUnion<ReturnType<Mapping>>;
+/** `[BNF]` Creates a Union parser */
+export declare function Union<Parsers extends IParser[]>(parsers: [...Parsers]): IUnion<UnionParameter<Parsers>>;

package/build/esm/parser/runtime/types.mjs

@@ -1,32 +1,55 @@
 /** Maps input to output. This is the default Mapping */
 export const Identity = (value) => value;
 /** Maps the output as the given parameter T */
+// prettier-ignore
 export const As = (mapping) => (_) => mapping;
-export function Tuple(...args) {
-    const [parsers, mapping] = args.length === 2 ? [args[0], args[1]] : [args[0], Identity];
-    return { type: 'Tuple', parsers, mapping };
+/** `[Context]` Creates a Context Parser */
+export function Context(...args) {
+    const [left, right, mapping] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], args[1], Identity];
+    return { type: 'Context', left, right, mapping };
 }
-export function Union(...args) {
-    const [parsers, mapping] = args.length === 2 ? [args[0], args[1]] : [args[0], Identity];
-    return { type: 'Union', parsers, mapping };
+/** `[EBNF]` Creates an Array Parser */
+export function Array(...args) {
+    const [parser, mapping] = args.length === 2 ? [args[0], args[1]] : [args[0], Identity];
+    return { type: 'Array', parser, mapping };
 }
+/** `[TERM]` Creates a Const Parser */
 export function Const(...args) {
     const [value, mapping] = args.length === 2 ? [args[0], args[1]] : [args[0], Identity];
     return { type: 'Const', value, mapping };
 }
+/** `[BNF]` Creates a Ref Parser. This Parser can only be used in the context of a Module */
 export function Ref(...args) {
     const [ref, mapping] = args.length === 2 ? [args[0], args[1]] : [args[0], Identity];
     return { type: 'Ref', ref, mapping };
 }
+/** `[TERM]` Creates a String Parser. Options are an array of permissable quote characters */
 export function String(...params) {
     const [options, mapping] = params.length === 2 ? [params[0], params[1]] : [params[0], Identity];
     return { type: 'String', options, mapping };
 }
+/** `[TERM]` Creates an Ident Parser where Ident matches any valid JavaScript identifier */
 export function Ident(...params) {
     const mapping = params.length === 1 ? params[0] : Identity;
     return { type: 'Ident', mapping };
 }
+/** `[TERM]` Creates an Number Parser */
 export function Number(...params) {
     const mapping = params.length === 1 ? params[0] : Identity;
     return { type: 'Number', mapping };
 }
+/** `[EBNF]` Creates an Optional Parser */
+export function Optional(...args) {
+    const [parser, mapping] = args.length === 2 ? [args[0], args[1]] : [args[0], Identity];
+    return { type: 'Optional', parser, mapping };
+}
+/** `[BNF]` Creates a Tuple Parser */
+export function Tuple(...args) {
+    const [parsers, mapping] = args.length === 2 ? [args[0], args[1]] : [args[0], Identity];
+    return { type: 'Tuple', parsers, mapping };
+}
+/** `[BNF]` Creates a Union parser */
+export function Union(...args) {
+    const [parsers, mapping] = args.length === 2 ? [args[0], args[1]] : [args[0], Identity];
+    return { type: 'Union', parsers, mapping };
+}

package/build/esm/parser/static/parse.d.mts

@@ -1,12 +1,15 @@
 import * as Tokens from './token.mjs';
 import * as Types from './types.mjs';
-type TupleParser<Parsers extends Types.IParser[], Code extends string, Context extends unknown, Result extends unknown[] = []> = (Parsers extends [infer Left extends Types.IParser, ...infer Right extends Types.IParser[]] ? Parse<Left, Code, Context> extends [infer Value extends unknown, infer Rest extends string] ? TupleParser<Right, Rest, Context, [...Result, Value]> : [] : [Result, Code]);
-type UnionParser<Parsers extends Types.IParser[], Code extends string, Context extends unknown> = (Parsers extends [infer Left extends Types.IParser, ...infer Right extends Types.IParser[]] ? Parse<Left, Code, Context> extends [infer Value extends unknown, infer Rest extends string] ? [Value, Rest] : UnionParser<Right, Code, Context> : []);
+type ContextParser<Left extends Types.IParser, Right extends Types.IParser, Code extends string, Context extends unknown> = (Parse<Left, Code, Context> extends [infer Context extends unknown, infer Rest extends string] ? Parse<Right, Rest, Context> : []);
+type ArrayParser<Parser extends Types.IParser, Code extends string, Context extends unknown, Result extends unknown[] = []> = (Parse<Parser, Code, Context> extends [infer Value1 extends unknown, infer Rest extends string] ? ArrayParser<Parser, Rest, Context, [...Result, Value1]> : [Result, Code]);
 type ConstParser<Value extends string, Code extends string, _Context extends unknown> = (Tokens.Const<Value, Code> extends [infer Match extends Value, infer Rest extends string] ? [Match, Rest] : []);
 type IdentParser<Code extends string, _Context extends unknown> = (Tokens.Ident<Code> extends [infer Match extends string, infer Rest extends string] ? [Match, Rest] : []);
 type NumberParser<Code extends string, _Context extends unknown> = (Tokens.Number<Code> extends [infer Match extends string, infer Rest extends string] ? [Match, Rest] : []);
+type OptionalParser<Parser extends Types.IParser, Code extends string, Context extends unknown> = (Parse<Parser, Code, Context> extends [infer Value extends unknown, infer Rest extends string] ? [[Value], Rest] : [[], Code]);
 type StringParser<Options extends string[], Code extends string, _Context extends unknown> = (Tokens.String<Options, Code> extends [infer Match extends string, infer Rest extends string] ? [Match, Rest] : []);
-type ParseCode<Type extends Types.IParser, Code extends string, Context extends unknown = unknown> = (Type extends Types.Union<infer S extends Types.IParser[]> ? UnionParser<S, Code, Context> : Type extends Types.Tuple<infer S extends Types.IParser[]> ? TupleParser<S, Code, Context> : Type extends Types.Const<infer S extends string> ? ConstParser<S, Code, Context> : Type extends Types.String<infer S extends string[]> ? StringParser<S, Code, Context> : Type extends Types.Ident ? IdentParser<Code, Context> : Type extends Types.Number ? NumberParser<Code, Context> : [
+type TupleParser<Parsers extends Types.IParser[], Code extends string, Context extends unknown, Result extends unknown[] = []> = (Parsers extends [infer Left extends Types.IParser, ...infer Right extends Types.IParser[]] ? Parse<Left, Code, Context> extends [infer Value extends unknown, infer Rest extends string] ? TupleParser<Right, Rest, Context, [...Result, Value]> : [] : [Result, Code]);
+type UnionParser<Parsers extends Types.IParser[], Code extends string, Context extends unknown> = (Parsers extends [infer Left extends Types.IParser, ...infer Right extends Types.IParser[]] ? Parse<Left, Code, Context> extends [infer Value extends unknown, infer Rest extends string] ? [Value, Rest] : UnionParser<Right, Code, Context> : []);
+type ParseCode<Type extends Types.IParser, Code extends string, Context extends unknown = unknown> = (Type extends Types.Context<infer Left extends Types.IParser, infer Right extends Types.IParser> ? ContextParser<Left, Right, Code, Context> : Type extends Types.Array<infer Parser extends Types.IParser> ? ArrayParser<Parser, Code, Context> : Type extends Types.Const<infer Value extends string> ? ConstParser<Value, Code, Context> : Type extends Types.Ident ? IdentParser<Code, Context> : Type extends Types.Number ? NumberParser<Code, Context> : Type extends Types.Optional<infer Parser extends Types.IParser> ? OptionalParser<Parser, Code, Context> : Type extends Types.String<infer Options extends string[]> ? StringParser<Options, Code, Context> : Type extends Types.Tuple<infer Parsers extends Types.IParser[]> ? TupleParser<Parsers, Code, Context> : Type extends Types.Union<infer Parsers extends Types.IParser[]> ? UnionParser<Parsers, Code, Context> : [
 ]);
 type ParseMapping<Parser extends Types.IParser, Result extends unknown, Context extends unknown = unknown> = ((Parser['mapping'] & {
     input: Result;

package/build/esm/parser/static/types.d.mts

@@ -1,13 +1,20 @@
+/**
+ * `[ACTION]` Inference mapping base type. Used to specify semantic actions for
+ * Parser productions. This type is implemented as a higher-kinded type where
+ * productions are received on the `input` property with mapping assigned
+ * the `output` property. The parsing context is available on the `context`
+ * property.
+ */
 export interface IMapping {
     context: unknown;
     input: unknown;
     output: unknown;
 }
-/** Maps input to output. This is the default Mapping */
+/** `[ACTION]` Default inference mapping. */
 export interface Identity extends IMapping {
     output: this['input'];
 }
-/** Maps the output as the given parameter T */
+/** `[ACTION]` Maps the given argument `T` as the mapping output */
 export interface As<T> extends IMapping {
     output: T;
 }
@@ -16,31 +23,47 @@ export interface IParser<Mapping extends IMapping = Identity> {
     type: string;
     mapping: Mapping;
 }
-/** Creates a Tuple Parser */
-export interface Tuple<Parsers extends IParser[] = [], Mapping extends IMapping = Identity> extends IParser<Mapping> {
-    type: 'Tuple';
-    parsers: [...Parsers];
+/** `[Context]` Creates a Context Parser */
+export interface Context<Left extends IParser = IParser, Right extends IParser = IParser, Mapping extends IMapping = Identity> extends IParser<Mapping> {
+    type: 'Context';
+    left: Left;
+    right: Right;
 }
-/** Creates a Union Parser */
-export interface Union<Parsers extends IParser[] = [], Mapping extends IMapping = Identity> extends IParser<Mapping> {
-    type: 'Union';
-    parsers: [...Parsers];
+/** `[EBNF]` Creates an Array Parser */
+export interface Array<Parser extends IParser = IParser, Mapping extends IMapping = Identity> extends IParser<Mapping> {
+    type: 'Array';
+    parser: Parser;
 }
-/** Creates a Const Parser */
+/** `[TERM]` Creates a Const Parser */
 export interface Const<Value extends string = string, Mapping extends IMapping = Identity> extends IParser<Mapping> {
     type: 'Const';
     value: Value;
 }
-/** Creates a String Parser. Options are an array of permissable quote characters */
-export interface String<Options extends string[], Mapping extends IMapping = Identity> extends IParser<Mapping> {
-    type: 'String';
-    quote: Options;
-}
-/** Creates an Ident Parser. */
+/** `[TERM]` Creates an Ident Parser. */
 export interface Ident<Mapping extends IMapping = Identity> extends IParser<Mapping> {
     type: 'Ident';
 }
-/** Creates a Number Parser. */
+/** `[TERM]` Creates a Number Parser. */
 export interface Number<Mapping extends IMapping = Identity> extends IParser<Mapping> {
     type: 'Number';
 }
+/** `[EBNF]` Creates a Optional Parser */
+export interface Optional<Parser extends IParser = IParser, Mapping extends IMapping = Identity> extends IParser<Mapping> {
+    type: 'Optional';
+    parser: Parser;
+}
+/** `[TERM]` Creates a String Parser. Options are an array of permissable quote characters */
+export interface String<Options extends string[], Mapping extends IMapping = Identity> extends IParser<Mapping> {
+    type: 'String';
+    quote: Options;
+}
+/** `[BNF]` Creates a Tuple Parser */
+export interface Tuple<Parsers extends IParser[] = [], Mapping extends IMapping = Identity> extends IParser<Mapping> {
+    type: 'Tuple';
+    parsers: [...Parsers];
+}
+/** `[BNF]` Creates a Union Parser */
+export interface Union<Parsers extends IParser[] = [], Mapping extends IMapping = Identity> extends IParser<Mapping> {
+    type: 'Union';
+    parsers: [...Parsers];
+}

package/build/esm/syntax/runtime.d.mts

@@ -2,7 +2,7 @@ import { Runtime } from '../parser/index.mjs';
 import * as t from '../type/index.mjs';
 export declare const Module: Runtime.Module<{
     GenericArgumentList: Runtime.IUnion<unknown[]>;
-    GenericArguments: Runtime.ITuple<{}>;
+    GenericArguments: Runtime.ITuple<t.TProperties>;
     Literal: Runtime.IUnion<t.TLiteral<string> | t.TLiteral<number> | t.TLiteral<boolean>>;
     Keyword: Runtime.IUnion<t.TAny | t.TBoolean | t.TBigInt | t.TNever | t.TString | t.TNumber | t.TInteger | t.TNull | t.TSymbol | t.TUndefined | t.TUnknown | t.TVoid>;
     KeyOf: Runtime.IUnion<boolean>;
@@ -14,7 +14,7 @@ export declare const Module: Runtime.Module<{
     ExprTerm: Runtime.ITuple<t.TSchema>;
     ExprTail: Runtime.IUnion<[] | ["|", unknown, unknown]>;
     Expr: Runtime.ITuple<t.TSchema>;
-    Type: Runtime.IRef<unknown>;
+    Type: Runtime.IUnion<unknown>;
     PropertyKey: Runtime.IUnion<string>;
     Readonly: Runtime.IUnion<boolean>;
     Optional: Runtime.IUnion<boolean>;

package/build/esm/syntax/runtime.mjs

@@ -56,15 +56,15 @@ const GenericArgumentList = Runtime.Union([
 // GenericArguments
 // ------------------------------------------------------------------
 // prettier-ignore
-const GenericArgumentsContext = (args) => {
+const GenericArgumentsContext = (args, context) => {
     return args.reduce((result, arg, index) => {
         return { ...result, [arg]: t.Argument(index) };
-    }, {});
+    }, context);
 };
 // prettier-ignore
-const GenericArgumentsMapping = (results) => {
+const GenericArgumentsMapping = (results, context) => {
     return results.length === 3
-        ? GenericArgumentsContext(results[1])
+        ? GenericArgumentsContext(results[1], context)
         : {};
 };
 // prettier-ignore
@@ -72,7 +72,7 @@ const GenericArguments = Runtime.Tuple([
     Runtime.Const(LAngle),
     Runtime.Ref('GenericArgumentList'),
     Runtime.Const(RAngle),
-], results => GenericArgumentsMapping(results));
+], (results, context) => GenericArgumentsMapping(results, context));
 // ------------------------------------------------------------------
 // GenericReference
 // ------------------------------------------------------------------
@@ -282,7 +282,11 @@ const Expr = Runtime.Tuple([
 // ------------------------------------------------------------------
 // Type
 // ------------------------------------------------------------------
-const Type = Runtime.Ref('Expr');
+// prettier-ignore
+const Type = Runtime.Union([
+    Runtime.Context(Runtime.Ref('GenericArguments'), Runtime.Ref('Expr')),
+    Runtime.Ref('Expr')
+]);
 // ------------------------------------------------------------------
 // Properties
 // ------------------------------------------------------------------
@@ -649,12 +653,12 @@ const Uint8Array = Runtime.Const('Uint8Array', Runtime.As(t.Uint8Array()));
 // prettier-ignore
 export const Module = new Runtime.Module({
     // ----------------------------------------------------------------
-    // Generic Arguments
+    // Generics
     // ----------------------------------------------------------------
     GenericArgumentList,
     GenericArguments,
     // ----------------------------------------------------------------
-    // Type Expressions
+    // Type
     // ----------------------------------------------------------------
     Literal,
     Keyword,
@@ -667,7 +671,7 @@ export const Module = new Runtime.Module({
     ExprTerm,
     ExprTail,
     Expr,
-    Type, // Alias for Expr
+    Type,
     PropertyKey,
     Readonly,
     Optional,

package/build/esm/syntax/static.d.mts

@@ -52,13 +52,13 @@ type GenericArgumentList = Static.Union<[
     Static.Tuple<[Static.Ident]>,
     Static.Tuple<[]>
 ], GenericArgumentListMapping>;
-type GenericArgumentsContext<Args extends string[], Result extends t.TProperties = {}> = (Args extends [...infer Left extends string[], infer Right extends string] ? GenericArgumentsContext<Left, Result & {
+type GenericArgumentsContext<Args extends string[], Context extends t.TProperties, Result extends t.TProperties = {}> = (Args extends [...infer Left extends string[], infer Right extends string] ? GenericArgumentsContext<Left, Context, Result & {
     [_ in Right]: t.TArgument<Left['length']>;
-}> : t.Evaluate<Result>);
+}> : t.Evaluate<Result & Context>);
 interface GenericArgumentsMapping extends Static.IMapping {
-    output: this['input'] extends [LAngle, infer Args extends string[], RAngle] ? GenericArgumentsContext<Args> : never;
+    output: this['input'] extends [LAngle, infer Args extends string[], RAngle] ? this['context'] extends infer Context extends t.TProperties ? GenericArgumentsContext<Args, Context> : never : never;
 }
-export type GenericArguments = Static.Tuple<[
+type GenericArguments = Static.Tuple<[
     Static.Const<LAngle>,
     GenericArgumentList,
     Static.Const<RAngle>
@@ -204,7 +204,10 @@ type Expr = Static.Tuple<[
     ExprTerm,
     ExprTail
 ], ExprBinaryMapping>;
-export type Type = Expr;
+export type Type = Static.Union<[
+    Static.Context<GenericArguments, Expr>,
+    Expr
+]>;
 interface PropertyKeyStringMapping extends Static.IMapping {
     output: this['input'];
 }

package/build/esm/syntax/syntax.d.mts

@@ -1,16 +1,15 @@
 import * as t from '../type/index.mjs';
 import { Static } from '../parser/index.mjs';
-import { Type, GenericArguments } from './static.mjs';
-type TParseSyntax<Context extends Record<PropertyKey, t.TSchema>, Code extends string> = (Static.Parse<GenericArguments, Code, {}> extends [infer Args extends t.TProperties, infer Rest extends string] ? Static.Parse<Type, Rest, Context & Args> : Static.Parse<Type, Code, Context>);
-/** Parses a TypeScript annotation into a TypeBox type but does not infer schematics */
+import { Type } from './static.mjs';
+/** `[Experimental]` Parses a TypeScript annotation into a TypeBox type but does not infer schematics */
 export declare function NoInfer<Context extends Record<PropertyKey, t.TSchema>, Code extends string>(context: Context, code: Code, options?: t.SchemaOptions): t.TSchema;
-/** Parses a TypeScript annotation into a TypeBox type but does not infer schematics */
+/** `[Experimental]` Parses a TypeScript annotation into a TypeBox type but does not infer schematics */
 export declare function NoInfer<Code extends string>(code: Code, options?: t.SchemaOptions): t.TSchema;
-/** Parses a TypeScript annotation into a TypeBox type */
-export type TSyntax<Context extends Record<PropertyKey, t.TSchema>, Code extends string> = (TParseSyntax<Context, Code> extends [infer Type extends t.TSchema, string] ? Type : t.TNever);
-/** Parses a TypeScript annotation into a TypeBox type */
+/** `[Experimental]` Parses a TypeScript annotation into a TypeBox type */
+export type TSyntax<Context extends Record<PropertyKey, t.TSchema>, Code extends string> = (Static.Parse<Type, Code, Context> extends [infer Type extends t.TSchema, string] ? Type : t.TNever);
+/** `[Experimental]` Parses a TypeScript annotation into a TypeBox type */
 export declare function Syntax<Context extends Record<PropertyKey, t.TSchema>, Annotation extends string>(context: Context, annotation: Annotation, options?: t.SchemaOptions): TSyntax<Context, Annotation>;
-/** Parses a TypeScript annotation into a TypeBox type */
+/** `[Experimental]` Parses a TypeScript annotation into a TypeBox type */
 export declare function Syntax<Annotation extends string>(annotation: Annotation, options?: t.SchemaOptions): TSyntax<{}, Annotation>;
 /**
  * @deprecated Use Syntax() function
@@ -28,4 +27,3 @@ export declare function ParseOnly<Context extends Record<PropertyKey, t.TSchema>
  * @deprecated Use NoInfer() function
  */
 export declare function ParseOnly<Code extends string>(code: Code, options?: t.SchemaOptions): t.TSchema | undefined;
-export {};

package/build/esm/syntax/syntax.mjs

@@ -1,23 +1,16 @@
 import * as t from '../type/index.mjs';
 import { Module } from './runtime.mjs';
-// prettier-ignore
-function ParseSyntax(context, code) {
-    const results = Module.Parse('GenericArguments', code, {}); // [ArgumentContext, Rest]
-    return (results.length === 2
-        ? Module.Parse('Type', results[1], { ...context, ...results[0] })
-        : Module.Parse('Type', code, context));
-}
-/** Parses a TypeScript annotation into a TypeBox type but does not infer schematics */
+/** `[Experimental]` Parses a TypeScript annotation into a TypeBox type but does not infer schematics */
 // prettier-ignore
 export function NoInfer(...args) {
     const withContext = typeof args[0] === 'string' ? false : true;
     const [context, code, options] = withContext ? [args[0], args[1], args[2] || {}] : [{}, args[0], args[1] || {}];
-    const result = ParseSyntax(context, code)[0];
+    const result = Module.Parse('Type', code, context)[0];
     return t.KindGuard.IsSchema(result)
         ? t.CloneType(result, options)
         : t.Never(options);
 }
-/** Parses a TypeScript annotation into a TypeBox type */
+/** `[Experimental]` Parses a TypeScript annotation into a TypeBox type */
 export function Syntax(...args) {
     return NoInfer.apply(null, args);
 }

package/build/esm/type/instantiate/instantiate.d.mts

@@ -24,7 +24,7 @@ type TFromArray<Args extends TSchema[], Type extends TSchema, Result extends TAr
 type TFromAsyncIterator<Args extends TSchema[], Type extends TSchema, Result extends TAsyncIterator = TAsyncIterator<TFromType<Args, Type>>> = Result;
 type TFromIterator<Args extends TSchema[], Type extends TSchema, Result extends TIterator = TIterator<TFromType<Args, Type>>> = Result;
 type TFromPromise<Args extends TSchema[], Type extends TSchema, Result extends TPromise = TPromise<TFromType<Args, Type>>> = Result;
-type TFromObject<Args extends TSchema[], Properties extends TProperties, Result extends TProperties = TFromProperties<Args, Properties>> = TObject<Result>;
+type TFromObject<Args extends TSchema[], Properties extends TProperties, MappedProperties extends TProperties = TFromProperties<Args, Properties>, Result extends TObject = TObject<MappedProperties>> = Result;
 type TFromRecord<Args extends TSchema[], Key extends TSchema, Value extends TSchema, MappedKey extends TSchema = TFromType<Args, Key>, MappedValue extends TSchema = TFromType<Args, Value>, Result extends TSchema = TRecordOrObject<MappedKey, MappedValue>> = Result;
 type TFromArgument<Args extends TSchema[], Index extends number, Result extends TSchema = Index extends keyof Args[Index] ? Args[Index] : TUnknown> = Result;
 type TFromProperty<Args extends TSchema[], Type extends TSchema, IsReadonly extends boolean = Type extends TReadonly<Type> ? true : false, IsOptional extends boolean = Type extends TOptional<Type> ? true : false, Mapped extends TSchema = TFromType<Args, Type>, Result extends TSchema = ([

package/build/esm/type/instantiate/instantiate.mjs

@@ -58,8 +58,8 @@ function FromPromise(args, type) {
 }
 // prettier-ignore
 function FromObject(args, type) {
-    const properties = FromProperties(args, type.properties);
-    return { ...type, ...Object(properties) }; // retain options
+    const mappedProperties = FromProperties(args, type.properties);
+    return { ...type, ...Object(mappedProperties) }; // retain options
 }
 // prettier-ignore
 function FromRecord(args, type) {

package/package.json

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

package/readme.md

@@ -100,6 +100,7 @@ License MIT
   - [Parameters](#syntax-parameters)
   - [Generics](#syntax-generics)
   - [Options](#syntax-options)
+  - [NoInfer](#syntax-no-infer)
 - [TypeRegistry](#typeregistry)
   - [Type](#typeregistry-type)
   - [Format](#typeregistry-format)
@@ -1306,7 +1307,7 @@ ValuePointer.Set(A, '/z', 1)                         // A' = { x: 1, y: 1, z: 1
 
 ## Syntax Types
 
-TypeBox includes support for parsing TypeScript annotation syntax into TypeBox schematics.
+TypeBox provides experimental support for parsing TypeScript annotation syntax into TypeBox types.
 
 This feature is provided via optional import.
 
@@ -1391,6 +1392,23 @@ const T = Syntax(`number`, { minimum: 42 })       // const T = {
                                                   // }
 ```
 
+<a name='syntax-no-infer'></a>
+
+### NoInfer
+
+Syntax parsing is an expensive type level operation and can impact on language service performance. Use the NoInfer function parse syntax at runtime only.
+
+```typescript
+import { NoInfer } from '@sinclair/typebox/syntax'
+
+const T = NoInfer(`number | string`)                // const T: TSchema = {
+                                                    //   anyOf: [
+                                                    //     { type: 'number' },
+                                                    //     { type: 'string' }
+                                                    //   ]
+                                                    // }
+```
+
 <a name='typeregistry'></a>
 
 ## TypeRegistry