@babel/traverse 8.0.0-alpha.2 → 8.0.0-alpha.4

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

@@ -1,31 +0,0 @@
-export 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;
-  }
-}, function (self, parent) {
-  if (parent.isSequenceExpression() && parent.node.expressions.length === 1) {
-    parent.replaceWith(parent.node.expressions[0]);
-    return true;
-  }
-}, function (self, parent) {
-  if (parent.isBinary()) {
-    if (self.key === "left") {
-      parent.replaceWith(parent.node.right);
-    } else {
-      parent.replaceWith(parent.node.left);
-    }
-    return true;
-  }
-}, function (self, parent) {
-  if (parent.isIfStatement() && self.key === "consequent" || self.key === "body" && (parent.isLoop() || parent.isArrowFunctionExpression())) {
-    self.replaceWith({
-      type: "BlockStatement",
-      body: []
-    });
-    return true;
-  }
-}];
-
-//# sourceMappingURL=removal-hooks.js.map

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

@@ -1 +0,0 @@
-{"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":"AAQA,OAAO,MAAMA,KAAK,GAAG,CACnB,UAAUC,IAAc,EAAEC,MAAgB,EAAE;EAC1C,MAAMC,YAAY,GAKfF,IAAI,CAACG,GAAG,KAAK,MAAM,KAAKF,MAAM,CAACG,OAAO,CAAC,CAAC,IAAIH,MAAM,CAACI,YAAY,CAAC,CAAC,CAAC,IAGlEL,IAAI,CAACG,GAAG,KAAK,aAAa,IAAIF,MAAM,CAACK,mBAAmB,CAAC,CAAE,IAG3DN,IAAI,CAACG,GAAG,KAAK,MAAM,IAAIF,MAAM,CAACM,kBAAkB,CAAC,CAAE,IAGnDP,IAAI,CAACQ,OAAO,KAAK,cAAc,IAC9BP,MAAM,CAACQ,qBAAqB,CAAC,CAAC,IAC9BR,MAAM,CAACS,IAAI,CAACC,YAAY,CAACC,MAAM,KAAK,CAAE,IAGvCZ,IAAI,CAACG,GAAG,KAAK,YAAY,IAAIF,MAAM,CAACY,qBAAqB,CAAC,CAAE;EAE/D,IAAIX,YAAY,EAAE;IAChBD,MAAM,CAACa,MAAM,CAAC,CAAC;IACf,OAAO,IAAI;EACb;AACF,CAAC,EAED,UAAUd,IAAc,EAAEC,MAAgB,EAAE;EAC1C,IAAIA,MAAM,CAACc,oBAAoB,CAAC,CAAC,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,CAAC,CAAC,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,CAAC,CAAC,IAAIrB,IAAI,CAACG,GAAG,KAAK,YAAY,IACnDH,IAAI,CAACG,GAAG,KAAK,MAAM,KACjBF,MAAM,CAACqB,MAAM,CAAC,CAAC,IAAIrB,MAAM,CAACsB,yBAAyB,CAAC,CAAC,CAAE,EAC1D;IACAvB,IAAI,CAACiB,WAAW,CAAC;MACfO,IAAI,EAAE,gBAAgB;MACtBC,IAAI,EAAE;IACR,CAAqB,CAAC;IACtB,OAAO,IAAI;EACb;AACF,CAAC,CACF"}

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

@@ -1,133 +0,0 @@
-import * as _t from "@babel/types";
-const {
-  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
-} = _t;
-const {
-  isCompatTag
-} = react;
-export function isReferencedIdentifier(opts) {
-  const {
-    node,
-    parent
-  } = this;
-  if (!isIdentifier(node, opts) && !isJSXMemberExpression(parent, opts)) {
-    if (isJSXIdentifier(node, opts)) {
-      if (isCompatTag(node.name)) return false;
-    } else {
-      return false;
-    }
-  }
-  return nodeIsReferenced(node, parent, this.parentPath.parent);
-}
-export function isReferencedMemberExpression() {
-  const {
-    node,
-    parent
-  } = this;
-  return isMemberExpression(node) && nodeIsReferenced(node, parent);
-}
-export function isBindingIdentifier() {
-  const {
-    node,
-    parent
-  } = this;
-  const grandparent = this.parentPath.parent;
-  return isIdentifier(node) && isBinding(node, parent, grandparent);
-}
-export function isStatement() {
-  const {
-    node,
-    parent
-  } = this;
-  if (nodeIsStatement(node)) {
-    if (isVariableDeclaration(node)) {
-      if (isForXStatement(parent, {
-        left: node
-      })) return false;
-      if (isForStatement(parent, {
-        init: node
-      })) return false;
-    }
-    return true;
-  } else {
-    return false;
-  }
-}
-export function isExpression() {
-  if (this.isIdentifier()) {
-    return this.isReferencedIdentifier();
-  } else {
-    return nodeIsExpression(this.node);
-  }
-}
-export function isScope() {
-  return nodeIsScope(this.node, this.parent);
-}
-export function isReferenced() {
-  return nodeIsReferenced(this.node, this.parent);
-}
-export function isBlockScoped() {
-  return nodeIsBlockScoped(this.node);
-}
-export function isVar() {
-  return nodeIsVar(this.node);
-}
-export function isUser() {
-  return this.node && !!this.node.loc;
-}
-export function isGenerated() {
-  return !this.isUser();
-}
-export function isPure(constantsOnly) {
-  return this.scope.isPure(this.node, constantsOnly);
-}
-export function isFlow() {
-  const {
-    node
-  } = this;
-  if (nodeIsFlow(node)) {
-    return true;
-  } else if (isImportDeclaration(node)) {
-    return node.importKind === "type" || node.importKind === "typeof";
-  } else if (isExportDeclaration(node)) {
-    return node.exportKind === "type";
-  } else if (isImportSpecifier(node)) {
-    return node.importKind === "type" || node.importKind === "typeof";
-  } else {
-    return false;
-  }
-}
-export function isRestProperty() {
-  return nodeIsRestElement(this.node) && this.parentPath && this.parentPath.isObjectPattern();
-}
-export function isSpreadProperty() {
-  return nodeIsRestElement(this.node) && this.parentPath && this.parentPath.isObjectExpression();
-}
-export function isForAwaitStatement() {
-  return isForOfStatement(this.node, {
-    await: true
-  });
-}
-;
-
-//# sourceMappingURL=virtual-types-validator.js.map

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

