@babel/traverse 7.20.0 → 7.20.1

package/lib/path/lib/hoister.js.map

@@ -1 +1 @@
-{"version":3,"names":["react","cloneNode","jsxExpressionContainer","variableDeclaration","variableDeclarator","referenceVisitor","ReferencedIdentifier","path","state","isJSXIdentifier","isCompatTag","node","name","parentPath","isJSXMemberExpression","scope","isFunction","isArrowFunctionExpression","parent","breakOnScopePaths","push","binding","getBinding","violation","constantViolations","mutableBinding","stop","bindings","PathHoister","constructor","scopes","attachAfter","isCompatibleScope","key","Object","keys","bindingIdentifierEquals","identifier","getCompatibleScopes","indexOf","getAttachmentPath","_getAttachmentPath","targetScope","isProgram","hasOwnBinding","kind","parentKey","bindingParentPath","getAttachmentParentForPath","violationPath","pop","hasOwnParamBindings","bodies","get","i","length","_blockHoist","getNextScopeAttachmentParent","Array","isArray","container","isStatement","constant","run","traverse","attachTo","getFunctionParent","uid","generateUidIdentifier","declarator","insertFn","attached","isVariableDeclarator","isJSXElement","children","replaceWith"],"sources":["../../../src/path/lib/hoister.ts"],"sourcesContent":["import { react } from \"@babel/types\";\nimport {\n  cloneNode,\n  jsxExpressionContainer,\n  variableDeclaration,\n  variableDeclarator,\n} from \"@babel/types\";\nimport type * as t from \"@babel/types\";\nimport type Scope from \"../../scope\";\nimport type NodePath from \"../index\";\nimport type Binding from \"../../scope/binding\";\nimport type { Visitor } from \"../../types\";\n\nconst referenceVisitor: Visitor<PathHoister> = {\n  // This visitor looks for bindings to establish a topmost scope for hoisting.\n  ReferencedIdentifier(path, state) {\n    // Don't hoist regular JSX identifiers ('div', 'span', etc).\n    // We do have to consider member expressions for hoisting (e.g. `this.component`)\n    if (\n      path.isJSXIdentifier() &&\n      react.isCompatTag(path.node.name) &&\n      !path.parentPath.isJSXMemberExpression()\n    ) {\n      return;\n    }\n\n    // If the identifier refers to `this`, we need to break on the closest non-arrow scope.\n    if (path.node.name === \"this\") {\n      let scope = path.scope;\n      do {\n        if (\n          scope.path.isFunction() &&\n          !scope.path.isArrowFunctionExpression()\n        ) {\n          break;\n        }\n      } while ((scope = scope.parent));\n      if (scope) state.breakOnScopePaths.push(scope.path);\n    }\n\n    // direct references that we need to track to hoist this to the highest scope we can\n    const binding = path.scope.getBinding(path.node.name);\n    if (!binding) return;\n\n    // we can handle reassignments only if they happen in the same scope as the declaration\n    for (const violation of binding.constantViolations) {\n      if (violation.scope !== binding.path.scope) {\n        state.mutableBinding = true;\n        path.stop();\n        return;\n      }\n    }\n\n    // this binding isn't accessible from the parent scope so we can safely ignore it\n    // eg. it's in a closure etc\n    if (binding !== state.scope.getBinding(path.node.name)) return;\n\n    state.bindings[path.node.name] = binding;\n  },\n};\n\nexport default class PathHoister<T extends t.Node = t.Node> {\n  breakOnScopePaths: NodePath[];\n  bindings: { [k: string]: Binding };\n  mutableBinding: boolean;\n  private scopes: Scope[];\n  scope: Scope;\n  private path: NodePath<T>;\n  private attachAfter: boolean;\n\n  constructor(path: NodePath<T>, scope: Scope) {\n    // Storage for scopes we can't hoist above.\n    this.breakOnScopePaths = [];\n    // Storage for bindings that may affect what path we can hoist to.\n    this.bindings = {};\n    // \"true\" if the current path contains a reference to a binding whose\n    // value can change and thus can't be safely hoisted.\n    this.mutableBinding = false;\n    // Storage for eligible scopes.\n    this.scopes = [];\n    // Our original scope and path.\n    this.scope = scope;\n    this.path = path;\n    // By default, we attach as far up as we can; but if we're trying\n    // to avoid referencing a binding, we may have to go after.\n    this.attachAfter = false;\n  }\n\n  // A scope is compatible if all required bindings are reachable.\n  isCompatibleScope(scope: Scope) {\n    for (const key of Object.keys(this.bindings)) {\n      const binding = this.bindings[key];\n      if (!scope.bindingIdentifierEquals(key, binding.identifier)) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  // Look through all scopes and push compatible ones.\n  getCompatibleScopes() {\n    let scope = this.path.scope;\n    do {\n      if (this.isCompatibleScope(scope)) {\n        this.scopes.push(scope);\n      } else {\n        break;\n      }\n\n      // deopt: These scopes are set in the visitor on const violations\n      if (this.breakOnScopePaths.indexOf(scope.path) >= 0) {\n        break;\n      }\n    } while ((scope = scope.parent));\n  }\n\n  getAttachmentPath() {\n    let path = this._getAttachmentPath();\n    if (!path) return;\n\n    let targetScope = path.scope;\n\n    // don't allow paths that have their own lexical environments to pollute\n    if (targetScope.path === path) {\n      targetScope = path.scope.parent;\n    }\n\n    // avoid hoisting to a scope that contains bindings that are executed after our attachment path\n    if (targetScope.path.isProgram() || targetScope.path.isFunction()) {\n      for (const name of Object.keys(this.bindings)) {\n        // check binding is a direct child of this paths scope\n        if (!targetScope.hasOwnBinding(name)) continue;\n\n        const binding = this.bindings[name];\n\n        // allow parameter references and expressions in params (like destructuring rest)\n        if (binding.kind === \"param\" || binding.path.parentKey === \"params\") {\n          continue;\n        }\n\n        // For each binding, get its attachment parent. This gives us an idea of where we might\n        // introduce conflicts.\n        const bindingParentPath = this.getAttachmentParentForPath(binding.path);\n\n        // If the binding's attachment appears at or after our attachment point, then we move after it.\n        if (bindingParentPath.key >= path.key) {\n          this.attachAfter = true;\n          path = binding.path;\n\n          // We also move past any constant violations.\n          for (const violationPath of binding.constantViolations) {\n            if (this.getAttachmentParentForPath(violationPath).key > path.key) {\n              path = violationPath;\n            }\n          }\n        }\n      }\n    }\n\n    return path;\n  }\n\n  _getAttachmentPath() {\n    const scopes = this.scopes;\n\n    const scope = scopes.pop();\n    // deopt: no compatible scopes\n    if (!scope) return;\n\n    if (scope.path.isFunction()) {\n      if (this.hasOwnParamBindings(scope)) {\n        // deopt: should ignore this scope since it's ourselves\n        if (this.scope === scope) return;\n\n        // needs to be attached to the body\n        const bodies = scope.path.get(\"body\").get(\"body\") as NodePath[];\n        for (let i = 0; i < bodies.length; i++) {\n          // Don't attach to something that's going to get hoisted,\n          // like a default parameter\n          // @ts-expect-error todo(flow->ts): avoid mutating the node, introducing new fields\n          if (bodies[i].node._blockHoist) continue;\n          return bodies[i];\n        }\n        // deopt: If here, no attachment path found\n      } else {\n        // doesn't need to be be attached to this scope\n        return this.getNextScopeAttachmentParent();\n      }\n    } else if (scope.path.isProgram()) {\n      return this.getNextScopeAttachmentParent();\n    }\n  }\n\n  getNextScopeAttachmentParent() {\n    const scope = this.scopes.pop();\n    if (scope) return this.getAttachmentParentForPath(scope.path);\n  }\n\n  // Find an attachment for this path.\n  getAttachmentParentForPath(path: NodePath) {\n    do {\n      if (\n        // Beginning of the scope\n        !path.parentPath ||\n        // Has siblings and is a statement\n        (Array.isArray(path.container) && path.isStatement())\n      ) {\n        return path;\n      }\n    } while ((path = path.parentPath));\n  }\n\n  // Returns true if a scope has param bindings.\n  hasOwnParamBindings(scope: Scope) {\n    for (const name of Object.keys(this.bindings)) {\n      if (!scope.hasOwnBinding(name)) continue;\n\n      const binding = this.bindings[name];\n      // Ensure constant; without it we could place behind a reassignment\n      if (binding.kind === \"param\" && binding.constant) return true;\n    }\n    return false;\n  }\n\n  run() {\n    this.path.traverse(referenceVisitor, this);\n\n    if (this.mutableBinding) return;\n\n    this.getCompatibleScopes();\n\n    const attachTo = this.getAttachmentPath();\n    if (!attachTo) return;\n\n    // don't bother hoisting to the same function as this will cause multiple branches to be\n    // evaluated more than once leading to a bad optimisation\n    if (attachTo.getFunctionParent() === this.path.getFunctionParent()) return;\n\n    // generate declaration and insert it to our point\n    let uid: t.Identifier | t.JSXExpressionContainer =\n      attachTo.scope.generateUidIdentifier(\"ref\");\n\n    // @ts-expect-error todo(flow->ts): more specific type for this.path\n    const declarator = variableDeclarator(uid, this.path.node);\n\n    const insertFn = this.attachAfter ? \"insertAfter\" : \"insertBefore\";\n    const [attached] = attachTo[insertFn]([\n      attachTo.isVariableDeclarator()\n        ? declarator\n        : variableDeclaration(\"var\", [declarator]),\n    ]);\n\n    const parent = this.path.parentPath;\n    if (parent.isJSXElement() && this.path.container === parent.node.children) {\n      // turning the `span` in `<div><span /></div>` to an expression so we need to wrap it with\n      // an expression container\n      uid = jsxExpressionContainer(uid);\n    }\n\n    this.path.replaceWith(cloneNode(uid));\n\n    return attachTo.isVariableDeclarator()\n      ? attached.get(\"init\")\n      : attached.get(\"declarations.0.init\");\n  }\n}\n"],"mappings":"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"}
+{"version":3,"names":["react","cloneNode","jsxExpressionContainer","variableDeclaration","variableDeclarator","referenceVisitor","ReferencedIdentifier","path","state","isJSXIdentifier","isCompatTag","node","name","parentPath","isJSXMemberExpression","scope","isFunction","isArrowFunctionExpression","parent","breakOnScopePaths","push","binding","getBinding","violation","constantViolations","mutableBinding","stop","bindings","PathHoister","constructor","scopes","attachAfter","isCompatibleScope","key","Object","keys","bindingIdentifierEquals","identifier","getCompatibleScopes","indexOf","getAttachmentPath","_getAttachmentPath","targetScope","isProgram","hasOwnBinding","kind","parentKey","bindingParentPath","getAttachmentParentForPath","violationPath","pop","hasOwnParamBindings","bodies","get","i","length","_blockHoist","getNextScopeAttachmentParent","Array","isArray","container","isStatement","constant","run","traverse","attachTo","getFunctionParent","uid","generateUidIdentifier","declarator","insertFn","attached","isVariableDeclarator","isJSXElement","children","replaceWith"],"sources":["../../../src/path/lib/hoister.ts"],"sourcesContent":["import { react } from \"@babel/types\";\nimport {\n  cloneNode,\n  jsxExpressionContainer,\n  variableDeclaration,\n  variableDeclarator,\n} from \"@babel/types\";\nimport type * as t from \"@babel/types\";\nimport type Scope from \"../../scope\";\nimport type NodePath from \"../index\";\nimport type Binding from \"../../scope/binding\";\nimport type { Visitor } from \"../../types\";\n\nconst referenceVisitor: Visitor<PathHoister> = {\n  // This visitor looks for bindings to establish a topmost scope for hoisting.\n  ReferencedIdentifier(path, state) {\n    // Don't hoist regular JSX identifiers ('div', 'span', etc).\n    // We do have to consider member expressions for hoisting (e.g. `this.component`)\n    if (\n      path.isJSXIdentifier() &&\n      react.isCompatTag(path.node.name) &&\n      !path.parentPath.isJSXMemberExpression()\n    ) {\n      return;\n    }\n\n    // If the identifier refers to `this`, we need to break on the closest non-arrow scope.\n    if (path.node.name === \"this\") {\n      let scope = path.scope;\n      do {\n        if (\n          scope.path.isFunction() &&\n          !scope.path.isArrowFunctionExpression()\n        ) {\n          break;\n        }\n      } while ((scope = scope.parent));\n      if (scope) state.breakOnScopePaths.push(scope.path);\n    }\n\n    // direct references that we need to track to hoist this to the highest scope we can\n    const binding = path.scope.getBinding(path.node.name);\n    if (!binding) return;\n\n    // we can handle reassignments only if they happen in the same scope as the declaration\n    for (const violation of binding.constantViolations) {\n      if (violation.scope !== binding.path.scope) {\n        state.mutableBinding = true;\n        path.stop();\n        return;\n      }\n    }\n\n    // this binding isn't accessible from the parent scope so we can safely ignore it\n    // eg. it's in a closure etc\n    if (binding !== state.scope.getBinding(path.node.name)) return;\n\n    state.bindings[path.node.name] = binding;\n  },\n};\n\nexport default class PathHoister<T extends t.Node = t.Node> {\n  breakOnScopePaths: NodePath[];\n  bindings: { [k: string]: Binding };\n  mutableBinding: boolean;\n  private scopes: Scope[];\n  scope: Scope;\n  private path: NodePath<T>;\n  private attachAfter: boolean;\n\n  constructor(path: NodePath<T>, scope: Scope) {\n    // Storage for scopes we can't hoist above.\n    this.breakOnScopePaths = [];\n    // Storage for bindings that may affect what path we can hoist to.\n    this.bindings = {};\n    // \"true\" if the current path contains a reference to a binding whose\n    // value can change and thus can't be safely hoisted.\n    this.mutableBinding = false;\n    // Storage for eligible scopes.\n    this.scopes = [];\n    // Our original scope and path.\n    this.scope = scope;\n    this.path = path;\n    // By default, we attach as far up as we can; but if we're trying\n    // to avoid referencing a binding, we may have to go after.\n    this.attachAfter = false;\n  }\n\n  // A scope is compatible if all required bindings are reachable.\n  isCompatibleScope(scope: Scope) {\n    for (const key of Object.keys(this.bindings)) {\n      const binding = this.bindings[key];\n      if (!scope.bindingIdentifierEquals(key, binding.identifier)) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  // Look through all scopes and push compatible ones.\n  getCompatibleScopes() {\n    let scope = this.path.scope;\n    do {\n      if (this.isCompatibleScope(scope)) {\n        this.scopes.push(scope);\n      } else {\n        break;\n      }\n\n      // deopt: These scopes are set in the visitor on const violations\n      if (this.breakOnScopePaths.indexOf(scope.path) >= 0) {\n        break;\n      }\n    } while ((scope = scope.parent));\n  }\n\n  getAttachmentPath() {\n    let path = this._getAttachmentPath();\n    if (!path) return;\n\n    let targetScope = path.scope;\n\n    // don't allow paths that have their own lexical environments to pollute\n    if (targetScope.path === path) {\n      targetScope = path.scope.parent;\n    }\n\n    // avoid hoisting to a scope that contains bindings that are executed after our attachment path\n    if (targetScope.path.isProgram() || targetScope.path.isFunction()) {\n      for (const name of Object.keys(this.bindings)) {\n        // check binding is a direct child of this paths scope\n        if (!targetScope.hasOwnBinding(name)) continue;\n\n        const binding = this.bindings[name];\n\n        // allow parameter references and expressions in params (like destructuring rest)\n        if (binding.kind === \"param\" || binding.path.parentKey === \"params\") {\n          continue;\n        }\n\n        // For each binding, get its attachment parent. This gives us an idea of where we might\n        // introduce conflicts.\n        const bindingParentPath = this.getAttachmentParentForPath(binding.path);\n\n        // If the binding's attachment appears at or after our attachment point, then we move after it.\n        if (bindingParentPath.key >= path.key) {\n          this.attachAfter = true;\n          path = binding.path;\n\n          // We also move past any constant violations.\n          for (const violationPath of binding.constantViolations) {\n            if (this.getAttachmentParentForPath(violationPath).key > path.key) {\n              path = violationPath;\n            }\n          }\n        }\n      }\n    }\n\n    return path;\n  }\n\n  _getAttachmentPath() {\n    const scopes = this.scopes;\n\n    const scope = scopes.pop();\n    // deopt: no compatible scopes\n    if (!scope) return;\n\n    if (scope.path.isFunction()) {\n      if (this.hasOwnParamBindings(scope)) {\n        // deopt: should ignore this scope since it's ourselves\n        if (this.scope === scope) return;\n\n        // needs to be attached to the body\n        const bodies = scope.path.get(\"body\").get(\"body\") as NodePath[];\n        for (let i = 0; i < bodies.length; i++) {\n          // Don't attach to something that's going to get hoisted,\n          // like a default parameter\n          // @ts-expect-error todo(flow->ts): avoid mutating the node, introducing new fields\n          if (bodies[i].node._blockHoist) continue;\n          return bodies[i];\n        }\n        // deopt: If here, no attachment path found\n      } else {\n        // doesn't need to be be attached to this scope\n        return this.getNextScopeAttachmentParent();\n      }\n    } else if (scope.path.isProgram()) {\n      return this.getNextScopeAttachmentParent();\n    }\n  }\n\n  getNextScopeAttachmentParent() {\n    const scope = this.scopes.pop();\n    if (scope) return this.getAttachmentParentForPath(scope.path);\n  }\n\n  // Find an attachment for this path.\n  getAttachmentParentForPath(path: NodePath) {\n    do {\n      if (\n        // Beginning of the scope\n        !path.parentPath ||\n        // Has siblings and is a statement\n        (Array.isArray(path.container) && path.isStatement())\n      ) {\n        return path;\n      }\n    } while ((path = path.parentPath));\n  }\n\n  // Returns true if a scope has param bindings.\n  hasOwnParamBindings(scope: Scope) {\n    for (const name of Object.keys(this.bindings)) {\n      if (!scope.hasOwnBinding(name)) continue;\n\n      const binding = this.bindings[name];\n      // Ensure constant; without it we could place behind a reassignment\n      if (binding.kind === \"param\" && binding.constant) return true;\n    }\n    return false;\n  }\n\n  run() {\n    this.path.traverse(referenceVisitor, this);\n\n    if (this.mutableBinding) return;\n\n    this.getCompatibleScopes();\n\n    const attachTo = this.getAttachmentPath();\n    if (!attachTo) return;\n\n    // don't bother hoisting to the same function as this will cause multiple branches to be\n    // evaluated more than once leading to a bad optimisation\n    if (attachTo.getFunctionParent() === this.path.getFunctionParent()) return;\n\n    // generate declaration and insert it to our point\n    let uid: t.Identifier | t.JSXExpressionContainer =\n      attachTo.scope.generateUidIdentifier(\"ref\");\n\n    // @ts-expect-error todo(flow->ts): more specific type for this.path\n    const declarator = variableDeclarator(uid, this.path.node);\n\n    const insertFn = this.attachAfter ? \"insertAfter\" : \"insertBefore\";\n    const [attached] = attachTo[insertFn]([\n      attachTo.isVariableDeclarator()\n        ? declarator\n        : variableDeclaration(\"var\", [declarator]),\n    ]);\n\n    const parent = this.path.parentPath;\n    if (parent.isJSXElement() && this.path.container === parent.node.children) {\n      // turning the `span` in `<div><span /></div>` to an expression so we need to wrap it with\n      // an expression container\n      uid = jsxExpressionContainer(uid);\n    }\n\n    this.path.replaceWith(cloneNode(uid));\n\n    return attachTo.isVariableDeclarator()\n      ? attached.get(\"init\")\n      : attached.get(\"declarations.0.init\");\n  }\n}\n"],"mappings":"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"}

