node-red-contrib-tak-registration 0.6.0 → 0.7.0

package/node_modules/@babel/parser/lib/util/class-scope.js

@@ -0,0 +1,92 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.ClassScope = void 0;
+var _scopeflags = require("./scopeflags");
+var _parseError = require("../parse-error");
+class ClassScope {
+  constructor() {
+    this.privateNames = new Set();
+    this.loneAccessors = new Map();
+    this.undefinedPrivateNames = new Map();
+  }
+}
+exports.ClassScope = ClassScope;
+class ClassScopeHandler {
+  constructor(parser) {
+    this.parser = void 0;
+    this.stack = [];
+    this.undefinedPrivateNames = new Map();
+    this.parser = parser;
+  }
+  current() {
+    return this.stack[this.stack.length - 1];
+  }
+  enter() {
+    this.stack.push(new ClassScope());
+  }
+  exit() {
+    const oldClassScope = this.stack.pop();
+    const current = this.current();
+    for (const [name, loc] of Array.from(oldClassScope.undefinedPrivateNames)) {
+      if (current) {
+        if (!current.undefinedPrivateNames.has(name)) {
+          current.undefinedPrivateNames.set(name, loc);
+        }
+      } else {
+        this.parser.raise(_parseError.Errors.InvalidPrivateFieldResolution, {
+          at: loc,
+          identifierName: name
+        });
+      }
+    }
+  }
+  declarePrivateName(name, elementType, loc) {
+    const {
+      privateNames,
+      loneAccessors,
+      undefinedPrivateNames
+    } = this.current();
+    let redefined = privateNames.has(name);
+    if (elementType & _scopeflags.CLASS_ELEMENT_KIND_ACCESSOR) {
+      const accessor = redefined && loneAccessors.get(name);
+      if (accessor) {
+        const oldStatic = accessor & _scopeflags.CLASS_ELEMENT_FLAG_STATIC;
+        const newStatic = elementType & _scopeflags.CLASS_ELEMENT_FLAG_STATIC;
+        const oldKind = accessor & _scopeflags.CLASS_ELEMENT_KIND_ACCESSOR;
+        const newKind = elementType & _scopeflags.CLASS_ELEMENT_KIND_ACCESSOR;
+        redefined = oldKind === newKind || oldStatic !== newStatic;
+        if (!redefined) loneAccessors.delete(name);
+      } else if (!redefined) {
+        loneAccessors.set(name, elementType);
+      }
+    }
+    if (redefined) {
+      this.parser.raise(_parseError.Errors.PrivateNameRedeclaration, {
+        at: loc,
+        identifierName: name
+      });
+    }
+    privateNames.add(name);
+    undefinedPrivateNames.delete(name);
+  }
+  usePrivateName(name, loc) {
+    let classScope;
+    for (classScope of this.stack) {
+      if (classScope.privateNames.has(name)) return;
+    }
+    if (classScope) {
+      classScope.undefinedPrivateNames.set(name, loc);
+    } else {
+      this.parser.raise(_parseError.Errors.InvalidPrivateFieldResolution, {
+        at: loc,
+        identifierName: name
+      });
+    }
+  }
+}
+exports.default = ClassScopeHandler;
+
+//# sourceMappingURL=class-scope.js.map

package/node_modules/@babel/parser/lib/util/class-scope.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_scopeflags","require","_parseError","ClassScope","constructor","privateNames","Set","loneAccessors","Map","undefinedPrivateNames","exports","ClassScopeHandler","parser","stack","current","length","enter","push","exit","oldClassScope","pop","name","loc","Array","from","has","set","raise","Errors","InvalidPrivateFieldResolution","at","identifierName","declarePrivateName","elementType","redefined","CLASS_ELEMENT_KIND_ACCESSOR","accessor","get","oldStatic","CLASS_ELEMENT_FLAG_STATIC","newStatic","oldKind","newKind","delete","PrivateNameRedeclaration","add","usePrivateName","classScope","default"],"sources":["../../src/util/class-scope.ts"],"sourcesContent":["import {\n  CLASS_ELEMENT_KIND_ACCESSOR,\n  CLASS_ELEMENT_FLAG_STATIC,\n  type ClassElementTypes,\n} from \"./scopeflags\";\nimport type { Position } from \"./location\";\nimport { Errors } from \"../parse-error\";\nimport type Tokenizer from \"../tokenizer\";\n\nexport class ClassScope {\n  // A list of private named declared in the current class\n  privateNames: Set<string> = new Set();\n\n  // A list of private getters of setters without their counterpart\n  loneAccessors: Map<string, ClassElementTypes> = new Map();\n\n  // A list of private names used before being defined, mapping to\n  // their position.\n  undefinedPrivateNames: Map<string, Position> = new Map();\n}\n\nexport default class ClassScopeHandler {\n  parser: Tokenizer;\n  stack: Array<ClassScope> = [];\n  undefinedPrivateNames: Map<string, Position> = new Map();\n\n  constructor(parser: Tokenizer) {\n    this.parser = parser;\n  }\n\n  current(): ClassScope {\n    return this.stack[this.stack.length - 1];\n  }\n\n  enter() {\n    this.stack.push(new ClassScope());\n  }\n\n  exit() {\n    const oldClassScope = this.stack.pop();\n\n    // Migrate the usage of not yet defined private names to the outer\n    // class scope, or raise an error if we reached the top-level scope.\n\n    const current = this.current();\n\n    // Array.from is needed because this is compiled to an array-like for loop\n    for (const [name, loc] of Array.from(oldClassScope.undefinedPrivateNames)) {\n      if (current) {\n        if (!current.undefinedPrivateNames.has(name)) {\n          current.undefinedPrivateNames.set(name, loc);\n        }\n      } else {\n        this.parser.raise(Errors.InvalidPrivateFieldResolution, {\n          at: loc,\n          identifierName: name,\n        });\n      }\n    }\n  }\n\n  declarePrivateName(\n    name: string,\n    elementType: ClassElementTypes,\n    loc: Position,\n  ) {\n    const { privateNames, loneAccessors, undefinedPrivateNames } =\n      this.current();\n    let redefined = privateNames.has(name);\n\n    if (elementType & CLASS_ELEMENT_KIND_ACCESSOR) {\n      const accessor = redefined && loneAccessors.get(name);\n      if (accessor) {\n        const oldStatic = accessor & CLASS_ELEMENT_FLAG_STATIC;\n        const newStatic = elementType & CLASS_ELEMENT_FLAG_STATIC;\n\n        const oldKind = accessor & CLASS_ELEMENT_KIND_ACCESSOR;\n        const newKind = elementType & CLASS_ELEMENT_KIND_ACCESSOR;\n\n        // The private name can be duplicated only if it is used by\n        // two accessors with different kind (get and set), and if\n        // they have the same placement (static or not).\n        redefined = oldKind === newKind || oldStatic !== newStatic;\n\n        if (!redefined) loneAccessors.delete(name);\n      } else if (!redefined) {\n        loneAccessors.set(name, elementType);\n      }\n    }\n\n    if (redefined) {\n      this.parser.raise(Errors.PrivateNameRedeclaration, {\n        at: loc,\n        identifierName: name,\n      });\n    }\n\n    privateNames.add(name);\n    undefinedPrivateNames.delete(name);\n  }\n\n  usePrivateName(name: string, loc: Position) {\n    let classScope;\n    for (classScope of this.stack) {\n      if (classScope.privateNames.has(name)) return;\n    }\n\n    if (classScope) {\n      classScope.undefinedPrivateNames.set(name, loc);\n    } else {\n      // top-level\n      this.parser.raise(Errors.InvalidPrivateFieldResolution, {\n        at: loc,\n        identifierName: name,\n      });\n    }\n  }\n}\n"],"mappings":"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"}

package/node_modules/@babel/parser/lib/util/expression-scope.js