@@ -1 +0,0 @@
-{"version":3,"names":["_t","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"],"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\ntype Opts<Obj> = Partial<{\n  [Prop in keyof Obj]: Obj[Prop] extends t.Node\n    ? t.Node\n    : Obj[Prop] extends t.Node[]\n    ? t.Node[]\n    : Obj[Prop];\n}>;\n\nexport interface VirtualTypeNodePathValidators {\n  isBindingIdentifier<T extends t.Node>(\n    this: NodePath<T>,\n    opts?: Opts<VirtualTypeAliases[\"BindingIdentifier\"]>,\n  ): this is NodePath<T & VirtualTypeAliases[\"BindingIdentifier\"]>;\n  isBlockScoped(opts?: Opts<VirtualTypeAliases[\"BlockScoped\"]>): boolean;\n  /**\n   * @deprecated\n   */\n  isExistentialTypeParam<T extends t.Node>(\n    this: NodePath<T>,\n    opts?: Opts<VirtualTypeAliases[\"ExistentialTypeParam\"]>,\n  ): this is NodePath<T & VirtualTypeAliases[\"ExistentialTypeParam\"]>;\n  isExpression<T extends t.Node>(\n    this: NodePath<T>,\n    opts?: Opts<VirtualTypeAliases[\"Expression\"]>,\n  ): this is NodePath<T & t.Expression>;\n  isFlow<T extends t.Node>(\n    this: NodePath<T>,\n    opts?: Opts<VirtualTypeAliases[\"Flow\"]>,\n  ): this is NodePath<T & t.Flow>;\n  isForAwaitStatement<T extends t.Node>(\n    this: NodePath<T>,\n    opts?: Opts<VirtualTypeAliases[\"ForAwaitStatement\"]>,\n  ): this is NodePath<T & VirtualTypeAliases[\"ForAwaitStatement\"]>;\n  isGenerated(opts?: VirtualTypeAliases[\"Generated\"]): boolean;\n  /**\n   * @deprecated\n   */\n  isNumericLiteralTypeAnnotation(\n    opts?: VirtualTypeAliases[\"NumericLiteralTypeAnnotation\"],\n  ): void;\n  isPure(opts?: VirtualTypeAliases[\"Pure\"]): boolean;\n  isReferenced(opts?: VirtualTypeAliases[\"Referenced\"]): boolean;\n  isReferencedIdentifier<T extends t.Node>(\n    this: NodePath<T>,\n    opts?: Opts<VirtualTypeAliases[\"ReferencedIdentifier\"]>,\n  ): this is NodePath<T & VirtualTypeAliases[\"ReferencedIdentifier\"]>;\n  isReferencedMemberExpression<T extends t.Node>(\n    this: NodePath<T>,\n    opts?: Opts<VirtualTypeAliases[\"ReferencedMemberExpression\"]>,\n  ): this is NodePath<T & VirtualTypeAliases[\"ReferencedMemberExpression\"]>;\n  isRestProperty<T extends t.Node>(\n    this: NodePath<T>,\n    opts?: Opts<VirtualTypeAliases[\"RestProperty\"]>,\n  ): this is NodePath<T & t.RestProperty>;\n  isScope<T extends t.Node>(\n    this: NodePath<T>,\n    opts?: Opts<VirtualTypeAliases[\"Scope\"]>,\n  ): this is NodePath<T & VirtualTypeAliases[\"Scope\"]>;\n  isSpreadProperty<T extends t.Node>(\n    this: NodePath<T>,\n    opts?: Opts<VirtualTypeAliases[\"SpreadProperty\"]>,\n  ): this is NodePath<T & t.SpreadProperty>;\n  isStatement<T extends t.Node>(\n    this: NodePath<T>,\n    opts?: Opts<VirtualTypeAliases[\"Statement\"]>,\n  ): this is NodePath<T & t.Statement>;\n  isUser(opts?: VirtualTypeAliases[\"User\"]): boolean;\n  isVar<T extends t.Node>(\n    this: NodePath<T>,\n    opts?: Opts<VirtualTypeAliases[\"Var\"]>,\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\nif (!process.env.BABEL_8_BREAKING) {\n  if (!USE_ESM) {\n    // eslint-disable-next-line no-restricted-globals\n    exports.isExistentialTypeParam = function isExistentialTypeParam(\n      this: NodePath,\n    ): void {\n      throw new Error(\n        \"`path.isExistentialTypeParam` has been renamed to `path.isExistsTypeAnnotation()` in Babel 7.\",\n      );\n    };\n\n    // eslint-disable-next-line no-restricted-globals\n    exports.isNumericLiteralTypeAnnotation =\n      function isNumericLiteralTypeAnnotation(this: NodePath): void {\n        throw new Error(\n          \"`path.isNumericLiteralTypeAnnotation()` has been renamed to `path.isNumberLiteralTypeAnnotation()` in Babel 7.\",\n        );\n      };\n  }\n}\n"],"mappings":"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"}

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

