xmlui 0.8.6 → 0.9.1

package/dist/xmlui.d.ts

@@ -28,6 +28,7 @@ declare interface ActionExecutionContext {
      * The state of the container that the action is executed in.
      */
     state: ContainerState;
+    getCurrentState: () => ContainerState;
     /**
      * The appContext object passed to the current app
      */
@@ -338,34 +339,43 @@ declare type AppWrapperProps = {
     sources?: Record<string, string>;
 };
 
+declare type ARRAY_DESTRUCTURE = typeof T_ARRAY_DESTRUCTURE;
+
+declare type ARRAY_LITERAL = typeof T_ARRAY_LITERAL;
+
 declare interface ArrayDestructure extends DestructureBase {
-    type: "ADestr";
+    type: ARRAY_DESTRUCTURE;
 }
 
 declare interface ArrayLiteral extends ExpressionBase {
-    type: "ALitE";
+    type: ARRAY_LITERAL;
     items: Expression[];
     loose?: boolean;
 }
 
+declare type ARROW_EXPRESSION = typeof T_ARROW_EXPRESSION;
+
+declare type ARROW_EXPRESSION_STATEMENT = typeof T_ARROW_EXPRESSION_STATEMENT;
+
 declare interface ArrowExpression extends ExpressionBase {
-    type: "ArrowE";
+    type: ARROW_EXPRESSION;
     name?: string;
     args: Expression[];
     statement: Statement;
-    closureContext?: BlockScope[];
 }
 
-declare interface ArrowExpressionStatement extends StatementBase {
-    type: "ArrowS";
-    expression: ArrowExpression;
+declare interface ArrowExpressionStatement extends ScripNodeBase {
+    type: ARROW_EXPRESSION_STATEMENT;
+    expr: ArrowExpression;
 }
 
+declare type ASSIGNMENT_EXPRESSION = typeof T_ASSIGNMENT_EXPRESSION;
+
 declare interface AssignmentExpression extends ExpressionBase {
-    type: "AsgnE";
+    type: ASSIGNMENT_EXPRESSION;
     leftValue: Expression;
-    operator: AssignmentSymbols;
-    operand: Expression;
+    op: AssignmentSymbols;
+    expr: Expression;
 }
 
 declare type AssignmentSymbols = "=" | "+=" | "-=" | "**=" | "*=" | "/=" | "%=" | "<<=" | ">>=" | ">>>=" | "&=" | "^=" | "|=" | "&&=" | "||=" | "??=";
@@ -380,71 +390,28 @@ declare type AuthDefinition = {
     defaultLoggedInUser?: any;
 };
 
-declare interface BaseNode {
-    /**
-     * Node type discriminator
-     */
-    type: Node_2["type"];
-    /**
-     * Start position (inclusive) of the node
-     */
-    startPosition?: number;
-    /**
-     * End position (exclusive)
-     */
-    endPosition?: number;
-    /**
-     * Start line number of the start token of the node
-     */
-    startLine?: number;
-    /**
-     * End line number of the end token of the node
-     */
-    endLine?: number;
-    /**
-     * Start column number (inclusive) of the node
-     */
-    startColumn?: number;
-    /**
-     * End column number (exclusive) of the node
-     */
-    endColumn?: number;
-    /**
-     * The source code of the expression
-     */
-    source?: string;
-    /**
-     * The start token of the node
-     */
-    startToken?: Token;
-    /**
-     * The end token of the node
-     */
-    endToken?: Token;
-}
+declare type BINARY_EXPRESSION = typeof T_BINARY_EXPRESSION;
 
 declare interface BinaryExpression extends ExpressionBase {
-    type: "BinaryE";
-    operator: BinaryOpSymbols;
+    type: BINARY_EXPRESSION;
+    op: BinaryOpSymbols;
     left: Expression;
     right: Expression;
 }
 
 declare type BinaryOpSymbols = "**" | "*" | "/" | "%" | "+" | "-" | "<<" | ">>" | ">>>" | "<" | "<=" | ">" | ">=" | "==" | "===" | "!=" | "!==" | "&" | "|" | "^" | "&&" | "||" | "??" | "in";
 
-declare type BlockScope = {
-    vars: Record<string, any>;
-    constVars?: Set<string>;
-    returnValue?: any;
-};
+declare type BLOCK_STATEMENT = typeof T_BLOCK_STATEMENT;
 
-declare interface BlockStatement extends StatementBase {
-    type: "BlockS";
-    statements: Statement[];
+declare interface BlockStatement extends ScripNodeBase {
+    type: BLOCK_STATEMENT;
+    stmts: Statement[];
 }
 
-declare interface BreakStatement extends StatementBase {
-    type: "BrkS";
+declare type BREAK_STATEMENT = typeof T_BREAK_STATEMENT;
+
+declare interface BreakStatement extends ScripNodeBase {
+    type: BREAK_STATEMENT;
 }
 
 export declare const Button: default_2.ForwardRefExoticComponent<{
@@ -478,9 +445,11 @@ declare type ButtonVariant = (typeof buttonVariantValues)[number];
 
 declare const buttonVariantValues: readonly ["solid", "outlined", "ghost"];
 
+declare type CALCULATED_MEMBER_ACCESS_EXPRESSION = typeof T_CALCULATED_MEMBER_ACCESS_EXPRESSION;
+
 declare interface CalculatedMemberAccessExpression extends ExpressionBase {
-    type: "CMembE";
-    object: Expression;
+    type: CALCULATED_MEMBER_ACCESS_EXPRESSION;
+    obj: Expression;
     member: Expression;
 }
 
@@ -743,17 +712,20 @@ export declare interface CompoundComponentDef extends Scriptable {
     debug?: Record<string, any>;
 }
 
+declare type CONDITIONAL_EXPRESSION = typeof T_CONDITIONAL_EXPRESSION;
+
 declare interface ConditionalExpression extends ExpressionBase {
-    type: "CondE";
-    condition: Expression;
-    consequent: Expression;
-    alternate: Expression;
+    type: CONDITIONAL_EXPRESSION;
+    cond: Expression;
+    thenE: Expression;
+    elseE: Expression;
 }
 
-declare interface ConstStatement extends StatementBase {
-    type: "ConstS";
-    declarations: VarDeclaration[];
-    isExported?: boolean;
+declare type CONST_STATEMENT = typeof T_CONST_STATEMENT;
+
+declare interface ConstStatement extends ScripNodeBase {
+    type: CONST_STATEMENT;
+    decls: VarDeclaration[];
 }
 
 /**
@@ -762,8 +734,10 @@ declare interface ConstStatement extends StatementBase {
  */
 declare type ContainerState = Record<string | symbol, any>;
 
-declare interface ContinueStatement extends StatementBase {
-    type: "ContS";
+declare type CONTINUE_STATEMENT = typeof T_CONTINUE_STATEMENT;
+
+declare interface ContinueStatement extends ScripNodeBase {
+    type: CONTINUE_STATEMENT;
 }
 
 /**
@@ -803,21 +777,25 @@ declare type DefaultThemeVars = Record<string | ThemeTone_2, string | Record<str
 
 declare type DefaultValueDescriptor = (string | ThemeIdDescriptor)[];
 
+declare type DESTRUCTURE = typeof T_DESTRUCTURE;
+
 declare interface Destructure extends DestructureBase {
-    type: "Destr";
-    arrayDestruct?: ArrayDestructure[];
-    objectDestruct?: ObjectDestructure[];
+    type: DESTRUCTURE;
+    aDestr?: ArrayDestructure[];
+    oDestr?: ObjectDestructure[];
 }
 
 declare interface DestructureBase extends ExpressionBase {
     id?: string;
-    arrayDestruct?: ArrayDestructure[];
-    objectDestruct?: ObjectDestructure[];
+    aDestr?: ArrayDestructure[];
+    oDestr?: ObjectDestructure[];
 }
 
-declare interface DoWhileStatement extends StatementBase {
-    type: "DoWS";
-    condition: Expression;
+declare type DO_WHILE_STATEMENT = typeof T_DO_WHILE_STATEMENT;
+
+declare interface DoWhileStatement extends ScripNodeBase {
+    type: DO_WHILE_STATEMENT;
+    cond: Expression;
     body: Statement;
 }
 
@@ -841,8 +819,10 @@ declare interface DynamicChildComponentDef extends ComponentDef {
     childToRender: ComponentDef;
 }
 
-declare interface EmptyStatement extends StatementBase {
-    type: "EmptyS";
+declare type EMPTY_STATEMENT = typeof T_EMPTY_STATEMENT;
+
+declare interface EmptyStatement extends ScripNodeBase {
+    type: EMPTY_STATEMENT;
 }
 
 /**
@@ -880,18 +860,17 @@ export declare class ErrorBoundary extends default_2.Component<Props, State> {
     render(): string | number | boolean | Iterable<default_2.ReactNode> | JSX_2.Element;
 }
 
-declare type Expression = UnaryExpression | BinaryExpression | SequenceExpression | ConditionalExpression | FunctionInvocationExpression | MemberAccessExpression | CalculatedMemberAccessExpression | Identifier | Literal | ArrayLiteral | ObjectLiteral | SpreadExpression | AssignmentExpression | NoArgExpression | ArrowExpression | PrefixOpExpression | PostfixOpExpression | ReactiveVarDeclaration | VarDeclaration | Destructure | ObjectDestructure | ArrayDestructure | TemplateLiteralExpression;
+declare type Expression = UnaryExpression | BinaryExpression | SequenceExpression | ConditionalExpression | FunctionInvocationExpression | MemberAccessExpression | CalculatedMemberAccessExpression | Identifier | TemplateLiteralExpression | Literal | ArrayLiteral | ObjectLiteral | SpreadExpression | AssignmentExpression | NoArgExpression | ArrowExpression | PrefixOpExpression | PostfixOpExpression | ReactiveVarDeclaration | VarDeclaration | Destructure | ObjectDestructure | ArrayDestructure | SwitchCase;
 
-declare interface ExpressionBase extends BaseNode {
-    value?: any;
+declare type EXPRESSION_STATEMENT = typeof T_EXPRESSION_STATEMENT;
+
+declare interface ExpressionBase extends ScripNodeBase {
     parenthesized?: number;
-    valueScope?: any;
-    valueIndex?: string | number;
 }
 
-declare interface ExpressionStatement extends StatementBase {
-    type: "ExprS";
-    expression: Expression;
+declare interface ExpressionStatement extends ScripNodeBase {
+    type: EXPRESSION_STATEMENT;
+    expr: Expression;
 }
 
 declare interface Extension {
@@ -968,50 +947,66 @@ declare type FontDef_2 = {
     src: string;
 } | string;
 
-declare interface ForInStatement extends StatementBase {
-    type: "ForInS";
-    varBinding: ForVarBinding;
-    id: string;
-    expression: Expression;
+declare type FOR_IN_STATEMENT = typeof T_FOR_IN_STATEMENT;
+
+declare type FOR_OF_STATEMENT = typeof T_FOR_OF_STATEMENT;
+
+declare type FOR_STATEMENT = typeof T_FOR_STATEMENT;
+
+declare interface ForInStatement extends ScripNodeBase {
+    type: FOR_IN_STATEMENT;
+    varB: ForVarBinding;
+    id: Identifier;
+    expr: Expression;
     body: Statement;
-    keys?: string[];
-    keyIndex?: number;
 }
 
-declare interface ForOfStatement extends StatementBase {
-    type: "ForOfS";
-    varBinding: ForVarBinding;
-    id: string;
-    expression: Expression;
+declare interface ForOfStatement extends ScripNodeBase {
+    type: FOR_OF_STATEMENT;
+    varB: ForVarBinding;
+    id: Identifier;
+    expr: Expression;
     body: Statement;
-    iterator?: any;
 }
 
-declare interface ForStatement extends StatementBase {
-    type: "ForS";
+declare interface ForStatement extends ScripNodeBase {
+    type: FOR_STATEMENT;
     init?: ExpressionStatement | LetStatement;
-    condition?: Expression;
-    update?: Expression;
+    cond?: Expression;
+    upd?: Expression;
     body: Statement;
 }
 
 declare type ForVarBinding = "let" | "const" | "none";
 
-declare interface FunctionDeclaration extends StatementBase {
-    type: "FuncD";
-    name?: string;
+declare type FUNCTION_DECLARATION = typeof T_FUNCTION_DECLARATION;
+
+declare type FUNCTION_INVOCATION_EXPRESSION = typeof T_FUNCTION_INVOCATION_EXPRESSION;
+
+declare interface FunctionDeclaration extends ScripNodeBase {
+    type: FUNCTION_DECLARATION;
+    id: Identifier;
     args: Expression[];
-    statement: BlockStatement;
-    isExported?: boolean;
-    closureContext?: BlockScope[];
+    stmt: BlockStatement;
 }
 
 declare interface FunctionInvocationExpression extends ExpressionBase {
-    type: "InvokeE";
-    object: Expression;
+    type: FUNCTION_INVOCATION_EXPRESSION;
+    obj: Expression;
     arguments: Expression[];
 }
 
+declare type GenericToken<T> = {
+    text: string;
+    type: T;
+    startPosition: number;
+    endPosition: number;
+    startLine: number;
+    endLine: number;
+    startColumn: number;
+    endColumn: number;
+};
+
 export declare function getColor(varName: string, format?: "hex" | "rgb" | "hsl"): string;
 
 declare type GlobalProps = Record<string, any>;
@@ -1032,24 +1027,21 @@ declare type IconPosition = (typeof iconPositionValues)[number];
 
 declare const iconPositionValues: readonly ["start", "end"];
 
+declare type IDENTIFIER = typeof T_IDENTIFIER;
+
 declare interface Identifier extends ExpressionBase {
-    type: "IdE";
+    type: IDENTIFIER;
     name: string;
     isGlobal?: boolean;
 }
 
-declare interface IfStatement extends StatementBase {
-    type: "IfS";
-    condition: Expression;
-    thenBranch: Statement;
-    elseBranch?: Statement;
-}
+declare type IF_STATEMENT = typeof T_IF_STATEMENT;
 
-declare interface ImportDeclaration extends StatementBase {
-    type: "ImportD";
-    imports: Record<string, string>;
-    moduleFile: string;
-    module?: ScriptModule | null;
+declare interface IfStatement extends ScripNodeBase {
+    type: IF_STATEMENT;
+    cond: Expression;
+    thenB: Statement;
+    elseB?: Statement;
 }
 
 declare type InterceptorOperationDef = {
@@ -1091,13 +1083,17 @@ declare type LayoutContext<T extends ComponentDef = ComponentDef> = {
     [key: string]: any;
 };
 
-declare interface LetStatement extends StatementBase {
-    type: "LetS";
-    declarations: VarDeclaration[];
+declare type LET_STATEMENT = typeof T_LET_STATEMENT;
+
+declare interface LetStatement extends ScripNodeBase {
+    type: LET_STATEMENT;
+    decls: VarDeclaration[];
 }
 
+declare type LITERAL = typeof T_LITERAL;
+
 declare interface Literal extends ExpressionBase {
-    type: "LitE";
+    type: LITERAL;
     value: any;
 }
 
@@ -1132,6 +1128,7 @@ declare type LookupActionOptions = {
      * This property declares the script code to use as a default for a particular event handler.
      */
     defaultHandler?: string;
+    context?: any;
 };
 
 /**
@@ -1177,11 +1174,13 @@ declare type MediaSize = {
     sizeIndex: number;
 };
 
+declare type MEMBER_ACCESS_EXPRESSION = typeof T_MEMBER_ACCESS_EXPRESSION;
+
 declare interface MemberAccessExpression extends ExpressionBase {
-    type: "MembE";
-    object: Expression;
+    type: MEMBER_ACCESS_EXPRESSION;
+    obj: Expression;
     member: string;
-    isOptional?: boolean;
+    opt?: boolean;
 }
 
 declare type Message = ValueOrFunction<Renderable, Toast>;
@@ -1191,20 +1190,24 @@ declare type Message = ValueOrFunction<Renderable, Toast>;
  */
 declare type ModuleErrors = Record<string, ScriptParserErrorMessage[]>;
 
+declare type NO_ARG_EXPRESSION = typeof T_NO_ARG_EXPRESSION;
+
 declare interface NoArgExpression extends ExpressionBase {
-    type: "NoArgE";
+    type: NO_ARG_EXPRESSION;
 }
 
-declare type Node_2 = Statement | Expression | SwitchCase;
+declare type OBJECT_DESTRUCTURE = typeof T_OBJECT_DESTRUCTURE;
+
+declare type OBJECT_LITERAL = typeof T_OBJECT_LITERAL;
 
 declare interface ObjectDestructure extends DestructureBase {
-    type: "ODestr";
+    type: OBJECT_DESTRUCTURE;
     id: string;
     alias?: string;
 }
 
 declare interface ObjectLiteral extends ExpressionBase {
-    type: "OLitE";
+    type: OBJECT_LITERAL;
     props: (SpreadExpression | [Expression, Expression])[];
 }
 
@@ -1225,16 +1228,20 @@ declare interface ParentRenderContext {
  */
 export declare function parseScssVar(scssStr: any): any;
 
+declare type POSTFIX_OP_EXPRESSION = typeof T_POSTFIX_OP_EXPRESSION;
+
 declare interface PostfixOpExpression extends ExpressionBase {
-    type: "PostfE";
-    operator: PrefixOpSymbol;
-    operand: Expression;
+    type: POSTFIX_OP_EXPRESSION;
+    op: PrefixOpSymbol;
+    expr: Expression;
 }
 
+declare type PREFIX_OP_EXPRESSION = typeof T_PREFIX_OP_EXPRESSION;
+
 declare interface PrefixOpExpression extends ExpressionBase {
-    type: "PrefE";
-    operator: PrefixOpSymbol;
-    operand: Expression;
+    type: PREFIX_OP_EXPRESSION;
+    op: PrefixOpSymbol;
+    expr: Expression;
 }
 
 declare type PrefixOpSymbol = "++" | "--";
@@ -1270,10 +1277,12 @@ declare type Props_2 = {
     onMount?: any;
 };
 
+declare type REACTIVE_VAR_DECLARATION = typeof T_REACTIVE_VAR_DECLARATION;
+
 declare interface ReactiveVarDeclaration extends ExpressionBase {
-    type: "RVarD";
-    id: string;
-    expression: Expression;
+    type: REACTIVE_VAR_DECLARATION;
+    id: Identifier;
+    expr: Expression;
 }
 
 /**
@@ -1323,9 +1332,11 @@ export declare interface RendererContext<TMd extends ComponentMetadata = Compone
     layoutCss: CSSProperties;
 }
 
-declare interface ReturnStatement extends StatementBase {
-    type: "RetS";
-    expression?: Expression;
+declare type RETURN_STATEMENT = typeof T_RETURN_STATEMENT;
+
+declare interface ReturnStatement extends ScripNodeBase {
+    type: RETURN_STATEMENT;
+    expr?: Expression;
 }
 
 declare type SchemaDescriptor = {
@@ -1334,6 +1345,13 @@ declare type SchemaDescriptor = {
     dtos?: any;
 };
 
+declare interface ScripNodeBase {
+    type: ScriptNode["type"];
+    nodeId: number;
+    startToken?: ScriptingToken;
+    endToken?: ScriptingToken;
+}
+
 /**
  * This interface holds the properties representing a scriptable component definition.
  */
@@ -1352,20 +1370,9 @@ declare interface Scriptable {
     scriptError?: any;
 }
 
-/**
- * Represents a parsed and resolved module
- */
-declare type ScriptModule = {
-    type: "ScriptModule";
-    name: string;
-    parent?: ScriptModule | null;
-    exports: Map<string, any>;
-    imports: Record<string, Record<string, any>>;
-    importedModules: ScriptModule[];
-    functions: Record<string, FunctionDeclaration>;
-    statements: Statement[];
-    executed: boolean;
-};
+declare type ScriptingToken = GenericToken<TokenType>;
+
+declare type ScriptNode = Statement | Expression;
 
 declare interface ScriptParserErrorMessage {
     code: ScriptParsingErrorCodes;
@@ -1377,9 +1384,11 @@ declare interface ScriptParserErrorMessage {
 
 declare type ScriptParsingErrorCodes = "W001" | "W002" | "W003" | "W004" | "W005" | "W006" | "W007" | "W008" | "W009" | "W010" | "W011" | "W012" | "W013" | "W014" | "W015" | "W016" | "W017" | "W018" | "W019" | "W020" | "W021" | "W022" | "W023" | "W024" | "W025" | "W026" | "W027" | "W028" | "W029" | "W030" | "W031";
 
+declare type SEQUENCE_EXPRESSION = typeof T_SEQUENCE_EXPRESSION;
+
 declare interface SequenceExpression extends ExpressionBase {
-    type: "SeqE";
-    expressions: Expression[];
+    type: SEQUENCE_EXPRESSION;
+    exprs: Expression[];
     loose?: boolean;
 }
 
@@ -1400,9 +1409,11 @@ declare type SplitterProps = {
     maxPrimarySize?: string;
 };
 
+declare type SPREAD_EXPRESSION = typeof T_SPREAD_EXPRESSION;
+
 declare interface SpreadExpression extends ExpressionBase {
-    type: "SpreadE";
-    operand: Expression;
+    type: SPREAD_EXPRESSION;
+    expr: Expression;
 }
 
 export declare const Stack: ForwardRefExoticComponent<Props_2 & RefAttributes<any>>;
@@ -1495,25 +1506,21 @@ declare type State = {
     error: Error | null;
 };
 
-declare type Statement = BlockStatement | EmptyStatement | ExpressionStatement | ArrowExpressionStatement | LetStatement | ConstStatement | VarStatement | IfStatement | ReturnStatement | BreakStatement | ContinueStatement | WhileStatement | DoWhileStatement | ForStatement | ForInStatement | ForOfStatement | ThrowStatement | TryStatement | SwitchStatement | FunctionDeclaration | ImportDeclaration;
+declare type Statement = BlockStatement | EmptyStatement | ExpressionStatement | ArrowExpressionStatement | LetStatement | ConstStatement | VarStatement | IfStatement | ReturnStatement | BreakStatement | ContinueStatement | WhileStatement | DoWhileStatement | ForStatement | ForInStatement | ForOfStatement | ThrowStatement | TryStatement | SwitchStatement | FunctionDeclaration;
 
-declare interface StatementBase extends BaseNode {
-    guard?: boolean;
-    removeBlockScope?: boolean;
-    completeTryBlock?: boolean;
-    completeCatchBlock?: boolean;
-    completeFinallyBlock?: boolean;
-}
+declare type SWITCH_CASE = typeof T_SWITCH_CASE;
+
+declare type SWITCH_STATEMENT = typeof T_SWITCH_STATEMENT;
 
-declare interface SwitchCase extends BaseNode {
-    type: "SwitchC";
-    caseExpression?: Expression;
-    statements?: Statement[];
+declare interface SwitchCase extends ExpressionBase {
+    type: SWITCH_CASE;
+    caseE?: Expression;
+    stmts?: Statement[];
 }
 
-declare interface SwitchStatement extends StatementBase {
-    type: "SwitchS";
-    expression: Expression;
+declare interface SwitchStatement extends ScripNodeBase {
+    type: SWITCH_STATEMENT;
+    expr: Expression;
     cases: SwitchCase[];
 }
 
@@ -1522,6 +1529,94 @@ declare interface SwitchStatement extends StatementBase {
  */
 declare type SyncFunction = (...args: any) => any;
 
+declare const T_ARRAY_DESTRUCTURE = 202;
+
+declare const T_ARRAY_LITERAL = 110;
+
+declare const T_ARROW_EXPRESSION = 115;
+
+declare const T_ARROW_EXPRESSION_STATEMENT = 4;
+
+declare const T_ASSIGNMENT_EXPRESSION = 113;
+
+declare const T_BINARY_EXPRESSION = 101;
+
+declare const T_BLOCK_STATEMENT = 1;
+
+declare const T_BREAK_STATEMENT = 10;
+
+declare const T_CALCULATED_MEMBER_ACCESS_EXPRESSION = 106;
+
+declare const T_CONDITIONAL_EXPRESSION = 103;
+
+declare const T_CONST_STATEMENT = 6;
+
+declare const T_CONTINUE_STATEMENT = 11;
+
+declare const T_DESTRUCTURE = 201;
+
+declare const T_DO_WHILE_STATEMENT = 13;
+
+declare const T_EMPTY_STATEMENT = 2;
+
+declare const T_EXPRESSION_STATEMENT = 3;
+
+declare const T_FOR_IN_STATEMENT = 15;
+
+declare const T_FOR_OF_STATEMENT = 16;
+
+declare const T_FOR_STATEMENT = 14;
+
+declare const T_FUNCTION_DECLARATION = 20;
+
+declare const T_FUNCTION_INVOCATION_EXPRESSION = 104;
+
+declare const T_IDENTIFIER = 107;
+
+declare const T_IF_STATEMENT = 8;
+
+declare const T_LET_STATEMENT = 5;
+
+declare const T_LITERAL = 109;
+
+declare const T_MEMBER_ACCESS_EXPRESSION = 105;
+
+declare const T_NO_ARG_EXPRESSION = 114;
+
+declare const T_OBJECT_DESTRUCTURE = 203;
+
+declare const T_OBJECT_LITERAL = 111;
+
+declare const T_POSTFIX_OP_EXPRESSION = 117;
+
+declare const T_PREFIX_OP_EXPRESSION = 116;
+
+declare const T_REACTIVE_VAR_DECLARATION = 118;
+
+declare const T_RETURN_STATEMENT = 9;
+
+declare const T_SEQUENCE_EXPRESSION = 102;
+
+declare const T_SPREAD_EXPRESSION = 112;
+
+declare const T_SWITCH_CASE = 204;
+
+declare const T_SWITCH_STATEMENT = 19;
+
+declare const T_TEMPLATE_LITERAL_EXPRESSION = 108;
+
+declare const T_THROW_STATEMENT = 17;
+
+declare const T_TRY_STATEMENT = 18;
+
+declare const T_UNARY_EXPRESSION = 100;
+
+declare const T_VAR_DECLARATION = 200;
+
+declare const T_VAR_STATEMENT = 7;
+
+declare const T_WHILE_STATEMENT = 12;
+
 declare type TableDescriptor = {
     name: string;
     fields?: Record<string, any>;
@@ -1529,8 +1624,10 @@ declare type TableDescriptor = {
     indexes?: Array<string>;
 };
 
+declare type TEMPLATE_LITERAL_EXPRESSION = typeof T_TEMPLATE_LITERAL_EXPRESSION;
+
 declare interface TemplateLiteralExpression extends ExpressionBase {
-    type: "TempLitE";
+    type: TEMPLATE_LITERAL_EXPRESSION;
     segments: (Literal | Expression)[];
 }
 
@@ -1668,9 +1765,11 @@ declare const ThemeToneKeys: readonly ["light", "dark"];
  */
 declare const ThemeToneKeys_2: readonly ["light", "dark"];
 
-declare interface ThrowStatement extends StatementBase {
-    type: "ThrowS";
-    expression: Expression;
+declare type THROW_STATEMENT = typeof T_THROW_STATEMENT;
+
+declare interface ThrowStatement extends ScripNodeBase {
+    type: THROW_STATEMENT;
+    expr: Expression;
 }
 
 declare type ToastHandler = (message: Message, options?: ToastOptions) => string;
@@ -1681,22 +1780,7 @@ declare type ToastHandler = (message: Message, options?: ToastOptions) => string
  */
 export declare function toCssVar(c: string | ThemeIdDescriptor): string;
 
-declare type Token = {
-    readonly text: string;
-    readonly type: TokenType;
-    readonly location: TokenLocation;
-};
-
-declare interface TokenLocation {
-    readonly startPosition: number;
-    readonly endPosition: number;
-    readonly startLine: number;
-    readonly endLine: number;
-    readonly startColumn: number;
-    readonly endColumn: number;
-}
-
-declare const enum TokenType {
+declare enum TokenType {
     Eof = -1,
     Ws = -2,
     BlockComment = -3,
@@ -1797,10 +1881,8 @@ declare const enum TokenType {
     Default = 93,
     Delete = 94,
     Function = 95,
-    Export = 96,
-    Import = 97,
-    As = 98,
-    From = 99
+    As = 96,
+    From = 97
 }
 
 export declare interface TreeNode {
@@ -1816,18 +1898,22 @@ export declare interface TreeNode {
     [x: string]: any;
 }
 
-declare interface TryStatement extends StatementBase {
-    type: "TryS";
-    tryBlock: BlockStatement;
-    catchBlock?: BlockStatement;
-    catchVariable?: string;
-    finallyBlock?: BlockStatement;
+declare type TRY_STATEMENT = typeof T_TRY_STATEMENT;
+
+declare interface TryStatement extends ScripNodeBase {
+    type: TRY_STATEMENT;
+    tryB: BlockStatement;
+    catchB?: BlockStatement;
+    catchV?: Identifier;
+    finallyB?: BlockStatement;
 }
 
+declare type UNARY_EXPRESSION = typeof T_UNARY_EXPRESSION;
+
 declare interface UnaryExpression extends ExpressionBase {
-    type: "UnaryE";
-    operator: UnaryOpSymbols;
-    operand: Expression;
+    type: UNARY_EXPRESSION;
+    op: UnaryOpSymbols;
+    expr: Expression;
 }
 
 declare type UnaryOpSymbols = "+" | "-" | "~" | "!" | "typeof" | "delete";
@@ -1902,22 +1988,28 @@ declare type ValueExtractor = {
     asSize(expression?: any): string;
 };
 
+declare type VAR_DECLARATION = typeof T_VAR_DECLARATION;
+
+declare type VAR_STATEMENT = typeof T_VAR_STATEMENT;
+
 declare interface VarDeclaration extends ExpressionBase {
-    type: "VarD";
+    type: VAR_DECLARATION;
     id?: string;
-    arrayDestruct?: ArrayDestructure[];
-    objectDestruct?: ObjectDestructure[];
-    expression?: Expression;
+    aDestr?: ArrayDestructure[];
+    oDestr?: ObjectDestructure[];
+    expr?: Expression;
 }
 
-declare interface VarStatement extends StatementBase {
-    type: "VarS";
-    declarations: ReactiveVarDeclaration[];
+declare interface VarStatement extends ScripNodeBase {
+    type: VAR_STATEMENT;
+    decls: ReactiveVarDeclaration[];
 }
 
-declare interface WhileStatement extends StatementBase {
-    type: "WhileS";
-    condition: Expression;
+declare type WHILE_STATEMENT = typeof T_WHILE_STATEMENT;
+
+declare interface WhileStatement extends ScripNodeBase {
+    type: WHILE_STATEMENT;
+    cond: Expression;
     body: Statement;
 }