@sinclair/typebox 0.33.19 → 0.33.21

package/build/esm/parse/parsebox/runtime/module.mjs

@@ -0,0 +1,17 @@
+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]] :
+            args.length === 2 ? [args[0], args[1], undefined] :
+                (() => { throw Error('Invalid parse arguments'); })();
+        return Parse(this.properties[key], this.properties, code, context);
+    }
+}

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

@@ -0,0 +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];

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

@@ -0,0 +1,95 @@
+import * as Guard from './guard.mjs';
+import * as Token from './token.mjs';
+// ------------------------------------------------------------------
+// Tuple
+// ------------------------------------------------------------------
+// prettier-ignore
+function ParseTuple(parsers, properties, code, context) {
+    const buffer = [];
+    let rest = code;
+    for (const parser of parsers) {
+        const result = ParseParser(parser, properties, rest, context);
+        if (result.length === 0)
+            return [];
+        buffer.push(result[0]);
+        rest = result[1];
+    }
+    return [buffer, rest];
+}
+// ------------------------------------------------------------------
+// Union
+// ------------------------------------------------------------------
+// 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 [];
+}
+// ------------------------------------------------------------------
+// Const
+// ------------------------------------------------------------------
+// prettier-ignore
+function ParseConst(value, code, context) {
+    return Token.Const(value, code);
+}
+// ------------------------------------------------------------------
+// Ref
+// ------------------------------------------------------------------
+// prettier-ignore
+function ParseRef(ref, properties, code, context) {
+    const parser = properties[ref];
+    if (!Guard.IsParser(parser))
+        throw Error(`Cannot dereference parser '${ref}'`);
+    return ParseParser(parser, properties, code, context);
+}
+// ------------------------------------------------------------------
+// String
+// ------------------------------------------------------------------
+// prettier-ignore
+function ParseString(options, code, _context) {
+    return Token.String(options, code);
+}
+// ------------------------------------------------------------------
+// Number
+// ------------------------------------------------------------------
+// prettier-ignore
+function ParseNumber(code, _context) {
+    return Token.Number(code);
+}
+// ------------------------------------------------------------------
+// Ident
+// ------------------------------------------------------------------
+// prettier-ignore
+function ParseIdent(code, _context) {
+    return Token.Ident(code);
+}
+// ------------------------------------------------------------------
+// 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) :
+            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) :
+                                []);
+    return (result.length === 2
+        ? [parser.mapping(result[0], context), result[1]]
+        : result);
+}
+/** 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
+        ? [args[0], args[1], args[2], args[3]]
+        : [args[0], {}, args[1], args[2]];
+    return ParseParser(parser, properties, code, context);
+}

package/build/esm/parse/parsebox/runtime/token.d.mts

@@ -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/esm/parse/parsebox/runtime/token.mjs

@@ -0,0 +1,223 @@
+// ------------------------------------------------------------------
+// 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
+export 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
+export 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
+export 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
+export function String(options, code) {
+    return NextString(options, Trim.TrimAll(code));
+}

package/build/esm/parse/parsebox/runtime/types.d.mts

@@ -0,0 +1,68 @@
+export type IModuleProperties = Record<PropertyKey, IParser>;
+/** 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 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[];
+}
+/** 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[];
+}
+/** 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>>;
+export interface IConst<Output extends unknown = unknown> extends IParser<Output> {
+    type: 'Const';
+    value: string;
+}
+/** 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 */
+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 */
+export declare function Ref<Type extends unknown, Mapping extends IMapping<Type>>(ref: string, mapping: Mapping): IRef<ReturnType<Mapping>>;
+/** Creates a Ref parser */
+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 */
+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 */
+export declare function String(options: string[]): IString<string>;
+export interface IIdent<Output extends unknown = unknown> extends IParser<Output> {
+    type: 'Ident';
+}
+/** Creates an Ident parser */
+export declare function Ident<Mapping extends IMapping<string>>(mapping: Mapping): IIdent<ReturnType<Mapping>>;
+/** Creates an Ident parser */
+export declare function Ident(): IIdent<string>;
+export interface INumber<Output extends unknown = unknown> extends IParser<Output> {
+    type: 'Number';
+}
+/** Creates a Number parser */
+export declare function Number<Mapping extends IMapping<string>>(mapping: Mapping): INumber<ReturnType<Mapping>>;
+/** Creates a Number parser */
+export declare function Number(): INumber<string>;

package/build/esm/parse/parsebox/runtime/types.mjs