@@ -1,20 +0,0 @@
-export const ReferencedIdentifier = ["Identifier", "JSXIdentifier"];
-export const ReferencedMemberExpression = ["MemberExpression"];
-export const BindingIdentifier = ["Identifier"];
-export const Statement = ["Statement"];
-export const Expression = ["Expression"];
-export const Scope = ["Scopable", "Pattern"];
-export const Referenced = null;
-export const BlockScoped = null;
-export const Var = ["VariableDeclaration"];
-export const User = null;
-export const Generated = null;
-export const Pure = null;
-export const Flow = ["Flow", "ImportDeclaration", "ExportDeclaration", "ImportSpecifier"];
-export const RestProperty = ["RestElement"];
-export const SpreadProperty = ["RestElement"];
-export const ExistentialTypeParam = ["ExistsTypeAnnotation"];
-export const NumericLiteralTypeAnnotation = ["NumberLiteralTypeAnnotation"];
-export const ForAwaitStatement = ["ForOfStatement"];
-
-//# sourceMappingURL=virtual-types.js.map

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

@@ -1 +0,0 @@
-{"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;\n\nexport const BlockScoped: VirtualTypeMapping = null;\n\nexport const Var: VirtualTypeMapping = [\"VariableDeclaration\"];\n\nexport const User: VirtualTypeMapping = null;\n\nexport const Generated: VirtualTypeMapping = null;\n\nexport const Pure: VirtualTypeMapping = 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":"AAyBA,OAAO,MAAMA,oBAAwC,GAAG,CACtD,YAAY,EACZ,eAAe,CACP;AAEV,OAAO,MAAMC,0BAA8C,GAAG,CAC5D,kBAAkB,CACV;AAEV,OAAO,MAAMC,iBAAqC,GAAG,CAAC,YAAY,CAAU;AAE5E,OAAO,MAAMC,SAA6B,GAAG,CAAC,WAAW,CAAU;AAEnE,OAAO,MAAMC,UAA8B,GAAG,CAAC,YAAY,CAAU;AAErE,OAAO,MAAMC,KAAyB,GAAG,CAAC,UAAU,EAAE,SAAS,CAAU;AAEzE,OAAO,MAAMC,UAA8B,GAAG,IAAI;AAElD,OAAO,MAAMC,WAA+B,GAAG,IAAI;AAEnD,OAAO,MAAMC,GAAuB,GAAG,CAAC,qBAAqB,CAAC;AAE9D,OAAO,MAAMC,IAAwB,GAAG,IAAI;AAE5C,OAAO,MAAMC,SAA6B,GAAG,IAAI;AAEjD,OAAO,MAAMC,IAAwB,GAAG,IAAI;AAE5C,OAAO,MAAMC,IAAwB,GAAG,CACtC,MAAM,EACN,mBAAmB,EACnB,mBAAmB,EACnB,iBAAiB,CACT;AAGV,OAAO,MAAMC,YAAgC,GAAG,CAAC,aAAa,CAAU;AAExE,OAAO,MAAMC,cAAkC,GAAG,CAAC,aAAa,CAAU;AAE1E,OAAO,MAAMC,oBAAwC,GAAG,CACtD,sBAAsB,CACd;AAEV,OAAO,MAAMC,4BAAgD,GAAG,CAC9D,6BAA6B,CACrB;AAEV,OAAO,MAAMC,iBAAqC,GAAG,CACnD,gBAAgB,CACR"}

package/lib/path/modification.js

