@zzzen/pyright-internal 1.2.0-dev.20231112 → 1.2.0-dev.20231126

package/dist/parser/parseNodes.js

@@ -92,7 +92,7 @@ var ParseNodeType;
     ParseNodeType[ParseNodeType["TypeParameter"] = 75] = "TypeParameter";
     ParseNodeType[ParseNodeType["TypeParameterList"] = 76] = "TypeParameterList";
     ParseNodeType[ParseNodeType["TypeAlias"] = 77] = "TypeAlias";
-})(ParseNodeType = exports.ParseNodeType || (exports.ParseNodeType = {}));
+})(ParseNodeType || (exports.ParseNodeType = ParseNodeType = {}));
 var ErrorExpressionCategory;
 (function (ErrorExpressionCategory) {
     ErrorExpressionCategory[ErrorExpressionCategory["MissingIn"] = 0] = "MissingIn";
@@ -110,7 +110,7 @@ var ErrorExpressionCategory;
     ErrorExpressionCategory[ErrorExpressionCategory["MissingPatternSubject"] = 12] = "MissingPatternSubject";
     ErrorExpressionCategory[ErrorExpressionCategory["MissingDictValue"] = 13] = "MissingDictValue";
     ErrorExpressionCategory[ErrorExpressionCategory["MaxDepthExceeded"] = 14] = "MaxDepthExceeded";
-})(ErrorExpressionCategory = exports.ErrorExpressionCategory || (exports.ErrorExpressionCategory = {}));
+})(ErrorExpressionCategory || (exports.ErrorExpressionCategory = ErrorExpressionCategory = {}));
 let _nextNodeId = 1;
 function getNextNodeId() {
     return _nextNodeId++;
@@ -130,35 +130,35 @@ var ModuleNode;
         const node = {
             start: range.start,
             length: range.length,
-            nodeType: 36 /* Module */,
+            nodeType: 36 /* ParseNodeType.Module */,
             id: _nextNodeId++,
             statements: [],
         };
         return node;
     }
     ModuleNode.create = create;