package/lib/path/lib/removal-hooks.js

@@ -4,9 +4,14 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.hooks = void 0;
-const hooks = [function (self, parent) {
-  const removeParent = self.key === "test" && (parent.isWhile() || parent.isSwitchCase()) || self.key === "declaration" && parent.isExportDeclaration() || self.key === "body" && parent.isLabeledStatement() || self.listKey === "declarations" && parent.isVariableDeclaration() && parent.node.declarations.length === 1 || self.key === "expression" && parent.isExpressionStatement();
 
+const hooks = [function (self, parent) {
+  const removeParent =
+  self.key === "test" && (parent.isWhile() || parent.isSwitchCase()) ||
+  self.key === "declaration" && parent.isExportDeclaration() ||
+  self.key === "body" && parent.isLabeledStatement() ||
+  self.listKey === "declarations" && parent.isVariableDeclaration() && parent.node.declarations.length === 1 ||
+  self.key === "expression" && parent.isExpressionStatement();
   if (removeParent) {
     parent.remove();
     return true;
@@ -23,7 +28,6 @@ const hooks = [function (self, parent) {
     } else {
       parent.replaceWith(parent.node.left);
     }
-
     return true;
   }
 }, function (self, parent) {

package/lib/path/lib/removal-hooks.js.map

@@ -1 +1 @@
-{"version":3,"names":["hooks","self","parent","removeParent","key","isWhile","isSwitchCase","isExportDeclaration","isLabeledStatement","listKey","isVariableDeclaration","node","declarations","length","isExpressionStatement","remove","isSequenceExpression","expressions","replaceWith","isBinary","right","left","isIfStatement","isLoop","isArrowFunctionExpression","type","body"],"sources":["../../../src/path/lib/removal-hooks.ts"],"sourcesContent":["// this file contains hooks that handle ancestry cleanup of parent nodes when removing children\n\nimport type NodePath from \"..\";\nimport type * as t from \"@babel/types\";\n/**\n * Pre hooks should be used for either rejecting removal or delegating removal\n */\n\nexport const hooks = [\n  function (self: NodePath, parent: NodePath) {\n    const removeParent =\n      // while (NODE);\n      // removing the test of a while/switch, we can either just remove it entirely *or* turn the\n      // `test` into `true` unlikely that the latter will ever be what's wanted so we just remove\n      // the loop to avoid infinite recursion\n      (self.key === \"test\" && (parent.isWhile() || parent.isSwitchCase())) ||\n      // export NODE;\n      // just remove a declaration for an export as this is no longer valid\n      (self.key === \"declaration\" && parent.isExportDeclaration()) ||\n      // label: NODE\n      // stray labeled statement with no body\n      (self.key === \"body\" && parent.isLabeledStatement()) ||\n      // let NODE;\n      // remove an entire declaration if there are no declarators left\n      (self.listKey === \"declarations\" &&\n        parent.isVariableDeclaration() &&\n        parent.node.declarations.length === 1) ||\n      // NODE;\n      // remove the entire expression statement if there's no expression\n      (self.key === \"expression\" && parent.isExpressionStatement());\n\n    if (removeParent) {\n      parent.remove();\n      return true;\n    }\n  },\n\n  function (self: NodePath, parent: NodePath) {\n    if (parent.isSequenceExpression() && parent.node.expressions.length === 1) {\n      // (node, NODE);\n      // we've just removed the second element of a sequence expression so let's turn that sequence\n      // expression into a regular expression\n      parent.replaceWith(parent.node.expressions[0]);\n      return true;\n    }\n  },\n\n  function (self: NodePath, parent: NodePath) {\n    if (parent.isBinary()) {\n      // left + NODE;\n      // NODE + right;\n      // we're in a binary expression, better remove it and replace it with the last expression\n      if (self.key === \"left\") {\n        parent.replaceWith(parent.node.right);\n      } else {\n        // key === \"right\"\n        parent.replaceWith(parent.node.left);\n      }\n      return true;\n    }\n  },\n\n  function (self: NodePath, parent: NodePath) {\n    if (\n      (parent.isIfStatement() && self.key === \"consequent\") ||\n      (self.key === \"body\" &&\n        (parent.isLoop() || parent.isArrowFunctionExpression()))\n    ) {\n      self.replaceWith({\n        type: \"BlockStatement\",\n        body: [],\n      } as t.BlockStatement);\n      return true;\n    }\n  },\n];\n"],"mappings":";;;;;;AAQO,MAAMA,KAAK,GAAG,CACnB,UAAUC,IAAV,EAA0BC,MAA1B,EAA4C;EAC1C,MAAMC,YAAY,GAKfF,IAAI,CAACG,GAAL,KAAa,MAAb,KAAwBF,MAAM,CAACG,OAAP,MAAoBH,MAAM,CAACI,YAAP,EAA5C,CAAD,IAGCL,IAAI,CAACG,GAAL,KAAa,aAAb,IAA8BF,MAAM,CAACK,mBAAP,EAH/B,IAMCN,IAAI,CAACG,GAAL,KAAa,MAAb,IAAuBF,MAAM,CAACM,kBAAP,EANxB,IASCP,IAAI,CAACQ,OAAL,KAAiB,cAAjB,IACCP,MAAM,CAACQ,qBAAP,EADD,IAECR,MAAM,CAACS,IAAP,CAAYC,YAAZ,CAAyBC,MAAzB,KAAoC,CAXtC,IAcCZ,IAAI,CAACG,GAAL,KAAa,YAAb,IAA6BF,MAAM,CAACY,qBAAP,EAnBhC;;EAqBA,IAAIX,YAAJ,EAAkB;IAChBD,MAAM,CAACa,MAAP;IACA,OAAO,IAAP;EACD;AACF,CA3BkB,EA6BnB,UAAUd,IAAV,EAA0BC,MAA1B,EAA4C;EAC1C,IAAIA,MAAM,CAACc,oBAAP,MAAiCd,MAAM,CAACS,IAAP,CAAYM,WAAZ,CAAwBJ,MAAxB,KAAmC,CAAxE,EAA2E;IAIzEX,MAAM,CAACgB,WAAP,CAAmBhB,MAAM,CAACS,IAAP,CAAYM,WAAZ,CAAwB,CAAxB,CAAnB;IACA,OAAO,IAAP;EACD;AACF,CArCkB,EAuCnB,UAAUhB,IAAV,EAA0BC,MAA1B,EAA4C;EAC1C,IAAIA,MAAM,CAACiB,QAAP,EAAJ,EAAuB;IAIrB,IAAIlB,IAAI,CAACG,GAAL,KAAa,MAAjB,EAAyB;MACvBF,MAAM,CAACgB,WAAP,CAAmBhB,MAAM,CAACS,IAAP,CAAYS,KAA/B;IACD,CAFD,MAEO;MAELlB,MAAM,CAACgB,WAAP,CAAmBhB,MAAM,CAACS,IAAP,CAAYU,IAA/B;IACD;;IACD,OAAO,IAAP;EACD;AACF,CApDkB,EAsDnB,UAAUpB,IAAV,EAA0BC,MAA1B,EAA4C;EAC1C,IACGA,MAAM,CAACoB,aAAP,MAA0BrB,IAAI,CAACG,GAAL,KAAa,YAAxC,IACCH,IAAI,CAACG,GAAL,KAAa,MAAb,KACEF,MAAM,CAACqB,MAAP,MAAmBrB,MAAM,CAACsB,yBAAP,EADrB,CAFH,EAIE;IACAvB,IAAI,CAACiB,WAAL,CAAiB;MACfO,IAAI,EAAE,gBADS;MAEfC,IAAI,EAAE;IAFS,CAAjB;IAIA,OAAO,IAAP;EACD;AACF,CAlEkB,CAAd"}
+{"version":3,"names":["hooks","self","parent","removeParent","key","isWhile","isSwitchCase","isExportDeclaration","isLabeledStatement","listKey","isVariableDeclaration","node","declarations","length","isExpressionStatement","remove","isSequenceExpression","expressions","replaceWith","isBinary","right","left","isIfStatement","isLoop","isArrowFunctionExpression","type","body"],"sources":["../../../src/path/lib/removal-hooks.ts"],"sourcesContent":["// this file contains hooks that handle ancestry cleanup of parent nodes when removing children\n\nimport type NodePath from \"..\";\nimport type * as t from \"@babel/types\";\n/**\n * Pre hooks should be used for either rejecting removal or delegating removal\n */\n\nexport const hooks = [\n  function (self: NodePath, parent: NodePath) {\n    const removeParent =\n      // while (NODE);\n      // removing the test of a while/switch, we can either just remove it entirely *or* turn the\n      // `test` into `true` unlikely that the latter will ever be what's wanted so we just remove\n      // the loop to avoid infinite recursion\n      (self.key === \"test\" && (parent.isWhile() || parent.isSwitchCase())) ||\n      // export NODE;\n      // just remove a declaration for an export as this is no longer valid\n      (self.key === \"declaration\" && parent.isExportDeclaration()) ||\n      // label: NODE\n      // stray labeled statement with no body\n      (self.key === \"body\" && parent.isLabeledStatement()) ||\n      // let NODE;\n      // remove an entire declaration if there are no declarators left\n      (self.listKey === \"declarations\" &&\n        parent.isVariableDeclaration() &&\n        parent.node.declarations.length === 1) ||\n      // NODE;\n      // remove the entire expression statement if there's no expression\n      (self.key === \"expression\" && parent.isExpressionStatement());\n\n    if (removeParent) {\n      parent.remove();\n      return true;\n    }\n  },\n\n  function (self: NodePath, parent: NodePath) {\n    if (parent.isSequenceExpression() && parent.node.expressions.length === 1) {\n      // (node, NODE);\n      // we've just removed the second element of a sequence expression so let's turn that sequence\n      // expression into a regular expression\n      parent.replaceWith(parent.node.expressions[0]);\n      return true;\n    }\n  },\n\n  function (self: NodePath, parent: NodePath) {\n    if (parent.isBinary()) {\n      // left + NODE;\n      // NODE + right;\n      // we're in a binary expression, better remove it and replace it with the last expression\n      if (self.key === \"left\") {\n        parent.replaceWith(parent.node.right);\n      } else {\n        // key === \"right\"\n        parent.replaceWith(parent.node.left);\n      }\n      return true;\n    }\n  },\n\n  function (self: NodePath, parent: NodePath) {\n    if (\n      (parent.isIfStatement() && self.key === \"consequent\") ||\n      (self.key === \"body\" &&\n        (parent.isLoop() || parent.isArrowFunctionExpression()))\n    ) {\n      self.replaceWith({\n        type: \"BlockStatement\",\n        body: [],\n      } as t.BlockStatement);\n      return true;\n    }\n  },\n];\n"],"mappings":";;;;;;;AAQO,MAAMA,KAAK,GAAG,CACnB,UAAUC,IAAc,EAAEC,MAAgB,EAAE;EAC1C,MAAMC,YAAY;EAKfF,IAAI,CAACG,GAAG,KAAK,MAAM,KAAKF,MAAM,CAACG,OAAO,EAAE,IAAIH,MAAM,CAACI,YAAY,EAAE,CAAC;EAGlEL,IAAI,CAACG,GAAG,KAAK,aAAa,IAAIF,MAAM,CAACK,mBAAmB,EAAG;EAG3DN,IAAI,CAACG,GAAG,KAAK,MAAM,IAAIF,MAAM,CAACM,kBAAkB,EAAG;EAGnDP,IAAI,CAACQ,OAAO,KAAK,cAAc,IAC9BP,MAAM,CAACQ,qBAAqB,EAAE,IAC9BR,MAAM,CAACS,IAAI,CAACC,YAAY,CAACC,MAAM,KAAK,CAAE;EAGvCZ,IAAI,CAACG,GAAG,KAAK,YAAY,IAAIF,MAAM,CAACY,qBAAqB,EAAG;EAE/D,IAAIX,YAAY,EAAE;IAChBD,MAAM,CAACa,MAAM,EAAE;IACf,OAAO,IAAI;EACb;AACF,CAAC,EAED,UAAUd,IAAc,EAAEC,MAAgB,EAAE;EAC1C,IAAIA,MAAM,CAACc,oBAAoB,EAAE,IAAId,MAAM,CAACS,IAAI,CAACM,WAAW,CAACJ,MAAM,KAAK,CAAC,EAAE;IAIzEX,MAAM,CAACgB,WAAW,CAAChB,MAAM,CAACS,IAAI,CAACM,WAAW,CAAC,CAAC,CAAC,CAAC;IAC9C,OAAO,IAAI;EACb;AACF,CAAC,EAED,UAAUhB,IAAc,EAAEC,MAAgB,EAAE;EAC1C,IAAIA,MAAM,CAACiB,QAAQ,EAAE,EAAE;IAIrB,IAAIlB,IAAI,CAACG,GAAG,KAAK,MAAM,EAAE;MACvBF,MAAM,CAACgB,WAAW,CAAChB,MAAM,CAACS,IAAI,CAACS,KAAK,CAAC;IACvC,CAAC,MAAM;MAELlB,MAAM,CAACgB,WAAW,CAAChB,MAAM,CAACS,IAAI,CAACU,IAAI,CAAC;IACtC;IACA,OAAO,IAAI;EACb;AACF,CAAC,EAED,UAAUpB,IAAc,EAAEC,MAAgB,EAAE;EAC1C,IACGA,MAAM,CAACoB,aAAa,EAAE,IAAIrB,IAAI,CAACG,GAAG,KAAK,YAAY,IACnDH,IAAI,CAACG,GAAG,KAAK,MAAM,KACjBF,MAAM,CAACqB,MAAM,EAAE,IAAIrB,MAAM,CAACsB,yBAAyB,EAAE,CAAE,EAC1D;IACAvB,IAAI,CAACiB,WAAW,CAAC;MACfO,IAAI,EAAE,gBAAgB;MACtBC,IAAI,EAAE;IACR,CAAC,CAAqB;IACtB,OAAO,IAAI;EACb;AACF,CAAC,CACF;AAAC"}

package/lib/path/lib/virtual-types-validator.js

@@ -21,9 +21,7 @@ exports.isSpreadProperty = isSpreadProperty;
 exports.isStatement = isStatement;
 exports.isUser = isUser;
 exports.isVar = isVar;
-
 var _t = require("@babel/types");
-
 const {
   isBinding,
   isBlockScoped: nodeIsBlockScoped,
@@ -50,13 +48,11 @@ const {
 const {
   isCompatTag
 } = react;
-
 function isReferencedIdentifier(opts) {
   const {
     node,
     parent
   } = this;
-
   if (!isIdentifier(node, opts) && !isJSXMemberExpression(parent, opts)) {
     if (isJSXIdentifier(node, opts)) {
       if (isCompatTag(node.name)) return false;
@@ -67,7 +63,6 @@ function isReferencedIdentifier(opts) {
 
   return nodeIsReferenced(node, parent, this.parentPath.parent);
 }
-
 function isReferencedMemberExpression() {
   const {
     node,
@@ -75,7 +70,6 @@ function isReferencedMemberExpression() {
   } = this;
   return isMemberExpression(node) && nodeIsReferenced(node, parent);
 }
-
 function isBindingIdentifier() {
   const {
     node,
@@ -84,13 +78,11 @@ function isBindingIdentifier() {
   const grandparent = this.parentPath.parent;
   return isIdentifier(node) && isBinding(node, parent, grandparent);
 }
-
 function isStatement() {
   const {
     node,
     parent
   } = this;
-
   if (nodeIsStatement(node)) {
     if (isVariableDeclaration(node)) {
       if (isForXStatement(parent, {
@@ -100,13 +92,11 @@ function isStatement() {
         init: node
       })) return false;
     }
-
     return true;
   } else {
     return false;
   }
 }
-
 function isExpression() {
   if (this.isIdentifier()) {
     return this.isReferencedIdentifier();
@@ -114,40 +104,31 @@ function isExpression() {
     return nodeIsExpression(this.node);
   }
 }
-
 function isScope() {
   return nodeIsScope(this.node, this.parent);
 }
-
 function isReferenced() {
   return nodeIsReferenced(this.node, this.parent);
 }
-
 function isBlockScoped() {
   return nodeIsBlockScoped(this.node);
 }
-
 function isVar() {
   return nodeIsVar(this.node);
 }
-
 function isUser() {
   return this.node && !!this.node.loc;
 }
-
 function isGenerated() {
   return !this.isUser();
 }
-
 function isPure(constantsOnly) {
   return this.scope.isPure(this.node, constantsOnly);
 }
-
 function isFlow() {
   const {
     node
   } = this;
-
   if (nodeIsFlow(node)) {
     return true;
   } else if (isImportDeclaration(node)) {
@@ -164,21 +145,17 @@ function isFlow() {
 function isRestProperty() {
   return nodeIsRestElement(this.node) && this.parentPath && this.parentPath.isObjectPattern();
 }
-
 function isSpreadProperty() {
   return nodeIsRestElement(this.node) && this.parentPath && this.parentPath.isObjectExpression();
 }
-
 function isForAwaitStatement() {
   return isForOfStatement(this.node, {
     await: true
   });
 }
-
 function isExistentialTypeParam() {
   throw new Error("`path.isExistentialTypeParam` has been renamed to `path.isExistsTypeAnnotation()` in Babel 7.");
 }
-
 function isNumericLiteralTypeAnnotation() {
   throw new Error("`path.isNumericLiteralTypeAnnotation()` has been renamed to `path.isNumberLiteralTypeAnnotation()` in Babel 7.");
 }

package/lib/path/lib/virtual-types-validator.js.map

@@ -1 +1 @@
-{"version":3,"names":["isBinding","isBlockScoped","nodeIsBlockScoped","isExportDeclaration","isExpression","nodeIsExpression","isFlow","nodeIsFlow","isForStatement","isForXStatement","isIdentifier","isImportDeclaration","isImportSpecifier","isJSXIdentifier","isJSXMemberExpression","isMemberExpression","isRestElement","nodeIsRestElement","isReferenced","nodeIsReferenced","isScope","nodeIsScope","isStatement","nodeIsStatement","isVar","nodeIsVar","isVariableDeclaration","react","isForOfStatement","isCompatTag","isReferencedIdentifier","opts","node","parent","name","parentPath","isReferencedMemberExpression","isBindingIdentifier","grandparent","left","init","isUser","loc","isGenerated","isPure","constantsOnly","scope","importKind","exportKind","isRestProperty","isObjectPattern","isSpreadProperty","isObjectExpression","isForAwaitStatement","await","isExistentialTypeParam","Error","isNumericLiteralTypeAnnotation"],"sources":["../../../src/path/lib/virtual-types-validator.ts"],"sourcesContent":["import type NodePath from \"../index\";\nimport {\n  isBinding,\n  isBlockScoped as nodeIsBlockScoped,\n  isExportDeclaration,\n  isExpression as nodeIsExpression,\n  isFlow as nodeIsFlow,\n  isForStatement,\n  isForXStatement,\n  isIdentifier,\n  isImportDeclaration,\n  isImportSpecifier,\n  isJSXIdentifier,\n  isJSXMemberExpression,\n  isMemberExpression,\n  isRestElement as nodeIsRestElement,\n  isReferenced as nodeIsReferenced,\n  isScope as nodeIsScope,\n  isStatement as nodeIsStatement,\n  isVar as nodeIsVar,\n  isVariableDeclaration,\n  react,\n  isForOfStatement,\n} from \"@babel/types\";\nimport type * as t from \"@babel/types\";\nconst { isCompatTag } = react;\nimport type { VirtualTypeAliases } from \"./virtual-types\";\n\nexport interface VirtualTypeNodePathValidators {\n  isBindingIdentifier<T extends t.Node>(\n    this: NodePath<T>,\n    opts?: object,\n  ): this is NodePath<T & VirtualTypeAliases[\"BindingIdentifier\"]>;\n  isBlockScoped(opts?: object): boolean;\n  /**\n   * @deprecated\n   */\n  isExistentialTypeParam<T extends t.Node>(\n    this: NodePath<T>,\n    opts?: object,\n  ): this is NodePath<T & VirtualTypeAliases[\"ExistentialTypeParam\"]>;\n  isExpression<T extends t.Node>(\n    this: NodePath<T>,\n    opts?: object,\n  ): this is NodePath<T & t.Expression>;\n  isFlow<T extends t.Node>(\n    this: NodePath<T>,\n    opts?: object,\n  ): this is NodePath<T & t.Flow>;\n  isForAwaitStatement<T extends t.Node>(\n    this: NodePath<T>,\n    opts?: object,\n  ): this is NodePath<T & VirtualTypeAliases[\"ForAwaitStatement\"]>;\n  isGenerated(opts?: object): boolean;\n  /**\n   * @deprecated\n   */\n  isNumericLiteralTypeAnnotation(opts?: object): void;\n  isPure(opts?: object): boolean;\n  isReferenced(opts?: object): boolean;\n  isReferencedIdentifier<T extends t.Node>(\n    this: NodePath<T>,\n    opts?: object,\n  ): this is NodePath<T & VirtualTypeAliases[\"ReferencedIdentifier\"]>;\n  isReferencedMemberExpression<T extends t.Node>(\n    this: NodePath<T>,\n    opts?: object,\n  ): this is NodePath<T & VirtualTypeAliases[\"ReferencedMemberExpression\"]>;\n  isRestProperty<T extends t.Node>(\n    this: NodePath<T>,\n    opts?: object,\n  ): this is NodePath<T & t.RestProperty>;\n  isScope<T extends t.Node>(\n    this: NodePath<T>,\n    opts?: object,\n  ): this is NodePath<T & VirtualTypeAliases[\"Scope\"]>;\n  isSpreadProperty<T extends t.Node>(\n    this: NodePath<T>,\n    opts?: object,\n  ): this is NodePath<T & t.SpreadProperty>;\n  isStatement<T extends t.Node>(\n    this: NodePath<T>,\n    opts?: object,\n  ): this is NodePath<T & t.Statement>;\n  isUser(opts?: object): boolean;\n  isVar<T extends t.Node>(\n    this: NodePath<T>,\n    opts?: object,\n  ): this is NodePath<T & VirtualTypeAliases[\"Var\"]>;\n}\n\nexport function isReferencedIdentifier(this: NodePath, opts?: any): boolean {\n  const { node, parent } = this;\n  if (!isIdentifier(node, opts) && !isJSXMemberExpression(parent, opts)) {\n    if (isJSXIdentifier(node, opts)) {\n      if (isCompatTag(node.name)) return false;\n    } else {\n      // not a JSXIdentifier or an Identifier\n      return false;\n    }\n  }\n\n  // check if node is referenced\n  return nodeIsReferenced(node, parent, this.parentPath.parent);\n}\n\nexport function isReferencedMemberExpression(this: NodePath): boolean {\n  const { node, parent } = this;\n  return isMemberExpression(node) && nodeIsReferenced(node, parent);\n}\n\nexport function isBindingIdentifier(this: NodePath): boolean {\n  const { node, parent } = this;\n  const grandparent = this.parentPath.parent;\n  return isIdentifier(node) && isBinding(node, parent, grandparent);\n}\n\nexport function isStatement(this: NodePath): boolean {\n  const { node, parent } = this;\n  if (nodeIsStatement(node)) {\n    if (isVariableDeclaration(node)) {\n      if (isForXStatement(parent, { left: node })) return false;\n      if (isForStatement(parent, { init: node })) return false;\n    }\n\n    return true;\n  } else {\n    return false;\n  }\n}\n\nexport function isExpression(this: NodePath): boolean {\n  if (this.isIdentifier()) {\n    return this.isReferencedIdentifier();\n  } else {\n    return nodeIsExpression(this.node);\n  }\n}\n\nexport function isScope(this: NodePath): boolean {\n  return nodeIsScope(this.node, this.parent);\n}\n\nexport function isReferenced(this: NodePath): boolean {\n  return nodeIsReferenced(this.node, this.parent);\n}\n\nexport function isBlockScoped(this: NodePath): boolean {\n  return nodeIsBlockScoped(this.node);\n}\n\nexport function isVar(this: NodePath): boolean {\n  return nodeIsVar(this.node);\n}\n\nexport function isUser(this: NodePath): boolean {\n  return this.node && !!this.node.loc;\n}\n\nexport function isGenerated(this: NodePath): boolean {\n  return !this.isUser();\n}\n\nexport function isPure(this: NodePath, constantsOnly?: boolean): boolean {\n  return this.scope.isPure(this.node, constantsOnly);\n}\n\nexport function isFlow(this: NodePath): boolean {\n  const { node } = this;\n  if (nodeIsFlow(node)) {\n    return true;\n  } else if (isImportDeclaration(node)) {\n    return node.importKind === \"type\" || node.importKind === \"typeof\";\n  } else if (isExportDeclaration(node)) {\n    return node.exportKind === \"type\";\n  } else if (isImportSpecifier(node)) {\n    return node.importKind === \"type\" || node.importKind === \"typeof\";\n  } else {\n    return false;\n  }\n}\n\n// TODO: 7.0 Backwards Compat\nexport function isRestProperty(this: NodePath): boolean {\n  return (\n    nodeIsRestElement(this.node) &&\n    this.parentPath &&\n    this.parentPath.isObjectPattern()\n  );\n}\n\nexport function isSpreadProperty(this: NodePath): boolean {\n  return (\n    nodeIsRestElement(this.node) &&\n    this.parentPath &&\n    this.parentPath.isObjectExpression()\n  );\n}\n\nexport function isForAwaitStatement(this: NodePath): boolean {\n  return isForOfStatement(this.node, { await: true });\n}\n\nexport function isExistentialTypeParam(this: NodePath): void {\n  throw new Error(\n    \"`path.isExistentialTypeParam` has been renamed to `path.isExistsTypeAnnotation()` in Babel 7.\",\n  );\n}\n\nexport function isNumericLiteralTypeAnnotation(this: NodePath): void {\n  throw new Error(\n    \"`path.isNumericLiteralTypeAnnotation()` has been renamed to `path.isNumberLiteralTypeAnnotation()` in Babel 7.\",\n  );\n}\n"],"mappings":"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"}
+{"version":3,"names":["isBinding","isBlockScoped","nodeIsBlockScoped","isExportDeclaration","isExpression","nodeIsExpression","isFlow","nodeIsFlow","isForStatement","isForXStatement","isIdentifier","isImportDeclaration","isImportSpecifier","isJSXIdentifier","isJSXMemberExpression","isMemberExpression","isRestElement","nodeIsRestElement","isReferenced","nodeIsReferenced","isScope","nodeIsScope","isStatement","nodeIsStatement","isVar","nodeIsVar","isVariableDeclaration","react","isForOfStatement","isCompatTag","isReferencedIdentifier","opts","node","parent","name","parentPath","isReferencedMemberExpression","isBindingIdentifier","grandparent","left","init","isUser","loc","isGenerated","isPure","constantsOnly","scope","importKind","exportKind","isRestProperty","isObjectPattern","isSpreadProperty","isObjectExpression","isForAwaitStatement","await","isExistentialTypeParam","Error","isNumericLiteralTypeAnnotation"],"sources":["../../../src/path/lib/virtual-types-validator.ts"],"sourcesContent":["import type NodePath from \"../index\";\nimport {\n  isBinding,\n  isBlockScoped as nodeIsBlockScoped,\n  isExportDeclaration,\n  isExpression as nodeIsExpression,\n  isFlow as nodeIsFlow,\n  isForStatement,\n  isForXStatement,\n  isIdentifier,\n  isImportDeclaration,\n  isImportSpecifier,\n  isJSXIdentifier,\n  isJSXMemberExpression,\n  isMemberExpression,\n  isRestElement as nodeIsRestElement,\n  isReferenced as nodeIsReferenced,\n  isScope as nodeIsScope,\n  isStatement as nodeIsStatement,\n  isVar as nodeIsVar,\n  isVariableDeclaration,\n  react,\n  isForOfStatement,\n} from \"@babel/types\";\nimport type * as t from \"@babel/types\";\nconst { isCompatTag } = react;\nimport type { VirtualTypeAliases } from \"./virtual-types\";\n\nexport interface VirtualTypeNodePathValidators {\n  isBindingIdentifier<T extends t.Node>(\n    this: NodePath<T>,\n    opts?: object,\n  ): this is NodePath<T & VirtualTypeAliases[\"BindingIdentifier\"]>;\n  isBlockScoped(opts?: object): boolean;\n  /**\n   * @deprecated\n   */\n  isExistentialTypeParam<T extends t.Node>(\n    this: NodePath<T>,\n    opts?: object,\n  ): this is NodePath<T & VirtualTypeAliases[\"ExistentialTypeParam\"]>;\n  isExpression<T extends t.Node>(\n    this: NodePath<T>,\n    opts?: object,\n  ): this is NodePath<T & t.Expression>;\n  isFlow<T extends t.Node>(\n    this: NodePath<T>,\n    opts?: object,\n  ): this is NodePath<T & t.Flow>;\n  isForAwaitStatement<T extends t.Node>(\n    this: NodePath<T>,\n    opts?: object,\n  ): this is NodePath<T & VirtualTypeAliases[\"ForAwaitStatement\"]>;\n  isGenerated(opts?: object): boolean;\n  /**\n   * @deprecated\n   */\n  isNumericLiteralTypeAnnotation(opts?: object): void;\n  isPure(opts?: object): boolean;\n  isReferenced(opts?: object): boolean;\n  isReferencedIdentifier<T extends t.Node>(\n    this: NodePath<T>,\n    opts?: object,\n  ): this is NodePath<T & VirtualTypeAliases[\"ReferencedIdentifier\"]>;\n  isReferencedMemberExpression<T extends t.Node>(\n    this: NodePath<T>,\n    opts?: object,\n  ): this is NodePath<T & VirtualTypeAliases[\"ReferencedMemberExpression\"]>;\n  isRestProperty<T extends t.Node>(\n    this: NodePath<T>,\n    opts?: object,\n  ): this is NodePath<T & t.RestProperty>;\n  isScope<T extends t.Node>(\n    this: NodePath<T>,\n    opts?: object,\n  ): this is NodePath<T & VirtualTypeAliases[\"Scope\"]>;\n  isSpreadProperty<T extends t.Node>(\n    this: NodePath<T>,\n    opts?: object,\n  ): this is NodePath<T & t.SpreadProperty>;\n  isStatement<T extends t.Node>(\n    this: NodePath<T>,\n    opts?: object,\n  ): this is NodePath<T & t.Statement>;\n  isUser(opts?: object): boolean;\n  isVar<T extends t.Node>(\n    this: NodePath<T>,\n    opts?: object,\n  ): this is NodePath<T & VirtualTypeAliases[\"Var\"]>;\n}\n\nexport function isReferencedIdentifier(this: NodePath, opts?: any): boolean {\n  const { node, parent } = this;\n  if (!isIdentifier(node, opts) && !isJSXMemberExpression(parent, opts)) {\n    if (isJSXIdentifier(node, opts)) {\n      if (isCompatTag(node.name)) return false;\n    } else {\n      // not a JSXIdentifier or an Identifier\n      return false;\n    }\n  }\n\n  // check if node is referenced\n  return nodeIsReferenced(node, parent, this.parentPath.parent);\n}\n\nexport function isReferencedMemberExpression(this: NodePath): boolean {\n  const { node, parent } = this;\n  return isMemberExpression(node) && nodeIsReferenced(node, parent);\n}\n\nexport function isBindingIdentifier(this: NodePath): boolean {\n  const { node, parent } = this;\n  const grandparent = this.parentPath.parent;\n  return isIdentifier(node) && isBinding(node, parent, grandparent);\n}\n\nexport function isStatement(this: NodePath): boolean {\n  const { node, parent } = this;\n  if (nodeIsStatement(node)) {\n    if (isVariableDeclaration(node)) {\n      if (isForXStatement(parent, { left: node })) return false;\n      if (isForStatement(parent, { init: node })) return false;\n    }\n\n    return true;\n  } else {\n    return false;\n  }\n}\n\nexport function isExpression(this: NodePath): boolean {\n  if (this.isIdentifier()) {\n    return this.isReferencedIdentifier();\n  } else {\n    return nodeIsExpression(this.node);\n  }\n}\n\nexport function isScope(this: NodePath): boolean {\n  return nodeIsScope(this.node, this.parent);\n}\n\nexport function isReferenced(this: NodePath): boolean {\n  return nodeIsReferenced(this.node, this.parent);\n}\n\nexport function isBlockScoped(this: NodePath): boolean {\n  return nodeIsBlockScoped(this.node);\n}\n\nexport function isVar(this: NodePath): boolean {\n  return nodeIsVar(this.node);\n}\n\nexport function isUser(this: NodePath): boolean {\n  return this.node && !!this.node.loc;\n}\n\nexport function isGenerated(this: NodePath): boolean {\n  return !this.isUser();\n}\n\nexport function isPure(this: NodePath, constantsOnly?: boolean): boolean {\n  return this.scope.isPure(this.node, constantsOnly);\n}\n\nexport function isFlow(this: NodePath): boolean {\n  const { node } = this;\n  if (nodeIsFlow(node)) {\n    return true;\n  } else if (isImportDeclaration(node)) {\n    return node.importKind === \"type\" || node.importKind === \"typeof\";\n  } else if (isExportDeclaration(node)) {\n    return node.exportKind === \"type\";\n  } else if (isImportSpecifier(node)) {\n    return node.importKind === \"type\" || node.importKind === \"typeof\";\n  } else {\n    return false;\n  }\n}\n\n// TODO: 7.0 Backwards Compat\nexport function isRestProperty(this: NodePath): boolean {\n  return (\n    nodeIsRestElement(this.node) &&\n    this.parentPath &&\n    this.parentPath.isObjectPattern()\n  );\n}\n\nexport function isSpreadProperty(this: NodePath): boolean {\n  return (\n    nodeIsRestElement(this.node) &&\n    this.parentPath &&\n    this.parentPath.isObjectExpression()\n  );\n}\n\nexport function isForAwaitStatement(this: NodePath): boolean {\n  return isForOfStatement(this.node, { await: true });\n}\n\nexport function isExistentialTypeParam(this: NodePath): void {\n  throw new Error(\n    \"`path.isExistentialTypeParam` has been renamed to `path.isExistsTypeAnnotation()` in Babel 7.\",\n  );\n}\n\nexport function isNumericLiteralTypeAnnotation(this: NodePath): void {\n  throw new Error(\n    \"`path.isNumericLiteralTypeAnnotation()` has been renamed to `path.isNumberLiteralTypeAnnotation()` in Babel 7.\",\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AACA;AAsBsB;EArBpBA,SAAS;EACTC,aAAa,EAAIC,iBAAiB;EAClCC,mBAAmB;EACnBC,YAAY,EAAIC,gBAAgB;EAChCC,MAAM,EAAIC,UAAU;EACpBC,cAAc;EACdC,eAAe;EACfC,YAAY;EACZC,mBAAmB;EACnBC,iBAAiB;EACjBC,eAAe;EACfC,qBAAqB;EACrBC,kBAAkB;EAClBC,aAAa,EAAIC,iBAAiB;EAClCC,YAAY,EAAIC,gBAAgB;EAChCC,OAAO,EAAIC,WAAW;EACtBC,WAAW,EAAIC,eAAe;EAC9BC,KAAK,EAAIC,SAAS;EAClBC,qBAAqB;EACrBC,KAAK;EACLC;AAAgB;AAGlB,MAAM;EAAEC;AAAY,CAAC,GAAGF,KAAK;AAkEtB,SAASG,sBAAsB,CAAiBC,IAAU,EAAW;EAC1E,MAAM;IAAEC,IAAI;IAAEC;EAAO,CAAC,GAAG,IAAI;EAC7B,IAAI,CAACvB,YAAY,CAACsB,IAAI,EAAED,IAAI,CAAC,IAAI,CAACjB,qBAAqB,CAACmB,MAAM,EAAEF,IAAI,CAAC,EAAE;IACrE,IAAIlB,eAAe,CAACmB,IAAI,EAAED,IAAI,CAAC,EAAE;MAC/B,IAAIF,WAAW,CAACG,IAAI,CAACE,IAAI,CAAC,EAAE,OAAO,KAAK;IAC1C,CAAC,MAAM;MAEL,OAAO,KAAK;IACd;EACF;;EAGA,OAAOf,gBAAgB,CAACa,IAAI,EAAEC,MAAM,EAAE,IAAI,CAACE,UAAU,CAACF,MAAM,CAAC;AAC/D;AAEO,SAASG,4BAA4B,GAA0B;EACpE,MAAM;IAAEJ,IAAI;IAAEC;EAAO,CAAC,GAAG,IAAI;EAC7B,OAAOlB,kBAAkB,CAACiB,IAAI,CAAC,IAAIb,gBAAgB,CAACa,IAAI,EAAEC,MAAM,CAAC;AACnE;AAEO,SAASI,mBAAmB,GAA0B;EAC3D,MAAM;IAAEL,IAAI;IAAEC;EAAO,CAAC,GAAG,IAAI;EAC7B,MAAMK,WAAW,GAAG,IAAI,CAACH,UAAU,CAACF,MAAM;EAC1C,OAAOvB,YAAY,CAACsB,IAAI,CAAC,IAAIhC,SAAS,CAACgC,IAAI,EAAEC,MAAM,EAAEK,WAAW,CAAC;AACnE;AAEO,SAAShB,WAAW,GAA0B;EACnD,MAAM;IAAEU,IAAI;IAAEC;EAAO,CAAC,GAAG,IAAI;EAC7B,IAAIV,eAAe,CAACS,IAAI,CAAC,EAAE;IACzB,IAAIN,qBAAqB,CAACM,IAAI,CAAC,EAAE;MAC/B,IAAIvB,eAAe,CAACwB,MAAM,EAAE;QAAEM,IAAI,EAAEP;MAAK,CAAC,CAAC,EAAE,OAAO,KAAK;MACzD,IAAIxB,cAAc,CAACyB,MAAM,EAAE;QAAEO,IAAI,EAAER;MAAK,CAAC,CAAC,EAAE,OAAO,KAAK;IAC1D;IAEA,OAAO,IAAI;EACb,CAAC,MAAM;IACL,OAAO,KAAK;EACd;AACF;AAEO,SAAS5B,YAAY,GAA0B;EACpD,IAAI,IAAI,CAACM,YAAY,EAAE,EAAE;IACvB,OAAO,IAAI,CAACoB,sBAAsB,EAAE;EACtC,CAAC,MAAM;IACL,OAAOzB,gBAAgB,CAAC,IAAI,CAAC2B,IAAI,CAAC;EACpC;AACF;AAEO,SAASZ,OAAO,GAA0B;EAC/C,OAAOC,WAAW,CAAC,IAAI,CAACW,IAAI,EAAE,IAAI,CAACC,MAAM,CAAC;AAC5C;AAEO,SAASf,YAAY,GAA0B;EACpD,OAAOC,gBAAgB,CAAC,IAAI,CAACa,IAAI,EAAE,IAAI,CAACC,MAAM,CAAC;AACjD;AAEO,SAAShC,aAAa,GAA0B;EACrD,OAAOC,iBAAiB,CAAC,IAAI,CAAC8B,IAAI,CAAC;AACrC;AAEO,SAASR,KAAK,GAA0B;EAC7C,OAAOC,SAAS,CAAC,IAAI,CAACO,IAAI,CAAC;AAC7B;AAEO,SAASS,MAAM,GAA0B;EAC9C,OAAO,IAAI,CAACT,IAAI,IAAI,CAAC,CAAC,IAAI,CAACA,IAAI,CAACU,GAAG;AACrC;AAEO,SAASC,WAAW,GAA0B;EACnD,OAAO,CAAC,IAAI,CAACF,MAAM,EAAE;AACvB;AAEO,SAASG,MAAM,CAAiBC,aAAuB,EAAW;EACvE,OAAO,IAAI,CAACC,KAAK,CAACF,MAAM,CAAC,IAAI,CAACZ,IAAI,EAAEa,aAAa,CAAC;AACpD;AAEO,SAASvC,MAAM,GAA0B;EAC9C,MAAM;IAAE0B;EAAK,CAAC,GAAG,IAAI;EACrB,IAAIzB,UAAU,CAACyB,IAAI,CAAC,EAAE;IACpB,OAAO,IAAI;EACb,CAAC,MAAM,IAAIrB,mBAAmB,CAACqB,IAAI,CAAC,EAAE;IACpC,OAAOA,IAAI,CAACe,UAAU,KAAK,MAAM,IAAIf,IAAI,CAACe,UAAU,KAAK,QAAQ;EACnE,CAAC,MAAM,IAAI5C,mBAAmB,CAAC6B,IAAI,CAAC,EAAE;IACpC,OAAOA,IAAI,CAACgB,UAAU,KAAK,MAAM;EACnC,CAAC,MAAM,IAAIpC,iBAAiB,CAACoB,IAAI,CAAC,EAAE;IAClC,OAAOA,IAAI,CAACe,UAAU,KAAK,MAAM,IAAIf,IAAI,CAACe,UAAU,KAAK,QAAQ;EACnE,CAAC,MAAM;IACL,OAAO,KAAK;EACd;AACF;;AAGO,SAASE,cAAc,GAA0B;EACtD,OACEhC,iBAAiB,CAAC,IAAI,CAACe,IAAI,CAAC,IAC5B,IAAI,CAACG,UAAU,IACf,IAAI,CAACA,UAAU,CAACe,eAAe,EAAE;AAErC;AAEO,SAASC,gBAAgB,GAA0B;EACxD,OACElC,iBAAiB,CAAC,IAAI,CAACe,IAAI,CAAC,IAC5B,IAAI,CAACG,UAAU,IACf,IAAI,CAACA,UAAU,CAACiB,kBAAkB,EAAE;AAExC;AAEO,SAASC,mBAAmB,GAA0B;EAC3D,OAAOzB,gBAAgB,CAAC,IAAI,CAACI,IAAI,EAAE;IAAEsB,KAAK,EAAE;EAAK,CAAC,CAAC;AACrD;AAEO,SAASC,sBAAsB,GAAuB;EAC3D,MAAM,IAAIC,KAAK,CACb,+FAA+F,CAChG;AACH;AAEO,SAASC,8BAA8B,GAAuB;EACnE,MAAM,IAAID,KAAK,CACb,gHAAgH,CACjH;AACH"}

package/lib/path/lib/virtual-types.js

@@ -29,6 +29,7 @@ exports.Generated = Generated;
 const Pure = null;
 exports.Pure = Pure;
 const Flow = ["Flow", "ImportDeclaration", "ExportDeclaration", "ImportSpecifier"];
+
 exports.Flow = Flow;
 const RestProperty = ["RestElement"];
 exports.RestProperty = RestProperty;

package/lib/path/lib/virtual-types.js.map

@@ -1 +1 @@
-{"version":3,"names":["ReferencedIdentifier","ReferencedMemberExpression","BindingIdentifier","Statement","Expression","Scope","Referenced","BlockScoped","Var","User","Generated","Pure","Flow","RestProperty","SpreadProperty","ExistentialTypeParam","NumericLiteralTypeAnnotation","ForAwaitStatement"],"sources":["../../../src/path/lib/virtual-types.ts"],"sourcesContent":["import type * as t from \"@babel/types\";\n\nexport interface VirtualTypeAliases {\n  BindingIdentifier: t.Identifier;\n  BlockScoped: t.Node;\n  ExistentialTypeParam: t.ExistsTypeAnnotation;\n  Expression: t.Expression;\n  Flow: t.Flow | t.ImportDeclaration | t.ExportDeclaration | t.ImportSpecifier;\n  ForAwaitStatement: t.ForOfStatement;\n  Generated: t.Node;\n  NumericLiteralTypeAnnotation: t.NumberLiteralTypeAnnotation;\n  Pure: t.Node;\n  Referenced: t.Node;\n  ReferencedIdentifier: t.Identifier | t.JSXIdentifier;\n  ReferencedMemberExpression: t.MemberExpression;\n  RestProperty: t.RestElement;\n  Scope: t.Scopable | t.Pattern;\n  SpreadProperty: t.RestElement;\n  Statement: t.Statement;\n  User: t.Node;\n  Var: t.VariableDeclaration;\n}\n\ntype VirtualTypeMapping = readonly (t.Node[\"type\"] | keyof t.Aliases)[] | null;\n\nexport const ReferencedIdentifier: VirtualTypeMapping = [\n  \"Identifier\",\n  \"JSXIdentifier\",\n] as const;\n\nexport const ReferencedMemberExpression: VirtualTypeMapping = [\n  \"MemberExpression\",\n] as const;\n\nexport const BindingIdentifier: VirtualTypeMapping = [\"Identifier\"] as const;\n\nexport const Statement: VirtualTypeMapping = [\"Statement\"] as const;\n\nexport const Expression: VirtualTypeMapping = [\"Expression\"] as const;\n\nexport const Scope: VirtualTypeMapping = [\"Scopable\", \"Pattern\"] as const;\n\nexport const Referenced: VirtualTypeMapping = null as null;\n\nexport const BlockScoped: VirtualTypeMapping = null as null;\n\nexport const Var: VirtualTypeMapping = [\"VariableDeclaration\"];\n\nexport const User: VirtualTypeMapping = null as null;\n\nexport const Generated: VirtualTypeMapping = null as null;\n\nexport const Pure: VirtualTypeMapping = null as null;\n\nexport const Flow: VirtualTypeMapping = [\n  \"Flow\",\n  \"ImportDeclaration\",\n  \"ExportDeclaration\",\n  \"ImportSpecifier\",\n] as const;\n\n// TODO: 7.0 Backwards Compat\nexport const RestProperty: VirtualTypeMapping = [\"RestElement\"] as const;\n\nexport const SpreadProperty: VirtualTypeMapping = [\"RestElement\"] as const;\n\nexport const ExistentialTypeParam: VirtualTypeMapping = [\n  \"ExistsTypeAnnotation\",\n] as const;\n\nexport const NumericLiteralTypeAnnotation: VirtualTypeMapping = [\n  \"NumberLiteralTypeAnnotation\",\n] as const;\n\nexport const ForAwaitStatement: VirtualTypeMapping = [\n  \"ForOfStatement\",\n] as const;\n"],"mappings":";;;;;;AAyBO,MAAMA,oBAAwC,GAAG,CACtD,YADsD,EAEtD,eAFsD,CAAjD;;AAKA,MAAMC,0BAA8C,GAAG,CAC5D,kBAD4D,CAAvD;;AAIA,MAAMC,iBAAqC,GAAG,CAAC,YAAD,CAA9C;;AAEA,MAAMC,SAA6B,GAAG,CAAC,WAAD,CAAtC;;AAEA,MAAMC,UAA8B,GAAG,CAAC,YAAD,CAAvC;;AAEA,MAAMC,KAAyB,GAAG,CAAC,UAAD,EAAa,SAAb,CAAlC;;AAEA,MAAMC,UAA8B,GAAG,IAAvC;;AAEA,MAAMC,WAA+B,GAAG,IAAxC;;AAEA,MAAMC,GAAuB,GAAG,CAAC,qBAAD,CAAhC;;AAEA,MAAMC,IAAwB,GAAG,IAAjC;;AAEA,MAAMC,SAA6B,GAAG,IAAtC;;AAEA,MAAMC,IAAwB,GAAG,IAAjC;;AAEA,MAAMC,IAAwB,GAAG,CACtC,MADsC,EAEtC,mBAFsC,EAGtC,mBAHsC,EAItC,iBAJsC,CAAjC;;AAQA,MAAMC,YAAgC,GAAG,CAAC,aAAD,CAAzC;;AAEA,MAAMC,cAAkC,GAAG,CAAC,aAAD,CAA3C;;AAEA,MAAMC,oBAAwC,GAAG,CACtD,sBADsD,CAAjD;;AAIA,MAAMC,4BAAgD,GAAG,CAC9D,6BAD8D,CAAzD;;AAIA,MAAMC,iBAAqC,GAAG,CACnD,gBADmD,CAA9C"}
+{"version":3,"names":["ReferencedIdentifier","ReferencedMemberExpression","BindingIdentifier","Statement","Expression","Scope","Referenced","BlockScoped","Var","User","Generated","Pure","Flow","RestProperty","SpreadProperty","ExistentialTypeParam","NumericLiteralTypeAnnotation","ForAwaitStatement"],"sources":["../../../src/path/lib/virtual-types.ts"],"sourcesContent":["import type * as t from \"@babel/types\";\n\nexport interface VirtualTypeAliases {\n  BindingIdentifier: t.Identifier;\n  BlockScoped: t.Node;\n  ExistentialTypeParam: t.ExistsTypeAnnotation;\n  Expression: t.Expression;\n  Flow: t.Flow | t.ImportDeclaration | t.ExportDeclaration | t.ImportSpecifier;\n  ForAwaitStatement: t.ForOfStatement;\n  Generated: t.Node;\n  NumericLiteralTypeAnnotation: t.NumberLiteralTypeAnnotation;\n  Pure: t.Node;\n  Referenced: t.Node;\n  ReferencedIdentifier: t.Identifier | t.JSXIdentifier;\n  ReferencedMemberExpression: t.MemberExpression;\n  RestProperty: t.RestElement;\n  Scope: t.Scopable | t.Pattern;\n  SpreadProperty: t.RestElement;\n  Statement: t.Statement;\n  User: t.Node;\n  Var: t.VariableDeclaration;\n}\n\ntype VirtualTypeMapping = readonly (t.Node[\"type\"] | keyof t.Aliases)[] | null;\n\nexport const ReferencedIdentifier: VirtualTypeMapping = [\n  \"Identifier\",\n  \"JSXIdentifier\",\n] as const;\n\nexport const ReferencedMemberExpression: VirtualTypeMapping = [\n  \"MemberExpression\",\n] as const;\n\nexport const BindingIdentifier: VirtualTypeMapping = [\"Identifier\"] as const;\n\nexport const Statement: VirtualTypeMapping = [\"Statement\"] as const;\n\nexport const Expression: VirtualTypeMapping = [\"Expression\"] as const;\n\nexport const Scope: VirtualTypeMapping = [\"Scopable\", \"Pattern\"] as const;\n\nexport const Referenced: VirtualTypeMapping = null as null;\n\nexport const BlockScoped: VirtualTypeMapping = null as null;\n\nexport const Var: VirtualTypeMapping = [\"VariableDeclaration\"];\n\nexport const User: VirtualTypeMapping = null as null;\n\nexport const Generated: VirtualTypeMapping = null as null;\n\nexport const Pure: VirtualTypeMapping = null as null;\n\nexport const Flow: VirtualTypeMapping = [\n  \"Flow\",\n  \"ImportDeclaration\",\n  \"ExportDeclaration\",\n  \"ImportSpecifier\",\n] as const;\n\n// TODO: 7.0 Backwards Compat\nexport const RestProperty: VirtualTypeMapping = [\"RestElement\"] as const;\n\nexport const SpreadProperty: VirtualTypeMapping = [\"RestElement\"] as const;\n\nexport const ExistentialTypeParam: VirtualTypeMapping = [\n  \"ExistsTypeAnnotation\",\n] as const;\n\nexport const NumericLiteralTypeAnnotation: VirtualTypeMapping = [\n  \"NumberLiteralTypeAnnotation\",\n] as const;\n\nexport const ForAwaitStatement: VirtualTypeMapping = [\n  \"ForOfStatement\",\n] as const;\n"],"mappings":";;;;;;AAyBO,MAAMA,oBAAwC,GAAG,CACtD,YAAY,EACZ,eAAe,CACP;AAAC;AAEJ,MAAMC,0BAA8C,GAAG,CAC5D,kBAAkB,CACV;AAAC;AAEJ,MAAMC,iBAAqC,GAAG,CAAC,YAAY,CAAU;AAAC;AAEtE,MAAMC,SAA6B,GAAG,CAAC,WAAW,CAAU;AAAC;AAE7D,MAAMC,UAA8B,GAAG,CAAC,YAAY,CAAU;AAAC;AAE/D,MAAMC,KAAyB,GAAG,CAAC,UAAU,EAAE,SAAS,CAAU;AAAC;AAEnE,MAAMC,UAA8B,GAAG,IAAY;AAAC;AAEpD,MAAMC,WAA+B,GAAG,IAAY;AAAC;AAErD,MAAMC,GAAuB,GAAG,CAAC,qBAAqB,CAAC;AAAC;AAExD,MAAMC,IAAwB,GAAG,IAAY;AAAC;AAE9C,MAAMC,SAA6B,GAAG,IAAY;AAAC;AAEnD,MAAMC,IAAwB,GAAG,IAAY;AAAC;AAE9C,MAAMC,IAAwB,GAAG,CACtC,MAAM,EACN,mBAAmB,EACnB,mBAAmB,EACnB,iBAAiB,CACT;;AAAC;AAGJ,MAAMC,YAAgC,GAAG,CAAC,aAAa,CAAU;AAAC;AAElE,MAAMC,cAAkC,GAAG,CAAC,aAAa,CAAU;AAAC;AAEpE,MAAMC,oBAAwC,GAAG,CACtD,sBAAsB,CACd;AAAC;AAEJ,MAAMC,4BAAgD,GAAG,CAC9D,6BAA6B,CACrB;AAAC;AAEJ,MAAMC,iBAAqC,GAAG,CACnD,gBAAgB,CACR;AAAC"}

package/lib/path/modification.js

@@ -13,15 +13,10 @@ exports.insertBefore = insertBefore;
 exports.pushContainer = pushContainer;
 exports.unshiftContainer = unshiftContainer;
 exports.updateSiblingKeys = updateSiblingKeys;
-
 var _cache = require("../cache");
-
 var _hoister = require("./lib/hoister");
-
 var _index = require("./index");
-
 var _t = require("@babel/types");
-
 const {
   arrowFunctionExpression,
   assertExpression,
@@ -41,13 +36,10 @@ const {
 
 function insertBefore(nodes_) {
   this._assertUnremoved();
-
   const nodes = this._verifyNodeList(nodes_);
-
   const {
     parentPath
   } = this;
-
   if (parentPath.isExpressionStatement() || parentPath.isLabeledStatement() || parentPath.isExportNamedDeclaration() || parentPath.isExportDefaultDeclaration() && this.isDeclaration()) {
     return parentPath.insertBefore(nodes);
   } else if (this.isNodeType("Expression") && !this.isJSXElement() || parentPath.isForStatement() && this.key === "init") {
@@ -59,77 +51,64 @@ function insertBefore(nodes_) {
     const node = this.node;
     const shouldInsertCurrentNode = node && (!this.isExpressionStatement() || node.expression != null);
     this.replaceWith(blockStatement(shouldInsertCurrentNode ? [node] : []));
-    return this.unshiftContainer("body", nodes);
+    return this.unshiftContainer("body",
+    nodes);
   } else {
     throw new Error("We don't know what to do with this node type. " + "We were previously a Statement but we can't fit in here?");
   }
 }
-
 function _containerInsert(from, nodes) {
   this.updateSiblingKeys(from, nodes.length);
   const paths = [];
-  this.container.splice(from, 0, ...nodes);
 
+  this.container.splice(from, 0, ...nodes);
   for (let i = 0; i < nodes.length; i++) {
     const to = from + i;
     const path = this.getSibling(to);
     paths.push(path);
-
     if (this.context && this.context.queue) {
       path.pushContext(this.context);
     }
   }
-
   const contexts = this._getQueueContexts();
-
   for (const path of paths) {
     path.setScope();
     path.debug("Inserted.");
-
     for (const context of contexts) {
       context.maybeQueue(path, true);
     }
   }
-
   return paths;
 }
-
 function _containerInsertBefore(nodes) {
   return this._containerInsert(this.key, nodes);
 }
-
 function _containerInsertAfter(nodes) {
   return this._containerInsert(this.key + 1, nodes);
 }
-
 const last = arr => arr[arr.length - 1];
-
 function isHiddenInSequenceExpression(path) {
   return isSequenceExpression(path.parent) && (last(path.parent.expressions) !== path.node || isHiddenInSequenceExpression(path.parentPath));
 }
-
 function isAlmostConstantAssignment(node, scope) {
   if (!isAssignmentExpression(node) || !isIdentifier(node.left)) {
     return false;
   }
 
   const blockScope = scope.getBlockParent();
+
   return blockScope.hasOwnBinding(node.left.name) && blockScope.getOwnBinding(node.left.name).constantViolations.length <= 1;
 }
 
 function insertAfter(nodes_) {
   this._assertUnremoved();
-
   if (this.isSequenceExpression()) {
     return last(this.get("expressions")).insertAfter(nodes_);
   }
-
   const nodes = this._verifyNodeList(nodes_);
-
   const {
     parentPath
   } = this;
-
   if (parentPath.isExpressionStatement() || parentPath.isLabeledStatement() || parentPath.isExportNamedDeclaration() || parentPath.isExportDefaultDeclaration() && this.isDeclaration()) {
     return parentPath.insertAfter(nodes.map(node => {
       return isExpression(node) ? expressionStatement(node) : node;
@@ -140,17 +119,16 @@ function insertAfter(nodes_) {
       let {
         scope
       } = this;
-
       if (scope.path.isPattern()) {
         assertExpression(node);
         this.replaceWith(callExpression(arrowFunctionExpression([], node), []));
         this.get("callee.body").insertAfter(nodes);
         return [this];
       }
-
       if (isHiddenInSequenceExpression(this)) {
         nodes.unshift(node);
-      } else if (isCallExpression(node) && isSuper(node.callee)) {
+      }
+      else if (isCallExpression(node) && isSuper(node.callee)) {
         nodes.unshift(node);
         nodes.push(thisExpression());
       } else if (isAlmostConstantAssignment(node, scope)) {
@@ -165,13 +143,12 @@ function insertAfter(nodes_) {
         })) {
           scope = scope.parent;
         }
-
         const temp = scope.generateDeclaredUidIdentifier();
-        nodes.unshift(expressionStatement(assignmentExpression("=", cloneNode(temp), node)));
+        nodes.unshift(expressionStatement(
+        assignmentExpression("=", cloneNode(temp), node)));
         nodes.push(expressionStatement(cloneNode(temp)));
       }
     }
-
     return this.replaceExpressionWithStatements(nodes);
   } else if (Array.isArray(this.container)) {
     return this._containerInsertAfter(nodes);
@@ -187,29 +164,23 @@ function insertAfter(nodes_) {
 
 function updateSiblingKeys(fromIndex, incrementBy) {
   if (!this.parent) return;
-
   const paths = _cache.path.get(this.parent);
-
   for (const [, path] of paths) {
     if (path.key >= fromIndex) {
       path.key += incrementBy;
     }
   }
 }
-
 function _verifyNodeList(nodes) {
   if (!nodes) {
     return [];
   }
-
   if (!Array.isArray(nodes)) {
     nodes = [nodes];
   }
-
   for (let i = 0; i < nodes.length; i++) {
     const node = nodes[i];
     let msg;
-
     if (!node) {
       msg = "has falsy node";
     } else if (typeof node !== "object") {
@@ -219,16 +190,13 @@ function _verifyNodeList(nodes) {
     } else if (node instanceof _index.default) {
       msg = "has a NodePath when it expected a raw object";
     }
-
     if (msg) {
       const type = Array.isArray(node) ? "array" : typeof node;
       throw new Error(`Node list ${msg} with the index of ${i} and type of ${type}`);
     }
   }
-
   return nodes;
 }
-
 function unshiftContainer(listKey, nodes) {
   this._assertUnremoved();
 
@@ -241,17 +209,15 @@ function unshiftContainer(listKey, nodes) {
     listKey,
     key: 0
   }).setContext(this.context);
-
-  return path._containerInsertBefore(nodes);
+  return path._containerInsertBefore(
+  nodes);
 }
-
 function pushContainer(listKey, nodes) {
   this._assertUnremoved();
-
-  const verifiedNodes = this._verifyNodeList(nodes);
+  const verifiedNodes = this._verifyNodeList(
+  nodes);
 
   const container = this.node[listKey];
-
   const path = _index.default.get({
     parentPath: this,
     parent: this.node,
@@ -259,7 +225,6 @@ function pushContainer(listKey, nodes) {
     listKey,
     key: container.length
   }).setContext(this.context);
-
   return path.replaceWithMultiple(verifiedNodes);
 }