@@ -1,209 +0,0 @@
-import { getCachedPaths } from "../cache.js";
-import PathHoister from "./lib/hoister.js";
-import NodePath from "./index.js";
-import * as _t from "@babel/types";
-const {
-  arrowFunctionExpression,
-  assertExpression,
-  assignmentExpression,
-  blockStatement,
-  callExpression,
-  cloneNode,
-  expressionStatement,
-  isAssignmentExpression,
-  isCallExpression,
-  isExportNamedDeclaration,
-  isExpression,
-  isIdentifier,
-  isSequenceExpression,
-  isSuper,
-  thisExpression
-} = _t;
-export function insertBefore(nodes_) {
-  this._assertUnremoved();
-  const nodes = this._verifyNodeList(nodes_);
-  const {
-    parentPath,
-    parent
-  } = this;
-  if (parentPath.isExpressionStatement() || parentPath.isLabeledStatement() || isExportNamedDeclaration(parent) || parentPath.isExportDefaultDeclaration() && this.isDeclaration()) {
-    return parentPath.insertBefore(nodes);
-  } else if (this.isNodeType("Expression") && !this.isJSXElement() || parentPath.isForStatement() && this.key === "init") {
-    if (this.node) nodes.push(this.node);
-    return this.replaceExpressionWithStatements(nodes);
-  } else if (Array.isArray(this.container)) {
-    return this._containerInsertBefore(nodes);
-  } else if (this.isStatementOrBlock()) {
-    const node = this.node;
-    const shouldInsertCurrentNode = node && (!this.isExpressionStatement() || node.expression != null);
-    this.replaceWith(blockStatement(shouldInsertCurrentNode ? [node] : []));
-    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?");
-  }
-}
-export function _containerInsert(from, nodes) {
-  this.updateSiblingKeys(from, nodes.length);
-  const paths = [];
-  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?.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;
-}
-export function _containerInsertBefore(nodes) {
-  return this._containerInsert(this.key, nodes);
-}
-export 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;
-}
-export function insertAfter(nodes_) {
-  this._assertUnremoved();
-  if (this.isSequenceExpression()) {
-    return last(this.get("expressions")).insertAfter(nodes_);
-  }
-  const nodes = this._verifyNodeList(nodes_);
-  const {
-    parentPath,
-    parent
-  } = this;
-  if (parentPath.isExpressionStatement() || parentPath.isLabeledStatement() || isExportNamedDeclaration(parent) || parentPath.isExportDefaultDeclaration() && this.isDeclaration()) {
-    return parentPath.insertAfter(nodes.map(node => {
-      return isExpression(node) ? expressionStatement(node) : node;
-    }));
-  } else if (this.isNodeType("Expression") && !this.isJSXElement() && !parentPath.isJSXElement() || parentPath.isForStatement() && this.key === "init") {
-    if (this.node) {
-      const node = this.node;
-      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)) {
-        nodes.unshift(node);
-        nodes.push(thisExpression());
-      } else if (isAlmostConstantAssignment(node, scope)) {
-        nodes.unshift(node);
-        nodes.push(cloneNode(node.left));
-      } else if (scope.isPure(node, true)) {
-        nodes.push(node);
-      } else {
-        if (parentPath.isMethod({
-          computed: true,
-          key: node
-        })) {
-          scope = scope.parent;
-        }
-        const temp = scope.generateDeclaredUidIdentifier();
-        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);
-  } else if (this.isStatementOrBlock()) {
-    const node = this.node;
-    const shouldInsertCurrentNode = node && (!this.isExpressionStatement() || node.expression != null);
-    this.replaceWith(blockStatement(shouldInsertCurrentNode ? [node] : []));
-    return this.pushContainer("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?");
-  }
-}
-export function updateSiblingKeys(fromIndex, incrementBy) {
-  if (!this.parent) return;
-  const paths = getCachedPaths(this.hub, this.parent) || [];
-  for (const [, path] of paths) {
-    if (typeof path.key === "number" && path.key >= fromIndex) {
-      path.key += incrementBy;
-    }
-  }
-}
-export 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") {
-      msg = "contains a non-object node";
-    } else if (!node.type) {
-      msg = "without a type";
-    } else if (node instanceof NodePath) {
-      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;
-}
-export function unshiftContainer(listKey, nodes) {
-  this._assertUnremoved();
-  nodes = this._verifyNodeList(nodes);
-  const path = NodePath.get({
-    parentPath: this,
-    parent: this.node,
-    container: this.node[listKey],
-    listKey,
-    key: 0
-  }).setContext(this.context);
-  return path._containerInsertBefore(nodes);
-}
-export function pushContainer(listKey, nodes) {
-  this._assertUnremoved();
-  const verifiedNodes = this._verifyNodeList(nodes);
-  const container = this.node[listKey];
-  const path = NodePath.get({
-    parentPath: this,
-    parent: this.node,
-    container: container,
-    listKey,
-    key: container.length
-  }).setContext(this.context);
-  return path.replaceWithMultiple(verifiedNodes);
-}
-export function hoist(scope = this.scope) {
-  const hoister = new PathHoister(this, scope);
-  return hoister.run();
-}
-
-//# sourceMappingURL=modification.js.map