-})(ModuleNode = exports.ModuleNode || (exports.ModuleNode = {}));
+})(ModuleNode || (exports.ModuleNode = ModuleNode = {}));
 var SuiteNode;
 (function (SuiteNode) {
     function create(range) {
         const node = {
             start: range.start,
             length: range.length,
-            nodeType: 50 /* Suite */,
+            nodeType: 50 /* ParseNodeType.Suite */,
             id: _nextNodeId++,
             statements: [],
         };
         return node;
     }
     SuiteNode.create = create;
-})(SuiteNode = exports.SuiteNode || (exports.SuiteNode = {}));
+})(SuiteNode || (exports.SuiteNode = SuiteNode = {}));
 var IfNode;
 (function (IfNode) {
     function create(ifOrElifToken, testExpression, ifSuite, elseSuite) {
         const node = {
             start: ifOrElifToken.start,
             length: ifOrElifToken.length,
-            nodeType: 19 /* If */,
+            nodeType: 19 /* ParseNodeType.If */,
             id: _nextNodeId++,
             testExpression,
             ifSuite,
@@ -175,14 +175,14 @@ var IfNode;
         return node;
     }
     IfNode.create = create;
-})(IfNode = exports.IfNode || (exports.IfNode = {}));
+})(IfNode || (exports.IfNode = IfNode = {}));
 var WhileNode;
 (function (WhileNode) {
     function create(whileToken, testExpression, whileSuite) {
         const node = {
             start: whileToken.start,
             length: whileToken.length,
-            nodeType: 57 /* While */,
+            nodeType: 57 /* ParseNodeType.While */,
             id: _nextNodeId++,
             testExpression,
             whileSuite,
@@ -193,14 +193,14 @@ var WhileNode;
         return node;
     }
     WhileNode.create = create;
-})(WhileNode = exports.WhileNode || (exports.WhileNode = {}));
+})(WhileNode || (exports.WhileNode = WhileNode = {}));
 var ForNode;
 (function (ForNode) {
     function create(forToken, targetExpression, iterableExpression, forSuite) {
         const node = {
             start: forToken.start,
             length: forToken.length,
-            nodeType: 26 /* For */,
+            nodeType: 26 /* ParseNodeType.For */,
             id: _nextNodeId++,
             targetExpression,
             iterableExpression,
@@ -213,14 +213,14 @@ var ForNode;
         return node;
     }
     ForNode.create = create;
-})(ForNode = exports.ForNode || (exports.ForNode = {}));
+})(ForNode || (exports.ForNode = ForNode = {}));
 var ListComprehensionForNode;
 (function (ListComprehensionForNode) {
     function create(startToken, targetExpression, iterableExpression) {
         const node = {
             start: startToken.start,
             length: startToken.length,
-            nodeType: 33 /* ListComprehensionFor */,
+            nodeType: 33 /* ParseNodeType.ListComprehensionFor */,
             id: _nextNodeId++,
             targetExpression,
             iterableExpression,
@@ -232,14 +232,14 @@ var ListComprehensionForNode;
         return node;
     }
     ListComprehensionForNode.create = create;
-})(ListComprehensionForNode = exports.ListComprehensionForNode || (exports.ListComprehensionForNode = {}));
+})(ListComprehensionForNode || (exports.ListComprehensionForNode = ListComprehensionForNode = {}));
 var ListComprehensionIfNode;
 (function (ListComprehensionIfNode) {
     function create(ifToken, testExpression) {
         const node = {
             start: ifToken.start,
             length: ifToken.length,
-            nodeType: 34 /* ListComprehensionIf */,
+            nodeType: 34 /* ParseNodeType.ListComprehensionIf */,
             id: _nextNodeId++,
             testExpression,
         };
@@ -248,14 +248,14 @@ var ListComprehensionIfNode;
         return node;
     }
     ListComprehensionIfNode.create = create;
-})(ListComprehensionIfNode = exports.ListComprehensionIfNode || (exports.ListComprehensionIfNode = {}));
+})(ListComprehensionIfNode || (exports.ListComprehensionIfNode = ListComprehensionIfNode = {}));
 var TryNode;
 (function (TryNode) {
     function create(tryToken, trySuite) {
         const node = {
             start: tryToken.start,
             length: tryToken.length,
-            nodeType: 53 /* Try */,
+            nodeType: 53 /* ParseNodeType.Try */,
             id: _nextNodeId++,
             trySuite,
             exceptClauses: [],
@@ -265,14 +265,14 @@ var TryNode;
         return node;
     }
     TryNode.create = create;
-})(TryNode = exports.TryNode || (exports.TryNode = {}));
+})(TryNode || (exports.TryNode = TryNode = {}));
 var ExceptNode;
 (function (ExceptNode) {
     function create(exceptToken, exceptSuite, isExceptGroup) {
         const node = {
             start: exceptToken.start,
             length: exceptToken.length,
-            nodeType: 25 /* Except */,
+            nodeType: 25 /* ParseNodeType.Except */,
             id: _nextNodeId++,
             exceptSuite,
             isExceptGroup,
@@ -282,14 +282,14 @@ var ExceptNode;
         return node;
     }
     ExceptNode.create = create;
-})(ExceptNode = exports.ExceptNode || (exports.ExceptNode = {}));
+})(ExceptNode || (exports.ExceptNode = ExceptNode = {}));
 var FunctionNode;
 (function (FunctionNode) {
     function create(defToken, name, suite, typeParameters) {
         const node = {
             start: defToken.start,
             length: defToken.length,
-            nodeType: 28 /* Function */,
+            nodeType: 28 /* ParseNodeType.Function */,
             id: _nextNodeId++,
             decorators: [],
             name,
@@ -306,34 +306,34 @@ var FunctionNode;
         return node;
     }
     FunctionNode.create = create;
-})(FunctionNode = exports.FunctionNode || (exports.FunctionNode = {}));
+})(FunctionNode || (exports.FunctionNode = FunctionNode = {}));
 var ParameterCategory;
 (function (ParameterCategory) {
     ParameterCategory[ParameterCategory["Simple"] = 0] = "Simple";
     ParameterCategory[ParameterCategory["ArgsList"] = 1] = "ArgsList";
     ParameterCategory[ParameterCategory["KwargsDict"] = 2] = "KwargsDict";
-})(ParameterCategory = exports.ParameterCategory || (exports.ParameterCategory = {}));
+})(ParameterCategory || (exports.ParameterCategory = ParameterCategory = {}));
 var ParameterNode;
 (function (ParameterNode) {
     function create(startToken, paramCategory) {
         const node = {
             start: startToken.start,
             length: startToken.length,
-            nodeType: 41 /* Parameter */,
+            nodeType: 41 /* ParseNodeType.Parameter */,
             id: _nextNodeId++,
             category: paramCategory,
         };
         return node;
     }
     ParameterNode.create = create;
-})(ParameterNode = exports.ParameterNode || (exports.ParameterNode = {}));
+})(ParameterNode || (exports.ParameterNode = ParameterNode = {}));
 var ClassNode;
 (function (ClassNode) {
     function create(classToken, name, suite, typeParameters) {
         const node = {
             start: classToken.start,
             length: classToken.length,
-            nodeType: 10 /* Class */,
+            nodeType: 10 /* ParseNodeType.Class */,
             id: _nextNodeId++,
             decorators: [],
             name,
@@ -357,16 +357,16 @@ var ClassNode;
         const node = {
             start: decorators[0].start,
             length: 0,
-            nodeType: 10 /* Class */,
+            nodeType: 10 /* ParseNodeType.Class */,
             id: _nextNodeId++,
             decorators,
             name: {
                 start: decorators[0].start,
                 length: 0,
                 id: 0,
-                nodeType: 38 /* Name */,
+                nodeType: 38 /* ParseNodeType.Name */,
                 token: {
-                    type: 7 /* Identifier */,
+                    type: 7 /* TokenType.Identifier */,
                     start: 0,
                     length: 0,
                     comments: [],
@@ -379,7 +379,7 @@ var ClassNode;
                 start: decorators[0].start,
                 length: 0,
                 id: 0,
-                nodeType: 50 /* Suite */,
+                nodeType: 50 /* ParseNodeType.Suite */,
                 statements: [],
             },
         };
@@ -392,14 +392,14 @@ var ClassNode;
         return node;
     }
     ClassNode.createDummyForDecorators = createDummyForDecorators;
-})(ClassNode = exports.ClassNode || (exports.ClassNode = {}));
+})(ClassNode || (exports.ClassNode = ClassNode = {}));
 var WithNode;
 (function (WithNode) {
     function create(withToken, suite) {
         const node = {
             start: withToken.start,
             length: withToken.length,
-            nodeType: 58 /* With */,
+            nodeType: 58 /* ParseNodeType.With */,
             id: _nextNodeId++,
             withItems: [],
             suite,
@@ -409,14 +409,14 @@ var WithNode;
         return node;
     }
     WithNode.create = create;
-})(WithNode = exports.WithNode || (exports.WithNode = {}));
+})(WithNode || (exports.WithNode = WithNode = {}));
 var WithItemNode;
 (function (WithItemNode) {
     function create(expression) {
         const node = {
             start: expression.start,
             length: expression.length,
-            nodeType: 59 /* WithItem */,
+            nodeType: 59 /* ParseNodeType.WithItem */,
             id: _nextNodeId++,
             expression,
         };
@@ -424,14 +424,14 @@ var WithItemNode;
         return node;
     }
     WithItemNode.create = create;
-})(WithItemNode = exports.WithItemNode || (exports.WithItemNode = {}));
+})(WithItemNode || (exports.WithItemNode = WithItemNode = {}));
 var DecoratorNode;
 (function (DecoratorNode) {
     function create(atToken, expression) {
         const node = {
             start: atToken.start,
             length: atToken.length,
-            nodeType: 13 /* Decorator */,
+            nodeType: 13 /* ParseNodeType.Decorator */,
             id: _nextNodeId++,
             expression,
         };
@@ -440,50 +440,50 @@ var DecoratorNode;
         return node;
     }
     DecoratorNode.create = create;
-})(DecoratorNode = exports.DecoratorNode || (exports.DecoratorNode = {}));
+})(DecoratorNode || (exports.DecoratorNode = DecoratorNode = {}));
 var StatementListNode;
 (function (StatementListNode) {
     function create(atToken) {
         const node = {
             start: atToken.start,
             length: atToken.length,
-            nodeType: 47 /* StatementList */,
+            nodeType: 47 /* ParseNodeType.StatementList */,
             id: _nextNodeId++,
             statements: [],
         };
         return node;
     }
     StatementListNode.create = create;
-})(StatementListNode = exports.StatementListNode || (exports.StatementListNode = {}));
+})(StatementListNode || (exports.StatementListNode = StatementListNode = {}));
 function isExpressionNode(node) {
     switch (node.nodeType) {
-        case 0 /* Error */:
-        case 55 /* UnaryOperation */:
-        case 7 /* BinaryOperation */:
-        case 4 /* AssignmentExpression */:
-        case 54 /* TypeAnnotation */:
-        case 6 /* Await */:
-        case 51 /* Ternary */:
-        case 56 /* Unpack */:
-        case 52 /* Tuple */:
-        case 9 /* Call */:
-        case 32 /* ListComprehension */:
-        case 24 /* Index */:
-        case 46 /* Slice */:
-        case 60 /* Yield */:
-        case 61 /* YieldFrom */:
-        case 35 /* MemberAccess */:
-        case 30 /* Lambda */:
-        case 38 /* Name */:
-        case 11 /* Constant */:
-        case 18 /* Ellipsis */:
-        case 40 /* Number */:
-        case 49 /* String */:
-        case 27 /* FormatString */:
-        case 48 /* StringList */:
-        case 15 /* Dictionary */:
-        case 31 /* List */:
-        case 45 /* Set */:
+        case 0 /* ParseNodeType.Error */:
+        case 55 /* ParseNodeType.UnaryOperation */:
+        case 7 /* ParseNodeType.BinaryOperation */:
+        case 4 /* ParseNodeType.AssignmentExpression */:
+        case 54 /* ParseNodeType.TypeAnnotation */:
+        case 6 /* ParseNodeType.Await */:
+        case 51 /* ParseNodeType.Ternary */:
+        case 56 /* ParseNodeType.Unpack */:
+        case 52 /* ParseNodeType.Tuple */:
+        case 9 /* ParseNodeType.Call */:
+        case 32 /* ParseNodeType.ListComprehension */:
+        case 24 /* ParseNodeType.Index */:
+        case 46 /* ParseNodeType.Slice */:
+        case 60 /* ParseNodeType.Yield */:
+        case 61 /* ParseNodeType.YieldFrom */:
+        case 35 /* ParseNodeType.MemberAccess */:
+        case 30 /* ParseNodeType.Lambda */:
+        case 38 /* ParseNodeType.Name */:
+        case 11 /* ParseNodeType.Constant */:
+        case 18 /* ParseNodeType.Ellipsis */:
+        case 40 /* ParseNodeType.Number */:
+        case 49 /* ParseNodeType.String */:
+        case 27 /* ParseNodeType.FormatString */:
+        case 48 /* ParseNodeType.StringList */:
+        case 15 /* ParseNodeType.Dictionary */:
+        case 31 /* ParseNodeType.List */:
+        case 45 /* ParseNodeType.Set */:
             return true;
         default:
             return false;
@@ -496,7 +496,7 @@ var ErrorNode;
         const node = {
             start: initialRange.start,
             length: initialRange.length,
-            nodeType: 0 /* Error */,
+            nodeType: 0 /* ParseNodeType.Error */,
             id: _nextNodeId++,
             category,
             child,
@@ -517,7 +517,7 @@ var ErrorNode;
         return node;
     }
     ErrorNode.create = create;
-})(ErrorNode = exports.ErrorNode || (exports.ErrorNode = {}));
+})(ErrorNode || (exports.ErrorNode = ErrorNode = {}));
 var UnaryOperationNode;
 (function (UnaryOperationNode) {
     function create(operatorToken, expression, operator) {
@@ -525,7 +525,7 @@ var UnaryOperationNode;
         const node = {
             start: operatorToken.start,
             length: operatorToken.length,
-            nodeType: 55 /* UnaryOperation */,
+            nodeType: 55 /* ParseNodeType.UnaryOperation */,
             id: _nextNodeId++,
             operator,
             operatorToken,
@@ -537,7 +537,7 @@ var UnaryOperationNode;
         return node;
     }
     UnaryOperationNode.create = create;
-})(UnaryOperationNode = exports.UnaryOperationNode || (exports.UnaryOperationNode = {}));
+})(UnaryOperationNode || (exports.UnaryOperationNode = UnaryOperationNode = {}));
 var BinaryOperationNode;
 (function (BinaryOperationNode) {
     function create(leftExpression, rightExpression, operatorToken, operator) {
@@ -545,7 +545,7 @@ var BinaryOperationNode;
         const node = {
             start: leftExpression.start,
             length: leftExpression.length,
-            nodeType: 7 /* BinaryOperation */,
+            nodeType: 7 /* ParseNodeType.BinaryOperation */,
             id: _nextNodeId++,
             leftExpression,
             operatorToken,
@@ -559,14 +559,14 @@ var BinaryOperationNode;
         return node;
     }
     BinaryOperationNode.create = create;
-})(BinaryOperationNode = exports.BinaryOperationNode || (exports.BinaryOperationNode = {}));
+})(BinaryOperationNode || (exports.BinaryOperationNode = BinaryOperationNode = {}));
 var AssignmentExpressionNode;
 (function (AssignmentExpressionNode) {
     function create(name, rightExpression) {
         const node = {
             start: name.start,
             length: name.length,
-            nodeType: 4 /* AssignmentExpression */,
+            nodeType: 4 /* ParseNodeType.AssignmentExpression */,
             id: _nextNodeId++,
             name,
             rightExpression,
@@ -577,14 +577,14 @@ var AssignmentExpressionNode;
         return node;
     }
     AssignmentExpressionNode.create = create;
-})(AssignmentExpressionNode = exports.AssignmentExpressionNode || (exports.AssignmentExpressionNode = {}));
+})(AssignmentExpressionNode || (exports.AssignmentExpressionNode = AssignmentExpressionNode = {}));
 var AssignmentNode;
 (function (AssignmentNode) {
     function create(leftExpression, rightExpression) {
         const node = {
             start: leftExpression.start,
             length: leftExpression.length,
-            nodeType: 3 /* Assignment */,
+            nodeType: 3 /* ParseNodeType.Assignment */,
             id: _nextNodeId++,
             leftExpression,
             rightExpression,
@@ -595,20 +595,20 @@ var AssignmentNode;
         return node;
     }
     AssignmentNode.create = create;
-})(AssignmentNode = exports.AssignmentNode || (exports.AssignmentNode = {}));
+})(AssignmentNode || (exports.AssignmentNode = AssignmentNode = {}));
 var TypeParameterCategory;
 (function (TypeParameterCategory) {
     TypeParameterCategory[TypeParameterCategory["TypeVar"] = 0] = "TypeVar";
     TypeParameterCategory[TypeParameterCategory["TypeVarTuple"] = 1] = "TypeVarTuple";
     TypeParameterCategory[TypeParameterCategory["ParamSpec"] = 2] = "ParamSpec";
-})(TypeParameterCategory = exports.TypeParameterCategory || (exports.TypeParameterCategory = {}));
+})(TypeParameterCategory || (exports.TypeParameterCategory = TypeParameterCategory = {}));
 var TypeParameterNode;
 (function (TypeParameterNode) {
     function create(name, typeParamCategory, boundExpression, defaultExpression) {
         const node = {
             start: name.start,
             length: name.length,
-            nodeType: 75 /* TypeParameter */,
+            nodeType: 75 /* ParseNodeType.TypeParameter */,
             id: _nextNodeId++,
             name,
             typeParamCategory,
@@ -627,14 +627,14 @@ var TypeParameterNode;
         return node;
     }
     TypeParameterNode.create = create;
-})(TypeParameterNode = exports.TypeParameterNode || (exports.TypeParameterNode = {}));
+})(TypeParameterNode || (exports.TypeParameterNode = TypeParameterNode = {}));
 var TypeParameterListNode;
 (function (TypeParameterListNode) {
     function create(startToken, endToken, parameters) {
         const node = {
             start: startToken.start,
             length: startToken.length,
-            nodeType: 76 /* TypeParameterList */,
+            nodeType: 76 /* ParseNodeType.TypeParameterList */,
             id: _nextNodeId++,
             parameters,
         };
@@ -646,14 +646,14 @@ var TypeParameterListNode;
         return node;
     }
     TypeParameterListNode.create = create;
-})(TypeParameterListNode = exports.TypeParameterListNode || (exports.TypeParameterListNode = {}));
+})(TypeParameterListNode || (exports.TypeParameterListNode = TypeParameterListNode = {}));
 var TypeAliasNode;
 (function (TypeAliasNode) {
     function create(typeToken, name, expression, typeParameters) {
         const node = {
             start: typeToken.start,
             length: typeToken.length,
-            nodeType: 77 /* TypeAlias */,
+            nodeType: 77 /* ParseNodeType.TypeAlias */,
             id: _nextNodeId++,
             name,
             typeParameters,
@@ -668,14 +668,14 @@ var TypeAliasNode;
         return node;
     }
     TypeAliasNode.create = create;
-})(TypeAliasNode = exports.TypeAliasNode || (exports.TypeAliasNode = {}));
+})(TypeAliasNode || (exports.TypeAliasNode = TypeAliasNode = {}));
 var TypeAnnotationNode;
 (function (TypeAnnotationNode) {
     function create(valueExpression, typeAnnotation) {
         const node = {
             start: valueExpression.start,
             length: valueExpression.length,
-            nodeType: 54 /* TypeAnnotation */,
+            nodeType: 54 /* ParseNodeType.TypeAnnotation */,
             id: _nextNodeId++,
             valueExpression,
             typeAnnotation,
@@ -686,14 +686,14 @@ var TypeAnnotationNode;
         return node;
     }
     TypeAnnotationNode.create = create;
-})(TypeAnnotationNode = exports.TypeAnnotationNode || (exports.TypeAnnotationNode = {}));
+})(TypeAnnotationNode || (exports.TypeAnnotationNode = TypeAnnotationNode = {}));
 var FunctionAnnotationNode;
 (function (FunctionAnnotationNode) {
     function create(openParenToken, isParamListEllipsis, paramTypeAnnotations, returnTypeAnnotation) {
         const node = {
             start: openParenToken.start,
             length: openParenToken.length,
-            nodeType: 62 /* FunctionAnnotation */,
+            nodeType: 62 /* ParseNodeType.FunctionAnnotation */,
             id: _nextNodeId++,
             isParamListEllipsis,
             paramTypeAnnotations,
@@ -707,14 +707,14 @@ var FunctionAnnotationNode;
         return node;
     }
     FunctionAnnotationNode.create = create;
-})(FunctionAnnotationNode = exports.FunctionAnnotationNode || (exports.FunctionAnnotationNode = {}));
+})(FunctionAnnotationNode || (exports.FunctionAnnotationNode = FunctionAnnotationNode = {}));
 var AugmentedAssignmentNode;
 (function (AugmentedAssignmentNode) {
     function create(leftExpression, rightExpression, operator, destExpression) {
         const node = {
             start: leftExpression.start,
             length: leftExpression.length,
-            nodeType: 5 /* AugmentedAssignment */,
+            nodeType: 5 /* ParseNodeType.AugmentedAssignment */,
             id: _nextNodeId++,
             leftExpression,
             operator,
@@ -728,14 +728,14 @@ var AugmentedAssignmentNode;
         return node;
     }
     AugmentedAssignmentNode.create = create;
-})(AugmentedAssignmentNode = exports.AugmentedAssignmentNode || (exports.AugmentedAssignmentNode = {}));
+})(AugmentedAssignmentNode || (exports.AugmentedAssignmentNode = AugmentedAssignmentNode = {}));
 var AwaitNode;
 (function (AwaitNode) {
     function create(awaitToken, expression) {
         const node = {
             start: awaitToken.start,
             length: awaitToken.length,
-            nodeType: 6 /* Await */,
+            nodeType: 6 /* ParseNodeType.Await */,
             id: _nextNodeId++,
             expression,
         };
@@ -744,14 +744,14 @@ var AwaitNode;
         return node;
     }
     AwaitNode.create = create;
-})(AwaitNode = exports.AwaitNode || (exports.AwaitNode = {}));
+})(AwaitNode || (exports.AwaitNode = AwaitNode = {}));
 var TernaryNode;
 (function (TernaryNode) {
     function create(ifExpression, testExpression, elseExpression) {
         const node = {
             start: ifExpression.start,
             length: ifExpression.length,
-            nodeType: 51 /* Ternary */,
+            nodeType: 51 /* ParseNodeType.Ternary */,
             id: _nextNodeId++,
             ifExpression,
             testExpression,
@@ -764,14 +764,14 @@ var TernaryNode;
         return node;
     }
     TernaryNode.create = create;
-})(TernaryNode = exports.TernaryNode || (exports.TernaryNode = {}));
+})(TernaryNode || (exports.TernaryNode = TernaryNode = {}));
 var UnpackNode;
 (function (UnpackNode) {
     function create(starToken, expression) {
         const node = {
             start: starToken.start,
             length: starToken.length,
-            nodeType: 56 /* Unpack */,
+            nodeType: 56 /* ParseNodeType.Unpack */,
             id: _nextNodeId++,
             expression,
         };
@@ -780,14 +780,14 @@ var UnpackNode;
         return node;
     }
     UnpackNode.create = create;
-})(UnpackNode = exports.UnpackNode || (exports.UnpackNode = {}));
+})(UnpackNode || (exports.UnpackNode = UnpackNode = {}));
 var TupleNode;
 (function (TupleNode) {
     function create(range, enclosedInParens) {
         const node = {
             start: range.start,
             length: range.length,
-            nodeType: 52 /* Tuple */,
+            nodeType: 52 /* ParseNodeType.Tuple */,
             id: _nextNodeId++,
             expressions: [],
             enclosedInParens,
@@ -795,7 +795,7 @@ var TupleNode;
         return node;
     }
     TupleNode.create = create;
-})(TupleNode = exports.TupleNode || (exports.TupleNode = {}));
+})(TupleNode || (exports.TupleNode = TupleNode = {}));
 var CallNode;
 (function (CallNode) {
     function create(leftExpression, argList, trailingComma) {
@@ -803,7 +803,7 @@ var CallNode;
         const node = {
             start: leftExpression.start,
             length: leftExpression.length,
-            nodeType: 9 /* Call */,
+            nodeType: 9 /* ParseNodeType.Call */,
             id: _nextNodeId++,
             leftExpression,
             arguments: argList,
@@ -820,14 +820,14 @@ var CallNode;
         return node;
     }
     CallNode.create = create;
-})(CallNode = exports.CallNode || (exports.CallNode = {}));
+})(CallNode || (exports.CallNode = CallNode = {}));
 var ListComprehensionNode;
 (function (ListComprehensionNode) {
     function create(expression, isGenerator) {
         const node = {
             start: expression.start,
             length: expression.length,
-            nodeType: 32 /* ListComprehension */,
+            nodeType: 32 /* ParseNodeType.ListComprehension */,
             id: _nextNodeId++,
             expression,
             forIfNodes: [],
@@ -837,7 +837,7 @@ var ListComprehensionNode;
         return node;
     }
     ListComprehensionNode.create = create;
-})(ListComprehensionNode = exports.ListComprehensionNode || (exports.ListComprehensionNode = {}));
+})(ListComprehensionNode || (exports.ListComprehensionNode = ListComprehensionNode = {}));
 var IndexNode;
 (function (IndexNode) {
     function create(baseExpression, items, trailingComma, closeBracketToken) {
@@ -845,7 +845,7 @@ var IndexNode;
         const node = {
             start: baseExpression.start,
             length: baseExpression.length,
-            nodeType: 24 /* Index */,
+            nodeType: 24 /* ParseNodeType.Index */,
             id: _nextNodeId++,
             baseExpression,
             items,
@@ -860,27 +860,27 @@ var IndexNode;
         return node;
     }
     IndexNode.create = create;
-})(IndexNode = exports.IndexNode || (exports.IndexNode = {}));
+})(IndexNode || (exports.IndexNode = IndexNode = {}));
 var SliceNode;
 (function (SliceNode) {
     function create(range) {
         const node = {
             start: range.start,
             length: range.length,
-            nodeType: 46 /* Slice */,
+            nodeType: 46 /* ParseNodeType.Slice */,
             id: _nextNodeId++,
         };
         return node;
     }
     SliceNode.create = create;
-})(SliceNode = exports.SliceNode || (exports.SliceNode = {}));
+})(SliceNode || (exports.SliceNode = SliceNode = {}));
 var YieldNode;
 (function (YieldNode) {
     function create(yieldToken, expression) {
         const node = {
             start: yieldToken.start,
             length: yieldToken.length,
-            nodeType: 60 /* Yield */,
+            nodeType: 60 /* ParseNodeType.Yield */,
             id: _nextNodeId++,
             expression,
         };
@@ -891,14 +891,14 @@ var YieldNode;
         return node;
     }
     YieldNode.create = create;
-})(YieldNode = exports.YieldNode || (exports.YieldNode = {}));
+})(YieldNode || (exports.YieldNode = YieldNode = {}));
 var YieldFromNode;
 (function (YieldFromNode) {
     function create(yieldToken, expression) {
         const node = {
             start: yieldToken.start,
             length: yieldToken.length,
-            nodeType: 61 /* YieldFrom */,
+            nodeType: 61 /* ParseNodeType.YieldFrom */,
             id: _nextNodeId++,
             expression,
         };
@@ -907,7 +907,7 @@ var YieldFromNode;
         return node;
     }
     YieldFromNode.create = create;
-})(YieldFromNode = exports.YieldFromNode || (exports.YieldFromNode = {}));
+})(YieldFromNode || (exports.YieldFromNode = YieldFromNode = {}));
 var MemberAccessNode;
 (function (MemberAccessNode) {
     function create(leftExpression, memberName) {
@@ -915,7 +915,7 @@ var MemberAccessNode;
         const node = {
             start: leftExpression.start,
             length: leftExpression.length,
-            nodeType: 35 /* MemberAccess */,
+            nodeType: 35 /* ParseNodeType.MemberAccess */,
             id: _nextNodeId++,
             leftExpression,
             memberName,
@@ -927,14 +927,14 @@ var MemberAccessNode;
         return node;
     }
     MemberAccessNode.create = create;
-})(MemberAccessNode = exports.MemberAccessNode || (exports.MemberAccessNode = {}));
+})(MemberAccessNode || (exports.MemberAccessNode = MemberAccessNode = {}));
 var LambdaNode;
 (function (LambdaNode) {
     function create(lambdaToken, expression) {
         const node = {
             start: lambdaToken.start,
             length: lambdaToken.length,
-            nodeType: 30 /* Lambda */,
+            nodeType: 30 /* ParseNodeType.Lambda */,
             id: _nextNodeId++,
             parameters: [],
             expression,
@@ -944,14 +944,14 @@ var LambdaNode;
         return node;
     }
     LambdaNode.create = create;
-})(LambdaNode = exports.LambdaNode || (exports.LambdaNode = {}));
+})(LambdaNode || (exports.LambdaNode = LambdaNode = {}));
 var NameNode;
 (function (NameNode) {
     function create(nameToken) {
         const node = {
             start: nameToken.start,
             length: nameToken.length,
-            nodeType: 38 /* Name */,
+            nodeType: 38 /* ParseNodeType.Name */,
             id: _nextNodeId++,
             token: nameToken,
             value: nameToken.value,
@@ -959,41 +959,41 @@ var NameNode;
         return node;
     }
     NameNode.create = create;
-})(NameNode = exports.NameNode || (exports.NameNode = {}));
+})(NameNode || (exports.NameNode = NameNode = {}));
 var ConstantNode;
 (function (ConstantNode) {
     function create(token) {
         const node = {
             start: token.start,
             length: token.length,
-            nodeType: 11 /* Constant */,
+            nodeType: 11 /* ParseNodeType.Constant */,
             id: _nextNodeId++,
             constType: token.keywordType,
         };
         return node;
     }
     ConstantNode.create = create;
-})(ConstantNode = exports.ConstantNode || (exports.ConstantNode = {}));
+})(ConstantNode || (exports.ConstantNode = ConstantNode = {}));
 var EllipsisNode;
 (function (EllipsisNode) {
     function create(range) {
         const node = {
             start: range.start,
             length: range.length,
-            nodeType: 18 /* Ellipsis */,
+            nodeType: 18 /* ParseNodeType.Ellipsis */,
             id: _nextNodeId++,
         };
         return node;
     }
     EllipsisNode.create = create;
-})(EllipsisNode = exports.EllipsisNode || (exports.EllipsisNode = {}));
+})(EllipsisNode || (exports.EllipsisNode = EllipsisNode = {}));
 var NumberNode;
 (function (NumberNode) {
     function create(token) {
         const node = {
             start: token.start,
             length: token.length,
-            nodeType: 40 /* Number */,
+            nodeType: 40 /* ParseNodeType.Number */,
             id: _nextNodeId++,
             value: token.value,
             isInteger: token.isInteger,
@@ -1002,14 +1002,14 @@ var NumberNode;
         return node;
     }
     NumberNode.create = create;
-})(NumberNode = exports.NumberNode || (exports.NumberNode = {}));
+})(NumberNode || (exports.NumberNode = NumberNode = {}));
 var StringNode;
 (function (StringNode) {
     function create(token, unescapedValue) {
         const node = {
             start: token.start,
             length: token.length,
-            nodeType: 49 /* String */,
+            nodeType: 49 /* ParseNodeType.String */,
             id: _nextNodeId++,
             token,
             value: unescapedValue,
@@ -1017,14 +1017,14 @@ var StringNode;
         return node;
     }
     StringNode.create = create;
-})(StringNode = exports.StringNode || (exports.StringNode = {}));
+})(StringNode || (exports.StringNode = StringNode = {}));
 var FormatStringNode;
 (function (FormatStringNode) {
     function create(startToken, endToken, middleTokens, fieldExpressions, formatExpressions) {
         const node = {
             start: startToken.start,
             length: startToken.length,
-            nodeType: 27 /* FormatString */,
+            nodeType: 27 /* ParseNodeType.FormatString */,
             id: _nextNodeId++,
             token: startToken,
             middleTokens,
@@ -1048,14 +1048,14 @@ var FormatStringNode;
         return node;
     }
     FormatStringNode.create = create;
-})(FormatStringNode = exports.FormatStringNode || (exports.FormatStringNode = {}));
+})(FormatStringNode || (exports.FormatStringNode = FormatStringNode = {}));
 var StringListNode;
 (function (StringListNode) {
     function create(strings) {
         const node = {
             start: strings[0].start,
             length: strings[0].length,
-            nodeType: 48 /* StringList */,
+            nodeType: 48 /* ParseNodeType.StringList */,
             id: _nextNodeId++,
             strings,
         };
@@ -1068,28 +1068,28 @@ var StringListNode;
         return node;
     }
     StringListNode.create = create;
-})(StringListNode = exports.StringListNode || (exports.StringListNode = {}));
+})(StringListNode || (exports.StringListNode = StringListNode = {}));
 var DictionaryNode;
 (function (DictionaryNode) {
     function create(range) {
         const node = {
             start: range.start,
             length: range.length,
-            nodeType: 15 /* Dictionary */,
+            nodeType: 15 /* ParseNodeType.Dictionary */,
             id: _nextNodeId++,
             entries: [],
         };
         return node;
     }
     DictionaryNode.create = create;
-})(DictionaryNode = exports.DictionaryNode || (exports.DictionaryNode = {}));
+})(DictionaryNode || (exports.DictionaryNode = DictionaryNode = {}));
 var DictionaryKeyEntryNode;
 (function (DictionaryKeyEntryNode) {
     function create(keyExpression, valueExpression) {
         const node = {
             start: keyExpression.start,
             length: keyExpression.length,
-            nodeType: 17 /* DictionaryKeyEntry */,
+            nodeType: 17 /* ParseNodeType.DictionaryKeyEntry */,
             id: _nextNodeId++,
             keyExpression,
             valueExpression,
@@ -1100,14 +1100,14 @@ var DictionaryKeyEntryNode;
         return node;
     }
     DictionaryKeyEntryNode.create = create;
-})(DictionaryKeyEntryNode = exports.DictionaryKeyEntryNode || (exports.DictionaryKeyEntryNode = {}));
+})(DictionaryKeyEntryNode || (exports.DictionaryKeyEntryNode = DictionaryKeyEntryNode = {}));
 var DictionaryExpandEntryNode;
 (function (DictionaryExpandEntryNode) {
     function create(expandExpression) {
         const node = {
             start: expandExpression.start,
             length: expandExpression.length,
-            nodeType: 16 /* DictionaryExpandEntry */,
+            nodeType: 16 /* ParseNodeType.DictionaryExpandEntry */,
             id: _nextNodeId++,
             expandExpression,
         };
@@ -1115,48 +1115,48 @@ var DictionaryExpandEntryNode;
         return node;
     }
     DictionaryExpandEntryNode.create = create;
-})(DictionaryExpandEntryNode = exports.DictionaryExpandEntryNode || (exports.DictionaryExpandEntryNode = {}));
+})(DictionaryExpandEntryNode || (exports.DictionaryExpandEntryNode = DictionaryExpandEntryNode = {}));
 var SetNode;
 (function (SetNode) {
     function create(range) {
         const node = {
             start: range.start,
             length: range.length,
-            nodeType: 45 /* Set */,
+            nodeType: 45 /* ParseNodeType.Set */,
             id: _nextNodeId++,
             entries: [],
         };
         return node;
     }
     SetNode.create = create;
-})(SetNode = exports.SetNode || (exports.SetNode = {}));
+})(SetNode || (exports.SetNode = SetNode = {}));
 var ListNode;
 (function (ListNode) {
     function create(range) {
         const node = {
             start: range.start,
             length: range.length,
-            nodeType: 31 /* List */,
+            nodeType: 31 /* ParseNodeType.List */,
             id: _nextNodeId++,
             entries: [],
         };
         return node;
     }
     ListNode.create = create;
-})(ListNode = exports.ListNode || (exports.ListNode = {}));
+})(ListNode || (exports.ListNode = ListNode = {}));
 var ArgumentCategory;
 (function (ArgumentCategory) {
     ArgumentCategory[ArgumentCategory["Simple"] = 0] = "Simple";
     ArgumentCategory[ArgumentCategory["UnpackedList"] = 1] = "UnpackedList";
     ArgumentCategory[ArgumentCategory["UnpackedDictionary"] = 2] = "UnpackedDictionary";
-})(ArgumentCategory = exports.ArgumentCategory || (exports.ArgumentCategory = {}));
+})(ArgumentCategory || (exports.ArgumentCategory = ArgumentCategory = {}));
 var ArgumentNode;
 (function (ArgumentNode) {
     function create(startToken, valueExpression, argCategory) {
         const node = {
             start: startToken ? startToken.start : valueExpression.start,
             length: startToken ? startToken.length : valueExpression.length,
-            nodeType: 1 /* Argument */,
+            nodeType: 1 /* ParseNodeType.Argument */,
             id: _nextNodeId++,
             valueExpression,
             argumentCategory: argCategory,
@@ -1166,55 +1166,55 @@ var ArgumentNode;
         return node;
     }
     ArgumentNode.create = create;
-})(ArgumentNode = exports.ArgumentNode || (exports.ArgumentNode = {}));
+})(ArgumentNode || (exports.ArgumentNode = ArgumentNode = {}));
 var DelNode;
 (function (DelNode) {
     function create(delToken) {
         const node = {
             start: delToken.start,
             length: delToken.length,
-            nodeType: 14 /* Del */,
+            nodeType: 14 /* ParseNodeType.Del */,
             id: _nextNodeId++,
             expressions: [],
         };
         return node;
     }
     DelNode.create = create;
-})(DelNode = exports.DelNode || (exports.DelNode = {}));
+})(DelNode || (exports.DelNode = DelNode = {}));
 var PassNode;
 (function (PassNode) {
     function create(passToken) {
         const node = {
             start: passToken.start,
             length: passToken.length,
-            nodeType: 42 /* Pass */,
+            nodeType: 42 /* ParseNodeType.Pass */,
             id: _nextNodeId++,
         };
         return node;
     }
     PassNode.create = create;
-})(PassNode = exports.PassNode || (exports.PassNode = {}));
+})(PassNode || (exports.PassNode = PassNode = {}));
 var ImportNode;
 (function (ImportNode) {
     function create(passToken) {
         const node = {
             start: passToken.start,
             length: passToken.length,
-            nodeType: 20 /* Import */,
+            nodeType: 20 /* ParseNodeType.Import */,
             id: _nextNodeId++,
             list: [],
         };
         return node;
     }
     ImportNode.create = create;
-})(ImportNode = exports.ImportNode || (exports.ImportNode = {}));
+})(ImportNode || (exports.ImportNode = ImportNode = {}));
 var ModuleNameNode;
 (function (ModuleNameNode) {
     function create(range) {
         const node = {
             start: range.start,
             length: range.length,
-            nodeType: 37 /* ModuleName */,
+            nodeType: 37 /* ParseNodeType.ModuleName */,
             id: _nextNodeId++,
             leadingDots: 0,
             nameParts: [],
@@ -1222,14 +1222,14 @@ var ModuleNameNode;
         return node;
     }
     ModuleNameNode.create = create;
-})(ModuleNameNode = exports.ModuleNameNode || (exports.ModuleNameNode = {}));
+})(ModuleNameNode || (exports.ModuleNameNode = ModuleNameNode = {}));
 var ImportAsNode;
 (function (ImportAsNode) {
     function create(module) {
         const node = {
             start: module.start,
             length: module.length,
-            nodeType: 21 /* ImportAs */,
+            nodeType: 21 /* ParseNodeType.ImportAs */,
             id: _nextNodeId++,
             module,
         };
@@ -1237,14 +1237,14 @@ var ImportAsNode;
         return node;
     }
     ImportAsNode.create = create;
-})(ImportAsNode = exports.ImportAsNode || (exports.ImportAsNode = {}));
+})(ImportAsNode || (exports.ImportAsNode = ImportAsNode = {}));
 var ImportFromNode;
 (function (ImportFromNode) {
     function create(fromToken, module) {
         const node = {
             start: fromToken.start,
             length: fromToken.length,
-            nodeType: 22 /* ImportFrom */,
+            nodeType: 22 /* ParseNodeType.ImportFrom */,
             id: _nextNodeId++,
             module,
             imports: [],
@@ -1256,14 +1256,14 @@ var ImportFromNode;
         return node;
     }
     ImportFromNode.create = create;
-})(ImportFromNode = exports.ImportFromNode || (exports.ImportFromNode = {}));
+})(ImportFromNode || (exports.ImportFromNode = ImportFromNode = {}));
 var ImportFromAsNode;
 (function (ImportFromAsNode) {
     function create(name) {
         const node = {
             start: name.start,
             length: name.length,
-            nodeType: 23 /* ImportFromAs */,
+            nodeType: 23 /* ParseNodeType.ImportFromAs */,
             id: _nextNodeId++,
             name,
         };
@@ -1271,42 +1271,42 @@ var ImportFromAsNode;
         return node;
     }
     ImportFromAsNode.create = create;
-})(ImportFromAsNode = exports.ImportFromAsNode || (exports.ImportFromAsNode = {}));
+})(ImportFromAsNode || (exports.ImportFromAsNode = ImportFromAsNode = {}));
 var GlobalNode;
 (function (GlobalNode) {
     function create(range) {
         const node = {
             start: range.start,
             length: range.length,
-            nodeType: 29 /* Global */,
+            nodeType: 29 /* ParseNodeType.Global */,
             id: _nextNodeId++,
             nameList: [],
         };
         return node;
     }
     GlobalNode.create = create;
-})(GlobalNode = exports.GlobalNode || (exports.GlobalNode = {}));
+})(GlobalNode || (exports.GlobalNode = GlobalNode = {}));
 var NonlocalNode;
 (function (NonlocalNode) {
     function create(range) {
         const node = {
             start: range.start,
             length: range.length,
-            nodeType: 39 /* Nonlocal */,
+            nodeType: 39 /* ParseNodeType.Nonlocal */,
             id: _nextNodeId++,
             nameList: [],
         };
         return node;
     }
     NonlocalNode.create = create;
-})(NonlocalNode = exports.NonlocalNode || (exports.NonlocalNode = {}));
+})(NonlocalNode || (exports.NonlocalNode = NonlocalNode = {}));
 var AssertNode;
 (function (AssertNode) {
     function create(assertToken, testExpression) {
         const node = {
             start: assertToken.start,
             length: assertToken.length,
-            nodeType: 2 /* Assert */,
+            nodeType: 2 /* ParseNodeType.Assert */,
             id: _nextNodeId++,
             testExpression,
         };
@@ -1315,66 +1315,66 @@ var AssertNode;
         return node;
     }
     AssertNode.create = create;
-})(AssertNode = exports.AssertNode || (exports.AssertNode = {}));
+})(AssertNode || (exports.AssertNode = AssertNode = {}));
 var BreakNode;
 (function (BreakNode) {
     function create(range) {
         const node = {
             start: range.start,
             length: range.length,
-            nodeType: 8 /* Break */,
+            nodeType: 8 /* ParseNodeType.Break */,
             id: _nextNodeId++,
         };
         return node;
     }
     BreakNode.create = create;
-})(BreakNode = exports.BreakNode || (exports.BreakNode = {}));
+})(BreakNode || (exports.BreakNode = BreakNode = {}));
 var ContinueNode;
 (function (ContinueNode) {
     function create(range) {
         const node = {
             start: range.start,
             length: range.length,
-            nodeType: 12 /* Continue */,
+            nodeType: 12 /* ParseNodeType.Continue */,
             id: _nextNodeId++,
         };
         return node;
     }
     ContinueNode.create = create;
-})(ContinueNode = exports.ContinueNode || (exports.ContinueNode = {}));
+})(ContinueNode || (exports.ContinueNode = ContinueNode = {}));
 var ReturnNode;
 (function (ReturnNode) {
     function create(range) {
         const node = {
             start: range.start,
             length: range.length,
-            nodeType: 44 /* Return */,
+            nodeType: 44 /* ParseNodeType.Return */,
             id: _nextNodeId++,
         };
         return node;
     }
     ReturnNode.create = create;
-})(ReturnNode = exports.ReturnNode || (exports.ReturnNode = {}));
+})(ReturnNode || (exports.ReturnNode = ReturnNode = {}));
 var RaiseNode;
 (function (RaiseNode) {
     function create(range) {
         const node = {
             start: range.start,
             length: range.length,
-            nodeType: 43 /* Raise */,
+            nodeType: 43 /* ParseNodeType.Raise */,
             id: _nextNodeId++,
         };
         return node;
     }
     RaiseNode.create = create;
-})(RaiseNode = exports.RaiseNode || (exports.RaiseNode = {}));
+})(RaiseNode || (exports.RaiseNode = RaiseNode = {}));
 var MatchNode;
 (function (MatchNode) {
     function create(matchToken, subjectExpression) {
         const node = {
             start: matchToken.start,
             length: matchToken.length,
-            nodeType: 63 /* Match */,
+            nodeType: 63 /* ParseNodeType.Match */,
             id: _nextNodeId++,
             subjectExpression,
             cases: [],
@@ -1384,14 +1384,14 @@ var MatchNode;
         return node;
     }
     MatchNode.create = create;
-})(MatchNode = exports.MatchNode || (exports.MatchNode = {}));
+})(MatchNode || (exports.MatchNode = MatchNode = {}));
 var CaseNode;
 (function (CaseNode) {
     function create(caseToken, pattern, isIrrefutable, guardExpression, suite) {
         const node = {
             start: caseToken.start,
             length: caseToken.length,
-            nodeType: 64 /* Case */,
+            nodeType: 64 /* ParseNodeType.Case */,
             id: _nextNodeId++,
             pattern,
             isIrrefutable,
@@ -1407,17 +1407,17 @@ var CaseNode;
         return node;
     }
     CaseNode.create = create;
-})(CaseNode = exports.CaseNode || (exports.CaseNode = {}));
+})(CaseNode || (exports.CaseNode = CaseNode = {}));
 var PatternSequenceNode;
 (function (PatternSequenceNode) {
     function create(firstToken, entries) {
         const starEntryIndex = entries.findIndex((entry) => entry.orPatterns.length === 1 &&
-            entry.orPatterns[0].nodeType === 69 /* PatternCapture */ &&
+            entry.orPatterns[0].nodeType === 69 /* ParseNodeType.PatternCapture */ &&
             entry.orPatterns[0].isStar);
         const node = {
             start: firstToken.start,
             length: firstToken.length,
-            nodeType: 65 /* PatternSequence */,
+            nodeType: 65 /* ParseNodeType.PatternSequence */,
             id: _nextNodeId++,
             entries,
             starEntryIndex: starEntryIndex >= 0 ? starEntryIndex : undefined,
@@ -1431,14 +1431,14 @@ var PatternSequenceNode;
         return node;
     }
     PatternSequenceNode.create = create;
-})(PatternSequenceNode = exports.PatternSequenceNode || (exports.PatternSequenceNode = {}));
+})(PatternSequenceNode || (exports.PatternSequenceNode = PatternSequenceNode = {}));
 var PatternAsNode;
 (function (PatternAsNode) {
     function create(orPatterns, target) {
         const node = {
             start: orPatterns[0].start,
             length: orPatterns[0].length,
-            nodeType: 66 /* PatternAs */,
+            nodeType: 66 /* ParseNodeType.PatternAs */,
             id: _nextNodeId++,
             orPatterns,
             target,
@@ -1456,14 +1456,14 @@ var PatternAsNode;
         return node;
     }
     PatternAsNode.create = create;
-})(PatternAsNode = exports.PatternAsNode || (exports.PatternAsNode = {}));
+})(PatternAsNode || (exports.PatternAsNode = PatternAsNode = {}));
 var PatternLiteralNode;
 (function (PatternLiteralNode) {
     function create(expression) {
         const node = {
             start: expression.start,
             length: expression.length,
-            nodeType: 67 /* PatternLiteral */,
+            nodeType: 67 /* ParseNodeType.PatternLiteral */,
             id: _nextNodeId++,
             expression,
         };
@@ -1471,14 +1471,14 @@ var PatternLiteralNode;
         return node;
     }
     PatternLiteralNode.create = create;
-})(PatternLiteralNode = exports.PatternLiteralNode || (exports.PatternLiteralNode = {}));
+})(PatternLiteralNode || (exports.PatternLiteralNode = PatternLiteralNode = {}));
 var PatternClassNode;
 (function (PatternClassNode) {
     function create(className, args) {
         const node = {
             start: className.start,
             length: className.length,
-            nodeType: 68 /* PatternClass */,
+            nodeType: 68 /* ParseNodeType.PatternClass */,
             id: _nextNodeId++,
             className,
             arguments: args,
@@ -1493,14 +1493,14 @@ var PatternClassNode;
         return node;
     }
     PatternClassNode.create = create;
-})(PatternClassNode = exports.PatternClassNode || (exports.PatternClassNode = {}));
+})(PatternClassNode || (exports.PatternClassNode = PatternClassNode = {}));
 var PatternClassArgumentNode;
 (function (PatternClassArgumentNode) {
     function create(pattern, name) {
         const node = {
             start: pattern.start,
             length: pattern.length,
-            nodeType: 74 /* PatternClassArgument */,
+            nodeType: 74 /* ParseNodeType.PatternClassArgument */,
             id: _nextNodeId++,
             pattern,
             name,
@@ -1513,14 +1513,14 @@ var PatternClassArgumentNode;
         return node;
     }
     PatternClassArgumentNode.create = create;
-})(PatternClassArgumentNode = exports.PatternClassArgumentNode || (exports.PatternClassArgumentNode = {}));
+})(PatternClassArgumentNode || (exports.PatternClassArgumentNode = PatternClassArgumentNode = {}));
 var PatternCaptureNode;
 (function (PatternCaptureNode) {
     function create(target, starToken) {
         const node = {
             start: target.start,
             length: target.length,
-            nodeType: 69 /* PatternCapture */,
+            nodeType: 69 /* ParseNodeType.PatternCapture */,
             id: _nextNodeId++,
             target,
             isStar: starToken !== undefined,
@@ -1533,14 +1533,14 @@ var PatternCaptureNode;
         return node;
     }
     PatternCaptureNode.create = create;
-})(PatternCaptureNode = exports.PatternCaptureNode || (exports.PatternCaptureNode = {}));
+})(PatternCaptureNode || (exports.PatternCaptureNode = PatternCaptureNode = {}));
 var PatternMappingNode;
 (function (PatternMappingNode) {
     function create(startToken, entries) {
         const node = {
             start: startToken.start,
             length: startToken.length,
-            nodeType: 70 /* PatternMapping */,
+            nodeType: 70 /* ParseNodeType.PatternMapping */,
             id: _nextNodeId++,
             entries,
         };
@@ -1553,14 +1553,14 @@ var PatternMappingNode;
         return node;
     }
     PatternMappingNode.create = create;
-})(PatternMappingNode = exports.PatternMappingNode || (exports.PatternMappingNode = {}));
+})(PatternMappingNode || (exports.PatternMappingNode = PatternMappingNode = {}));
 var PatternMappingKeyEntryNode;
 (function (PatternMappingKeyEntryNode) {
     function create(keyPattern, valuePattern) {
         const node = {
             start: keyPattern.start,
             length: keyPattern.length,
-            nodeType: 71 /* PatternMappingKeyEntry */,
+            nodeType: 71 /* ParseNodeType.PatternMappingKeyEntry */,
             id: _nextNodeId++,
             keyPattern,
             valuePattern,
@@ -1571,14 +1571,14 @@ var PatternMappingKeyEntryNode;
         return node;
     }
     PatternMappingKeyEntryNode.create = create;
-})(PatternMappingKeyEntryNode = exports.PatternMappingKeyEntryNode || (exports.PatternMappingKeyEntryNode = {}));
+})(PatternMappingKeyEntryNode || (exports.PatternMappingKeyEntryNode = PatternMappingKeyEntryNode = {}));
 var PatternMappingExpandEntryNode;
 (function (PatternMappingExpandEntryNode) {
     function create(starStarToken, target) {
         const node = {
             start: starStarToken.start,
             length: starStarToken.length,
-            nodeType: 72 /* PatternMappingExpandEntry */,
+            nodeType: 72 /* ParseNodeType.PatternMappingExpandEntry */,
             id: _nextNodeId++,
             target,
         };
@@ -1587,14 +1587,14 @@ var PatternMappingExpandEntryNode;
         return node;
     }
     PatternMappingExpandEntryNode.create = create;
-})(PatternMappingExpandEntryNode = exports.PatternMappingExpandEntryNode || (exports.PatternMappingExpandEntryNode = {}));
+})(PatternMappingExpandEntryNode || (exports.PatternMappingExpandEntryNode = PatternMappingExpandEntryNode = {}));
 var PatternValueNode;
 (function (PatternValueNode) {
     function create(expression) {
         const node = {
             start: expression.start,
             length: expression.length,
-            nodeType: 73 /* PatternValue */,
+            nodeType: 73 /* ParseNodeType.PatternValue */,
             id: _nextNodeId++,
             expression,
         };
@@ -1602,5 +1602,5 @@ var PatternValueNode;
         return node;
     }
     PatternValueNode.create = create;
-})(PatternValueNode = exports.PatternValueNode || (exports.PatternValueNode = {}));
+})(PatternValueNode || (exports.PatternValueNode = PatternValueNode = {}));
 //# sourceMappingURL=parseNodes.js.map