@depup/sinclair__typebox 0.34.48-depup.0

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

@@ -0,0 +1,160 @@
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parse = Parse;
+const Guard = __importStar(require("./guard"));
+const Token = __importStar(require("./token"));
+// ------------------------------------------------------------------
+// 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;
+    while (rest.length > 0) {
+        const result = ParseParser(moduleProperties, parser, rest, context);
+        if (result.length === 0)
+            return [buffer, rest];
+        buffer.push(result[0]);
+        rest = result[1];
+    }
+    return [buffer, rest];
+}
+// ------------------------------------------------------------------
+// Const
+// ------------------------------------------------------------------
+function ParseConst(value, code, context) {
+    return Token.Const(value, code);
+}
+// ------------------------------------------------------------------
+// Ident
+// ------------------------------------------------------------------
+function ParseIdent(code, _context) {
+    return Token.Ident(code);
+}
+// ------------------------------------------------------------------
+// Number
+// ------------------------------------------------------------------
+// prettier-ignore
+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
+// ------------------------------------------------------------------
+function ParseRef(moduleProperties, ref, code, context) {
+    const parser = moduleProperties[ref];
+    if (!Guard.IsParser(parser))
+        throw Error(`Cannot dereference Parser '${ref}'`);
+    return ParseParser(moduleProperties, parser, code, context);
+}
+// ------------------------------------------------------------------
+// String
+// ------------------------------------------------------------------
+// prettier-ignore
+function ParseString(options, code, _context) {
+    return Token.String(options, code);
+}
+// ------------------------------------------------------------------
+// Tuple
+// ------------------------------------------------------------------
+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];
+}
+// ------------------------------------------------------------------
+// Union
+// ------------------------------------------------------------------
+// prettier-ignore
+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(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.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);
+}
+/** Parses content using the given parser */
+// prettier-ignore
+function Parse(...args) {
+    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(moduleProperties, parser, content, context);
+}

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

@@ -0,0 +1,8 @@
+/** Takes the next constant string value skipping any whitespace */
+export declare function Const(value: string, code: string): [] | [string, string];
+/** Scans for the next Ident token */
+export declare function Ident(code: string): [] | [string, string];
+/** Scans for the next number token */
+export declare function Number(code: string): [string, string] | [];
+/** Scans the next Literal String value */
+export declare function String(options: string[], code: string): [string, string] | [];

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