package/lib/path/modification.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["getCachedPaths","PathHoister","NodePath","_t","arrowFunctionExpression","assertExpression","assignmentExpression","blockStatement","callExpression","cloneNode","expressionStatement","isAssignmentExpression","isCallExpression","isExportNamedDeclaration","isExpression","isIdentifier","isSequenceExpression","isSuper","thisExpression","insertBefore","nodes_","_assertUnremoved","nodes","_verifyNodeList","parentPath","parent","isExpressionStatement","isLabeledStatement","isExportDefaultDeclaration","isDeclaration","isNodeType","isJSXElement","isForStatement","key","node","push","replaceExpressionWithStatements","Array","isArray","container","_containerInsertBefore","isStatementOrBlock","shouldInsertCurrentNode","expression","replaceWith","unshiftContainer","Error","_containerInsert","from","updateSiblingKeys","length","paths","splice","i","to","path","getSibling","context","queue","pushContext","contexts","_getQueueContexts","setScope","debug","maybeQueue","_containerInsertAfter","last","arr","isHiddenInSequenceExpression","expressions","isAlmostConstantAssignment","scope","left","blockScope","getBlockParent","hasOwnBinding","name","getOwnBinding","constantViolations","insertAfter","get","map","isPattern","unshift","callee","isPure","isMethod","computed","temp","generateDeclaredUidIdentifier","pushContainer","fromIndex","incrementBy","hub","msg","type","listKey","setContext","verifiedNodes","replaceWithMultiple","hoist","hoister","run"],"sources":["../../src/path/modification.ts"],"sourcesContent":["// This file contains methods that modify the path/node in some ways.\n\nimport { getCachedPaths } from \"../cache\";\nimport PathHoister from \"./lib/hoister\";\nimport NodePath from \"./index\";\nimport {\n  arrowFunctionExpression,\n  assertExpression,\n  assignmentExpression,\n  blockStatement,\n  callExpression,\n  cloneNode,\n  expressionStatement,\n  isAssignmentExpression,\n  isCallExpression,\n  isExportNamedDeclaration,\n  isExpression,\n  isIdentifier,\n  isSequenceExpression,\n  isSuper,\n  thisExpression,\n} from \"@babel/types\";\nimport type * as t from \"@babel/types\";\nimport type Scope from \"../scope\";\n\n/**\n * Insert the provided nodes before the current one.\n */\n\nexport function insertBefore(\n  this: NodePath,\n  nodes_: t.Node | t.Node[],\n): NodePath[] {\n  this._assertUnremoved();\n\n  const nodes = this._verifyNodeList(nodes_);\n\n  const { parentPath, parent } = this;\n\n  if (\n    parentPath.isExpressionStatement() ||\n    parentPath.isLabeledStatement() ||\n    // https://github.com/babel/babel/issues/15293\n    // When Babel transforms `export class String { field }`, the class properties plugin will inject the defineProperty\n    // helper, which depends on the builtins e.g. String, Number, Symbol, etc. To prevent them from being shadowed by local\n    // exports, the helper injector replaces the named export into `class _String { field }; export { _String as String }`,\n    // with `parentPath` here changed to the moved ClassDeclaration, causing rare inconsistency between `parent` and `parentPath`.\n    // Here we retrieve the parent type from the `parent` property. This is a temporary fix and we should revisit when\n    // helpers should get injected.\n    isExportNamedDeclaration(parent) ||\n    (parentPath.isExportDefaultDeclaration() && this.isDeclaration())\n  ) {\n    return parentPath.insertBefore(nodes);\n  } else if (\n    (this.isNodeType(\"Expression\") && !this.isJSXElement()) ||\n    (parentPath.isForStatement() && this.key === \"init\")\n  ) {\n    if (this.node) nodes.push(this.node);\n    // @ts-expect-error todo(flow->ts): check that nodes is an array of statements\n    return this.replaceExpressionWithStatements(nodes);\n  } else if (Array.isArray(this.container)) {\n    return this._containerInsertBefore(nodes);\n  } else if (this.isStatementOrBlock()) {\n    const node = this.node as t.Statement;\n    const shouldInsertCurrentNode =\n      node &&\n      (!this.isExpressionStatement() ||\n        (node as t.ExpressionStatement).expression != null);\n\n    this.replaceWith(blockStatement(shouldInsertCurrentNode ? [node] : []));\n    return (this as NodePath<t.BlockStatement>).unshiftContainer(\n      \"body\",\n      // @ts-expect-error Fixme: refine nodes to t.BlockStatement[\"body\"] when this is a BlockStatement path\n      nodes,\n    );\n  } else {\n    throw new Error(\n      \"We don't know what to do with this node type. \" +\n        \"We were previously a Statement but we can't fit in here?\",\n    );\n  }\n}\n\nexport function _containerInsert<N extends t.Node>(\n  this: NodePath,\n  from: number,\n  nodes: N[],\n): NodePath<N>[] {\n  this.updateSiblingKeys(from, nodes.length);\n\n  const paths: NodePath<N>[] = [];\n\n  // @ts-expect-error todo(flow->ts): this.container could be a NodePath\n  this.container.splice(from, 0, ...nodes);\n  for (let i = 0; i < nodes.length; i++) {\n    const to = from + i;\n    const path = this.getSibling(to) as NodePath<N>;\n    paths.push(path);\n\n    if (this.context?.queue) {\n      path.pushContext(this.context);\n    }\n  }\n\n  const contexts = this._getQueueContexts();\n\n  for (const path of paths) {\n    path.setScope();\n    path.debug(\"Inserted.\");\n\n    for (const context of contexts) {\n      context.maybeQueue(path, true);\n    }\n  }\n\n  return paths;\n}\n\nexport function _containerInsertBefore<N extends t.Node>(\n  this: NodePath,\n  nodes: N[],\n) {\n  return this._containerInsert(this.key as number, nodes);\n}\n\nexport function _containerInsertAfter<N extends t.Node>(\n  this: NodePath,\n  nodes: N[],\n) {\n  return this._containerInsert((this.key as number) + 1, nodes);\n}\n\nconst last = <T>(arr: T[]) => arr[arr.length - 1];\n\nfunction isHiddenInSequenceExpression(path: NodePath): boolean {\n  return (\n    isSequenceExpression(path.parent) &&\n    (last(path.parent.expressions) !== path.node ||\n      isHiddenInSequenceExpression(path.parentPath))\n  );\n}\n\nfunction isAlmostConstantAssignment(\n  node: t.Node,\n  scope: Scope,\n): node is t.AssignmentExpression & { left: t.Identifier } {\n  if (!isAssignmentExpression(node) || !isIdentifier(node.left)) {\n    return false;\n  }\n\n  // Not every scope can contain variables. For example, we might be in\n  // a ClassScope either in the ClassHeritage or in a computed key.\n  const blockScope = scope.getBlockParent();\n\n  // If the variable is defined in the current scope and only assigned here,\n  // we can be sure that its value won't change.\n  return (\n    blockScope.hasOwnBinding(node.left.name) &&\n    blockScope.getOwnBinding(node.left.name).constantViolations.length <= 1\n  );\n}\n\n/**\n * Insert the provided nodes after the current one. When inserting nodes after an\n * expression, ensure that the completion record is correct by pushing the current node.\n */\n\nexport function insertAfter(\n  this: NodePath,\n  nodes_: t.Node | t.Node[],\n): NodePath[] {\n  this._assertUnremoved();\n\n  if (this.isSequenceExpression()) {\n    return last(this.get(\"expressions\")).insertAfter(nodes_);\n  }\n\n  const nodes = this._verifyNodeList(nodes_);\n\n  const { parentPath, parent } = this;\n  if (\n    parentPath.isExpressionStatement() ||\n    parentPath.isLabeledStatement() ||\n    // see insertBefore\n    isExportNamedDeclaration(parent) ||\n    (parentPath.isExportDefaultDeclaration() && this.isDeclaration())\n  ) {\n    return parentPath.insertAfter(\n      nodes.map(node => {\n        // Usually after an expression we can safely insert another expression:\n        //   A.insertAfter(B)\n        //     foo = A;  -> foo = (A, B);\n        // If A is an expression statement, it isn't safe anymore so we need to\n        // convert B to an expression statement\n        //     A;        -> A; B // No semicolon! It could break if followed by [!\n        return isExpression(node) ? expressionStatement(node) : node;\n      }),\n    );\n  } else if (\n    (this.isNodeType(\"Expression\") &&\n      !this.isJSXElement() &&\n      !parentPath.isJSXElement()) ||\n    (parentPath.isForStatement() && this.key === \"init\")\n  ) {\n    if (this.node) {\n      const node = this.node as t.Expression | t.VariableDeclaration;\n      let { scope } = this;\n\n      if (scope.path.isPattern()) {\n        assertExpression(node);\n\n        this.replaceWith(callExpression(arrowFunctionExpression([], node), []));\n        (this.get(\"callee.body\") as NodePath<t.Expression>).insertAfter(nodes);\n        return [this];\n      }\n\n      if (isHiddenInSequenceExpression(this)) {\n        nodes.unshift(node);\n      }\n      // We need to preserve the value of this expression.\n      else if (isCallExpression(node) && isSuper(node.callee)) {\n        nodes.unshift(node);\n        // `super(...)` always evaluates to `this`.\n        nodes.push(thisExpression());\n      } else if (isAlmostConstantAssignment(node, scope)) {\n        nodes.unshift(node);\n        nodes.push(cloneNode(node.left));\n      } else if (scope.isPure(node, true)) {\n        // Insert the nodes before rather than after; it's not observable.\n        nodes.push(node);\n      } else {\n        // Inserting after the computed key of a method should insert the\n        // temporary binding in the method's parent's scope.\n        if (parentPath.isMethod({ computed: true, key: node })) {\n          scope = scope.parent;\n        }\n        const temp = scope.generateDeclaredUidIdentifier();\n        nodes.unshift(\n          expressionStatement(\n            // @ts-expect-error todo(flow->ts): This can be a variable\n            // declaration in the \"init\" of a for statement, but that's\n            // invalid here.\n            assignmentExpression(\"=\", cloneNode(temp), node),\n          ),\n        );\n        nodes.push(expressionStatement(cloneNode(temp)));\n      }\n    }\n    // @ts-expect-error todo(flow->ts): check that nodes is an array of statements\n    return this.replaceExpressionWithStatements(nodes);\n  } else if (Array.isArray(this.container)) {\n    return this._containerInsertAfter(nodes);\n  } else if (this.isStatementOrBlock()) {\n    const node = this.node as t.Statement;\n    const shouldInsertCurrentNode =\n      node &&\n      (!this.isExpressionStatement() ||\n        (node as t.ExpressionStatement).expression != null);\n\n    this.replaceWith(blockStatement(shouldInsertCurrentNode ? [node] : []));\n    // @ts-expect-error Fixme: refine nodes to t.BlockStatement[\"body\"] when this is a BlockStatement path\n    return this.pushContainer(\"body\", nodes);\n  } else {\n    throw new Error(\n      \"We don't know what to do with this node type. \" +\n        \"We were previously a Statement but we can't fit in here?\",\n    );\n  }\n}\n\n/**\n * Update all sibling node paths after `fromIndex` by `incrementBy`.\n */\n\nexport function updateSiblingKeys(\n  this: NodePath,\n  fromIndex: number,\n  incrementBy: number,\n) {\n  if (!this.parent) return;\n\n  const paths = getCachedPaths(this.hub, this.parent) || ([] as never[]);\n\n  for (const [, path] of paths) {\n    if (typeof path.key === \"number\" && path.key >= fromIndex) {\n      path.key += incrementBy;\n    }\n  }\n}\n\nexport function _verifyNodeList<N extends t.Node>(\n  this: NodePath,\n  nodes: N | N[],\n): N[] {\n  if (!nodes) {\n    return [];\n  }\n\n  if (!Array.isArray(nodes)) {\n    nodes = [nodes];\n  }\n\n  for (let i = 0; i < nodes.length; i++) {\n    const node = nodes[i];\n    let msg;\n\n    if (!node) {\n      msg = \"has falsy node\";\n    } else if (typeof node !== \"object\") {\n      msg = \"contains a non-object node\";\n    } else if (!node.type) {\n      msg = \"without a type\";\n    } else if (node instanceof NodePath) {\n      msg = \"has a NodePath when it expected a raw object\";\n    }\n\n    if (msg) {\n      const type = Array.isArray(node) ? \"array\" : typeof node;\n      throw new Error(\n        `Node list ${msg} with the index of ${i} and type of ${type}`,\n      );\n    }\n  }\n\n  return nodes;\n}\n\nexport function unshiftContainer<N extends t.Node, K extends keyof N & string>(\n  this: NodePath<N>,\n  listKey: K,\n  nodes: N[K] extends (infer E)[]\n    ? E | E[]\n    : // todo: refine to t.Node[]\n      //  ? E extends t.Node\n      //    ? E | E[]\n      //    : never\n      never,\n) {\n  // todo: NodePaths<Nodes>\n  this._assertUnremoved();\n\n  // @ts-expect-error fixme\n  nodes = this._verifyNodeList(nodes);\n\n  // get the first path and insert our nodes before it, if it doesn't exist then it\n  // doesn't matter, our nodes will be inserted anyway\n  const path = NodePath.get({\n    parentPath: this,\n    parent: this.node,\n    container: this.node[listKey] as unknown as t.Node | t.Node[],\n    listKey,\n    key: 0,\n  }).setContext(this.context);\n\n  return path._containerInsertBefore(\n    // @ts-expect-error typings needed to narrow down nodes as t.Node[]\n    nodes,\n  );\n}\n\nexport function pushContainer<N extends t.Node, K extends keyof N & string>(\n  this: NodePath<N>,\n  listKey: K,\n  nodes: N[K] extends (infer E)[]\n    ? E | E[]\n    : // todo: refine to t.Node[]\n      //  ? E extends t.Node\n      //    ? E | E[]\n      //    : never\n      never,\n) {\n  this._assertUnremoved();\n\n  const verifiedNodes = this._verifyNodeList(\n    // @ts-expect-error refine typings\n    nodes,\n  );\n\n  // get an invisible path that represents the last node + 1 and replace it with our\n  // nodes, effectively inlining it\n\n  const container = this.node[listKey];\n  const path = NodePath.get({\n    parentPath: this,\n    parent: this.node,\n    container: container as unknown as t.Node | t.Node[],\n    listKey,\n    // @ts-expect-error TS cannot infer that container is t.Node[]\n    key: container.length,\n  }).setContext(this.context);\n\n  return path.replaceWithMultiple(verifiedNodes);\n}\n\n/**\n * Hoist the current node to the highest scope possible and return a UID\n * referencing it.\n */\nexport function hoist<T extends t.Node>(\n  this: NodePath<T>,\n  scope: Scope = this.scope,\n) {\n  const hoister = new PathHoister<T>(this, scope);\n  return hoister.run();\n}\n"],"mappings":"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"}

