@sinclair/typebox 0.34.25 → 0.34.26

package/build/cjs/parser/runtime/guard.d.ts

@@ -1,17 +1,23 @@
-import { IIdent, INumber, IRef, IString, IConst, ITuple, IUnion } from './types';
-/** Returns true if the value is a Tuple Parser */
-export declare function IsTuple(value: unknown): value is ITuple;
-/** Returns true if the value is a Union Parser */
-export declare function IsUnion(value: unknown): value is IUnion;
+import { IArray, IConst, IContext, IIdent, INumber, IOptional, IRef, IString, ITuple, IUnion } from './types';
+/** Returns true if the value is a Array Parser */
+export declare function IsArray(value: unknown): value is IArray;
 /** Returns true if the value is a Const Parser */
 export declare function IsConst(value: unknown): value is IConst;
+/** Returns true if the value is a Context Parser */
+export declare function IsContext(value: unknown): value is IContext;
 /** Returns true if the value is a Ident Parser */
 export declare function IsIdent(value: unknown): value is IIdent;
 /** Returns true if the value is a Number Parser */
 export declare function IsNumber(value: unknown): value is INumber;
+/** Returns true if the value is a Optional Parser */
+export declare function IsOptional(value: unknown): value is IOptional;
 /** Returns true if the value is a Ref Parser */
 export declare function IsRef(value: unknown): value is IRef;
 /** Returns true if the value is a String Parser */
 export declare function IsString(value: unknown): value is IString;
+/** Returns true if the value is a Tuple Parser */
+export declare function IsTuple(value: unknown): value is ITuple;
+/** Returns true if the value is a Union Parser */
+export declare function IsUnion(value: unknown): value is IUnion;
 /** Returns true if the value is a Parser */
-export declare function IsParser(value: unknown): value is IUnion<unknown> | ITuple<unknown> | IConst<unknown> | IIdent<unknown> | INumber<unknown> | IRef<unknown> | IString<unknown>;
+export declare function IsParser(value: unknown): value is IContext<unknown> | IUnion<unknown> | IArray<unknown> | IConst<unknown> | IIdent<unknown> | INumber<unknown> | IOptional<unknown> | IRef<unknown> | IString<unknown> | ITuple<unknown>;

package/build/cjs/parser/runtime/guard.js

@@ -1,13 +1,16 @@
 "use strict";
 
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IsTuple = IsTuple;
-exports.IsUnion = IsUnion;
+exports.IsArray = IsArray;
 exports.IsConst = IsConst;
+exports.IsContext = IsContext;
 exports.IsIdent = IsIdent;
 exports.IsNumber = IsNumber;
+exports.IsOptional = IsOptional;
 exports.IsRef = IsRef;
 exports.IsString = IsString;
+exports.IsTuple = IsTuple;
+exports.IsUnion = IsUnion;
 exports.IsParser = IsParser;
 // ------------------------------------------------------------------
 // Value Guard
@@ -27,49 +30,57 @@ function IsArrayValue(value) {
 // ------------------------------------------------------------------
 // Parser Guard
 // ------------------------------------------------------------------
-/** Returns true if the value is a Tuple Parser */
-// prettier-ignore
-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
-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 */
+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
 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 */
+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
 function IsIdent(value) {
     return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'Ident';
 }
 /** Returns true if the value is a Number Parser */
-// prettier-ignore
 function IsNumber(value) {
     return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'Number';
 }
+/** Returns true if the value is a Optional Parser */
+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
 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
 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 */
+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 */
+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
 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/cjs/parser/runtime/module.d.ts

@@ -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/cjs/parser/runtime/module.js

@@ -6,17 +6,17 @@ const parse_1 = require("./parse");
 // ------------------------------------------------------------------
 // Module
 // ------------------------------------------------------------------
-// prettier-ignore
 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 (0, parse_1.Parse)(this.properties[key], this.properties, code, context);
+                (() => { throw Error('Invalid parse arguments'); })());
+        return (0, parse_1.Parse)(this.properties, this.properties[key], content, context);
     }
 }
 exports.Module = Module;

package/build/cjs/parser/runtime/parse.d.ts

@@ -1,9 +1,9 @@
 import * as Types from './types';
-/** 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/cjs/parser/runtime/parse.js

@@ -5,50 +5,61 @@ exports.Parse = Parse;
 const Guard = require("./guard");
 const Token = require("./token");
 // ------------------------------------------------------------------
-// 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
@@ -58,32 +69,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);
@@ -91,9 +119,9 @@ function ParseParser(parser, properties, code, context) {
 /** Parses content using the given parser */
 // prettier-ignore
 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/cjs/parser/runtime/types.d.ts

@@ -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/cjs/parser/runtime/types.js

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

package/build/cjs/parser/static/parse.d.ts

@@ -1,12 +1,15 @@
 import * as Tokens from './token';
 import * as Types from './types';
-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;