@sinclair/typebox 0.34.25 → 0.34.27

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

@@ -16,49 +16,57 @@ function IsArrayValue(value) {
 // ------------------------------------------------------------------
 // Parser Guard
 // ------------------------------------------------------------------
-/** Returns true if the value is a Tuple Parser */
-// prettier-ignore
-export function IsTuple(value) {
-    return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'Tuple' && HasPropertyKey(value, 'parsers') && IsArrayValue(value.parsers);
-}
-/** Returns true if the value is a Union Parser */
-// prettier-ignore
-export function IsUnion(value) {
-    return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'Union' && HasPropertyKey(value, 'parsers') && IsArrayValue(value.parsers);
+/** Returns true if the value is a Array Parser */
+export function IsArray(value) {
+    return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'Array' && HasPropertyKey(value, 'parser') && IsObjectValue(value.parser);
 }
 /** Returns true if the value is a Const Parser */
-// prettier-ignore
 export function IsConst(value) {
     return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'Const' && HasPropertyKey(value, 'value') && typeof value.value === 'string';
 }
+/** Returns true if the value is a Context Parser */
+export function IsContext(value) {
+    return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'Context' && HasPropertyKey(value, 'left') && IsParser(value.left) && HasPropertyKey(value, 'right') && IsParser(value.right);
+}
 /** Returns true if the value is a Ident Parser */
-// prettier-ignore
 export function IsIdent(value) {
     return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'Ident';
 }
 /** Returns true if the value is a Number Parser */
-// prettier-ignore
 export function IsNumber(value) {
     return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'Number';
 }
+/** Returns true if the value is a Optional Parser */
+export function IsOptional(value) {
+    return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'Optional' && HasPropertyKey(value, 'parser') && IsObjectValue(value.parser);
+}
 /** Returns true if the value is a Ref Parser */
-// prettier-ignore
 export function IsRef(value) {
     return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'Ref' && HasPropertyKey(value, 'ref') && typeof value.ref === 'string';
 }
 /** Returns true if the value is a String Parser */
-// prettier-ignore
 export function IsString(value) {
     return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'String' && HasPropertyKey(value, 'options') && IsArrayValue(value.options);
 }
+/** Returns true if the value is a Tuple Parser */
+export function IsTuple(value) {
+    return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'Tuple' && HasPropertyKey(value, 'parsers') && IsArrayValue(value.parsers);
+}
+/** Returns true if the value is a Union Parser */
+export function IsUnion(value) {
+    return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'Union' && HasPropertyKey(value, 'parsers') && IsArrayValue(value.parsers);
+}
 /** Returns true if the value is a Parser */
-// prettier-ignore
 export function IsParser(value) {
-    return (IsTuple(value) ||
-        IsUnion(value) ||
+    // prettier-ignore
+    return (IsArray(value) ||
         IsConst(value) ||
+        IsContext(value) ||
         IsIdent(value) ||
         IsNumber(value) ||
+        IsOptional(value) ||
         IsRef(value) ||
-        IsString(value));
+        IsString(value) ||
+        IsTuple(value) ||
+        IsUnion(value));
 }

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

@@ -3,7 +3,7 @@ export declare class Module<Properties extends Types.IModuleProperties = Types.I
     private readonly properties;
     constructor(properties: Properties);
     /** Parses using one of the parsers defined on this instance */
-    Parse<Key extends keyof Properties>(key: Key, code: string, context: unknown): [] | [Types.StaticParser<Properties[Key]>, string];
+    Parse<Key extends keyof Properties>(key: Key, content: string, context: unknown): [] | [Types.StaticParser<Properties[Key]>, string];
     /** Parses using one of the parsers defined on this instance */
-    Parse<Key extends keyof Properties>(key: Key, code: string): [] | [Types.StaticParser<Properties[Key]>, string];
+    Parse<Key extends keyof Properties>(key: Key, content: string): [] | [Types.StaticParser<Properties[Key]>, string];
 }

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

@@ -2,16 +2,16 @@ import { Parse } from './parse.mjs';
 // ------------------------------------------------------------------
 // Module
 // ------------------------------------------------------------------
-// prettier-ignore
 export class Module {
     constructor(properties) {
         this.properties = properties;
     }
     /** Parses using one of the parsers defined on this instance */
     Parse(...args) {
-        const [key, code, context] = args.length === 3 ? [args[0], args[1], args[2]] :
+        // prettier-ignore
+        const [key, content, context] = (args.length === 3 ? [args[0], args[1], args[2]] :
             args.length === 2 ? [args[0], args[1], undefined] :
-                (() => { throw Error('Invalid parse arguments'); })();
-        return Parse(this.properties[key], this.properties, code, context);
+                (() => { throw Error('Invalid parse arguments'); })());
+        return Parse(this.properties, this.properties[key], content, context);
     }
 }

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

@@ -1,9 +1,9 @@
 import * as Types from './types.mjs';
-/** Parses content using the given parser */
-export declare function Parse<Parser extends Types.IParser>(parser: Parser, properties: Types.IModuleProperties, code: string, context: unknown): [] | [Types.StaticParser<Parser>, string];
-/** Parses content using the given parser */
-export declare function Parse<Parser extends Types.IParser>(parser: Parser, properties: Types.IModuleProperties, code: string): [] | [Types.StaticParser<Parser>, string];
-/** Parses content using the given parser */
-export declare function Parse<Parser extends Types.IParser>(parser: Parser, code: string, context: unknown): [] | [Types.StaticParser<Parser>, string];
-/** Parses content using the given parser */
-export declare function Parse<Parser extends Types.IParser>(parser: Parser, code: string): [] | [Types.StaticParser<Parser>, string];
+/** Parses content using the given Parser */
+export declare function Parse<Parser extends Types.IParser>(moduleProperties: Types.IModuleProperties, parser: Parser, code: string, context: unknown): [] | [Types.StaticParser<Parser>, string];
+/** Parses content using the given Parser */
+export declare function Parse<Parser extends Types.IParser>(moduleProperties: Types.IModuleProperties, parser: Parser, code: string): [] | [Types.StaticParser<Parser>, string];
+/** Parses content using the given Parser */
+export declare function Parse<Parser extends Types.IParser>(parser: Parser, content: string, context: unknown): [] | [Types.StaticParser<Parser>, string];
+/** Parses content using the given Parser */
+export declare function Parse<Parser extends Types.IParser>(parser: Parser, content: string): [] | [Types.StaticParser<Parser>, string];

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

@@ -1,50 +1,61 @@
 import * as Guard from './guard.mjs';
 import * as Token from './token.mjs';
 // ------------------------------------------------------------------
-// Tuple
+// Context
 // ------------------------------------------------------------------
-// prettier-ignore
-function ParseTuple(parsers, properties, code, context) {
+function ParseContext(moduleProperties, left, right, code, context) {
+    const result = ParseParser(moduleProperties, left, code, context);
+    return result.length === 2 ? ParseParser(moduleProperties, right, result[1], result[0]) : [];
+}
+// ------------------------------------------------------------------
+// Array
+// ------------------------------------------------------------------
+function ParseArray(moduleProperties, parser, code, context) {
     const buffer = [];
     let rest = code;
-    for (const parser of parsers) {
-        const result = ParseParser(parser, properties, rest, context);
+    while (rest.length > 0) {
+        const result = ParseParser(moduleProperties, parser, rest, context);
         if (result.length === 0)
-            return [];
+            return [buffer, rest];
         buffer.push(result[0]);
         rest = result[1];
     }
     return [buffer, rest];
 }
 // ------------------------------------------------------------------
-// Union
+// Const
 // ------------------------------------------------------------------
-// prettier-ignore
-function ParseUnion(parsers, properties, code, context) {
-    for (const parser of parsers) {
-        const result = ParseParser(parser, properties, code, context);
-        if (result.length === 0)
-            continue;
-        return result;
-    }
-    return [];
+function ParseConst(value, code, context) {
+    return Token.Const(value, code);
 }
 // ------------------------------------------------------------------
-// Const
+// Ident
+// ------------------------------------------------------------------
+function ParseIdent(code, _context) {
+    return Token.Ident(code);
+}
+// ------------------------------------------------------------------
+// Number
 // ------------------------------------------------------------------
 // prettier-ignore
-function ParseConst(value, code, context) {
-    return Token.Const(value, code);
+function ParseNumber(code, _context) {
+    return Token.Number(code);
+}
+// ------------------------------------------------------------------
+// Optional
+// ------------------------------------------------------------------
+function ParseOptional(moduleProperties, parser, code, context) {
+    const result = ParseParser(moduleProperties, parser, code, context);
+    return (result.length === 2 ? [[result[0]], result[1]] : [[], code]);
 }
 // ------------------------------------------------------------------
 // Ref
 // ------------------------------------------------------------------
-// prettier-ignore
-function ParseRef(ref, properties, code, context) {
-    const parser = properties[ref];
+function ParseRef(moduleProperties, ref, code, context) {
+    const parser = moduleProperties[ref];
     if (!Guard.IsParser(parser))
-        throw Error(`Cannot dereference parser '${ref}'`);
-    return ParseParser(parser, properties, code, context);
+        throw Error(`Cannot dereference Parser '${ref}'`);
+    return ParseParser(moduleProperties, parser, code, context);
 }
 // ------------------------------------------------------------------
 // String
@@ -54,32 +65,49 @@ function ParseString(options, code, _context) {
     return Token.String(options, code);
 }
 // ------------------------------------------------------------------
-// Number
+// Tuple
 // ------------------------------------------------------------------
-// prettier-ignore
-function ParseNumber(code, _context) {
-    return Token.Number(code);
+function ParseTuple(moduleProperties, parsers, code, context) {
+    const buffer = [];
+    let rest = code;
+    for (const parser of parsers) {
+        const result = ParseParser(moduleProperties, parser, rest, context);
+        if (result.length === 0)
+            return [];
+        buffer.push(result[0]);
+        rest = result[1];
+    }
+    return [buffer, rest];
 }
 // ------------------------------------------------------------------
-// Ident
+// Union
 // ------------------------------------------------------------------
 // prettier-ignore
-function ParseIdent(code, _context) {
-    return Token.Ident(code);
+function ParseUnion(moduleProperties, parsers, code, context) {
+    for (const parser of parsers) {
+        const result = ParseParser(moduleProperties, parser, code, context);
+        if (result.length === 0)
+            continue;
+        return result;
+    }
+    return [];
 }
 // ------------------------------------------------------------------
 // Parser
 // ------------------------------------------------------------------
 // prettier-ignore
-function ParseParser(parser, properties, code, context) {
-    const result = (Guard.IsTuple(parser) ? ParseTuple(parser.parsers, properties, code, context) :
-        Guard.IsUnion(parser) ? ParseUnion(parser.parsers, properties, code, context) :
+function ParseParser(moduleProperties, parser, code, context) {
+    const result = (Guard.IsContext(parser) ? ParseContext(moduleProperties, parser.left, parser.right, code, context) :
+        Guard.IsArray(parser) ? ParseArray(moduleProperties, parser.parser, code, context) :
             Guard.IsConst(parser) ? ParseConst(parser.value, code, context) :
-                Guard.IsRef(parser) ? ParseRef(parser.ref, properties, code, context) :
-                    Guard.IsString(parser) ? ParseString(parser.options, code, context) :
-                        Guard.IsIdent(parser) ? ParseIdent(code, context) :
-                            Guard.IsNumber(parser) ? ParseNumber(code, context) :
-                                []);
+                Guard.IsIdent(parser) ? ParseIdent(code, context) :
+                    Guard.IsNumber(parser) ? ParseNumber(code, context) :
+                        Guard.IsOptional(parser) ? ParseOptional(moduleProperties, parser.parser, code, context) :
+                            Guard.IsRef(parser) ? ParseRef(moduleProperties, parser.ref, code, context) :
+                                Guard.IsString(parser) ? ParseString(parser.options, code, context) :
+                                    Guard.IsTuple(parser) ? ParseTuple(moduleProperties, parser.parsers, code, context) :
+                                        Guard.IsUnion(parser) ? ParseUnion(moduleProperties, parser.parsers, code, context) :
+                                            []);
     return (result.length === 2
         ? [parser.mapping(result[0], context), result[1]]
         : result);
@@ -87,9 +115,9 @@ function ParseParser(parser, properties, code, context) {
 /** Parses content using the given parser */
 // prettier-ignore
 export function Parse(...args) {
-    const withProperties = typeof args[1] === 'string' ? false : true;
-    const [parser, properties, code, context] = withProperties
+    const withModuleProperties = typeof args[1] === 'string' ? false : true;
+    const [moduleProperties, parser, content, context] = withModuleProperties
         ? [args[0], args[1], args[2], args[3]]
-        : [args[0], {}, args[1], args[2]];
-    return ParseParser(parser, properties, code, context);
+        : [{}, args[0], args[1], args[2]];
+    return ParseParser(moduleProperties, parser, content, context);
 }

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