@@ -0,0 +1,230 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Const = Const;
+exports.Ident = Ident;
+exports.Number = Number;
+exports.String = String;
+// ------------------------------------------------------------------
+// Chars
+// ------------------------------------------------------------------
+// prettier-ignore
+var Chars;
+(function (Chars) {
+    /** Returns true if the char code is a whitespace */
+    function IsWhitespace(value) {
+        return value === 32;
+    }
+    Chars.IsWhitespace = IsWhitespace;
+    /** Returns true if the char code is a newline */
+    function IsNewline(value) {
+        return value === 10;
+    }
+    Chars.IsNewline = IsNewline;
+    /** Returns true if the char code is a alpha  */
+    function IsAlpha(value) {
+        return ((value >= 65 && value <= 90) || // A-Z 
+            (value >= 97 && value <= 122) // a-z
+        );
+    }
+    Chars.IsAlpha = IsAlpha;
+    /** Returns true if the char code is zero */
+    function IsZero(value) {
+        return value === 48;
+    }
+    Chars.IsZero = IsZero;
+    /** Returns true if the char code is non-zero */
+    function IsNonZero(value) {
+        return value >= 49 && value <= 57;
+    }
+    Chars.IsNonZero = IsNonZero;
+    /** Returns true if the char code is a digit */
+    function IsDigit(value) {
+        return (IsNonZero(value) ||
+            IsZero(value));
+    }
+    Chars.IsDigit = IsDigit;
+    /** Returns true if the char code is a dot */
+    function IsDot(value) {
+        return value === 46;
+    }
+    Chars.IsDot = IsDot;
+    /** Returns true if this char code is a underscore */
+    function IsUnderscore(value) {
+        return value === 95;
+    }
+    Chars.IsUnderscore = IsUnderscore;
+    /** Returns true if this char code is a dollar sign */
+    function IsDollarSign(value) {
+        return value === 36;
+    }
+    Chars.IsDollarSign = IsDollarSign;
+})(Chars || (Chars = {}));
+// ------------------------------------------------------------------
+// Trim
+// ------------------------------------------------------------------
+// prettier-ignore
+var Trim;
+(function (Trim) {
+    /** Trims Whitespace and retains Newline, Tabspaces, etc. */
+    function TrimWhitespaceOnly(code) {
+        for (let i = 0; i < code.length; i++) {
+            if (Chars.IsWhitespace(code.charCodeAt(i)))
+                continue;
+            return code.slice(i);
+        }
+        return code;
+    }
+    Trim.TrimWhitespaceOnly = TrimWhitespaceOnly;
+    /** Trims Whitespace including Newline, Tabspaces, etc. */
+    function TrimAll(code) {
+        return code.trimStart();
+    }
+    Trim.TrimAll = TrimAll;
+})(Trim || (Trim = {}));
+// ------------------------------------------------------------------
+// Const
+// ------------------------------------------------------------------
+/** Checks the value matches the next string  */
+// prettier-ignore
+function NextTokenCheck(value, code) {
+    if (value.length > code.length)
+        return false;
+    for (let i = 0; i < value.length; i++) {
+        if (value.charCodeAt(i) !== code.charCodeAt(i))
+            return false;
+    }
+    return true;
+}
+/** Gets the next constant string value or empty if no match */
+// prettier-ignore
+function NextConst(value, code) {
+    return NextTokenCheck(value, code)
+        ? [code.slice(0, value.length), code.slice(value.length)]
+        : [];
+}
+/** Takes the next constant string value skipping any whitespace */
+// prettier-ignore
+function Const(value, code) {
+    if (value.length === 0)
+        return ['', code];
+    const char_0 = value.charCodeAt(0);
+    return (Chars.IsNewline(char_0) ? NextConst(value, Trim.TrimWhitespaceOnly(code)) :
+        Chars.IsWhitespace(char_0) ? NextConst(value, code) :
+            NextConst(value, Trim.TrimAll(code)));
+}
+// ------------------------------------------------------------------
+// Ident
+// ------------------------------------------------------------------
+// prettier-ignore
+function IdentIsFirst(char) {
+    return (Chars.IsAlpha(char) ||
+        Chars.IsDollarSign(char) ||
+        Chars.IsUnderscore(char));
+}
+// prettier-ignore
+function IdentIsRest(char) {
+    return (Chars.IsAlpha(char) ||
+        Chars.IsDigit(char) ||
+        Chars.IsDollarSign(char) ||
+        Chars.IsUnderscore(char));
+}
+// prettier-ignore
+function NextIdent(code) {
+    if (!IdentIsFirst(code.charCodeAt(0)))
+        return [];
+    for (let i = 1; i < code.length; i++) {
+        const char = code.charCodeAt(i);
+        if (IdentIsRest(char))
+            continue;
+        const slice = code.slice(0, i);
+        const rest = code.slice(i);
+        return [slice, rest];
+    }
+    return [code, ''];
+}
+/** Scans for the next Ident token */
+// prettier-ignore
+function Ident(code) {
+    return NextIdent(Trim.TrimAll(code));
+}
+// ------------------------------------------------------------------
+// Number
+// ------------------------------------------------------------------
+/** Checks that the next number is not a leading zero */
+// prettier-ignore
+function NumberLeadingZeroCheck(code, index) {
+    const char_0 = code.charCodeAt(index + 0);
+    const char_1 = code.charCodeAt(index + 1);
+    return ((
+    // 1-9
+    Chars.IsNonZero(char_0)) || (
+    // 0
+    Chars.IsZero(char_0) &&
+        !Chars.IsDigit(char_1)) || (
+    // 0.
+    Chars.IsZero(char_0) &&
+        Chars.IsDot(char_1)) || (
+    // .0
+    Chars.IsDot(char_0) &&
+        Chars.IsDigit(char_1)));
+}
+/** Gets the next number token */
+// prettier-ignore
+function NextNumber(code) {
+    const negated = code.charAt(0) === '-';
+    const index = negated ? 1 : 0;
+    if (!NumberLeadingZeroCheck(code, index)) {
+        return [];
+    }
+    const dash = negated ? '-' : '';
+    let hasDot = false;
+    for (let i = index; i < code.length; i++) {
+        const char_i = code.charCodeAt(i);
+        if (Chars.IsDigit(char_i)) {
+            continue;
+        }
+        if (Chars.IsDot(char_i)) {
+            if (hasDot) {
+                const slice = code.slice(index, i);
+                const rest = code.slice(i);
+                return [`${dash}${slice}`, rest];
+            }
+            hasDot = true;
+            continue;
+        }
+        const slice = code.slice(index, i);
+        const rest = code.slice(i);
+        return [`${dash}${slice}`, rest];
+    }
+    return [code, ''];
+}
+/** Scans for the next number token */
+// prettier-ignore
+function Number(code) {
+    return NextNumber(Trim.TrimAll(code));
+}
+// ------------------------------------------------------------------
+// String
+// ------------------------------------------------------------------
+// prettier-ignore
+function NextString(options, code) {
+    const first = code.charAt(0);
+    if (!options.includes(first))
+        return [];
+    const quote = first;
+    for (let i = 1; i < code.length; i++) {
+        const char = code.charAt(i);
+        if (char === quote) {
+            const slice = code.slice(1, i);
+            const rest = code.slice(i + 1);
+            return [slice, rest];
+        }
+    }
+    return [];
+}
+/** Scans the next Literal String value */
+// prettier-ignore
+function String(options, code) {
+    return NextString(options, Trim.TrimAll(code));
+}

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

