@evalops/maestro 0.10.20 → 0.10.21

package/node_modules/@sinclair/typebox/build/cjs/parser/runtime/parse.js

@@ -1,160 +0,0 @@
-"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/node_modules/@sinclair/typebox/build/cjs/parser/runtime/token.d.ts

@@ -1,8 +0,0 @@
-/** 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/node_modules/@sinclair/typebox/build/cjs/parser/runtime/token.js

@@ -1,230 +0,0 @@
-"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/node_modules/@sinclair/typebox/build/cjs/parser/runtime/types.d.ts

@@ -1,98 +0,0 @@
-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/cjs/parser/runtime/types.js

@@ -1,71 +0,0 @@
-"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/node_modules/@sinclair/typebox/build/cjs/parser/static/index.d.ts

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

package/node_modules/@sinclair/typebox/build/cjs/parser/static/index.js

@@ -1,43 +0,0 @@
-"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/node_modules/@sinclair/typebox/build/cjs/parser/static/parse.d.ts

@@ -1,20 +0,0 @@
-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/node_modules/@sinclair/typebox/build/cjs/parser/static/parse.js

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