@@ -0,0 +1,147 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.newArrowHeadScope = newArrowHeadScope;
+exports.newAsyncArrowScope = newAsyncArrowScope;
+exports.newExpressionScope = newExpressionScope;
+exports.newParameterDeclarationScope = newParameterDeclarationScope;
+var _parseError = require("../parse-error");
+const kExpression = 0,
+  kMaybeArrowParameterDeclaration = 1,
+  kMaybeAsyncArrowParameterDeclaration = 2,
+  kParameterDeclaration = 3;
+class ExpressionScope {
+  constructor(type = kExpression) {
+    this.type = void 0;
+    this.type = type;
+  }
+  canBeArrowParameterDeclaration() {
+    return this.type === kMaybeAsyncArrowParameterDeclaration || this.type === kMaybeArrowParameterDeclaration;
+  }
+  isCertainlyParameterDeclaration() {
+    return this.type === kParameterDeclaration;
+  }
+}
+class ArrowHeadParsingScope extends ExpressionScope {
+  constructor(type) {
+    super(type);
+    this.declarationErrors = new Map();
+  }
+  recordDeclarationError(ParsingErrorClass, {
+    at
+  }) {
+    const index = at.index;
+    this.declarationErrors.set(index, [ParsingErrorClass, at]);
+  }
+  clearDeclarationError(index) {
+    this.declarationErrors.delete(index);
+  }
+  iterateErrors(iterator) {
+    this.declarationErrors.forEach(iterator);
+  }
+}
+class ExpressionScopeHandler {
+  constructor(parser) {
+    this.parser = void 0;
+    this.stack = [new ExpressionScope()];
+    this.parser = parser;
+  }
+  enter(scope) {
+    this.stack.push(scope);
+  }
+  exit() {
+    this.stack.pop();
+  }
+  recordParameterInitializerError(toParseError, {
+    at: node
+  }) {
+    const origin = {
+      at: node.loc.start
+    };
+    const {
+      stack
+    } = this;
+    let i = stack.length - 1;
+    let scope = stack[i];
+    while (!scope.isCertainlyParameterDeclaration()) {
+      if (scope.canBeArrowParameterDeclaration()) {
+        scope.recordDeclarationError(toParseError, origin);
+      } else {
+        return;
+      }
+      scope = stack[--i];
+    }
+    this.parser.raise(toParseError, origin);
+  }
+  recordArrowParameterBindingError(error, {
+    at: node
+  }) {
+    const {
+      stack
+    } = this;
+    const scope = stack[stack.length - 1];
+    const origin = {
+      at: node.loc.start
+    };
+    if (scope.isCertainlyParameterDeclaration()) {
+      this.parser.raise(error, origin);
+    } else if (scope.canBeArrowParameterDeclaration()) {
+      scope.recordDeclarationError(error, origin);
+    } else {
+      return;
+    }
+  }
+  recordAsyncArrowParametersError({
+    at
+  }) {
+    const {
+      stack
+    } = this;
+    let i = stack.length - 1;
+    let scope = stack[i];
+    while (scope.canBeArrowParameterDeclaration()) {
+      if (scope.type === kMaybeAsyncArrowParameterDeclaration) {
+        scope.recordDeclarationError(_parseError.Errors.AwaitBindingIdentifier, {
+          at
+        });
+      }
+      scope = stack[--i];
+    }
+  }
+  validateAsPattern() {
+    const {
+      stack
+    } = this;
+    const currentScope = stack[stack.length - 1];
+    if (!currentScope.canBeArrowParameterDeclaration()) return;
+    currentScope.iterateErrors(([toParseError, loc]) => {
+      this.parser.raise(toParseError, {
+        at: loc
+      });
+      let i = stack.length - 2;
+      let scope = stack[i];
+      while (scope.canBeArrowParameterDeclaration()) {
+        scope.clearDeclarationError(loc.index);
+        scope = stack[--i];
+      }
+    });
+  }
+}
+exports.default = ExpressionScopeHandler;
+function newParameterDeclarationScope() {
+  return new ExpressionScope(kParameterDeclaration);
+}
+function newArrowHeadScope() {
+  return new ArrowHeadParsingScope(kMaybeArrowParameterDeclaration);
+}
+function newAsyncArrowScope() {
+  return new ArrowHeadParsingScope(kMaybeAsyncArrowParameterDeclaration);
+}
+function newExpressionScope() {
+  return new ExpressionScope();
+}
+
+//# sourceMappingURL=expression-scope.js.map

package/node_modules/@babel/parser/lib/util/expression-scope.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_parseError","require","kExpression","kMaybeArrowParameterDeclaration","kMaybeAsyncArrowParameterDeclaration","kParameterDeclaration","ExpressionScope","constructor","type","canBeArrowParameterDeclaration","isCertainlyParameterDeclaration","ArrowHeadParsingScope","declarationErrors","Map","recordDeclarationError","ParsingErrorClass","at","index","set","clearDeclarationError","delete","iterateErrors","iterator","forEach","ExpressionScopeHandler","parser","stack","enter","scope","push","exit","pop","recordParameterInitializerError","toParseError","node","origin","loc","start","i","length","raise","recordArrowParameterBindingError","error","recordAsyncArrowParametersError","Errors","AwaitBindingIdentifier","validateAsPattern","currentScope","exports","default","newParameterDeclarationScope","newArrowHeadScope","newAsyncArrowScope","newExpressionScope"],"sources":["../../src/util/expression-scope.ts"],"sourcesContent":["import { Errors, type ParseErrorConstructor } from \"../parse-error\";\nimport type { Position } from \"./location\";\nimport type { Node } from \"../types\";\nimport type Tokenizer from \"../tokenizer\";\n\n/**\n * @module util/expression-scope\n\nExpressionScope is used to track declaration errors in these ambiguous patterns:\n\n- CoverParenthesizedExpressionAndArrowParameterList\n  e.g. we don't know if `({ x })` is an parenthesized expression or an\n  arrow function parameters until we see an `=>` after `)`.\n\n- CoverCallExpressionAndAsyncArrowHead\n  e.g. we don't know if `async({ x })` is a call expression or an async arrow\n  function parameters until we see an `=>` after `)`\n\nThe following declaration errors (@see parser-errors/standard) will be recorded in\nsome expression scopes and thrown later when we know what the ambiguous pattern is\n\n- AwaitBindingIdentifier\n- AwaitExpressionFormalParameter\n- YieldInParameter\n- InvalidParenthesizedAssignment when parenthesized is an identifier\n\nThere are four different expression scope\n- Expression\n  A general scope that represents program / function body / static block. No errors\n  will be recorded nor thrown in this scope.\n\n- MaybeArrowParameterDeclaration\n  A scope that represents ambiguous arrow head e.g. `(x)`. Errors will be recorded\n  alongside parent scopes and thrown when `ExpressionScopeHandler#validateAsPattern`\n  is called.\n\n- MaybeAsyncArrowParameterDeclaration\n  A scope that represents ambiguous async arrow head e.g. `async(x)`. Errors will\n  be recorded alongside parent scopes and thrown when\n  `ExpressionScopeHandler#validateAsPattern` is called.\n\n- ParameterDeclaration\n  A scope that represents unambiguous function parameters `function(x)`. Errors\n  recorded in this scope will be thrown immediately. No errors will be recorded in\n  this scope.\n\n// @see {@link https://docs.google.com/document/d/1FAvEp9EUK-G8kHfDIEo_385Hs2SUBCYbJ5H-NnLvq8M|V8 Expression Scope design docs}\n */\n\nconst kExpression = 0,\n  kMaybeArrowParameterDeclaration = 1,\n  kMaybeAsyncArrowParameterDeclaration = 2,\n  kParameterDeclaration = 3;\n\ntype ExpressionScopeType = 0 | 1 | 2 | 3;\n\nclass ExpressionScope {\n  type: ExpressionScopeType;\n\n  constructor(type: ExpressionScopeType = kExpression) {\n    this.type = type;\n  }\n\n  canBeArrowParameterDeclaration(): this is ArrowHeadParsingScope {\n    return (\n      this.type === kMaybeAsyncArrowParameterDeclaration ||\n      this.type === kMaybeArrowParameterDeclaration\n    );\n  }\n\n  isCertainlyParameterDeclaration() {\n    return this.type === kParameterDeclaration;\n  }\n}\n\ntype ArrowHeadParsingParameterInitializerError =\n  | typeof Errors.AwaitExpressionFormalParameter\n  | typeof Errors.YieldInParameter;\ntype ArrowHeadParsingDeclarationError =\n  | ArrowHeadParsingParameterInitializerError\n  | typeof Errors.InvalidParenthesizedAssignment\n  | typeof Errors.AwaitBindingIdentifier;\n\nclass ArrowHeadParsingScope extends ExpressionScope {\n  declarationErrors: Map<number, [ParseErrorConstructor<{}>, Position]> =\n    new Map();\n  constructor(type: 1 | 2) {\n    super(type);\n  }\n  recordDeclarationError(\n    ParsingErrorClass: ParseErrorConstructor<{}>,\n    {\n      at,\n    }: {\n      at: Position;\n    },\n  ) {\n    const index = at.index;\n\n    this.declarationErrors.set(index, [ParsingErrorClass, at]);\n  }\n  clearDeclarationError(index: number) {\n    this.declarationErrors.delete(index);\n  }\n  iterateErrors(\n    iterator: (a: [ArrowHeadParsingDeclarationError, Position]) => void,\n  ) {\n    this.declarationErrors.forEach(iterator);\n  }\n}\n\nexport default class ExpressionScopeHandler {\n  parser: Tokenizer;\n  stack: Array<ExpressionScope> = [new ExpressionScope()];\n\n  constructor(parser: Tokenizer) {\n    this.parser = parser;\n  }\n  enter(scope: ExpressionScope) {\n    this.stack.push(scope);\n  }\n\n  exit() {\n    this.stack.pop();\n  }\n\n  /**\n   * Record likely parameter initializer errors\n   *\n   * When current scope is a ParameterDeclaration, the error will be thrown immediately,\n   * otherwise it will be recorded to any ancestry MaybeArrowParameterDeclaration and\n   * MaybeAsyncArrowParameterDeclaration scope until an Expression scope is seen.\n   */\n  recordParameterInitializerError(\n    toParseError: ArrowHeadParsingParameterInitializerError,\n    {\n      at: node,\n    }: {\n      at: Node;\n    },\n  ): void {\n    const origin = { at: node.loc.start };\n    const { stack } = this;\n    let i = stack.length - 1;\n    let scope: ExpressionScope = stack[i];\n    while (!scope.isCertainlyParameterDeclaration()) {\n      if (scope.canBeArrowParameterDeclaration()) {\n        scope.recordDeclarationError(toParseError, origin);\n      } else {\n        /*:: invariant(scope.type == kExpression) */\n        // Type-Expression is the boundary where initializer error can populate to\n        return;\n      }\n      scope = stack[--i];\n    }\n    this.parser.raise(toParseError, origin);\n  }\n\n  /**\n   * Record errors that must be thrown if the current pattern ends up being an arrow\n   * function parameter. This is used to record parenthesized identifiers, and to record\n   * \"a as T\" and \"<T> a\" type assertions when parsing typescript.\n   *\n   * A parenthesized identifier (or type assertion) in LHS can be ambiguous because the assignment\n   * can be transformed to an assignable later, but not vice versa:\n   * For example, in `([(a) = []] = []) => {}`, we think `(a) = []` is an LHS in `[(a) = []]`,\n   * an LHS within `[(a) = []] = []`. However the LHS chain is then transformed by toAssignable,\n   * and we should throw assignment `(a)`, which is only valid in LHS. Hence we record the\n   * location of parenthesized `(a)` to current scope if it is one of MaybeArrowParameterDeclaration\n   * and MaybeAsyncArrowParameterDeclaration\n   *\n   * Unlike `recordParameterInitializerError`, we don't record to ancestry scope because we\n   * validate arrow head parsing scope before exit, and then the LHS will be unambiguous:\n   * For example, in `( x = ( [(a) = []] = [] ) ) => {}`, we should not record `(a)` in `( x = ... ) =>`\n   * arrow scope because when we finish parsing `( [(a) = []] = [] )`, it is an unambiguous assignment\n   * expression and can not be cast to pattern\n   */\n  recordArrowParameterBindingError(\n    error: ParseErrorConstructor<{}>,\n    {\n      at: node,\n    }: {\n      at: Node;\n    },\n  ): void {\n    const { stack } = this;\n    const scope: ExpressionScope = stack[stack.length - 1];\n    const origin = { at: node.loc.start };\n    if (scope.isCertainlyParameterDeclaration()) {\n      this.parser.raise(error, origin);\n    } else if (scope.canBeArrowParameterDeclaration()) {\n      scope.recordDeclarationError(error, origin);\n    } else {\n      return;\n    }\n  }\n\n  /**\n   * Record likely async arrow parameter errors\n   *\n   * Errors will be recorded to any ancestry MaybeAsyncArrowParameterDeclaration\n   * scope until an Expression scope is seen.\n   */\n  recordAsyncArrowParametersError({ at }: { at: Position }): void {\n    const { stack } = this;\n    let i = stack.length - 1;\n    let scope: ExpressionScope = stack[i];\n    while (scope.canBeArrowParameterDeclaration()) {\n      if (scope.type === kMaybeAsyncArrowParameterDeclaration) {\n        scope.recordDeclarationError(Errors.AwaitBindingIdentifier, { at });\n      }\n      scope = stack[--i];\n    }\n  }\n\n  validateAsPattern(): void {\n    const { stack } = this;\n    const currentScope = stack[stack.length - 1];\n    if (!currentScope.canBeArrowParameterDeclaration()) return;\n    currentScope.iterateErrors(([toParseError, loc]) => {\n      this.parser.raise(toParseError, { at: loc });\n      // iterate from parent scope\n      let i = stack.length - 2;\n      let scope = stack[i];\n      while (scope.canBeArrowParameterDeclaration()) {\n        scope.clearDeclarationError(loc.index);\n        scope = stack[--i];\n      }\n    });\n  }\n}\n\nexport function newParameterDeclarationScope() {\n  return new ExpressionScope(kParameterDeclaration);\n}\n\nexport function newArrowHeadScope() {\n  return new ArrowHeadParsingScope(kMaybeArrowParameterDeclaration);\n}\n\nexport function newAsyncArrowScope() {\n  return new ArrowHeadParsingScope(kMaybeAsyncArrowParameterDeclaration);\n}\n\nexport function newExpressionScope() {\n  return new ExpressionScope();\n}\n"],"mappings":"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"}