@@ -0,0 +1,98 @@
+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;
+/** Maps input to output. This is the default Mapping */
+export declare const Identity: (value: unknown) => unknown;
+/** Maps the output as the given parameter T */
+export declare const As: <T>(mapping: T) => ((value: unknown) => T);
+export interface IParser<Output extends unknown = unknown> {
+    type: string;
+    mapping: IMapping<any, Output>;
+}
+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;
+}
+/** `[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;
+}
+/** `[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;
+}
+/** `[TERM]` Creates a Const Parser */
+export declare function Const<Value extends string, Mapping extends IMapping<Value>>(value: Value, mapping: Mapping): IConst<ReturnType<Mapping>>;
+/** `[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;
+}
+/** `[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>>;
+/** `[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[];
+}
+/** `[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>>;
+/** `[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';
+}
+/** `[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>>;
+/** `[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';
+}
+/** `[TERM]` Creates an Number Parser */
+export declare function Number<Mapping extends IMapping<string>>(mapping: Mapping): INumber<ReturnType<Mapping>>;
+/** `[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

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.As = exports.Identity = void 0;
+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;
+/** `[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 };
+}
+/** `[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/index.d.ts

@@ -0,0 +1,3 @@
+export * as Token from './token';
+export * from './parse';
+export * from './types';

package/build/cjs/parser/static/index.js

@@ -0,0 +1,43 @@
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Token = void 0;
+exports.Token = __importStar(require("./token"));
+__exportStar(require("./parse"), exports);
+__exportStar(require("./types"), exports);

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

@@ -0,0 +1,20 @@
+import * as Tokens from './token';
+import * as Types from './types';
+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 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;
+    context: Context;
+})['output']);
+/** Parses code with the given parser */
+export type Parse<Type extends Types.IParser, Code extends string, Context extends unknown = unknown> = (ParseCode<Type, Code, Context> extends [infer L extends unknown, infer R extends string] ? [ParseMapping<Type, L, Context>, R] : []);
+export {};

package/build/cjs/parser/static/parse.js

@@ -0,0 +1,3 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });