autoit3-pegjs 4.0.0 → 4.1.1

package/dist/autoit3.d.ts

@@ -228,8 +228,20 @@ type LineContinuation = [
   LineTerminatorSequence,
 ];
 type ConstDeclarationList = [ConstDeclaration, ...ConstDeclaration[]];
+type ConstDeclarationListInWith = [
+  ConstDeclarationInWith,
+  ...ConstDeclarationInWith[],
+];
 type EnumDeclarationList = [EnumDeclaration, ...EnumDeclaration[]];
+type EnumDeclarationListInWith = [
+  EnumDeclarationInWith,
+  ...EnumDeclarationInWith[],
+];
 type VariableDeclarationList = [VariableDeclaration, ...VariableDeclaration[]];
+type VariableDeclarationListInWith = [
+  VariableDeclarationInWith,
+  ...VariableDeclarationInWith[],
+];
 type VariableDeclaration = {
   type: "VariableDeclarator";
   id: VariableIdentifier;
@@ -237,12 +249,25 @@ type VariableDeclaration = {
   init: Initialiser | null;
   location: LocationRange;
 };
+type VariableDeclarationInWith = {
+  type: "VariableDeclarator";
+  id: VariableIdentifier;
+  dimensions: (ExpressionInWith | null)[];
+  init: InitialiserInWith | null;
+  location: LocationRange;
+};
 type EnumDeclaration = {
   type: "VariableDeclarator";
   id: VariableIdentifier;
   init: AssignmentExpression | null;
   location: LocationRange;
 };
+type EnumDeclarationInWith = {
+  type: "VariableDeclarator";
+  id: VariableIdentifier;
+  init: AssignmentExpressionInWith | null;
+  location: LocationRange;
+};
 type ConstDeclaration = {
   type: "VariableDeclarator";
   id: VariableIdentifier;
@@ -250,7 +275,15 @@ type ConstDeclaration = {
   init: AssignmentExpression | ArrayDeclaration;
   location: LocationRange;
 };
+type ConstDeclarationInWith = {
+  type: "VariableDeclarator";
+  id: VariableIdentifier;
+  dimensions: (ExpressionInWith | null)[];
+  init: AssignmentExpressionInWith | ArrayDeclarationInWith;
+  location: LocationRange;
+};
 type Initialiser = AssignmentExpression | ArrayDeclaration;
+type InitialiserInWith = AssignmentExpressionInWith | ArrayDeclarationInWith;
 type VariableIdentifier = {
   type: "VariableIdentifier";
   name: string;
@@ -287,10 +320,19 @@ type ArrayDeclaration = {
   elements: ArrayDeclarationElementList | null;
   location: LocationRange;
 };
+type ArrayDeclarationInWith = {
+  type: "ArrayDeclaration";
+  elements: ArrayDeclarationElementListInWith | null;
+  location: LocationRange;
+};
 type ArrayDeclarationElementList = [
   Expression | ArrayDeclaration,
   ...(Expression | ArrayDeclaration)[],
 ];
+type ArrayDeclarationElementListInWith = [
+  ExpressionInWith | ArrayDeclarationInWith,
+  ...(ExpressionInWith | ArrayDeclarationInWith)[],
+];
 type Identifier = IdentifierName;
 type IdentifierName = {
   type: "Identifier";
@@ -348,7 +390,7 @@ type FutureReservedWord = "@RESERVED";
 type WithStatement = {
   type: "WithStatement";
   object: Expression;
-  body: never[] | NonNullable<StatementList | null>;
+  body: never[] | NonNullable<StatementListInWith | null>;
   location: LocationRange;
 };
 type ReturnStatement = {
@@ -356,16 +398,31 @@ type ReturnStatement = {
   value: Expression | null;
   location: LocationRange;
 };
+type ReturnStatementInWith = {
+  type: "ReturnStatement";
+  value: ExpressionInWith | null;
+  location: LocationRange;
+};
 type ExitLoopStatement = {
   type: "ExitLoopStatement";
   level: Expression | null;
   location: LocationRange;
 };
+type ExitLoopStatementInWith = {
+  type: "ExitLoopStatement";
+  level: ExpressionInWith | null;
+  location: LocationRange;
+};
 type ContinueLoopStatement = {
   type: "ContinueLoopStatement";
   level: Expression | null;
   location: LocationRange;
 };
+type ContinueLoopStatementInWith = {
+  type: "ContinueLoopStatement";
+  level: ExpressionInWith | null;
+  location: LocationRange;
+};
 type ContinueCaseStatement = {
   type: "ContinueCaseStatement";
   location: LocationRange;
@@ -375,20 +432,42 @@ type SelectStatement = {
   cases: SelectCaseBlock;
   location: LocationRange;
 };
+type SelectStatementInWith = {
+  type: "SelectStatement";
+  cases: SelectCaseBlockInWith;
+  location: LocationRange;
+};
 type SelectCaseBlock =
   | (
       | DefaultClause
       | (never[] | NonNullable<SelectCaseClauses | null>)[number]
       | (never[] | NonNullable<SelectCaseClauses | null>)[number]
     )[]
-  | (never[] | NonNullable<SelectCaseClauses | null>);
+  | SelectCaseClauses;
+type SelectCaseBlockInWith =
+  | (
+      | DefaultClauseInWith
+      | (never[] | NonNullable<SelectCaseClausesInWith | null>)[number]
+      | (never[] | NonNullable<SelectCaseClausesInWith | null>)[number]
+    )[]
+  | SelectCaseClauses;
 type SelectCaseClauses = [SelectCaseClause, ...SelectCaseClause[]];
+type SelectCaseClausesInWith = [
+  SelectCaseClauseInWith,
+  ...SelectCaseClauseInWith[],
+];
 type SelectCaseClause = {
   type: "SelectCase";
   tests: AssignmentExpression;
   consequent: never[] | NonNullable<StatementList | null>;
   location: LocationRange;
 };
+type SelectCaseClauseInWith = {
+  type: "SelectCase";
+  tests: AssignmentExpressionInWith;
+  consequent: never[] | NonNullable<StatementListInWith | null>;
+  location: LocationRange;
+};
 type BooleanLiteral =
   | { type: "Literal"; value: true; location: LocationRange }
   | { type: "Literal"; value: false; location: LocationRange };
@@ -457,6 +536,8 @@ type ExponentIndicator = string;
 type SignedInteger = [string | null, DecimalDigit[]];
 type MemberExpression =
   PrimaryExpression | ({type: "MemberExpression", object: MemberExpression|PrimaryExpression, location: LocationRange } & ({property: Expression, computed: true} | {property:IdentifierName, computed: false}));
+type MemberExpressionInWith =
+  PrimaryExpression | ({type: "MemberExpression", object: MemberExpression|PrimaryExpression, location: LocationRange } & ({property: Expression, computed: true} | {property:IdentifierName, computed: false}));
 type DefaultKeyword = {
   type: "Keyword";
   value: "Default";
@@ -468,6 +549,12 @@ type PrimaryExpression =
   | Literal
   | ParenthesizedExpression
   | DefaultKeyword;
+type PrimaryExpressionInWith =
+  | Identifier
+  | VariableIdentifier
+  | Literal
+  | ParenthesizedExpression
+  | DefaultKeyword;
 type ParenthesizedExpression = {
   type: "ParenthesizedExpression";
   expression: Expression;
@@ -475,9 +562,19 @@ type ParenthesizedExpression = {
 };
 type CallExpression =
   {type: "CallExpression", callee: MemberExpression | CallExpression, arguments: Arguments, location: LocationRange } | {type: "MemberExpression", object: MemberExpression | CallExpression, property: Expression | IdentifierName, computed: boolean, location: LocationRange };
+type CallExpressionInWith =
+  {type: "CallExpression", callee: MemberExpression | CallExpression, arguments: Arguments, location: LocationRange } | {type: "MemberExpression", object: MemberExpression | CallExpression | null, property: Expression | IdentifierName, computed: boolean, location: LocationRange };
 type Arguments = never[] | NonNullable<ArgumentList | null>;
+type ArgumentsInWith = never[] | NonNullable<ArgumentListInWith | null>;
 type ArgumentList = [AssignmentExpression, ...AssignmentExpression[]];
+type ArgumentListInWith = [
+  AssignmentExpressionInWith,
+  ...AssignmentExpressionInWith[],
+];
 type LeftHandSideExpression = CallExpression | MemberExpression;
+type LeftHandSideExpressionInWith =
+  | CallExpressionInWith
+  | MemberExpressionInWith;
 type AssignmentExpression =
   | {
       type: "AssignmentExpression";
@@ -494,6 +591,22 @@ type AssignmentExpression =
       location: LocationRange;
     }
   | ConditionalExpression;
+type AssignmentExpressionInWith =
+  | {
+      type: "AssignmentExpression";
+      operator: "=";
+      left: LeftHandSideExpressionInWith;
+      right: AssignmentExpressionInWith;
+      location: LocationRange;
+    }
+  | {
+      type: "AssignmentExpression";
+      operator: AssignmentOperator;
+      left: LeftHandSideExpressionInWith;
+      right: AssignmentExpressionInWith;
+      location: LocationRange;
+    }
+  | ConditionalExpressionInWith;
 type AssignmentOperator = "*=" | "/=" | "+=" | "-=" | "&=";
 type ConditionalExpression =
   | {
@@ -504,6 +617,15 @@ type ConditionalExpression =
       location: LocationRange;
     }
   | LogicalORExpression;
+type ConditionalExpressionInWith =
+  | {
+      type: "ConditionalExpression";
+      test: LogicalORExpressionInWith;
+      consequent: AssignmentExpressionInWith;
+      alternate: AssignmentExpressionInWith;
+      location: LocationRange;
+    }
+  | LogicalORExpressionInWith;
 type LogicalORExpression =
   | {
       type: "LogicalExpression";
@@ -513,6 +635,15 @@ type LogicalORExpression =
       location: LocationRange;
     }
   | LogicalANDExpression;
+type LogicalORExpressionInWith =
+  | {
+      type: "LogicalExpression";
+      operator: LogicalOROperator;
+      left: LogicalANDExpressionInWith;
+      right: LogicalORExpressionInWith;
+      location: LocationRange;
+    }
+  | LogicalANDExpressionInWith;
 type LogicalANDExpression =
   | {
       type: "LogicalExpression";
@@ -522,6 +653,15 @@ type LogicalANDExpression =
       location: LocationRange;
     }
   | EqualityExpression;
+type LogicalANDExpressionInWith =
+  | {
+      type: "LogicalExpression";
+      operator: LogicalANDOperator;
+      left: EqualityExpressionInWith;
+      right: LogicalANDExpressionInWith;
+      location: LocationRange;
+    }
+  | EqualityExpressionInWith;
 type LogicalOROperator = string;
 type LogicalANDOperator = string;
 type EqualityExpression =
@@ -533,6 +673,15 @@ type EqualityExpression =
       location: LocationRange;
     }
   | RelationalExpression;
+type EqualityExpressionInWith =
+  | {
+      type: "BinaryExpression";
+      operator: EqualityOperator;
+      left: RelationalExpressionInWith;
+      right: EqualityExpressionInWith;
+      location: LocationRange;
+    }
+  | RelationalExpressionInWith;
 type EqualityOperator = "==" | "=";
 type RelationalExpression =
   | {
@@ -543,6 +692,15 @@ type RelationalExpression =
       location: LocationRange;
     }
   | AdditiveExpression;
+type RelationalExpressionInWith =
+  | {
+      type: "BinaryExpression";
+      operator: RelationalOperator;
+      left: AdditiveExpressionInWith;
+      right: AdditiveExpressionInWith;
+      location: LocationRange;
+    }
+  | AdditiveExpressionInWith;
 type AdditiveExpression =
   | {
       type: "BinaryExpression";
@@ -552,6 +710,15 @@ type AdditiveExpression =
       location: LocationRange;
     }
   | MultiplicativeExpression;
+type AdditiveExpressionInWith =
+  | {
+      type: "BinaryExpression";
+      operator: AdditiveOperator;
+      left: MultiplicativeExpressionInWith;
+      right: AdditiveExpressionInWith;
+      location: LocationRange;
+    }
+  | MultiplicativeExpressionInWith;
 type AdditiveOperator = "+" | "-" | "&";
 type RelationalOperator = "<=" | ">=" | "<>" | "<" | ">";
 type MultiplicativeExpression =
@@ -563,20 +730,35 @@ type MultiplicativeExpression =
       location: LocationRange;
     }
   | ExponentialExpression;
+type MultiplicativeExpressionInWith =
+  | {
+      type: "BinaryExpression";
+      operator: MultiplicativeOperator;
+      left: ExponentialExpressionInWith;
+      right: MultiplicativeExpressionInWith;
+      location: LocationRange;
+    }
+  | ExponentialExpressionInWith;
 type MultiplicativeOperator = "*" | "/";
 type ExponentialExpression =
   | {
       type: "BinaryExpression";
       operator: ExponentialOperator;
-      left: NotExpression;
+      left: UnaryExpression;
       right: ExponentialExpression;
       location: LocationRange;
     }
-  | NotExpression;
-type ExponentialOperator = "^";
-type NotExpression =
-  | { type: "NotExpression"; value: UnaryExpression; location: LocationRange }
   | UnaryExpression;
+type ExponentialExpressionInWith =
+  | {
+      type: "BinaryExpression";
+      operator: ExponentialOperator;
+      left: UnaryExpressionInWith;
+      right: ExponentialExpressionInWith;
+      location: LocationRange;
+    }
+  | UnaryExpressionInWith;
+type ExponentialOperator = "^";
 type UnaryExpression =
   | LeftHandSideExpression
   | {
@@ -586,12 +768,17 @@ type UnaryExpression =
       prefix: true;
       location: LocationRange;
     };
-type UnaryOperator = string;
-type Program = {
-  type: "Program";
-  body: never[] | NonNullable<SourceElements | null>;
-};
-type SourceElements = [SourceElement, ...SourceElement[]];
+type UnaryExpressionInWith =
+  | LeftHandSideExpressionInWith
+  | {
+      type: "UnaryExpression";
+      operator: UnaryOperator;
+      argument: UnaryExpressionInWith;
+      prefix: true;
+      location: LocationRange;
+    };
+type UnaryOperator = string | NotToken;
+type Program = { type: "Program"; body: SourceElement[] };
 type SourceElement = Statement | FunctionDeclaration;
 type PreProcStatement = PreProc;
 type FunctionDeclaration = {
@@ -609,20 +796,20 @@ type FormalParameter =
       const: boolean;
       byref: true;
       id: VariableIdentifier;
-      init: Expression | null;
+      init: null;
       location: LocationRange;
     }
   | {
       type: "Parameter";
-      byref: boolean;
+      byref: true;
       const: true;
       id: VariableIdentifier;
-      init: Expression | null;
+      init: null;
       location: LocationRange;
     }
   | {
       type: "Parameter";
-      const: false;
+      const: boolean;
       byref: false;
       id: VariableIdentifier;
       init: Expression | null;
@@ -645,8 +832,26 @@ type Statement =
   | PreProcStatement
   | MultiLineComment
   | SelectStatement;
+type StatementInWith =
+  | VariableStatementInWith
+  | EmptyStatement
+  | SingleLineComment
+  | ExpressionStatementInWIth
+  | IfStatementInWith
+  | IterationStatementInWith
+  | ContinueLoopStatementInWith
+  | ContinueCaseStatement
+  | ExitLoopStatementInWith
+  | ReturnStatementInWith
+  | WithStatement
+  | SwitchStatementInWith
+  | ExitStatementInWIth
+  | PreProcStatement
+  | MultiLineComment
+  | SelectStatementInWith;
 type EmptyStatement = { type: "EmptyStatement"; location: LocationRange };
 type StatementList = [Statement, ...Statement[]];
+type StatementListInWith = [StatementInWith, ...StatementInWith[]];
 type VariableStatement =
   | {
       scope: string;
@@ -673,11 +878,43 @@ type VariableStatement =
       location: LocationRange;
     }
   | {
-      scope: null;
+      type: "RedimExpression";
+      declarations: [RedimIdentifierExpression, ...RedimIdentifierExpression[]];
+      location: LocationRange;
+    }
+  | {
+      scope: string | null;
+      constant: boolean;
+      static: false;
+      type: "EnumDeclaration";
+      declarations: EnumDeclarationList;
+      stepoperator: string;
+      stepval: number;
+      location: LocationRange;
+    };
+type VariableStatementInWith =
+  | {
+      scope: string;
       constant: false;
       static_: false;
       type: "VariableDeclaration";
-      declarations: [ConstDeclaration];
+      declarations: VariableDeclarationListInWith;
+      location: LocationRange;
+    }
+  | {
+      scope: string | null;
+      constant: true;
+      static_: false;
+      type: "VariableDeclaration";
+      declarations: ConstDeclarationListInWith;
+      location: LocationRange;
+    }
+  | {
+      scope: string | null;
+      constant: false;
+      static_: true;
+      type: "VariableDeclaration";
+      declarations: VariableDeclarationListInWith;
       location: LocationRange;
     }
   | {
@@ -690,7 +927,7 @@ type VariableStatement =
       constant: boolean;
       static: false;
       type: "EnumDeclaration";
-      declarations: EnumDeclarationList;
+      declarations: EnumDeclarationListInWith;
       stepoperator: string;
       stepval: number;
       location: LocationRange;
@@ -705,6 +942,11 @@ type ExpressionStatement = {
   expression: Expression;
   location: LocationRange;
 };
+type ExpressionStatementInWIth = {
+  type: "ExpressionStatement";
+  expression: ExpressionInWith;
+  location: LocationRange;
+};
 type IfStatement =
   | {
       type: "IfStatement";
@@ -729,24 +971,66 @@ type IfStatement =
         | ExitStatement;
       location: LocationRange;
     };
+type IfStatementInWith =
+  | {
+      type: "IfStatement";
+      test: ExpressionInWith;
+      consequent: StatementList | null;
+      alternate: (
+        | NonNullable<ElseClauseInWith | null>
+        | (never[] | NonNullable<ElseIfClausesInWith | null>)[number]
+      )[];
+      location: LocationRange;
+    }
+  | {
+      type: "IfStatement";
+      test: Expression;
+      consequent:
+        | ExpressionStatement
+        | VariableStatement
+        | ContinueLoopStatement
+        | ContinueCaseStatement
+        | ExitLoopStatement
+        | ReturnStatement
+        | ExitStatement;
+      location: LocationRange;
+    };
 type ElseIfClauses = [ElseIfClause, ...ElseIfClause[]];
+type ElseIfClausesInWith = [ElseIfClauseInWith, ...ElseIfClauseInWith[]];
 type ElseIfClause = {
   type: "ElseIfStatement";
   test: Expression;
   consequent: StatementList | null;
   location: LocationRange;
 };
+type ElseIfClauseInWith = {
+  type: "ElseIfStatement";
+  test: ExpressionInWith;
+  consequent: StatementListInWith | null;
+  location: LocationRange;
+};
 type ElseClause = {
   type: "ElseStatement";
   consequent: StatementList | null;
   location: LocationRange;
 };
+type ElseClauseInWith = {
+  type: "ElseStatement";
+  consequent: StatementListInWith | null;
+  location: LocationRange;
+};
 type ForLoopVariableDeclaration = {
   type: "VariableDeclarator";
   id: VariableIdentifier;
   init: Expression;
   location: LocationRange;
 };
+type ForLoopVariableDeclarationInWith = {
+  type: "VariableDeclarator";
+  id: VariableIdentifier;
+  init: ExpressionInWith;
+  location: LocationRange;
+};
 type ForInLoopVariableDeclaration = {
   type: "VariableDeclarator";
   id: VariableIdentifier;
@@ -781,6 +1065,34 @@ type IterationStatement =
       body: never[] | NonNullable<StatementList | null>;
       location: LocationRange;
     };
+type IterationStatementInWith =
+  | {
+      type: "DoWhileStatement";
+      body: never[] | NonNullable<StatementListInWith | null>;
+      test: ExpressionInWith;
+      location: LocationRange;
+    }
+  | {
+      type: "WhileStatement";
+      test: ExpressionInWith;
+      body: never[] | NonNullable<StatementListInWith | null>;
+      location: LocationRange;
+    }
+  | {
+      type: "ForStatement";
+      init: ForLoopVariableDeclarationInWith;
+      test: ExpressionInWith;
+      update: ExpressionInWith | null;
+      body: never[] | NonNullable<StatementListInWith | null>;
+      location: LocationRange;
+    }
+  | {
+      type: "ForInStatement";
+      left: ForInLoopVariableDeclaration;
+      right: ExpressionInWith;
+      body: never[] | NonNullable<StatementListInWith | null>;
+      location: LocationRange;
+    };
 type EOS =
   | [__, SingleLineComment | null, LineTerminatorSequence | EOF]
   | [__, EOF];
@@ -788,25 +1100,45 @@ type EOF = undefined;
 type __ = Whitespace[];
 type LineTerminatorSequence = "\n" | "\r\n" | string;
 type Expression = AssignmentExpression;
+type ExpressionInWith = AssignmentExpressionInWith;
 type ExitStatement = {
   type: "ExitStatement";
   argument: (AssignmentExpression | null) | null;
   location: LocationRange;
 };
+type ExitStatementInWIth = {
+  type: "ExitStatement";
+  argument: (AssignmentExpressionInWith | null) | null;
+  location: LocationRange;
+};
 type SwitchStatement = {
   type: "SwitchStatement";
   discriminant: Expression;
   cases: CaseBlock;
   location: LocationRange;
 };
+type SwitchStatementInWith = {
+  type: "SwitchStatement";
+  discriminant: ExpressionInWith;
+  cases: CaseBlockInWith;
+  location: LocationRange;
+};
 type CaseBlock =
   | (
       | DefaultClause
       | (never[] | NonNullable<CaseClauses | null>)[number]
       | (never[] | NonNullable<CaseClauses | null>)[number]
     )[]
-  | (never[] | NonNullable<CaseClauses | null>);
+  | CaseClauses;
+type CaseBlockInWith =
+  | (
+      | DefaultClauseInWith
+      | (never[] | NonNullable<CaseClausesInWith | null>)[number]
+      | (never[] | NonNullable<CaseClausesInWith | null>)[number]
+    )[]
+  | CaseClausesInWith;
 type CaseClauses = [CaseClause, ...CaseClause[]];
+type CaseClausesInWith = [CaseClauseInWith, ...CaseClauseInWith[]];
 type CaseClause =
   | {
       type: "SwitchCase";
@@ -815,13 +1147,28 @@ type CaseClause =
       location: LocationRange;
     }
   | SingleLineComment;
+type CaseClauseInWith =
+  | {
+      type: "SwitchCase";
+      tests: CaseValueListInWith;
+      consequent: never[] | NonNullable<StatementListInWith | null>;
+      location: LocationRange;
+    }
+  | SingleLineComment;
 type DefaultClause = {
   type: "SwitchCase";
   tests: null;
   consequent: never[] | NonNullable<StatementList | null>;
   location: LocationRange;
 };
+type DefaultClauseInWith = {
+  type: "SwitchCase";
+  tests: null;
+  consequent: never[] | NonNullable<StatementListInWith | null>;
+  location: LocationRange;
+};
 type CaseValueList = [SwitchCaseValue, ...SwitchCaseValue[]];
+type CaseValueListInWith = [SwitchCaseValueInWith, ...SwitchCaseValueInWith[]];
 type SwitchCaseValue =
   | {
       type: "SwitchCaseRange";
@@ -830,5 +1177,13 @@ type SwitchCaseValue =
       location: LocationRange;
     }
   | Expression;
+type SwitchCaseValueInWith =
+  | {
+      type: "SwitchCaseRange";
+      from: ExpressionInWith;
+      to: ExpressionInWith;
+      location: LocationRange;
+    }
+  | ExpressionInWith;
 
 }