package/lib/path/removal.js

@@ -1,48 +0,0 @@
-import { hooks } from "./lib/removal-hooks.js";
-import { getCachedPaths } from "../cache.js";
-import { REMOVED, SHOULD_SKIP } from "./index.js";
-export function remove() {
-  this._assertUnremoved();
-  this.resync();
-  if (!this.opts?.noScope) {
-    this._removeFromScope();
-  }
-  if (this._callRemovalHooks()) {
-    this._markRemoved();
-    return;
-  }
-  this.shareCommentsWithSiblings();
-  this._remove();
-  this._markRemoved();
-}
-export function _removeFromScope() {
-  const bindings = this.getBindingIdentifiers();
-  Object.keys(bindings).forEach(name => this.scope.removeBinding(name));
-}
-export function _callRemovalHooks() {
-  for (const fn of hooks) {
-    if (fn(this, this.parentPath)) return true;
-  }
-}
-export function _remove() {
-  if (Array.isArray(this.container)) {
-    this.container.splice(this.key, 1);
-    this.updateSiblingKeys(this.key, -1);
-  } else {
-    this._replaceWith(null);
-  }
-}
-export function _markRemoved() {
-  this._traverseFlags |= SHOULD_SKIP | REMOVED;
-  if (this.parent) {
-    getCachedPaths(this.hub, this.parent).delete(this.node);
-  }
-  this.node = null;
-}
-export function _assertUnremoved() {
-  if (this.removed) {
-    throw this.buildCodeFrameError("NodePath has been removed so is read-only.");
-  }
-}
-
-//# sourceMappingURL=removal.js.map

