@wecode-ai/weibo-openclaw-plugin 1.0.1 → 1.0.2

package/node_modules/@sinclair/typebox/build/esm/parser/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/node_modules/@sinclair/typebox/build/esm/parser/runtime/types.d.mts

@@ -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/node_modules/@sinclair/typebox/build/esm/parser/runtime/types.mjs

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

package/node_modules/@sinclair/typebox/build/esm/parser/static/index.d.mts

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

package/node_modules/@sinclair/typebox/build/esm/parser/static/index.mjs

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

package/node_modules/@sinclair/typebox/build/esm/parser/static/parse.d.mts

@@ -0,0 +1,20 @@
+import * as Tokens from './token.mjs';
+import * as Types from './types.mjs';
+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/node_modules/@sinclair/typebox/build/esm/parser/static/parse.mjs

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

package/node_modules/@sinclair/typebox/build/esm/parser/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/node_modules/@sinclair/typebox/build/esm/parser/static/token.mjs

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

package/node_modules/@sinclair/typebox/build/esm/parser/static/types.d.mts

@@ -0,0 +1,69 @@
+/**
+ * `[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;
+}
+/** `[ACTION]` Default inference mapping. */
+export interface Identity extends IMapping {
+    output: this['input'];
+}
+/** `[ACTION]` Maps the given argument `T` as the mapping output */
+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;
+}
+/** `[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;
+}
+/** `[EBNF]` Creates an Array Parser */
+export interface Array<Parser extends IParser = IParser, Mapping extends IMapping = Identity> extends IParser<Mapping> {
+    type: 'Array';
+    parser: Parser;
+}
+/** `[TERM]` Creates a Const Parser */
+export interface Const<Value extends string = string, Mapping extends IMapping = Identity> extends IParser<Mapping> {
+    type: 'Const';
+    value: Value;
+}
+/** `[TERM]` Creates an Ident Parser. */
+export interface Ident<Mapping extends IMapping = Identity> extends IParser<Mapping> {
+    type: 'Ident';
+}
+/** `[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/node_modules/@sinclair/typebox/build/esm/parser/static/types.mjs

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

package/node_modules/@sinclair/typebox/build/esm/syntax/index.d.mts

@@ -0,0 +1 @@
+export * from './syntax.mjs';

package/node_modules/@sinclair/typebox/build/esm/syntax/index.mjs

@@ -0,0 +1 @@
+export * from './syntax.mjs';