@@ -0,0 +1,32 @@
+/** Maps input to output. This is the default Mapping */
+export const Identity = (value) => value;
+/** Maps the output as the given parameter T */
+export const As = (mapping) => (_) => mapping;
+export function Tuple(...args) {
+    const [parsers, mapping] = args.length === 2 ? [args[0], args[1]] : [args[0], Identity];
+    return { type: 'Tuple', parsers, mapping };
+}
+export function Union(...args) {
+    const [parsers, mapping] = args.length === 2 ? [args[0], args[1]] : [args[0], Identity];
+    return { type: 'Union', parsers, mapping };
+}
+export function Const(...args) {
+    const [value, mapping] = args.length === 2 ? [args[0], args[1]] : [args[0], Identity];
+    return { type: 'Const', value, mapping };
+}
+export function Ref(...args) {
+    const [ref, mapping] = args.length === 2 ? [args[0], args[1]] : [args[0], Identity];
+    return { type: 'Ref', ref, mapping };
+}
+export function String(...params) {
+    const [options, mapping] = params.length === 2 ? [params[0], params[1]] : [params[0], Identity];
+    return { type: 'String', options, mapping };
+}
+export function Ident(...params) {
+    const mapping = params.length === 1 ? params[0] : Identity;
+    return { type: 'Ident', mapping };
+}
+export function Number(...params) {
+    const mapping = params.length === 1 ? params[0] : Identity;
+    return { type: 'Number', mapping };
+}

package/build/esm/parse/parsebox/static/index.d.mts

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

package/build/esm/parse/parsebox/static/index.mjs

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

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

@@ -0,0 +1,17 @@
+import * as Tokens from './token.mjs';
+import * as Types from './types.mjs';
+type TupleParser<Parsers extends Types.IParser[], Code extends string, Context extends unknown, Result extends unknown[] = []> = (Parsers extends [infer Left extends Types.IParser, ...infer Right extends Types.IParser[]] ? Parse<Left, Code, Context> extends [infer Value extends unknown, infer Rest extends string] ? TupleParser<Right, Rest, Context, [...Result, Value]> : [] : [Result, Code]);
+type UnionParser<Parsers extends Types.IParser[], Code extends string, Context extends unknown> = (Parsers extends [infer Left extends Types.IParser, ...infer Right extends Types.IParser[]] ? Parse<Left, Code, Context> extends [infer Value extends unknown, infer Rest extends string] ? [Value, Rest] : UnionParser<Right, Code, Context> : []);
+type 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 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 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/esm/parse/parsebox/static/parse.mjs

@@ -0,0 +1 @@
+export {};

package/build/esm/parse/parsebox/static/token.d.mts