package/node_modules/@babel/parser/lib/util/identifier.js

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.canBeReservedWord = canBeReservedWord;
+Object.defineProperty(exports, "isIdentifierChar", {
+  enumerable: true,
+  get: function () {
+    return _helperValidatorIdentifier.isIdentifierChar;
+  }
+});
+Object.defineProperty(exports, "isIdentifierStart", {
+  enumerable: true,
+  get: function () {
+    return _helperValidatorIdentifier.isIdentifierStart;
+  }
+});
+exports.isIteratorStart = isIteratorStart;
+Object.defineProperty(exports, "isKeyword", {
+  enumerable: true,
+  get: function () {
+    return _helperValidatorIdentifier.isKeyword;
+  }
+});
+Object.defineProperty(exports, "isReservedWord", {
+  enumerable: true,
+  get: function () {
+    return _helperValidatorIdentifier.isReservedWord;
+  }
+});
+Object.defineProperty(exports, "isStrictBindOnlyReservedWord", {
+  enumerable: true,
+  get: function () {
+    return _helperValidatorIdentifier.isStrictBindOnlyReservedWord;
+  }
+});
+Object.defineProperty(exports, "isStrictBindReservedWord", {
+  enumerable: true,
+  get: function () {
+    return _helperValidatorIdentifier.isStrictBindReservedWord;
+  }
+});
+Object.defineProperty(exports, "isStrictReservedWord", {
+  enumerable: true,
+  get: function () {
+    return _helperValidatorIdentifier.isStrictReservedWord;
+  }
+});
+exports.keywordRelationalOperator = void 0;
+var _helperValidatorIdentifier = require("@babel/helper-validator-identifier");
+const keywordRelationalOperator = /^in(stanceof)?$/;
+exports.keywordRelationalOperator = keywordRelationalOperator;
+function isIteratorStart(current, next, next2) {
+  return current === 64 && next === 64 && (0, _helperValidatorIdentifier.isIdentifierStart)(next2);
+}
+const reservedWordLikeSet = new Set(["break", "case", "catch", "continue", "debugger", "default", "do", "else", "finally", "for", "function", "if", "return", "switch", "throw", "try", "var", "const", "while", "with", "new", "this", "super", "class", "extends", "export", "import", "null", "true", "false", "in", "instanceof", "typeof", "void", "delete", "implements", "interface", "let", "package", "private", "protected", "public", "static", "yield", "eval", "arguments", "enum", "await"]);
+function canBeReservedWord(word) {
+  return reservedWordLikeSet.has(word);
+}
+
+//# sourceMappingURL=identifier.js.map

