@nyariv/sandboxjs 0.8.23 → 0.8.24

package/dist/node/parser.d.ts

@@ -1,94 +1,4 @@
-export declare const enum LispType {
-    None = 0,
-    Prop = 1,
-    StringIndex = 2,
-    Let = 3,
-    Const = 4,
-    Call = 5,
-    KeyVal = 6,
-    Number = 7,
-    Return = 8,
-    Assign = 9,
-    InlineFunction = 10,
-    ArrowFunction = 11,
-    CreateArray = 12,
-    If = 13,
-    IfCase = 14,
-    InlineIf = 15,
-    InlineIfCase = 16,
-    SpreadObject = 17,
-    SpreadArray = 18,
-    ArrayProp = 19,
-    PropOptional = 20,
-    CallOptional = 21,
-    CreateObject = 22,
-    Group = 23,
-    Not = 24,
-    IncrementBefore = 25,
-    IncrementAfter = 26,
-    DecrementBefore = 27,
-    DecrementAfter = 28,
-    And = 29,
-    Or = 30,
-    StrictNotEqual = 31,
-    StrictEqual = 32,
-    Plus = 33,
-    Var = 34,
-    GlobalSymbol = 35,
-    Literal = 36,
-    Function = 37,
-    Loop = 38,
-    Try = 39,
-    Switch = 40,
-    SwitchCase = 41,
-    Block = 42,
-    Expression = 43,
-    Await = 44,
-    New = 45,
-    Throw = 46,
-    Minus = 47,
-    Divide = 48,
-    Power = 49,
-    Multiply = 50,
-    Modulus = 51,
-    Equal = 52,
-    NotEqual = 53,
-    SmallerEqualThan = 54,
-    LargerEqualThan = 55,
-    SmallerThan = 56,
-    LargerThan = 57,
-    Negative = 58,
-    Positive = 59,
-    Typeof = 60,
-    Delete = 61,
-    Instanceof = 62,
-    In = 63,
-    Inverse = 64,
-    SubractEquals = 65,
-    AddEquals = 66,
-    DivideEquals = 67,
-    PowerEquals = 68,
-    MultiplyEquals = 69,
-    ModulusEquals = 70,
-    BitNegateEquals = 71,
-    BitAndEquals = 72,
-    BitOrEquals = 73,
-    UnsignedShiftRightEquals = 74,
-    ShiftRightEquals = 75,
-    ShiftLeftEquals = 76,
-    BitAnd = 77,
-    BitOr = 78,
-    BitNegate = 79,
-    BitShiftLeft = 80,
-    BitShiftRight = 81,
-    BitUnsignedShiftRight = 82,
-    BigInt = 83,
-    LiteralIndex = 84,
-    RegexIndex = 85,
-    LoopAction = 86,
-    Void = 87,
-    True = 88
-}
+import { CodeString, LispType } from './utils.js';
 export type DefineLisp<op extends LispType, a extends LispItem | LispItem, b extends LispItem | LispItem> = [op, a, b];
 export type ExtractLispOp<L> = L extends DefineLisp<infer i, any, any> ? i : never;
 export type ExtractLispA<L> = L extends DefineLisp<any, infer i, any> ? i : never;
@@ -103,7 +13,7 @@ export type If = DefineLisp<LispType.If, Lisp, IfCase>;
 export type InlineIf = DefineLisp<LispType.InlineIf, Lisp, InlineIfCase>;
 export type IfCase = DefineLisp<LispType.IfCase, Lisp[], Lisp[]>;
 export type InlineIfCase = DefineLisp<LispType.InlineIfCase, Lisp, Lisp>;
-export type KeyVal = DefineLisp<LispType.KeyVal, string | Lisp, Lisp[]>;
+export type KeyVal = DefineLisp<LispType.KeyVal, string | Lisp, Lisp>;
 export type SpreadObject = DefineLisp<LispType.SpreadObject, LispType.None, Lisp>;
 export type SpreadArray = DefineLisp<LispType.SpreadArray, LispType.None, Lisp>;
 export type ArrayProp = DefineLisp<LispType.ArrayProp, Lisp, Lisp>;
@@ -209,151 +119,11 @@ export declare class ParseError extends Error {
     code: string;
     constructor(message: string, code: string);
 }