@@ -0,0 +1,108 @@
+declare namespace Chars {
+    type Empty = '';
+    type Space = ' ';
+    type Newline = '\n';
+    type Dot = '.';
+    type Hyphen = '-';
+    type Digit = [
+        '0',
+        '1',
+        '2',
+        '3',
+        '4',
+        '5',
+        '6',
+        '7',
+        '8',
+        '9'
+    ];
+    type Alpha = [
+        'a',
+        'b',
+        'c',
+        'd',
+        'e',
+        'f',
+        'g',
+        'h',
+        'i',
+        'j',
+        'k',
+        'l',
+        'm',
+        'n',
+        'o',
+        'p',
+        'q',
+        'r',
+        's',
+        't',
+        'u',
+        'v',
+        'w',
+        'x',
+        'y',
+        'z',
+        'A',
+        'B',
+        'C',
+        'D',
+        'E',
+        'F',
+        'G',
+        'H',
+        'I',
+        'J',
+        'K',
+        'L',
+        'M',
+        'N',
+        'O',
+        'P',
+        'Q',
+        'R',
+        'S',
+        'T',
+        'U',
+        'V',
+        'W',
+        'X',
+        'Y',
+        'Z'
+    ];
+}
+declare namespace Trim {
+    type W4 = `${W3}${W3}`;
+    type W3 = `${W2}${W2}`;
+    type W2 = `${W1}${W1}`;
+    type W1 = `${W0}${W0}`;
+    type W0 = ` `;
+    /** Trims whitespace only */
+    export type TrimWhitespace<Code extends string> = (Code extends `${W4}${infer Rest extends string}` ? TrimWhitespace<Rest> : Code extends `${W3}${infer Rest extends string}` ? TrimWhitespace<Rest> : Code extends `${W1}${infer Rest extends string}` ? TrimWhitespace<Rest> : Code extends `${W0}${infer Rest extends string}` ? TrimWhitespace<Rest> : Code);
+    /** Trims Whitespace and Newline */
+    export type TrimAll<Code extends string> = (Code extends `${W4}${infer Rest extends string}` ? TrimAll<Rest> : Code extends `${W3}${infer Rest extends string}` ? TrimAll<Rest> : Code extends `${W1}${infer Rest extends string}` ? TrimAll<Rest> : Code extends `${W0}${infer Rest extends string}` ? TrimAll<Rest> : Code extends `${Chars.Newline}${infer Rest extends string}` ? TrimAll<Rest> : Code);
+    export {};
+}
+/** Scans for the next match union */
+type NextUnion<Variants extends string[], Code extends string> = (Variants extends [infer Variant extends string, ...infer Rest1 extends string[]] ? NextConst<Variant, Code> extends [infer Match extends string, infer Rest2 extends string] ? [Match, Rest2] : NextUnion<Rest1, Code> : []);
+type NextConst<Value extends string, Code extends string> = (Code extends `${Value}${infer Rest extends string}` ? [Value, Rest] : []);
+/** Scans for the next constant value */
+export type Const<Value extends string, Code extends string> = (Value extends '' ? ['', Code] : Value extends `${infer First extends string}${string}` ? (First extends Chars.Newline ? NextConst<Value, Trim.TrimWhitespace<Code>> : First extends Chars.Space ? NextConst<Value, Code> : NextConst<Value, Trim.TrimAll<Code>>) : never);
+type NextNumberNegate<Code extends string> = (Code extends `${Chars.Hyphen}${infer Rest extends string}` ? [Chars.Hyphen, Rest] : [Chars.Empty, Code]);
+type NextNumberZeroCheck<Code extends string> = (Code extends `0${infer Rest}` ? NextUnion<Chars.Digit, Rest> extends [string, string] ? false : true : true);
+type NextNumberScan<Code extends string, HasDecimal extends boolean = false, Result extends string = Chars.Empty> = (NextUnion<[...Chars.Digit, Chars.Dot], Code> extends [infer Char extends string, infer Rest extends string] ? Char extends Chars.Dot ? HasDecimal extends false ? NextNumberScan<Rest, true, `${Result}${Char}`> : [Result, `.${Rest}`] : NextNumberScan<Rest, HasDecimal, `${Result}${Char}`> : [Result, Code]);
+export type NextNumber<Code extends string> = (NextNumberNegate<Code> extends [infer Negate extends string, infer Rest extends string] ? NextNumberZeroCheck<Rest> extends true ? NextNumberScan<Rest> extends [infer Number extends string, infer Rest2 extends string] ? Number extends Chars.Empty ? [] : [`${Negate}${Number}`, Rest2] : [] : [] : []);
+/** Scans for the next literal number */
+export type Number<Code extends string> = NextNumber<Trim.TrimAll<Code>>;
+type NextStringQuote<Options extends string[], Code extends string> = NextUnion<Options, Code>;
+type NextStringBody<Code extends string, Quote extends string, Result extends string = Chars.Empty> = (Code extends `${infer Char extends string}${infer Rest extends string}` ? Char extends Quote ? [Result, Rest] : NextStringBody<Rest, Quote, `${Result}${Char}`> : []);
+type NextString<Options extends string[], Code extends string> = (NextStringQuote<Options, Code> extends [infer Quote extends string, infer Rest extends string] ? NextStringBody<Rest, Quote> extends [infer String extends string, infer Rest extends string] ? [String, Rest] : [] : []);
+/** Scans for the next literal string */
+export type String<Options extends string[], Code extends string> = NextString<Options, Trim.TrimAll<Code>>;
+type IdentLeft = [...Chars.Alpha, '_', '$'];
+type IdentRight = [...Chars.Digit, ...IdentLeft];
+type NextIdentScan<Code extends string, Result extends string = Chars.Empty> = (NextUnion<IdentRight, Code> extends [infer Char extends string, infer Rest extends string] ? NextIdentScan<Rest, `${Result}${Char}`> : [Result, Code]);
+type NextIdent<Code extends string> = (NextUnion<IdentLeft, Code> extends [infer Left extends string, infer Rest1 extends string] ? NextIdentScan<Rest1> extends [infer Right extends string, infer Rest2 extends string] ? [`${Left}${Right}`, Rest2] : [] : []);
+/** Scans for the next Ident */
+export type Ident<Code extends string> = NextIdent<Trim.TrimAll<Code>>;
+export {};

package/build/esm/parse/parsebox/static/token.mjs

@@ -0,0 +1 @@
+export {};

package/build/esm/parse/parsebox/static/types.d.mts

@@ -0,0 +1,46 @@
+export interface IMapping {
+    context: unknown;
+    input: unknown;
+    output: unknown;
+}
+/** Maps input to output. This is the default Mapping */
+export interface Identity extends IMapping {
+    output: this['input'];
+}
+/** Maps the output as the given parameter T */
+export interface As<T> extends IMapping {
+    output: T;
+}
+/** Base type Parser implemented by all other parsers */
+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];
+}
+/** Creates a Union Parser */
+export interface Union<Parsers extends IParser[] = [], Mapping extends IMapping = Identity> extends IParser<Mapping> {
+    type: 'Union';
+    parsers: [...Parsers];
+}
+/** 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. */
+export interface Ident<Mapping extends IMapping = Identity> extends IParser<Mapping> {
+    type: 'Ident';
+}
+/** Creates a Number Parser. */
+export interface Number<Mapping extends IMapping = Identity> extends IParser<Mapping> {
+    type: 'Number';
+}

package/build/esm/parse/parsebox/static/types.mjs

@@ -0,0 +1 @@
+export {};