@sinclair/typebox 0.34.24 → 0.34.26

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

@@ -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/cjs/syntax/runtime.d.ts

@@ -2,7 +2,7 @@ import { Runtime } from '../parser/index';
 import * as t from '../type/index';
 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/cjs/syntax/runtime.js

@@ -60,15 +60,15 @@ const GenericArgumentList = index_1.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
@@ -76,7 +76,7 @@ const GenericArguments = index_1.Runtime.Tuple([
     index_1.Runtime.Const(LAngle),
     index_1.Runtime.Ref('GenericArgumentList'),
     index_1.Runtime.Const(RAngle),
-], results => GenericArgumentsMapping(results));
+], (results, context) => GenericArgumentsMapping(results, context));
 // ------------------------------------------------------------------
 // GenericReference
 // ------------------------------------------------------------------
@@ -286,7 +286,11 @@ const Expr = index_1.Runtime.Tuple([
 // ------------------------------------------------------------------
 // Type
 // ------------------------------------------------------------------
-const Type = index_1.Runtime.Ref('Expr');
+// prettier-ignore
+const Type = index_1.Runtime.Union([
+    index_1.Runtime.Context(index_1.Runtime.Ref('GenericArguments'), index_1.Runtime.Ref('Expr')),
+    index_1.Runtime.Ref('Expr')
+]);
 // ------------------------------------------------------------------
 // Properties
 // ------------------------------------------------------------------
@@ -653,12 +657,12 @@ const Uint8Array = index_1.Runtime.Const('Uint8Array', index_1.Runtime.As(t.Uint
 // prettier-ignore
 exports.Module = new index_1.Runtime.Module({
     // ----------------------------------------------------------------
-    // Generic Arguments
+    // Generics
     // ----------------------------------------------------------------
     GenericArgumentList,
     GenericArguments,
     // ----------------------------------------------------------------
-    // Type Expressions
+    // Type
     // ----------------------------------------------------------------
     Literal,
     Keyword,
@@ -671,7 +675,7 @@ exports.Module = new index_1.Runtime.Module({
     ExprTerm,
     ExprTail,
     Expr,
-    Type, // Alias for Expr
+    Type,
     PropertyKey,
     Readonly,
     Optional,

package/build/cjs/syntax/static.d.ts

@@ -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/cjs/syntax/syntax.d.ts

@@ -1,16 +1,15 @@
 import * as t from '../type/index';
 import { Static } from '../parser/index';
-import { Type, GenericArguments } from './static';
-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';
+/** `[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/cjs/syntax/syntax.js

@@ -7,24 +7,17 @@ exports.Parse = Parse;
 exports.ParseOnly = ParseOnly;
 const t = require("../type/index");
 const runtime_1 = require("./runtime");
-// prettier-ignore
-function ParseSyntax(context, code) {
-    const results = runtime_1.Module.Parse('GenericArguments', code, {}); // [ArgumentContext, Rest]
-    return (results.length === 2
-        ? runtime_1.Module.Parse('Type', results[1], { ...context, ...results[0] })
-        : runtime_1.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
 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 = runtime_1.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 */
 function Syntax(...args) {
     return NoInfer.apply(null, args);
 }

package/build/cjs/type/instantiate/instantiate.d.ts

@@ -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/cjs/type/instantiate/instantiate.js

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

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

@@ -1,17 +1,23 @@
-import { IIdent, INumber, IRef, IString, IConst, ITuple, IUnion } from './types.mjs';
-/** 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.mjs';
+/** 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/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);
 }