package/lib/path/removal.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["hooks","getCachedPaths","REMOVED","SHOULD_SKIP","remove","_assertUnremoved","resync","opts","noScope","_removeFromScope","_callRemovalHooks","_markRemoved","shareCommentsWithSiblings","_remove","bindings","getBindingIdentifiers","Object","keys","forEach","name","scope","removeBinding","fn","parentPath","Array","isArray","container","splice","key","updateSiblingKeys","_replaceWith","_traverseFlags","parent","hub","delete","node","removed","buildCodeFrameError"],"sources":["../../src/path/removal.ts"],"sourcesContent":["// This file contains methods responsible for removing a node.\n\nimport { hooks } from \"./lib/removal-hooks\";\nimport { getCachedPaths } from \"../cache\";\nimport type NodePath from \"./index\";\nimport { REMOVED, SHOULD_SKIP } from \"./index\";\n\nexport function remove(this: NodePath) {\n  this._assertUnremoved();\n\n  this.resync();\n  if (!this.opts?.noScope) {\n    this._removeFromScope();\n  }\n\n  if (this._callRemovalHooks()) {\n    this._markRemoved();\n    return;\n  }\n\n  this.shareCommentsWithSiblings();\n  this._remove();\n  this._markRemoved();\n}\n\nexport function _removeFromScope(this: NodePath) {\n  const bindings = this.getBindingIdentifiers();\n  Object.keys(bindings).forEach(name => this.scope.removeBinding(name));\n}\n\nexport function _callRemovalHooks(this: NodePath) {\n  for (const fn of hooks) {\n    if (fn(this, this.parentPath)) return true;\n  }\n}\n\nexport function _remove(this: NodePath) {\n  if (Array.isArray(this.container)) {\n    this.container.splice(this.key as number, 1);\n    this.updateSiblingKeys(this.key as number, -1);\n  } else {\n    this._replaceWith(null);\n  }\n}\n\nexport function _markRemoved(this: NodePath) {\n  // this.shouldSkip = true; this.removed = true;\n  this._traverseFlags |= SHOULD_SKIP | REMOVED;\n  if (this.parent) {\n    getCachedPaths(this.hub, this.parent).delete(this.node);\n  }\n  this.node = null;\n}\n\nexport function _assertUnremoved(this: NodePath) {\n  if (this.removed) {\n    throw this.buildCodeFrameError(\n      \"NodePath has been removed so is read-only.\",\n    );\n  }\n}\n"],"mappings":"AAEA,SAASA,KAAK,QAAQ,wBAAqB;AAC3C,SAASC,cAAc,QAAQ,aAAU;AAEzC,SAASC,OAAO,EAAEC,WAAW,QAAQ,YAAS;AAE9C,OAAO,SAASC,MAAMA,CAAA,EAAiB;EACrC,IAAI,CAACC,gBAAgB,CAAC,CAAC;EAEvB,IAAI,CAACC,MAAM,CAAC,CAAC;EACb,IAAI,CAAC,IAAI,CAACC,IAAI,EAAEC,OAAO,EAAE;IACvB,IAAI,CAACC,gBAAgB,CAAC,CAAC;EACzB;EAEA,IAAI,IAAI,CAACC,iBAAiB,CAAC,CAAC,EAAE;IAC5B,IAAI,CAACC,YAAY,CAAC,CAAC;IACnB;EACF;EAEA,IAAI,CAACC,yBAAyB,CAAC,CAAC;EAChC,IAAI,CAACC,OAAO,CAAC,CAAC;EACd,IAAI,CAACF,YAAY,CAAC,CAAC;AACrB;AAEA,OAAO,SAASF,gBAAgBA,CAAA,EAAiB;EAC/C,MAAMK,QAAQ,GAAG,IAAI,CAACC,qBAAqB,CAAC,CAAC;EAC7CC,MAAM,CAACC,IAAI,CAACH,QAAQ,CAAC,CAACI,OAAO,CAACC,IAAI,IAAI,IAAI,CAACC,KAAK,CAACC,aAAa,CAACF,IAAI,CAAC,CAAC;AACvE;AAEA,OAAO,SAAST,iBAAiBA,CAAA,EAAiB;EAChD,KAAK,MAAMY,EAAE,IAAItB,KAAK,EAAE;IACtB,IAAIsB,EAAE,CAAC,IAAI,EAAE,IAAI,CAACC,UAAU,CAAC,EAAE,OAAO,IAAI;EAC5C;AACF;AAEA,OAAO,SAASV,OAAOA,CAAA,EAAiB;EACtC,IAAIW,KAAK,CAACC,OAAO,CAAC,IAAI,CAACC,SAAS,CAAC,EAAE;IACjC,IAAI,CAACA,SAAS,CAACC,MAAM,CAAC,IAAI,CAACC,GAAG,EAAY,CAAC,CAAC;IAC5C,IAAI,CAACC,iBAAiB,CAAC,IAAI,CAACD,GAAG,EAAY,CAAC,CAAC,CAAC;EAChD,CAAC,MAAM;IACL,IAAI,CAACE,YAAY,CAAC,IAAI,CAAC;EACzB;AACF;AAEA,OAAO,SAASnB,YAAYA,CAAA,EAAiB;EAE3C,IAAI,CAACoB,cAAc,IAAI5B,WAAW,GAAGD,OAAO;EAC5C,IAAI,IAAI,CAAC8B,MAAM,EAAE;IACf/B,cAAc,CAAC,IAAI,CAACgC,GAAG,EAAE,IAAI,CAACD,MAAM,CAAC,CAACE,MAAM,CAAC,IAAI,CAACC,IAAI,CAAC;EACzD;EACA,IAAI,CAACA,IAAI,GAAG,IAAI;AAClB;AAEA,OAAO,SAAS9B,gBAAgBA,CAAA,EAAiB;EAC/C,IAAI,IAAI,CAAC+B,OAAO,EAAE;IAChB,MAAM,IAAI,CAACC,mBAAmB,CAC5B,4CACF,CAAC;EACH;AACF"}