-export declare let expectTypes: {
-    readonly splitter: {
-        readonly types: {
-            readonly opHigh: RegExp;
-            readonly op: RegExp;
-            readonly comparitor: RegExp;
-            readonly boolOp: RegExp;
-            readonly bitwise: RegExp;
-        };
-        readonly next: readonly ["modifier", "value", "prop", "incrementerBefore"];
-    };
-    readonly inlineIf: {
-        readonly types: {
-            readonly inlineIf: RegExp;
-        };
-        readonly next: readonly ["expEnd"];
-    };
-    readonly assignment: {
-        readonly types: {
-            readonly assignModify: RegExp;
-            readonly assign: RegExp;
-        };
-        readonly next: readonly ["modifier", "value", "prop", "incrementerBefore"];
-    };
-    readonly incrementerBefore: {
-        readonly types: {
-            readonly incrementerBefore: RegExp;
-        };
-        readonly next: readonly ["prop"];
-    };
-    readonly expEdge: {
-        readonly types: {
-            readonly call: RegExp;
-            readonly incrementerAfter: RegExp;
-        };
-        readonly next: readonly ["splitter", "expEdge", "dot", "inlineIf", "expEnd"];
-    };
-    readonly modifier: {
-        readonly types: {
-            readonly not: RegExp;
-            readonly inverse: RegExp;
-            readonly negative: RegExp;
-            readonly positive: RegExp;
-            readonly typeof: RegExp;
-            readonly delete: RegExp;
-        };
-        readonly next: readonly ["modifier", "value", "prop", "incrementerBefore"];
-    };
-    readonly dot: {
-        readonly types: {
-            readonly arrayProp: RegExp;
-            readonly dot: RegExp;
-        };
-        readonly next: readonly ["splitter", "assignment", "expEdge", "dot", "inlineIf", "expEnd"];
-    };
-    readonly prop: {
-        readonly types: {
-            readonly prop: RegExp;
-        };
-        readonly next: readonly ["splitter", "assignment", "expEdge", "dot", "inlineIf", "expEnd"];
-    };
-    readonly value: {
-        readonly types: {
-            readonly createObject: RegExp;
-            readonly createArray: RegExp;
-            readonly number: RegExp;
-            readonly string: RegExp;
-            readonly literal: RegExp;
-            readonly regex: RegExp;
-            readonly boolean: RegExp;
-            readonly null: RegExp;
-            readonly und: RegExp;
-            readonly arrowFunctionSingle: RegExp;
-            readonly arrowFunction: RegExp;
-            readonly inlineFunction: RegExp;
-            readonly group: RegExp;
-            readonly NaN: RegExp;
-            readonly Infinity: RegExp;
-            readonly void: RegExp;
-            readonly await: RegExp;
-            readonly new: RegExp;
-        };
-        readonly next: readonly ["splitter", "expEdge", "dot", "inlineIf", "expEnd"];
-    };
-    readonly initialize: {
-        readonly types: {
-            readonly initialize: RegExp;
-            readonly return: RegExp;
-            readonly throw: RegExp;
-        };
-        readonly next: readonly ["modifier", "value", "prop", "incrementerBefore", "expEnd"];
-    };
-    readonly spreadObject: {
-        readonly types: {
-            readonly spreadObject: RegExp;
-        };
-        readonly next: readonly ["value", "prop"];
-    };
-    readonly spreadArray: {
-        readonly types: {
-            readonly spreadArray: RegExp;
-        };
-        readonly next: readonly ["value", "prop"];
-    };
-    readonly expEnd: {
-        readonly types: {};
-        readonly next: readonly [];
-    };
-    readonly expFunction: {
-        readonly types: {
-            readonly function: RegExp;
-        };
-        readonly next: readonly ["expEdge", "expEnd"];
-    };
-    readonly expSingle: {
-        readonly types: {
-            readonly for: RegExp;
-            readonly do: RegExp;
-            readonly while: RegExp;
-            readonly loopAction: RegExp;
-            readonly if: RegExp;
-            readonly try: RegExp;
-            readonly block: RegExp;
-            readonly switch: RegExp;
-        };
-        readonly next: readonly ["expEnd"];
-    };
-};
-export declare function testMultiple(str: string, tests: RegExp[]): RegExpExecArray;
-export declare class CodeString {
-    start: number;
-    end: number;
-    ref: {
-        str: string;
-    };
-    constructor(str: string | CodeString);
-    substring(start: number, end?: number): CodeString;
-    get length(): number;
-    char(i: number): string;
-    toString(): string;
-    trimStart(): CodeString;
-    slice(start: number, end?: number): CodeString;
-    trim(): CodeString;
-    valueOf(): string;
-}
+export declare const expectTypes: Record<string, {
+    types: Record<string, RegExp>;
+    next: string[];
+}>;
+export declare function testMultiple(str: string, tests: RegExp[]): RegExpExecArray | null;
 export interface restDetails {
     oneliner?: boolean;
     words?: string[];
@@ -369,12 +139,11 @@ export declare const setLispType: <T extends readonly string[]>(types: T, fn: Li
 export declare function lispifyReturnExpr(constants: IConstants, str: CodeString): Return;
 export declare function lispifyBlock(str: CodeString, constants: IConstants, expression?: boolean): Lisp[];
 export declare function lispifyFunction(str: CodeString, constants: IConstants, expression?: boolean): Lisp[];
-export declare function isLisp<Type extends Lisp = Lisp>(item: LispItem | LispItem): item is Type;
 export declare function insertSemicolons(constants: IConstants, str: CodeString): CodeString;
 export declare function checkRegex(str: string): IRegEx | null;
 export declare function extractConstants(constants: IConstants, str: string, currentEnclosure?: string): {
     str: string;
     length: number;
 };
-export declare function parse(code: string, eager?: boolean, expression?: boolean): IExecutionTree;
+export default function parse(code: string, eager?: boolean, expression?: boolean): IExecutionTree;
 export {};