package/node_modules/@babel/parser/lib/util/identifier.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_helperValidatorIdentifier","require","keywordRelationalOperator","exports","isIteratorStart","current","next","next2","isIdentifierStart","reservedWordLikeSet","Set","canBeReservedWord","word","has"],"sources":["../../src/util/identifier.ts"],"sourcesContent":["/* eslint max-len: 0 */\n\nimport * as charCodes from \"charcodes\";\nimport { isIdentifierStart } from \"@babel/helper-validator-identifier\";\n\nexport {\n  isIdentifierStart,\n  isIdentifierChar,\n  isReservedWord,\n  isStrictBindOnlyReservedWord,\n  isStrictBindReservedWord,\n  isStrictReservedWord,\n  isKeyword,\n} from \"@babel/helper-validator-identifier\";\n\nexport const keywordRelationalOperator = /^in(stanceof)?$/;\n\n// Test whether a current state character code and next character code is @\n\nexport function isIteratorStart(\n  current: number,\n  next: number,\n  next2: number,\n): boolean {\n  return (\n    current === charCodes.atSign &&\n    next === charCodes.atSign &&\n    isIdentifierStart(next2)\n  );\n}\n\n// This is the comprehensive set of JavaScript reserved words\n// If a word is in this set, it could be a reserved word,\n// depending on sourceType/strictMode/binding info. In other words\n// if a word is not in this set, it is not a reserved word under\n// any circumstance.\nconst reservedWordLikeSet = new Set([\n  \"break\",\n  \"case\",\n  \"catch\",\n  \"continue\",\n  \"debugger\",\n  \"default\",\n  \"do\",\n  \"else\",\n  \"finally\",\n  \"for\",\n  \"function\",\n  \"if\",\n  \"return\",\n  \"switch\",\n  \"throw\",\n  \"try\",\n  \"var\",\n  \"const\",\n  \"while\",\n  \"with\",\n  \"new\",\n  \"this\",\n  \"super\",\n  \"class\",\n  \"extends\",\n  \"export\",\n  \"import\",\n  \"null\",\n  \"true\",\n  \"false\",\n  \"in\",\n  \"instanceof\",\n  \"typeof\",\n  \"void\",\n  \"delete\",\n  // strict\n  \"implements\",\n  \"interface\",\n  \"let\",\n  \"package\",\n  \"private\",\n  \"protected\",\n  \"public\",\n  \"static\",\n  \"yield\",\n  // strictBind\n  \"eval\",\n  \"arguments\",\n  // reservedWorkLike\n  \"enum\",\n  \"await\",\n]);\n\nexport function canBeReservedWord(word: string): boolean {\n  return reservedWordLikeSet.has(word);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,IAAAA,0BAAA,GAAAC,OAAA;AAYO,MAAMC,yBAAyB,GAAG,iBAAiB;AAACC,OAAA,CAAAD,yBAAA,GAAAA,yBAAA;AAIpD,SAASE,eAAeA,CAC7BC,OAAe,EACfC,IAAY,EACZC,KAAa,EACJ;EACT,OACEF,OAAO,OAAqB,IAC5BC,IAAI,OAAqB,IACzB,IAAAE,4CAAiB,EAACD,KAAK,CAAC;AAE5B;AAOA,MAAME,mBAAmB,GAAG,IAAIC,GAAG,CAAC,CAClC,OAAO,EACP,MAAM,EACN,OAAO,EACP,UAAU,EACV,UAAU,EACV,SAAS,EACT,IAAI,EACJ,MAAM,EACN,SAAS,EACT,KAAK,EACL,UAAU,EACV,IAAI,EACJ,QAAQ,EACR,QAAQ,EACR,OAAO,EACP,KAAK,EACL,KAAK,EACL,OAAO,EACP,OAAO,EACP,MAAM,EACN,KAAK,EACL,MAAM,EACN,OAAO,EACP,OAAO,EACP,SAAS,EACT,QAAQ,EACR,QAAQ,EACR,MAAM,EACN,MAAM,EACN,OAAO,EACP,IAAI,EACJ,YAAY,EACZ,QAAQ,EACR,MAAM,EACN,QAAQ,EAER,YAAY,EACZ,WAAW,EACX,KAAK,EACL,SAAS,EACT,SAAS,EACT,WAAW,EACX,QAAQ,EACR,QAAQ,EACR,OAAO,EAEP,MAAM,EACN,WAAW,EAEX,MAAM,EACN,OAAO,CACR,CAAC;AAEK,SAASC,iBAAiBA,CAACC,IAAY,EAAW;EACvD,OAAOH,mBAAmB,CAACI,GAAG,CAACD,IAAI,CAAC;AACtC"}

package/node_modules/@babel/parser/lib/util/location.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SourceLocation = exports.Position = void 0;
+exports.createPositionWithColumnOffset = createPositionWithColumnOffset;
+class Position {
+  constructor(line, col, index) {
+    this.line = void 0;
+    this.column = void 0;
+    this.index = void 0;
+    this.line = line;
+    this.column = col;
+    this.index = index;
+  }
+}
+exports.Position = Position;
+class SourceLocation {
+  constructor(start, end) {
+    this.start = void 0;
+    this.end = void 0;
+    this.filename = void 0;
+    this.identifierName = void 0;
+    this.start = start;
+    this.end = end;
+  }
+}
+exports.SourceLocation = SourceLocation;
+function createPositionWithColumnOffset(position, columnOffset) {
+  const {
+    line,
+    column,
+    index
+  } = position;
+  return new Position(line, column + columnOffset, index + columnOffset);
+}
+
+//# sourceMappingURL=location.js.map

package/node_modules/@babel/parser/lib/util/location.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Position","constructor","line","col","index","column","exports","SourceLocation","start","end","filename","identifierName","createPositionWithColumnOffset","position","columnOffset"],"sources":["../../src/util/location.ts"],"sourcesContent":["export type Pos = {\n  start: number;\n};\n\n// These are used when `options.locations` is on, for the\n// `startLoc` and `endLoc` properties.\n\nexport class Position {\n  line: number;\n  column: number;\n  index: number;\n\n  constructor(line: number, col: number, index: number) {\n    this.line = line;\n    this.column = col;\n    this.index = index;\n  }\n}\n\nexport class SourceLocation {\n  start: Position;\n  end: Position;\n  filename: string;\n  identifierName: string | undefined | null;\n\n  constructor(start: Position, end?: Position) {\n    this.start = start;\n    // (may start as null, but initialized later)\n    this.end = end;\n  }\n}\n\n/**\n * creates a new position with a non-zero column offset from the given position.\n * This function should be only be used when we create AST node out of the token\n * boundaries, such as TemplateElement ends before tt.templateNonTail. This\n * function does not skip whitespaces.\n */\nexport function createPositionWithColumnOffset(\n  position: Position,\n  columnOffset: number,\n) {\n  const { line, column, index } = position;\n  return new Position(line, column + columnOffset, index + columnOffset);\n}\n"],"mappings":";;;;;;;AAOO,MAAMA,QAAQ,CAAC;EAKpBC,WAAWA,CAACC,IAAY,EAAEC,GAAW,EAAEC,KAAa,EAAE;IAAA,KAJtDF,IAAI;IAAA,KACJG,MAAM;IAAA,KACND,KAAK;IAGH,IAAI,CAACF,IAAI,GAAGA,IAAI;IAChB,IAAI,CAACG,MAAM,GAAGF,GAAG;IACjB,IAAI,CAACC,KAAK,GAAGA,KAAK;EACpB;AACF;AAACE,OAAA,CAAAN,QAAA,GAAAA,QAAA;AAEM,MAAMO,cAAc,CAAC;EAM1BN,WAAWA,CAACO,KAAe,EAAEC,GAAc,EAAE;IAAA,KAL7CD,KAAK;IAAA,KACLC,GAAG;IAAA,KACHC,QAAQ;IAAA,KACRC,cAAc;IAGZ,IAAI,CAACH,KAAK,GAAGA,KAAK;IAElB,IAAI,CAACC,GAAG,GAAGA,GAAG;EAChB;AACF;AAACH,OAAA,CAAAC,cAAA,GAAAA,cAAA;AAQM,SAASK,8BAA8BA,CAC5CC,QAAkB,EAClBC,YAAoB,EACpB;EACA,MAAM;IAAEZ,IAAI;IAAEG,MAAM;IAAED;EAAM,CAAC,GAAGS,QAAQ;EACxC,OAAO,IAAIb,QAAQ,CAACE,IAAI,EAAEG,MAAM,GAAGS,YAAY,EAAEV,KAAK,GAAGU,YAAY,CAAC;AACxE"}

package/node_modules/@babel/parser/lib/util/production-parameter.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.PARAM_YIELD = exports.PARAM_RETURN = exports.PARAM_IN = exports.PARAM_AWAIT = exports.PARAM = void 0;
+exports.functionFlags = functionFlags;
+const PARAM = 0b0000,
+  PARAM_YIELD = 0b0001,
+  PARAM_AWAIT = 0b0010,
+  PARAM_RETURN = 0b0100,
+  PARAM_IN = 0b1000;
+exports.PARAM_IN = PARAM_IN;
+exports.PARAM_RETURN = PARAM_RETURN;
+exports.PARAM_AWAIT = PARAM_AWAIT;
+exports.PARAM_YIELD = PARAM_YIELD;
+exports.PARAM = PARAM;
+class ProductionParameterHandler {
+  constructor() {
+    this.stacks = [];
+  }
+  enter(flags) {
+    this.stacks.push(flags);
+  }
+  exit() {
+    this.stacks.pop();
+  }
+  currentFlags() {
+    return this.stacks[this.stacks.length - 1];
+  }
+  get hasAwait() {
+    return (this.currentFlags() & PARAM_AWAIT) > 0;
+  }
+  get hasYield() {
+    return (this.currentFlags() & PARAM_YIELD) > 0;
+  }
+  get hasReturn() {
+    return (this.currentFlags() & PARAM_RETURN) > 0;
+  }
+  get hasIn() {
+    return (this.currentFlags() & PARAM_IN) > 0;
+  }
+}
+exports.default = ProductionParameterHandler;
+function functionFlags(isAsync, isGenerator) {
+  return (isAsync ? PARAM_AWAIT : 0) | (isGenerator ? PARAM_YIELD : 0);
+}
+
+//# sourceMappingURL=production-parameter.js.map

package/node_modules/@babel/parser/lib/util/production-parameter.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["PARAM","PARAM_YIELD","PARAM_AWAIT","PARAM_RETURN","PARAM_IN","exports","ProductionParameterHandler","constructor","stacks","enter","flags","push","exit","pop","currentFlags","length","hasAwait","hasYield","hasReturn","hasIn","default","functionFlags","isAsync","isGenerator"],"sources":["../../src/util/production-parameter.ts"],"sourcesContent":["export const // Initial Parameter flags\n  PARAM = 0b0000,\n  // track [Yield] production parameter\n  PARAM_YIELD = 0b0001,\n  // track [Await] production parameter\n  PARAM_AWAIT = 0b0010,\n  // track [Return] production parameter\n  PARAM_RETURN = 0b0100,\n  PARAM_IN = 0b1000; // track [In] production parameter\n\n// ProductionParameterHandler is a stack fashioned production parameter tracker\n// https://tc39.es/ecma262/#sec-grammar-notation\n// The tracked parameters are defined above.\n//\n// Whenever [+Await]/[+Yield] appears in the right-hand sides of a production,\n// we must enter a new tracking stack. For example when parsing\n//\n// AsyncFunctionDeclaration [Yield, Await]:\n//   async [no LineTerminator here] function BindingIdentifier[?Yield, ?Await]\n//     ( FormalParameters[~Yield, +Await] ) { AsyncFunctionBody }\n//\n// we must follow such process:\n//\n// 1. parse async keyword\n// 2. parse function keyword\n// 3. parse bindingIdentifier <= inherit current parameters: [?Await]\n// 4. enter new stack with (PARAM_AWAIT)\n// 5. parse formal parameters <= must have [Await] parameter [+Await]\n// 6. parse function body\n// 7. exit current stack\n\nexport type ParamKind = number;\n\n// todo(flow->ts) - check if more granular type can be used,\n//  type below is not good because things like PARAM_AWAIT|PARAM_YIELD are not included\n// export type ParamKind =\n//   | typeof PARAM\n//   | typeof PARAM_AWAIT\n//   | typeof PARAM_IN\n//   | typeof PARAM_RETURN\n//   | typeof PARAM_YIELD;\n\nexport default class ProductionParameterHandler {\n  stacks: Array<number> = [];\n  enter(flags: number) {\n    this.stacks.push(flags);\n  }\n\n  exit() {\n    this.stacks.pop();\n  }\n\n  currentFlags(): number {\n    return this.stacks[this.stacks.length - 1];\n  }\n\n  get hasAwait(): boolean {\n    return (this.currentFlags() & PARAM_AWAIT) > 0;\n  }\n\n  get hasYield(): boolean {\n    return (this.currentFlags() & PARAM_YIELD) > 0;\n  }\n\n  get hasReturn(): boolean {\n    return (this.currentFlags() & PARAM_RETURN) > 0;\n  }\n\n  get hasIn(): boolean {\n    return (this.currentFlags() & PARAM_IN) > 0;\n  }\n}\n\nexport function functionFlags(\n  isAsync: boolean,\n  isGenerator: boolean,\n): ParamKind {\n  return (isAsync ? PARAM_AWAIT : 0) | (isGenerator ? PARAM_YIELD : 0);\n}\n"],"mappings":";;;;;;;AAAO,MACLA,KAAK,GAAG,MAAM;EAEdC,WAAW,GAAG,MAAM;EAEpBC,WAAW,GAAG,MAAM;EAEpBC,YAAY,GAAG,MAAM;EACrBC,QAAQ,GAAG,MAAM;AAACC,OAAA,CAAAD,QAAA,GAAAA,QAAA;AAAAC,OAAA,CAAAF,YAAA,GAAAA,YAAA;AAAAE,OAAA,CAAAH,WAAA,GAAAA,WAAA;AAAAG,OAAA,CAAAJ,WAAA,GAAAA,WAAA;AAAAI,OAAA,CAAAL,KAAA,GAAAA,KAAA;AAkCL,MAAMM,0BAA0B,CAAC;EAAAC,YAAA;IAAA,KAC9CC,MAAM,GAAkB,EAAE;EAAA;EAC1BC,KAAKA,CAACC,KAAa,EAAE;IACnB,IAAI,CAACF,MAAM,CAACG,IAAI,CAACD,KAAK,CAAC;EACzB;EAEAE,IAAIA,CAAA,EAAG;IACL,IAAI,CAACJ,MAAM,CAACK,GAAG,CAAC,CAAC;EACnB;EAEAC,YAAYA,CAAA,EAAW;IACrB,OAAO,IAAI,CAACN,MAAM,CAAC,IAAI,CAACA,MAAM,CAACO,MAAM,GAAG,CAAC,CAAC;EAC5C;EAEA,IAAIC,QAAQA,CAAA,EAAY;IACtB,OAAO,CAAC,IAAI,CAACF,YAAY,CAAC,CAAC,GAAGZ,WAAW,IAAI,CAAC;EAChD;EAEA,IAAIe,QAAQA,CAAA,EAAY;IACtB,OAAO,CAAC,IAAI,CAACH,YAAY,CAAC,CAAC,GAAGb,WAAW,IAAI,CAAC;EAChD;EAEA,IAAIiB,SAASA,CAAA,EAAY;IACvB,OAAO,CAAC,IAAI,CAACJ,YAAY,CAAC,CAAC,GAAGX,YAAY,IAAI,CAAC;EACjD;EAEA,IAAIgB,KAAKA,CAAA,EAAY;IACnB,OAAO,CAAC,IAAI,CAACL,YAAY,CAAC,CAAC,GAAGV,QAAQ,IAAI,CAAC;EAC7C;AACF;AAACC,OAAA,CAAAe,OAAA,GAAAd,0BAAA;AAEM,SAASe,aAAaA,CAC3BC,OAAgB,EAChBC,WAAoB,EACT;EACX,OAAO,CAACD,OAAO,GAAGpB,WAAW,GAAG,CAAC,KAAKqB,WAAW,GAAGtB,WAAW,GAAG,CAAC,CAAC;AACtE"}

package/node_modules/@babel/parser/lib/util/scope.js

@@ -0,0 +1,161 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.Scope = void 0;
+var _scopeflags = require("./scopeflags");
+var _parseError = require("../parse-error");
+class Scope {
+  constructor(flags) {
+    this.var = new Set();
+    this.lexical = new Set();
+    this.functions = new Set();
+    this.flags = flags;
+  }
+}
+exports.Scope = Scope;
+class ScopeHandler {
+  constructor(parser, inModule) {
+    this.parser = void 0;
+    this.scopeStack = [];
+    this.inModule = void 0;
+    this.undefinedExports = new Map();
+    this.parser = parser;
+    this.inModule = inModule;
+  }
+  get inTopLevel() {
+    return (this.currentScope().flags & _scopeflags.SCOPE_PROGRAM) > 0;
+  }
+  get inFunction() {
+    return (this.currentVarScopeFlags() & _scopeflags.SCOPE_FUNCTION) > 0;
+  }
+  get allowSuper() {
+    return (this.currentThisScopeFlags() & _scopeflags.SCOPE_SUPER) > 0;
+  }
+  get allowDirectSuper() {
+    return (this.currentThisScopeFlags() & _scopeflags.SCOPE_DIRECT_SUPER) > 0;
+  }
+  get inClass() {
+    return (this.currentThisScopeFlags() & _scopeflags.SCOPE_CLASS) > 0;
+  }
+  get inClassAndNotInNonArrowFunction() {
+    const flags = this.currentThisScopeFlags();
+    return (flags & _scopeflags.SCOPE_CLASS) > 0 && (flags & _scopeflags.SCOPE_FUNCTION) === 0;
+  }
+  get inStaticBlock() {
+    for (let i = this.scopeStack.length - 1;; i--) {
+      const {
+        flags
+      } = this.scopeStack[i];
+      if (flags & _scopeflags.SCOPE_STATIC_BLOCK) {
+        return true;
+      }
+      if (flags & (_scopeflags.SCOPE_VAR | _scopeflags.SCOPE_CLASS)) {
+        return false;
+      }
+    }
+  }
+  get inNonArrowFunction() {
+    return (this.currentThisScopeFlags() & _scopeflags.SCOPE_FUNCTION) > 0;
+  }
+  get treatFunctionsAsVar() {
+    return this.treatFunctionsAsVarInScope(this.currentScope());
+  }
+  createScope(flags) {
+    return new Scope(flags);
+  }
+  enter(flags) {
+    this.scopeStack.push(this.createScope(flags));
+  }
+  exit() {
+    const scope = this.scopeStack.pop();
+    return scope.flags;
+  }
+  treatFunctionsAsVarInScope(scope) {
+    return !!(scope.flags & (_scopeflags.SCOPE_FUNCTION | _scopeflags.SCOPE_STATIC_BLOCK) || !this.parser.inModule && scope.flags & _scopeflags.SCOPE_PROGRAM);
+  }
+  declareName(name, bindingType, loc) {
+    let scope = this.currentScope();
+    if (bindingType & _scopeflags.BIND_SCOPE_LEXICAL || bindingType & _scopeflags.BIND_SCOPE_FUNCTION) {
+      this.checkRedeclarationInScope(scope, name, bindingType, loc);
+      if (bindingType & _scopeflags.BIND_SCOPE_FUNCTION) {
+        scope.functions.add(name);
+      } else {
+        scope.lexical.add(name);
+      }
+      if (bindingType & _scopeflags.BIND_SCOPE_LEXICAL) {
+        this.maybeExportDefined(scope, name);
+      }
+    } else if (bindingType & _scopeflags.BIND_SCOPE_VAR) {
+      for (let i = this.scopeStack.length - 1; i >= 0; --i) {
+        scope = this.scopeStack[i];
+        this.checkRedeclarationInScope(scope, name, bindingType, loc);
+        scope.var.add(name);
+        this.maybeExportDefined(scope, name);
+        if (scope.flags & _scopeflags.SCOPE_VAR) break;
+      }
+    }
+    if (this.parser.inModule && scope.flags & _scopeflags.SCOPE_PROGRAM) {
+      this.undefinedExports.delete(name);
+    }
+  }
+  maybeExportDefined(scope, name) {
+    if (this.parser.inModule && scope.flags & _scopeflags.SCOPE_PROGRAM) {
+      this.undefinedExports.delete(name);
+    }
+  }
+  checkRedeclarationInScope(scope, name, bindingType, loc) {
+    if (this.isRedeclaredInScope(scope, name, bindingType)) {
+      this.parser.raise(_parseError.Errors.VarRedeclaration, {
+        at: loc,
+        identifierName: name
+      });
+    }
+  }
+  isRedeclaredInScope(scope, name, bindingType) {
+    if (!(bindingType & _scopeflags.BIND_KIND_VALUE)) return false;
+    if (bindingType & _scopeflags.BIND_SCOPE_LEXICAL) {
+      return scope.lexical.has(name) || scope.functions.has(name) || scope.var.has(name);
+    }
+    if (bindingType & _scopeflags.BIND_SCOPE_FUNCTION) {
+      return scope.lexical.has(name) || !this.treatFunctionsAsVarInScope(scope) && scope.var.has(name);
+    }
+    return scope.lexical.has(name) && !(scope.flags & _scopeflags.SCOPE_SIMPLE_CATCH && scope.lexical.values().next().value === name) || !this.treatFunctionsAsVarInScope(scope) && scope.functions.has(name);
+  }
+  checkLocalExport(id) {
+    const {
+      name
+    } = id;
+    const topLevelScope = this.scopeStack[0];
+    if (!topLevelScope.lexical.has(name) && !topLevelScope.var.has(name) && !topLevelScope.functions.has(name)) {
+      this.undefinedExports.set(name, id.loc.start);
+    }
+  }
+  currentScope() {
+    return this.scopeStack[this.scopeStack.length - 1];
+  }
+  currentVarScopeFlags() {
+    for (let i = this.scopeStack.length - 1;; i--) {
+      const {
+        flags
+      } = this.scopeStack[i];
+      if (flags & _scopeflags.SCOPE_VAR) {
+        return flags;
+      }
+    }
+  }
+  currentThisScopeFlags() {
+    for (let i = this.scopeStack.length - 1;; i--) {
+      const {
+        flags
+      } = this.scopeStack[i];
+      if (flags & (_scopeflags.SCOPE_VAR | _scopeflags.SCOPE_CLASS) && !(flags & _scopeflags.SCOPE_ARROW)) {
+        return flags;
+      }
+    }
+  }
+}
+exports.default = ScopeHandler;
+
+//# sourceMappingURL=scope.js.map

package/node_modules/@babel/parser/lib/util/scope.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_scopeflags","require","_parseError","Scope","constructor","flags","var","Set","lexical","functions","exports","ScopeHandler","parser","inModule","scopeStack","undefinedExports","Map","inTopLevel","currentScope","SCOPE_PROGRAM","inFunction","currentVarScopeFlags","SCOPE_FUNCTION","allowSuper","currentThisScopeFlags","SCOPE_SUPER","allowDirectSuper","SCOPE_DIRECT_SUPER","inClass","SCOPE_CLASS","inClassAndNotInNonArrowFunction","inStaticBlock","i","length","SCOPE_STATIC_BLOCK","SCOPE_VAR","inNonArrowFunction","treatFunctionsAsVar","treatFunctionsAsVarInScope","createScope","enter","push","exit","scope","pop","declareName","name","bindingType","loc","BIND_SCOPE_LEXICAL","BIND_SCOPE_FUNCTION","checkRedeclarationInScope","add","maybeExportDefined","BIND_SCOPE_VAR","delete","isRedeclaredInScope","raise","Errors","VarRedeclaration","at","identifierName","BIND_KIND_VALUE","has","SCOPE_SIMPLE_CATCH","values","next","value","checkLocalExport","id","topLevelScope","set","start","SCOPE_ARROW","default"],"sources":["../../src/util/scope.ts"],"sourcesContent":["import {\n  SCOPE_ARROW,\n  SCOPE_DIRECT_SUPER,\n  SCOPE_FUNCTION,\n  SCOPE_SIMPLE_CATCH,\n  SCOPE_SUPER,\n  SCOPE_PROGRAM,\n  SCOPE_VAR,\n  SCOPE_CLASS,\n  SCOPE_STATIC_BLOCK,\n  BIND_SCOPE_FUNCTION,\n  BIND_SCOPE_VAR,\n  BIND_SCOPE_LEXICAL,\n  BIND_KIND_VALUE,\n  type ScopeFlags,\n  type BindingTypes,\n} from \"./scopeflags\";\nimport type { Position } from \"./location\";\nimport type * as N from \"../types\";\nimport { Errors } from \"../parse-error\";\nimport type Tokenizer from \"../tokenizer\";\n\n// Start an AST node, attaching a start offset.\nexport class Scope {\n  declare flags: ScopeFlags;\n  // A set of var-declared names in the current lexical scope\n  var: Set<string> = new Set();\n  // A set of lexically-declared names in the current lexical scope\n  lexical: Set<string> = new Set();\n  // A set of lexically-declared FunctionDeclaration names in the current lexical scope\n  functions: Set<string> = new Set();\n\n  constructor(flags: ScopeFlags) {\n    this.flags = flags;\n  }\n}\n\n// The functions in this module keep track of declared variables in the\n// current scope in order to detect duplicate variable names.\nexport default class ScopeHandler<IScope extends Scope = Scope> {\n  parser: Tokenizer;\n  scopeStack: Array<IScope> = [];\n  inModule: boolean;\n  undefinedExports: Map<string, Position> = new Map();\n\n  constructor(parser: Tokenizer, inModule: boolean) {\n    this.parser = parser;\n    this.inModule = inModule;\n  }\n\n  get inTopLevel() {\n    return (this.currentScope().flags & SCOPE_PROGRAM) > 0;\n  }\n  get inFunction() {\n    return (this.currentVarScopeFlags() & SCOPE_FUNCTION) > 0;\n  }\n  get allowSuper() {\n    return (this.currentThisScopeFlags() & SCOPE_SUPER) > 0;\n  }\n  get allowDirectSuper() {\n    return (this.currentThisScopeFlags() & SCOPE_DIRECT_SUPER) > 0;\n  }\n  get inClass() {\n    return (this.currentThisScopeFlags() & SCOPE_CLASS) > 0;\n  }\n  get inClassAndNotInNonArrowFunction() {\n    const flags = this.currentThisScopeFlags();\n    return (flags & SCOPE_CLASS) > 0 && (flags & SCOPE_FUNCTION) === 0;\n  }\n  get inStaticBlock() {\n    for (let i = this.scopeStack.length - 1; ; i--) {\n      const { flags } = this.scopeStack[i];\n      if (flags & SCOPE_STATIC_BLOCK) {\n        return true;\n      }\n      if (flags & (SCOPE_VAR | SCOPE_CLASS)) {\n        // function body, module body, class property initializers\n        return false;\n      }\n    }\n  }\n  get inNonArrowFunction() {\n    return (this.currentThisScopeFlags() & SCOPE_FUNCTION) > 0;\n  }\n  get treatFunctionsAsVar() {\n    return this.treatFunctionsAsVarInScope(this.currentScope());\n  }\n\n  createScope(flags: ScopeFlags): Scope {\n    return new Scope(flags);\n  }\n\n  enter(flags: ScopeFlags) {\n    /*:: +createScope: (flags: ScopeFlags) => IScope; */\n    // @ts-expect-error This method will be overwritten by subclasses\n    this.scopeStack.push(this.createScope(flags));\n  }\n\n  exit(): ScopeFlags {\n    const scope = this.scopeStack.pop();\n    return scope.flags;\n  }\n\n  // The spec says:\n  // > At the top level of a function, or script, function declarations are\n  // > treated like var declarations rather than like lexical declarations.\n  treatFunctionsAsVarInScope(scope: IScope): boolean {\n    return !!(\n      scope.flags & (SCOPE_FUNCTION | SCOPE_STATIC_BLOCK) ||\n      (!this.parser.inModule && scope.flags & SCOPE_PROGRAM)\n    );\n  }\n\n  declareName(name: string, bindingType: BindingTypes, loc: Position) {\n    let scope = this.currentScope();\n    if (bindingType & BIND_SCOPE_LEXICAL || bindingType & BIND_SCOPE_FUNCTION) {\n      this.checkRedeclarationInScope(scope, name, bindingType, loc);\n\n      if (bindingType & BIND_SCOPE_FUNCTION) {\n        scope.functions.add(name);\n      } else {\n        scope.lexical.add(name);\n      }\n\n      if (bindingType & BIND_SCOPE_LEXICAL) {\n        this.maybeExportDefined(scope, name);\n      }\n    } else if (bindingType & BIND_SCOPE_VAR) {\n      for (let i = this.scopeStack.length - 1; i >= 0; --i) {\n        scope = this.scopeStack[i];\n        this.checkRedeclarationInScope(scope, name, bindingType, loc);\n        scope.var.add(name);\n        this.maybeExportDefined(scope, name);\n\n        if (scope.flags & SCOPE_VAR) break;\n      }\n    }\n    if (this.parser.inModule && scope.flags & SCOPE_PROGRAM) {\n      this.undefinedExports.delete(name);\n    }\n  }\n\n  maybeExportDefined(scope: IScope, name: string) {\n    if (this.parser.inModule && scope.flags & SCOPE_PROGRAM) {\n      this.undefinedExports.delete(name);\n    }\n  }\n\n  checkRedeclarationInScope(\n    scope: IScope,\n    name: string,\n    bindingType: BindingTypes,\n    loc: Position,\n  ) {\n    if (this.isRedeclaredInScope(scope, name, bindingType)) {\n      this.parser.raise(Errors.VarRedeclaration, {\n        at: loc,\n        identifierName: name,\n      });\n    }\n  }\n\n  isRedeclaredInScope(\n    scope: IScope,\n    name: string,\n    bindingType: BindingTypes,\n  ): boolean {\n    if (!(bindingType & BIND_KIND_VALUE)) return false;\n\n    if (bindingType & BIND_SCOPE_LEXICAL) {\n      return (\n        scope.lexical.has(name) ||\n        scope.functions.has(name) ||\n        scope.var.has(name)\n      );\n    }\n\n    if (bindingType & BIND_SCOPE_FUNCTION) {\n      return (\n        scope.lexical.has(name) ||\n        (!this.treatFunctionsAsVarInScope(scope) && scope.var.has(name))\n      );\n    }\n\n    return (\n      (scope.lexical.has(name) &&\n        // Annex B.3.4\n        // https://tc39.es/ecma262/#sec-variablestatements-in-catch-blocks\n        !(\n          scope.flags & SCOPE_SIMPLE_CATCH &&\n          scope.lexical.values().next().value === name\n        )) ||\n      (!this.treatFunctionsAsVarInScope(scope) && scope.functions.has(name))\n    );\n  }\n\n  checkLocalExport(id: N.Identifier) {\n    const { name } = id;\n    const topLevelScope = this.scopeStack[0];\n    if (\n      !topLevelScope.lexical.has(name) &&\n      !topLevelScope.var.has(name) &&\n      // In strict mode, scope.functions will always be empty.\n      // Modules are strict by default, but the `scriptMode` option\n      // can overwrite this behavior.\n      !topLevelScope.functions.has(name)\n    ) {\n      this.undefinedExports.set(name, id.loc.start);\n    }\n  }\n\n  currentScope(): IScope {\n    return this.scopeStack[this.scopeStack.length - 1];\n  }\n\n  currentVarScopeFlags(): ScopeFlags {\n    for (let i = this.scopeStack.length - 1; ; i--) {\n      const { flags } = this.scopeStack[i];\n      if (flags & SCOPE_VAR) {\n        return flags;\n      }\n    }\n  }\n\n  // Could be useful for `arguments`, `this`, `new.target`, `super()`, `super.property`, and `super[property]`.\n  currentThisScopeFlags(): ScopeFlags {\n    for (let i = this.scopeStack.length - 1; ; i--) {\n      const { flags } = this.scopeStack[i];\n      if (flags & (SCOPE_VAR | SCOPE_CLASS) && !(flags & SCOPE_ARROW)) {\n        return flags;\n      }\n    }\n  }\n}\n"],"mappings":";;;;;;AAAA,IAAAA,WAAA,GAAAC,OAAA;AAmBA,IAAAC,WAAA,GAAAD,OAAA;AAIO,MAAME,KAAK,CAAC;EASjBC,WAAWA,CAACC,KAAiB,EAAE;IAAA,KAN/BC,GAAG,GAAgB,IAAIC,GAAG,CAAC,CAAC;IAAA,KAE5BC,OAAO,GAAgB,IAAID,GAAG,CAAC,CAAC;IAAA,KAEhCE,SAAS,GAAgB,IAAIF,GAAG,CAAC,CAAC;IAGhC,IAAI,CAACF,KAAK,GAAGA,KAAK;EACpB;AACF;AAACK,OAAA,CAAAP,KAAA,GAAAA,KAAA;AAIc,MAAMQ,YAAY,CAA+B;EAM9DP,WAAWA,CAACQ,MAAiB,EAAEC,QAAiB,EAAE;IAAA,KALlDD,MAAM;IAAA,KACNE,UAAU,GAAkB,EAAE;IAAA,KAC9BD,QAAQ;IAAA,KACRE,gBAAgB,GAA0B,IAAIC,GAAG,CAAC,CAAC;IAGjD,IAAI,CAACJ,MAAM,GAAGA,MAAM;IACpB,IAAI,CAACC,QAAQ,GAAGA,QAAQ;EAC1B;EAEA,IAAII,UAAUA,CAAA,EAAG;IACf,OAAO,CAAC,IAAI,CAACC,YAAY,CAAC,CAAC,CAACb,KAAK,GAAGc,yBAAa,IAAI,CAAC;EACxD;EACA,IAAIC,UAAUA,CAAA,EAAG;IACf,OAAO,CAAC,IAAI,CAACC,oBAAoB,CAAC,CAAC,GAAGC,0BAAc,IAAI,CAAC;EAC3D;EACA,IAAIC,UAAUA,CAAA,EAAG;IACf,OAAO,CAAC,IAAI,CAACC,qBAAqB,CAAC,CAAC,GAAGC,uBAAW,IAAI,CAAC;EACzD;EACA,IAAIC,gBAAgBA,CAAA,EAAG;IACrB,OAAO,CAAC,IAAI,CAACF,qBAAqB,CAAC,CAAC,GAAGG,8BAAkB,IAAI,CAAC;EAChE;EACA,IAAIC,OAAOA,CAAA,EAAG;IACZ,OAAO,CAAC,IAAI,CAACJ,qBAAqB,CAAC,CAAC,GAAGK,uBAAW,IAAI,CAAC;EACzD;EACA,IAAIC,+BAA+BA,CAAA,EAAG;IACpC,MAAMzB,KAAK,GAAG,IAAI,CAACmB,qBAAqB,CAAC,CAAC;IAC1C,OAAO,CAACnB,KAAK,GAAGwB,uBAAW,IAAI,CAAC,IAAI,CAACxB,KAAK,GAAGiB,0BAAc,MAAM,CAAC;EACpE;EACA,IAAIS,aAAaA,CAAA,EAAG;IAClB,KAAK,IAAIC,CAAC,GAAG,IAAI,CAAClB,UAAU,CAACmB,MAAM,GAAG,CAAC,GAAID,CAAC,EAAE,EAAE;MAC9C,MAAM;QAAE3B;MAAM,CAAC,GAAG,IAAI,CAACS,UAAU,CAACkB,CAAC,CAAC;MACpC,IAAI3B,KAAK,GAAG6B,8BAAkB,EAAE;QAC9B,OAAO,IAAI;MACb;MACA,IAAI7B,KAAK,IAAI8B,qBAAS,GAAGN,uBAAW,CAAC,EAAE;QAErC,OAAO,KAAK;MACd;IACF;EACF;EACA,IAAIO,kBAAkBA,CAAA,EAAG;IACvB,OAAO,CAAC,IAAI,CAACZ,qBAAqB,CAAC,CAAC,GAAGF,0BAAc,IAAI,CAAC;EAC5D;EACA,IAAIe,mBAAmBA,CAAA,EAAG;IACxB,OAAO,IAAI,CAACC,0BAA0B,CAAC,IAAI,CAACpB,YAAY,CAAC,CAAC,CAAC;EAC7D;EAEAqB,WAAWA,CAAClC,KAAiB,EAAS;IACpC,OAAO,IAAIF,KAAK,CAACE,KAAK,CAAC;EACzB;EAEAmC,KAAKA,CAACnC,KAAiB,EAAE;IAGvB,IAAI,CAACS,UAAU,CAAC2B,IAAI,CAAC,IAAI,CAACF,WAAW,CAAClC,KAAK,CAAC,CAAC;EAC/C;EAEAqC,IAAIA,CAAA,EAAe;IACjB,MAAMC,KAAK,GAAG,IAAI,CAAC7B,UAAU,CAAC8B,GAAG,CAAC,CAAC;IACnC,OAAOD,KAAK,CAACtC,KAAK;EACpB;EAKAiC,0BAA0BA,CAACK,KAAa,EAAW;IACjD,OAAO,CAAC,EACNA,KAAK,CAACtC,KAAK,IAAIiB,0BAAc,GAAGY,8BAAkB,CAAC,IAClD,CAAC,IAAI,CAACtB,MAAM,CAACC,QAAQ,IAAI8B,KAAK,CAACtC,KAAK,GAAGc,yBAAc,CACvD;EACH;EAEA0B,WAAWA,CAACC,IAAY,EAAEC,WAAyB,EAAEC,GAAa,EAAE;IAClE,IAAIL,KAAK,GAAG,IAAI,CAACzB,YAAY,CAAC,CAAC;IAC/B,IAAI6B,WAAW,GAAGE,8BAAkB,IAAIF,WAAW,GAAGG,+BAAmB,EAAE;MACzE,IAAI,CAACC,yBAAyB,CAACR,KAAK,EAAEG,IAAI,EAAEC,WAAW,EAAEC,GAAG,CAAC;MAE7D,IAAID,WAAW,GAAGG,+BAAmB,EAAE;QACrCP,KAAK,CAAClC,SAAS,CAAC2C,GAAG,CAACN,IAAI,CAAC;MAC3B,CAAC,MAAM;QACLH,KAAK,CAACnC,OAAO,CAAC4C,GAAG,CAACN,IAAI,CAAC;MACzB;MAEA,IAAIC,WAAW,GAAGE,8BAAkB,EAAE;QACpC,IAAI,CAACI,kBAAkB,CAACV,KAAK,EAAEG,IAAI,CAAC;MACtC;IACF,CAAC,MAAM,IAAIC,WAAW,GAAGO,0BAAc,EAAE;MACvC,KAAK,IAAItB,CAAC,GAAG,IAAI,CAAClB,UAAU,CAACmB,MAAM,GAAG,CAAC,EAAED,CAAC,IAAI,CAAC,EAAE,EAAEA,CAAC,EAAE;QACpDW,KAAK,GAAG,IAAI,CAAC7B,UAAU,CAACkB,CAAC,CAAC;QAC1B,IAAI,CAACmB,yBAAyB,CAACR,KAAK,EAAEG,IAAI,EAAEC,WAAW,EAAEC,GAAG,CAAC;QAC7DL,KAAK,CAACrC,GAAG,CAAC8C,GAAG,CAACN,IAAI,CAAC;QACnB,IAAI,CAACO,kBAAkB,CAACV,KAAK,EAAEG,IAAI,CAAC;QAEpC,IAAIH,KAAK,CAACtC,KAAK,GAAG8B,qBAAS,EAAE;MAC/B;IACF;IACA,IAAI,IAAI,CAACvB,MAAM,CAACC,QAAQ,IAAI8B,KAAK,CAACtC,KAAK,GAAGc,yBAAa,EAAE;MACvD,IAAI,CAACJ,gBAAgB,CAACwC,MAAM,CAACT,IAAI,CAAC;IACpC;EACF;EAEAO,kBAAkBA,CAACV,KAAa,EAAEG,IAAY,EAAE;IAC9C,IAAI,IAAI,CAAClC,MAAM,CAACC,QAAQ,IAAI8B,KAAK,CAACtC,KAAK,GAAGc,yBAAa,EAAE;MACvD,IAAI,CAACJ,gBAAgB,CAACwC,MAAM,CAACT,IAAI,CAAC;IACpC;EACF;EAEAK,yBAAyBA,CACvBR,KAAa,EACbG,IAAY,EACZC,WAAyB,EACzBC,GAAa,EACb;IACA,IAAI,IAAI,CAACQ,mBAAmB,CAACb,KAAK,EAAEG,IAAI,EAAEC,WAAW,CAAC,EAAE;MACtD,IAAI,CAACnC,MAAM,CAAC6C,KAAK,CAACC,kBAAM,CAACC,gBAAgB,EAAE;QACzCC,EAAE,EAAEZ,GAAG;QACPa,cAAc,EAAEf;MAClB,CAAC,CAAC;IACJ;EACF;EAEAU,mBAAmBA,CACjBb,KAAa,EACbG,IAAY,EACZC,WAAyB,EAChB;IACT,IAAI,EAAEA,WAAW,GAAGe,2BAAe,CAAC,EAAE,OAAO,KAAK;IAElD,IAAIf,WAAW,GAAGE,8BAAkB,EAAE;MACpC,OACEN,KAAK,CAACnC,OAAO,CAACuD,GAAG,CAACjB,IAAI,CAAC,IACvBH,KAAK,CAAClC,SAAS,CAACsD,GAAG,CAACjB,IAAI,CAAC,IACzBH,KAAK,CAACrC,GAAG,CAACyD,GAAG,CAACjB,IAAI,CAAC;IAEvB;IAEA,IAAIC,WAAW,GAAGG,+BAAmB,EAAE;MACrC,OACEP,KAAK,CAACnC,OAAO,CAACuD,GAAG,CAACjB,IAAI,CAAC,IACtB,CAAC,IAAI,CAACR,0BAA0B,CAACK,KAAK,CAAC,IAAIA,KAAK,CAACrC,GAAG,CAACyD,GAAG,CAACjB,IAAI,CAAE;IAEpE;IAEA,OACGH,KAAK,CAACnC,OAAO,CAACuD,GAAG,CAACjB,IAAI,CAAC,IAGtB,EACEH,KAAK,CAACtC,KAAK,GAAG2D,8BAAkB,IAChCrB,KAAK,CAACnC,OAAO,CAACyD,MAAM,CAAC,CAAC,CAACC,IAAI,CAAC,CAAC,CAACC,KAAK,KAAKrB,IAAI,CAC7C,IACF,CAAC,IAAI,CAACR,0BAA0B,CAACK,KAAK,CAAC,IAAIA,KAAK,CAAClC,SAAS,CAACsD,GAAG,CAACjB,IAAI,CAAE;EAE1E;EAEAsB,gBAAgBA,CAACC,EAAgB,EAAE;IACjC,MAAM;MAAEvB;IAAK,CAAC,GAAGuB,EAAE;IACnB,MAAMC,aAAa,GAAG,IAAI,CAACxD,UAAU,CAAC,CAAC,CAAC;IACxC,IACE,CAACwD,aAAa,CAAC9D,OAAO,CAACuD,GAAG,CAACjB,IAAI,CAAC,IAChC,CAACwB,aAAa,CAAChE,GAAG,CAACyD,GAAG,CAACjB,IAAI,CAAC,IAI5B,CAACwB,aAAa,CAAC7D,SAAS,CAACsD,GAAG,CAACjB,IAAI,CAAC,EAClC;MACA,IAAI,CAAC/B,gBAAgB,CAACwD,GAAG,CAACzB,IAAI,EAAEuB,EAAE,CAACrB,GAAG,CAACwB,KAAK,CAAC;IAC/C;EACF;EAEAtD,YAAYA,CAAA,EAAW;IACrB,OAAO,IAAI,CAACJ,UAAU,CAAC,IAAI,CAACA,UAAU,CAACmB,MAAM,GAAG,CAAC,CAAC;EACpD;EAEAZ,oBAAoBA,CAAA,EAAe;IACjC,KAAK,IAAIW,CAAC,GAAG,IAAI,CAAClB,UAAU,CAACmB,MAAM,GAAG,CAAC,GAAID,CAAC,EAAE,EAAE;MAC9C,MAAM;QAAE3B;MAAM,CAAC,GAAG,IAAI,CAACS,UAAU,CAACkB,CAAC,CAAC;MACpC,IAAI3B,KAAK,GAAG8B,qBAAS,EAAE;QACrB,OAAO9B,KAAK;MACd;IACF;EACF;EAGAmB,qBAAqBA,CAAA,EAAe;IAClC,KAAK,IAAIQ,CAAC,GAAG,IAAI,CAAClB,UAAU,CAACmB,MAAM,GAAG,CAAC,GAAID,CAAC,EAAE,EAAE;MAC9C,MAAM;QAAE3B;MAAM,CAAC,GAAG,IAAI,CAACS,UAAU,CAACkB,CAAC,CAAC;MACpC,IAAI3B,KAAK,IAAI8B,qBAAS,GAAGN,uBAAW,CAAC,IAAI,EAAExB,KAAK,GAAGoE,uBAAW,CAAC,EAAE;QAC/D,OAAOpE,KAAK;MACd;IACF;EACF;AACF;AAACK,OAAA,CAAAgE,OAAA,GAAA/D,YAAA"}