@babel/traverse 7.18.10 → 7.19.0

package/lib/cache.js

@@ -23,4 +23,6 @@ function clearPath() {
 
 function clearScope() {
   exports.scope = scope = new WeakMap();
-}
+}
+
+//# sourceMappingURL=cache.js.map

package/lib/cache.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["path","WeakMap","scope","clear","clearPath","clearScope"],"sources":["../src/cache.ts"],"sourcesContent":["export let path = new WeakMap();\nexport let scope = new WeakMap();\n\nexport function clear() {\n  clearPath();\n  clearScope();\n}\n\nexport function clearPath() {\n  path = new WeakMap();\n}\n\nexport function clearScope() {\n  scope = new WeakMap();\n}\n"],"mappings":";;;;;;;;;AAAO,IAAIA,IAAI,GAAG,IAAIC,OAAJ,EAAX;;AACA,IAAIC,KAAK,GAAG,IAAID,OAAJ,EAAZ;;;AAEA,SAASE,KAAT,GAAiB;EACtBC,SAAS;EACTC,UAAU;AACX;;AAEM,SAASD,SAAT,GAAqB;EAC1B,eAAAJ,IAAI,GAAG,IAAIC,OAAJ,EAAP;AACD;;AAEM,SAASI,UAAT,GAAsB;EAC3B,gBAAAH,KAAK,GAAG,IAAID,OAAJ,EAAR;AACD"}

package/lib/context.js

@@ -136,4 +136,6 @@ class TraversalContext {
 
 }
 
-exports.default = TraversalContext;
+exports.default = TraversalContext;
+
+//# sourceMappingURL=context.js.map

package/lib/context.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["VISITOR_KEYS","TraversalContext","constructor","scope","opts","state","parentPath","queue","priorityQueue","shouldVisit","node","enter","exit","type","keys","length","key","create","container","listKey","NodePath","get","parent","maybeQueue","path","notPriority","push","visitMultiple","visitQueue","visitSingle","visited","WeakSet","stop","resync","contexts","pushContext","has","add","visit","popContext","nodes","Array","isArray"],"sources":["../src/context.ts"],"sourcesContent":["import NodePath from \"./path\";\nimport { VISITOR_KEYS } from \"@babel/types\";\nimport type Scope from \"./scope\";\nimport type { TraverseOptions } from \".\";\nimport type * as t from \"@babel/types\";\nimport type { Visitor } from \"./types\";\n\nexport default class TraversalContext<S = unknown> {\n  constructor(\n    scope: Scope,\n    opts: TraverseOptions,\n    state: S,\n    parentPath: NodePath,\n  ) {\n    this.parentPath = parentPath;\n    this.scope = scope;\n    this.state = state;\n    this.opts = opts;\n  }\n\n  declare parentPath: NodePath;\n  declare scope: Scope;\n  declare state: S;\n  declare opts: TraverseOptions;\n  queue: Array<NodePath> | null = null;\n  priorityQueue: Array<NodePath> | null = null;\n\n  /**\n   * This method does a simple check to determine whether or not we really need to attempt\n   * visit a node. This will prevent us from constructing a NodePath.\n   */\n\n  shouldVisit(node: t.Node): boolean {\n    const opts = this.opts as Visitor;\n    if (opts.enter || opts.exit) return true;\n\n    // check if we have a visitor for this node\n    if (opts[node.type]) return true;\n\n    // check if we're going to traverse into this node\n    const keys: Array<string> | undefined = VISITOR_KEYS[node.type];\n    if (!keys?.length) return false;\n\n    // we need to traverse into this node so ensure that it has children to traverse into!\n    for (const key of keys) {\n      if (\n        // @ts-expect-error key is from visitor keys\n        node[key]\n      ) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  create(\n    node: t.Node,\n    container: t.Node | t.Node[],\n    key: string | number,\n    listKey?: string,\n  ): NodePath {\n    // We don't need to `.setContext()` here, since `.visitQueue()` already\n    // calls `.pushContext`.\n    return NodePath.get({\n      parentPath: this.parentPath,\n      parent: node,\n      container,\n      key: key,\n      listKey,\n    });\n  }\n\n  maybeQueue(path: NodePath, notPriority?: boolean) {\n    if (this.queue) {\n      if (notPriority) {\n        this.queue.push(path);\n      } else {\n        this.priorityQueue.push(path);\n      }\n    }\n  }\n\n  visitMultiple(container: t.Node[], parent: t.Node, listKey: string) {\n    // nothing to traverse!\n    if (container.length === 0) return false;\n\n    const queue = [];\n\n    // build up initial queue\n    for (let key = 0; key < container.length; key++) {\n      const node = container[key];\n      if (node && this.shouldVisit(node)) {\n        queue.push(this.create(parent, container, key, listKey));\n      }\n    }\n\n    return this.visitQueue(queue);\n  }\n\n  visitSingle(node: t.Node, key: string): boolean {\n    if (\n      this.shouldVisit(\n        // @ts-expect-error key may not index node\n        node[key],\n      )\n    ) {\n      return this.visitQueue([this.create(node, node, key)]);\n    } else {\n      return false;\n    }\n  }\n\n  visitQueue(queue: Array<NodePath>): boolean {\n    // set queue\n    this.queue = queue;\n    this.priorityQueue = [];\n\n    const visited = new WeakSet();\n    let stop = false;\n\n    // visit the queue\n    for (const path of queue) {\n      path.resync();\n\n      if (\n        path.contexts.length === 0 ||\n        path.contexts[path.contexts.length - 1] !== this\n      ) {\n        // The context might already have been pushed when this path was inserted and queued.\n        // If we always re-pushed here, we could get duplicates and risk leaving contexts\n        // on the stack after the traversal has completed, which could break things.\n        path.pushContext(this);\n      }\n\n      // this path no longer belongs to the tree\n      if (path.key === null) continue;\n\n      // ensure we don't visit the same node twice\n      const { node } = path;\n      if (visited.has(node)) continue;\n      if (node) visited.add(node);\n\n      if (path.visit()) {\n        stop = true;\n        break;\n      }\n\n      if (this.priorityQueue.length) {\n        stop = this.visitQueue(this.priorityQueue);\n        this.priorityQueue = [];\n        this.queue = queue;\n        if (stop) break;\n      }\n    }\n\n    // clear queue\n    for (const path of queue) {\n      path.popContext();\n    }\n\n    // clear queue\n    this.queue = null;\n\n    return stop;\n  }\n\n  visit(node: t.Node, key: string) {\n    // @ts-expect-error key may not index node\n    const nodes = node[key] as t.Node | t.Node[] | null;\n    if (!nodes) return false;\n\n    if (Array.isArray(nodes)) {\n      return this.visitMultiple(nodes, node, key);\n    } else {\n      return this.visitSingle(node, key);\n    }\n  }\n}\n"],"mappings":"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"}

package/lib/hub.js

@@ -20,4 +20,6 @@ class Hub {
 
 }
 
-exports.default = Hub;
+exports.default = Hub;
+
+//# sourceMappingURL=hub.js.map

package/lib/hub.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Hub","getCode","getScope","addHelper","Error","buildError","node","msg","TypeError"],"sources":["../src/hub.ts"],"sourcesContent":["import type Scope from \"./scope\";\nimport type { Node } from \"@babel/types\";\n\nexport interface HubInterface {\n  getCode(): string | void;\n  getScope(): Scope | void;\n  addHelper(name: string): any;\n  buildError(node: Node, msg: string, Error: new () => Error): Error;\n}\n\nexport default class Hub implements HubInterface {\n  getCode() {}\n\n  getScope() {}\n\n  addHelper() {\n    throw new Error(\"Helpers are not supported by the default hub.\");\n  }\n\n  buildError(node: Node, msg: string, Error = TypeError): Error {\n    return new Error(msg);\n  }\n}\n"],"mappings":";;;;;;;AAUe,MAAMA,GAAN,CAAkC;EAC/CC,OAAO,GAAG,CAAE;;EAEZC,QAAQ,GAAG,CAAE;;EAEbC,SAAS,GAAG;IACV,MAAM,IAAIC,KAAJ,CAAU,+CAAV,CAAN;EACD;;EAEDC,UAAU,CAACC,IAAD,EAAaC,GAAb,EAA0BH,KAAK,GAAGI,SAAlC,EAAoD;IAC5D,OAAO,IAAIJ,KAAJ,CAAUG,GAAV,CAAP;EACD;;AAX8C"}

package/lib/index.js

@@ -108,4 +108,6 @@ traverse.hasType = function (tree, type, denylistTypes) {
   return state.has;
 };
 
-traverse.cache = cache;
+traverse.cache = cache;
+
+//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["VISITOR_KEYS","removeProperties","traverseFast","traverse","parent","opts","scope","state","parentPath","noScope","type","Error","visitors","explode","traverseNode","verify","cheap","node","enter","path","skipKeys","clearNode","cache","delete","tree","hasDenylistedType","has","stop","hasType","denylistTypes","includes","denylist"],"sources":["../src/index.ts"],"sourcesContent":["import * as visitors from \"./visitors\";\nimport {\n  VISITOR_KEYS,\n  removeProperties,\n  type RemovePropertiesOptions,\n  traverseFast,\n} from \"@babel/types\";\nimport type * as t from \"@babel/types\";\nimport * as cache from \"./cache\";\nimport type NodePath from \"./path\";\nimport type { default as Scope, Binding } from \"./scope\";\nimport type { Visitor } from \"./types\";\nimport { traverseNode } from \"./traverse-node\";\n\nexport type { Visitor, Binding };\nexport { default as NodePath } from \"./path\";\nexport { default as Scope } from \"./scope\";\nexport { default as Hub } from \"./hub\";\nexport type { HubInterface } from \"./hub\";\n\nexport { visitors };\n\nexport type TraverseOptions<S = t.Node> = {\n  scope?: Scope;\n  noScope?: boolean;\n  denylist?: string[];\n} & Visitor<S>;\n\nfunction traverse<S>(\n  parent: t.Node,\n  opts: TraverseOptions<S>,\n  scope: Scope | undefined,\n  state: S,\n  parentPath?: NodePath,\n): void;\n\nfunction traverse(\n  parent: t.Node,\n  opts: TraverseOptions,\n  scope?: Scope,\n  state?: any,\n  parentPath?: NodePath,\n): void;\n\nfunction traverse<Options extends TraverseOptions>(\n  parent: t.Node,\n  // @ts-expect-error provide {} as default value for Options\n  opts: Options = {},\n  scope?: Scope,\n  state?: any,\n  parentPath?: NodePath,\n) {\n  if (!parent) return;\n\n  if (!opts.noScope && !scope) {\n    if (parent.type !== \"Program\" && parent.type !== \"File\") {\n      throw new Error(\n        \"You must pass a scope and parentPath unless traversing a Program/File. \" +\n          `Instead of that you tried to traverse a ${parent.type} node without ` +\n          \"passing scope and parentPath.\",\n      );\n    }\n  }\n\n  if (!VISITOR_KEYS[parent.type]) {\n    return;\n  }\n\n  visitors.explode(opts as Visitor);\n\n  traverseNode(parent, opts, scope, state, parentPath);\n}\n\nexport default traverse;\n\ntraverse.visitors = visitors;\ntraverse.verify = visitors.verify;\ntraverse.explode = visitors.explode;\n\ntraverse.cheap = function (node: t.Node, enter: (node: t.Node) => void) {\n  return traverseFast(node, enter);\n};\n\ntraverse.node = function (\n  node: t.Node,\n  opts: TraverseOptions,\n  scope?: Scope,\n  state?: any,\n  path?: NodePath,\n  skipKeys?: Record<string, boolean>,\n) {\n  traverseNode(node, opts, scope, state, path, skipKeys);\n  // traverse.node always returns undefined\n};\n\ntraverse.clearNode = function (node: t.Node, opts?: RemovePropertiesOptions) {\n  removeProperties(node, opts);\n\n  cache.path.delete(node);\n};\n\ntraverse.removeProperties = function (\n  tree: t.Node,\n  opts?: RemovePropertiesOptions,\n) {\n  traverseFast(tree, traverse.clearNode, opts);\n  return tree;\n};\n\ntype HasDenylistedTypeState = {\n  has: boolean;\n  type: t.Node[\"type\"];\n};\nfunction hasDenylistedType(path: NodePath, state: HasDenylistedTypeState) {\n  if (path.node.type === state.type) {\n    state.has = true;\n    path.stop();\n  }\n}\n\ntraverse.hasType = function (\n  tree: t.Node,\n  type: t.Node[\"type\"],\n  denylistTypes?: Array<string>,\n): boolean {\n  // the node we're searching in is denylisted\n  if (denylistTypes?.includes(tree.type)) return false;\n\n  // the type we're looking for is the same as the passed node\n  if (tree.type === type) return true;\n\n  const state: HasDenylistedTypeState = {\n    has: false,\n    type: type,\n  };\n\n  traverse(\n    tree,\n    {\n      noScope: true,\n      denylist: denylistTypes,\n      enter: hasDenylistedType,\n    },\n    null,\n    state,\n  );\n\n  return state.has;\n};\n\ntraverse.cache = cache;\n"],"mappings":"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"}

package/lib/path/ancestry.js

@@ -16,8 +16,6 @@ exports.isDescendant = isDescendant;
 
 var _t = require("@babel/types");
 
-var _index = require("./index");
-
 const {
   VISITOR_KEYS
 } = _t;
@@ -177,4 +175,6 @@ function inType(...candidateTypes) {
   }
 
   return false;
-}
+}
+
+//# sourceMappingURL=ancestry.js.map

package/lib/path/ancestry.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["VISITOR_KEYS","findParent","callback","path","parentPath","find","getFunctionParent","p","isFunction","getStatementParent","Array","isArray","container","isStatement","isProgram","isFile","Error","getEarliestCommonAncestorFrom","paths","getDeepestCommonAncestorFrom","deepest","i","ancestries","earliest","keys","type","ancestry","listKey","key","earliestKeyIndex","indexOf","parentKey","currentKeyIndex","filter","length","minDepth","Infinity","lastCommonIndex","lastCommon","map","unshift","first","depthLoop","shouldMatch","getAncestry","push","isAncestor","maybeDescendant","isDescendant","maybeAncestor","parent","inType","candidateTypes","node"],"sources":["../../src/path/ancestry.ts"],"sourcesContent":["// This file contains that retrieve or validate anything related to the current paths ancestry.\n\nimport { VISITOR_KEYS } from \"@babel/types\";\nimport type * as t from \"@babel/types\";\nimport type NodePath from \"./index\";\n\n/**\n * Starting at the parent path of the current `NodePath` and going up the\n * tree, return the first `NodePath` that causes the provided `callback`\n * to return a truthy value, or `null` if the `callback` never returns a\n * truthy value.\n */\n\nexport function findParent(\n  this: NodePath,\n  callback: (path: NodePath) => boolean,\n): NodePath | null {\n  let path = this;\n  while ((path = path.parentPath)) {\n    if (callback(path)) return path;\n  }\n  return null;\n}\n\n/**\n * Starting at current `NodePath` and going up the tree, return the first\n * `NodePath` that causes the provided `callback` to return a truthy value,\n * or `null` if the `callback` never returns a truthy value.\n */\n\nexport function find(\n  this: NodePath,\n  callback: (path: NodePath) => boolean,\n): NodePath | null {\n  let path = this;\n  do {\n    if (callback(path)) return path;\n  } while ((path = path.parentPath));\n  return null;\n}\n\n/**\n * Get the parent function of the current path.\n */\n\nexport function getFunctionParent(this: NodePath): NodePath<t.Function> | null {\n  return this.findParent(p => p.isFunction()) as NodePath<t.Function> | null;\n}\n\n/**\n * Walk up the tree until we hit a parent node path in a list.\n */\n\nexport function getStatementParent(this: NodePath): NodePath<t.Statement> {\n  let path = this;\n\n  do {\n    if (\n      !path.parentPath ||\n      (Array.isArray(path.container) && path.isStatement())\n    ) {\n      break;\n    } else {\n      path = path.parentPath;\n    }\n  } while (path);\n\n  if (path && (path.isProgram() || path.isFile())) {\n    throw new Error(\n      \"File/Program node, we can't possibly find a statement parent to this\",\n    );\n  }\n\n  return path as NodePath<t.Statement>;\n}\n\n/**\n * Get the deepest common ancestor and then from it, get the earliest relationship path\n * to that ancestor.\n *\n * Earliest is defined as being \"before\" all the other nodes in terms of list container\n * position and visiting key.\n */\n\nexport function getEarliestCommonAncestorFrom(\n  this: NodePath,\n  paths: Array<NodePath>,\n): NodePath {\n  return this.getDeepestCommonAncestorFrom(\n    paths,\n    function (deepest, i, ancestries) {\n      let earliest;\n      const keys = VISITOR_KEYS[deepest.type];\n\n      for (const ancestry of ancestries) {\n        const path = ancestry[i + 1];\n\n        // first path\n        if (!earliest) {\n          earliest = path;\n          continue;\n        }\n\n        // handle containers\n        if (path.listKey && earliest.listKey === path.listKey) {\n          // we're in the same container so check if we're earlier\n          if (path.key < earliest.key) {\n            earliest = path;\n            continue;\n          }\n        }\n\n        // handle keys\n        const earliestKeyIndex = keys.indexOf(earliest.parentKey);\n        const currentKeyIndex = keys.indexOf(path.parentKey as string);\n        if (earliestKeyIndex > currentKeyIndex) {\n          // key appears before so it's earlier\n          earliest = path;\n        }\n      }\n\n      return earliest;\n    },\n  );\n}\n\n/**\n * Get the earliest path in the tree where the provided `paths` intersect.\n *\n * TODO: Possible optimisation target.\n */\n\nexport function getDeepestCommonAncestorFrom(\n  this: NodePath,\n  paths: Array<NodePath>,\n  filter?: (deepest: NodePath, i: number, ancestries: NodePath[][]) => NodePath,\n): NodePath {\n  if (!paths.length) {\n    return this;\n  }\n\n  if (paths.length === 1) {\n    return paths[0];\n  }\n\n  // minimum depth of the tree so we know the highest node\n  let minDepth = Infinity;\n\n  // last common ancestor\n  let lastCommonIndex, lastCommon;\n\n  // get the ancestors of the path, breaking when the parent exceeds ourselves\n  const ancestries = paths.map(path => {\n    const ancestry: NodePath[] = [];\n\n    do {\n      ancestry.unshift(path);\n    } while ((path = path.parentPath) && path !== this);\n\n    // save min depth to avoid going too far in\n    if (ancestry.length < minDepth) {\n      minDepth = ancestry.length;\n    }\n\n    return ancestry;\n  });\n\n  // get the first ancestry so we have a seed to assess all other ancestries with\n  const first = ancestries[0];\n\n  // check ancestor equality\n  depthLoop: for (let i = 0; i < minDepth; i++) {\n    const shouldMatch = first[i];\n\n    for (const ancestry of ancestries) {\n      if (ancestry[i] !== shouldMatch) {\n        // we've hit a snag\n        break depthLoop;\n      }\n    }\n\n    // next iteration may break so store these so they can be returned\n    lastCommonIndex = i;\n    lastCommon = shouldMatch;\n  }\n\n  if (lastCommon) {\n    if (filter) {\n      return filter(lastCommon, lastCommonIndex, ancestries);\n    } else {\n      return lastCommon;\n    }\n  } else {\n    throw new Error(\"Couldn't find intersection\");\n  }\n}\n\n/**\n * Build an array of node paths containing the entire ancestry of the current node path.\n *\n * NOTE: The current node path is included in this.\n */\n\nexport function getAncestry(this: NodePath): Array<NodePath> {\n  let path = this;\n  const paths = [];\n  do {\n    paths.push(path);\n  } while ((path = path.parentPath));\n  return paths;\n}\n\n/**\n * A helper to find if `this` path is an ancestor of @param maybeDescendant\n */\nexport function isAncestor(this: NodePath, maybeDescendant: NodePath): boolean {\n  return maybeDescendant.isDescendant(this);\n}\n\n/**\n * A helper to find if `this` path is a descendant of @param maybeAncestor\n */\nexport function isDescendant(this: NodePath, maybeAncestor: NodePath): boolean {\n  return !!this.findParent(parent => parent === maybeAncestor);\n}\n\nexport function inType(this: NodePath, ...candidateTypes: string[]): boolean {\n  let path = this;\n  while (path) {\n    for (const type of candidateTypes) {\n      if (path.node.type === type) return true;\n    }\n    path = path.parentPath;\n  }\n\n  return false;\n}\n"],"mappings":"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"}

package/lib/path/comments.js

@@ -39,4 +39,6 @@ function addComment(type, content, line) {
 
 function addComments(type, comments) {
   _addComments(this.node, type, comments);
-}
+}
+
+//# sourceMappingURL=comments.js.map

package/lib/path/comments.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["addComment","_addComment","addComments","_addComments","shareCommentsWithSiblings","key","node","trailing","trailingComments","leading","leadingComments","prev","getSibling","next","hasPrev","Boolean","hasNext","type","content","line","comments"],"sources":["../../src/path/comments.ts"],"sourcesContent":["// This file contains methods responsible for dealing with comments.\nimport type * as t from \"@babel/types\";\nimport type NodePath from \"./index\";\nimport {\n  addComment as _addComment,\n  addComments as _addComments,\n} from \"@babel/types\";\n\n/**\n * Share comments amongst siblings.\n */\n\nexport function shareCommentsWithSiblings(this: NodePath) {\n  // NOTE: this assumes numbered keys\n  if (typeof this.key === \"string\") return;\n\n  const node = this.node;\n  if (!node) return;\n\n  const trailing = node.trailingComments;\n  const leading = node.leadingComments;\n  if (!trailing && !leading) return;\n\n  const prev = this.getSibling(this.key - 1);\n  const next = this.getSibling(this.key + 1);\n  const hasPrev = Boolean(prev.node);\n  const hasNext = Boolean(next.node);\n  if (hasPrev && !hasNext) {\n    prev.addComments(\"trailing\", trailing);\n  } else if (hasNext && !hasPrev) {\n    next.addComments(\"leading\", leading);\n  }\n}\n\nexport function addComment(\n  this: NodePath,\n  type: t.CommentTypeShorthand,\n  content: string,\n  line?: boolean,\n) {\n  _addComment(this.node, type, content, line);\n}\n\n/**\n * Give node `comments` of the specified `type`.\n */\n\nexport function addComments(\n  this: NodePath,\n  type: t.CommentTypeShorthand,\n  comments: t.Comment[],\n) {\n  _addComments(this.node, type, comments);\n}\n"],"mappings":";;;;;;;;;AAGA;;;EACEA,U,EAAcC,W;EACdC,W,EAAeC;;;AAOV,SAASC,yBAAT,GAAmD;EAExD,IAAI,OAAO,KAAKC,GAAZ,KAAoB,QAAxB,EAAkC;EAElC,MAAMC,IAAI,GAAG,KAAKA,IAAlB;EACA,IAAI,CAACA,IAAL,EAAW;EAEX,MAAMC,QAAQ,GAAGD,IAAI,CAACE,gBAAtB;EACA,MAAMC,OAAO,GAAGH,IAAI,CAACI,eAArB;EACA,IAAI,CAACH,QAAD,IAAa,CAACE,OAAlB,EAA2B;EAE3B,MAAME,IAAI,GAAG,KAAKC,UAAL,CAAgB,KAAKP,GAAL,GAAW,CAA3B,CAAb;EACA,MAAMQ,IAAI,GAAG,KAAKD,UAAL,CAAgB,KAAKP,GAAL,GAAW,CAA3B,CAAb;EACA,MAAMS,OAAO,GAAGC,OAAO,CAACJ,IAAI,CAACL,IAAN,CAAvB;EACA,MAAMU,OAAO,GAAGD,OAAO,CAACF,IAAI,CAACP,IAAN,CAAvB;;EACA,IAAIQ,OAAO,IAAI,CAACE,OAAhB,EAAyB;IACvBL,IAAI,CAACT,WAAL,CAAiB,UAAjB,EAA6BK,QAA7B;EACD,CAFD,MAEO,IAAIS,OAAO,IAAI,CAACF,OAAhB,EAAyB;IAC9BD,IAAI,CAACX,WAAL,CAAiB,SAAjB,EAA4BO,OAA5B;EACD;AACF;;AAEM,SAAST,UAAT,CAELiB,IAFK,EAGLC,OAHK,EAILC,IAJK,EAKL;EACAlB,WAAW,CAAC,KAAKK,IAAN,EAAYW,IAAZ,EAAkBC,OAAlB,EAA2BC,IAA3B,CAAX;AACD;;AAMM,SAASjB,WAAT,CAELe,IAFK,EAGLG,QAHK,EAIL;EACAjB,YAAY,CAAC,KAAKG,IAAN,EAAYW,IAAZ,EAAkBG,QAAlB,CAAZ;AACD"}

package/lib/path/context.js

@@ -267,4 +267,6 @@ function _getQueueContexts() {
   }
 
   return contexts;
-}
+}
+
+//# sourceMappingURL=context.js.map

package/lib/path/context.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["call","key","opts","debug","node","_call","type","fns","fn","ret","state","then","Error","_traverseFlags","isDenylisted","denylist","blacklist","indexOf","restoreContext","path","context","visit","shouldSkip","currentContext","shouldStop","traverseNode","scope","skipKeys","skip","skipKey","stop","SHOULD_SKIP","SHOULD_STOP","setScope","noScope","parentPath","listKey","isMethod","target","getScope","init","setContext","resync","removed","_resyncParent","_resyncList","_resyncKey","parent","container","Array","isArray","i","length","setKey","Object","keys","inList","newContainer","_resyncRemoved","_markRemoved","popContext","contexts","pop","undefined","pushContext","push","setup","requeue","pathToQueue","maybeQueue","_getQueueContexts"],"sources":["../../src/path/context.ts"],"sourcesContent":["// This file contains methods responsible for maintaining a TraversalContext.\n\nimport { traverseNode } from \"../traverse-node\";\nimport { SHOULD_SKIP, SHOULD_STOP } from \"./index\";\nimport type TraversalContext from \"../context\";\nimport type NodePath from \"./index\";\nimport type * as t from \"@babel/types\";\n\nexport function call(this: NodePath, key: string): boolean {\n  const opts = this.opts;\n\n  this.debug(key);\n\n  if (this.node) {\n    if (this._call(opts[key])) return true;\n  }\n\n  if (this.node) {\n    return this._call(opts[this.node.type] && opts[this.node.type][key]);\n  }\n\n  return false;\n}\n\nexport function _call(this: NodePath, fns?: Array<Function>): boolean {\n  if (!fns) return false;\n\n  for (const fn of fns) {\n    if (!fn) continue;\n\n    const node = this.node;\n    if (!node) return true;\n\n    const ret = fn.call(this.state, this, this.state);\n    if (ret && typeof ret === \"object\" && typeof ret.then === \"function\") {\n      throw new Error(\n        `You appear to be using a plugin with an async traversal visitor, ` +\n          `which your current version of Babel does not support. ` +\n          `If you're using a published plugin, you may need to upgrade ` +\n          `your @babel/core version.`,\n      );\n    }\n    if (ret) {\n      throw new Error(`Unexpected return value from visitor method ${fn}`);\n    }\n\n    // node has been replaced, it will have been requeued\n    if (this.node !== node) return true;\n\n    // this.shouldSkip || this.shouldStop || this.removed\n    if (this._traverseFlags > 0) return true;\n  }\n\n  return false;\n}\n\nexport function isDenylisted(this: NodePath): boolean {\n  const denylist = this.opts.denylist ?? this.opts.blacklist;\n  return denylist && denylist.indexOf(this.node.type) > -1;\n}\n\n// TODO: Remove in Babel 8\nexport { isDenylisted as isBlacklisted };\n\nfunction restoreContext(path: NodePath, context: TraversalContext) {\n  if (path.context !== context) {\n    path.context = context;\n    path.state = context.state;\n    path.opts = context.opts;\n  }\n}\n\nexport function visit(this: NodePath): boolean {\n  if (!this.node) {\n    return false;\n  }\n\n  if (this.isDenylisted()) {\n    return false;\n  }\n\n  if (this.opts.shouldSkip && this.opts.shouldSkip(this)) {\n    return false;\n  }\n\n  const currentContext = this.context;\n  // Note: We need to check \"this.shouldSkip\" first because\n  // another visitor can set it to true. Usually .shouldSkip is false\n  // before calling the enter visitor, but it can be true in case of\n  // a requeued node (e.g. by .replaceWith()) that is then marked\n  // with .skip().\n  if (this.shouldSkip || this.call(\"enter\")) {\n    this.debug(\"Skip...\");\n    return this.shouldStop;\n  }\n  restoreContext(this, currentContext);\n\n  this.debug(\"Recursing into...\");\n  this.shouldStop = traverseNode(\n    this.node,\n    this.opts,\n    this.scope,\n    this.state,\n    this,\n    this.skipKeys,\n  );\n\n  restoreContext(this, currentContext);\n\n  this.call(\"exit\");\n\n  return this.shouldStop;\n}\n\nexport function skip(this: NodePath) {\n  this.shouldSkip = true;\n}\n\nexport function skipKey(this: NodePath, key: string) {\n  if (this.skipKeys == null) {\n    this.skipKeys = {};\n  }\n  this.skipKeys[key] = true;\n}\n\nexport function stop(this: NodePath) {\n  // this.shouldSkip = true; this.shouldStop = true;\n  this._traverseFlags |= SHOULD_SKIP | SHOULD_STOP;\n}\n\nexport function setScope(this: NodePath) {\n  if (this.opts && this.opts.noScope) return;\n\n  let path = this.parentPath;\n\n  // Skip method scope if is computed method key or decorator expression\n  if (\n    (this.key === \"key\" || this.listKey === \"decorators\") &&\n    path.isMethod()\n  ) {\n    path = path.parentPath;\n  }\n\n  let target;\n  while (path && !target) {\n    if (path.opts && path.opts.noScope) return;\n\n    target = path.scope;\n    path = path.parentPath;\n  }\n\n  this.scope = this.getScope(target);\n  if (this.scope) this.scope.init();\n}\n\nexport function setContext<S = unknown>(\n  this: NodePath,\n  context?: TraversalContext<S>,\n) {\n  if (this.skipKeys != null) {\n    this.skipKeys = {};\n  }\n  // this.shouldSkip = false; this.shouldStop = false; this.removed = false;\n  this._traverseFlags = 0;\n\n  if (context) {\n    this.context = context;\n    this.state = context.state;\n    this.opts = context.opts;\n  }\n\n  this.setScope();\n\n  return this;\n}\n\n/**\n * Here we resync the node paths `key` and `container`. If they've changed according\n * to what we have stored internally then we attempt to resync by crawling and looking\n * for the new values.\n */\n\nexport function resync(this: NodePath) {\n  if (this.removed) return;\n\n  this._resyncParent();\n  this._resyncList();\n  this._resyncKey();\n  //this._resyncRemoved();\n}\n\nexport function _resyncParent(this: NodePath) {\n  if (this.parentPath) {\n    this.parent = this.parentPath.node;\n  }\n}\n\nexport function _resyncKey(this: NodePath) {\n  if (!this.container) return;\n\n  if (\n    this.node ===\n    // @ts-expect-error this.key should present in this.container\n    this.container[this.key]\n  ) {\n    return;\n  }\n\n  // grrr, path key is out of sync. this is likely due to a modification to the AST\n  // not done through our path APIs\n\n  if (Array.isArray(this.container)) {\n    for (let i = 0; i < this.container.length; i++) {\n      if (this.container[i] === this.node) {\n        return this.setKey(i);\n      }\n    }\n  } else {\n    for (const key of Object.keys(this.container)) {\n      // @ts-expect-error this.key should present in this.container\n      if (this.container[key] === this.node) {\n        return this.setKey(key);\n      }\n    }\n  }\n\n  // ¯\\_(ツ)_/¯ who knows where it's gone lol\n  this.key = null;\n}\n\nexport function _resyncList(this: NodePath) {\n  if (!this.parent || !this.inList) return;\n\n  const newContainer =\n    // @ts-expect-error this.listKey should present in this.parent\n    this.parent[this.listKey];\n  if (this.container === newContainer) return;\n\n  // container is out of sync. this is likely the result of it being reassigned\n  this.container = newContainer || null;\n}\n\nexport function _resyncRemoved(this: NodePath) {\n  if (\n    this.key == null ||\n    !this.container ||\n    // @ts-expect-error this.key should present in this.container\n    this.container[this.key] !== this.node\n  ) {\n    this._markRemoved();\n  }\n}\n\nexport function popContext(this: NodePath) {\n  this.contexts.pop();\n  if (this.contexts.length > 0) {\n    this.setContext(this.contexts[this.contexts.length - 1]);\n  } else {\n    this.setContext(undefined);\n  }\n}\n\nexport function pushContext(this: NodePath, context: TraversalContext) {\n  this.contexts.push(context);\n  this.setContext(context);\n}\n\nexport function setup(\n  this: NodePath,\n  parentPath: NodePath | undefined,\n  container: t.Node,\n  listKey: string,\n  key: string | number,\n) {\n  this.listKey = listKey;\n  this.container = container;\n\n  this.parentPath = parentPath || this.parentPath;\n  this.setKey(key);\n}\n\nexport function setKey(this: NodePath, key: string | number) {\n  this.key = key;\n  this.node =\n    // @ts-expect-error this.key must present in this.container\n    this.container[this.key];\n  this.type = this.node?.type;\n}\n\nexport function requeue(this: NodePath, pathToQueue = this) {\n  if (pathToQueue.removed) return;\n\n  // If a path is skipped, and then replaced with a\n  // new one, the new one shouldn't probably be skipped.\n  if (process.env.BABEL_8_BREAKING) {\n    pathToQueue.shouldSkip = false;\n  }\n\n  // TODO(loganfsmyth): This should be switched back to queue in parent contexts\n  // automatically once #2892 and #4135 have been resolved. See #4140.\n  // let contexts = this._getQueueContexts();\n  const contexts = this.contexts;\n\n  for (const context of contexts) {\n    context.maybeQueue(pathToQueue);\n  }\n}\n\nexport function _getQueueContexts(this: NodePath) {\n  let path = this;\n  let contexts = this.contexts;\n  while (!contexts.length) {\n    path = path.parentPath;\n    if (!path) break;\n    contexts = path.contexts;\n  }\n  return contexts;\n}\n"],"mappings":"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"}

package/lib/path/conversion.js

@@ -536,4 +536,6 @@ function getScopeInformation(fnPath) {
     superProps,
     superCalls
   };
-}
+}
+
+//# sourceMappingURL=conversion.js.map

package/lib/path/conversion.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["arrowFunctionExpression","assignmentExpression","binaryExpression","blockStatement","callExpression","conditionalExpression","expressionStatement","identifier","isIdentifier","jsxIdentifier","logicalExpression","LOGICAL_OPERATORS","memberExpression","metaProperty","numericLiteral","objectExpression","restElement","returnStatement","sequenceExpression","spreadElement","stringLiteral","super","_super","thisExpression","toExpression","unaryExpression","toComputedKey","key","isMemberExpression","node","property","isProperty","isMethod","ReferenceError","computed","name","ensureBlock","body","get","bodyNode","Array","isArray","Error","isBlockStatement","statements","stringPath","listKey","isStatement","push","isFunction","parentPath","setup","arrowFunctionToShadowed","isArrowFunctionExpression","arrowFunctionToExpression","unwrapFunctionEnvironment","isFunctionExpression","isFunctionDeclaration","buildCodeFrameError","hoistFunctionEnvironment","setType","path","type","allowInsertArrow","specCompliant","noNewArrows","thisBinding","fnPath","fn","checkBinding","scope","generateUidIdentifier","id","init","unshiftContainer","hub","addHelper","replaceWith","nameFunction","getSuperCallsVisitor","mergeVisitors","CallExpression","child","allSuperCalls","isSuper","environmentVisitor","arrowParent","thisEnvFn","findParent","p","isProgram","isClassProperty","static","isClassPrivateProperty","inConstructor","isClassMethod","kind","thisPaths","argumentsPaths","newTargetPaths","superProps","superCalls","getScopeInformation","length","traverse","superBinding","getSuperBinding","forEach","superCall","callee","loc","argumentsBinding","getBinding","args","buildUndefinedNode","argumentsChild","argsRef","newTargetBinding","targetChild","targetRef","flatSuperProps","reduce","acc","superProp","concat","standardizeSuperProperty","superParentPath","isAssignment","isAssignmentExpression","left","isCall","isCallExpression","getSuperPropBinding","value","right","call","getThisBinding","hasSuperClass","thisChild","thisRef","isJSX","isLogicalOp","op","includes","operator","assignmentPath","slice","isLogicalAssignment","tmp","generateDeclaredUidIdentifier","object","rightExpression","isUpdateExpression","updateExpr","computedKey","parts","prefix","superClass","assignSuperThisVisitor","supers","has","add","replaceWithMultiple","WeakSet","argsBinding","propName","argsList","fnBody","method","unshift","valueIdent","cacheKey","data","getData","setData","getScopeInformationVisitor","ThisExpression","JSXIdentifier","isJSXMemberExpression","isJSXOpeningElement","MemberExpression","Identifier","isReferencedIdentifier","curr","hasOwnBinding","rename","parent","MetaProperty"],"sources":["../../src/path/conversion.ts"],"sourcesContent":["// This file contains methods that convert the path node into another node or some other type of data.\n\nimport {\n  arrowFunctionExpression,\n  assignmentExpression,\n  binaryExpression,\n  blockStatement,\n  callExpression,\n  conditionalExpression,\n  expressionStatement,\n  identifier,\n  isIdentifier,\n  jsxIdentifier,\n  logicalExpression,\n  LOGICAL_OPERATORS,\n  memberExpression,\n  metaProperty,\n  numericLiteral,\n  objectExpression,\n  restElement,\n  returnStatement,\n  sequenceExpression,\n  spreadElement,\n  stringLiteral,\n  super as _super,\n  thisExpression,\n  toExpression,\n  unaryExpression,\n} from \"@babel/types\";\nimport type * as t from \"@babel/types\";\nimport environmentVisitor from \"@babel/helper-environment-visitor\";\nimport nameFunction from \"@babel/helper-function-name\";\nimport { merge as mergeVisitors } from \"../visitors\";\nimport type NodePath from \"./index\";\n\nexport function toComputedKey(this: NodePath) {\n  let key;\n  if (this.isMemberExpression()) {\n    key = this.node.property;\n  } else if (this.isProperty() || this.isMethod()) {\n    key = this.node.key;\n  } else {\n    throw new ReferenceError(\"todo\");\n  }\n\n  // @ts-expect-error todo(flow->ts) computed does not exist in ClassPrivateProperty\n  if (!this.node.computed) {\n    if (isIdentifier(key)) key = stringLiteral(key.name);\n  }\n\n  return key;\n}\n\nexport function ensureBlock(\n  this: NodePath<\n    t.Loop | t.WithStatement | t.Function | t.LabeledStatement | t.CatchClause\n  >,\n) {\n  const body = this.get(\"body\");\n  const bodyNode = body.node;\n\n  if (Array.isArray(body)) {\n    throw new Error(\"Can't convert array path to a block statement\");\n  }\n  if (!bodyNode) {\n    throw new Error(\"Can't convert node without a body\");\n  }\n\n  if (body.isBlockStatement()) {\n    return bodyNode;\n  }\n\n  const statements: Array<t.Statement> = [];\n\n  let stringPath = \"body\";\n  let key;\n  let listKey;\n  if (body.isStatement()) {\n    listKey = \"body\";\n    key = 0;\n    statements.push(body.node);\n  } else {\n    stringPath += \".body.0\";\n    if (this.isFunction()) {\n      key = \"argument\";\n      statements.push(returnStatement(body.node as t.Expression));\n    } else {\n      key = \"expression\";\n      statements.push(expressionStatement(body.node as t.Expression));\n    }\n  }\n\n  this.node.body = blockStatement(statements);\n  const parentPath = this.get(stringPath) as NodePath;\n  body.setup(\n    parentPath,\n    listKey\n      ? // @ts-expect-error listKey must present in parent path\n        parentPath.node[listKey]\n      : parentPath.node,\n    listKey,\n    key,\n  );\n\n  return this.node;\n}\n\n/**\n * Keeping this for backward-compatibility. You should use arrowFunctionToExpression() for >=7.x.\n */\n// TODO(Babel 8): Remove this\nexport function arrowFunctionToShadowed(this: NodePath) {\n  if (!this.isArrowFunctionExpression()) return;\n\n  this.arrowFunctionToExpression();\n}\n\n/**\n * Given an arbitrary function, process its content as if it were an arrow function, moving references\n * to \"this\", \"arguments\", \"super\", and such into the function's parent scope. This method is useful if\n * you have wrapped some set of items in an IIFE or other function, but want \"this\", \"arguments\", and super\"\n * to continue behaving as expected.\n */\nexport function unwrapFunctionEnvironment(this: NodePath) {\n  if (\n    !this.isArrowFunctionExpression() &&\n    !this.isFunctionExpression() &&\n    !this.isFunctionDeclaration()\n  ) {\n    throw this.buildCodeFrameError(\n      \"Can only unwrap the environment of a function.\",\n    );\n  }\n\n  hoistFunctionEnvironment(this);\n}\n\nfunction setType<N extends t.Node, T extends N[\"type\"]>(\n  path: NodePath<N>,\n  type: T,\n): asserts path is NodePath<Extract<N, { type: T }>> {\n  path.node.type = type;\n}\n\n/**\n * Convert a given arrow function into a normal ES5 function expression.\n */\nexport function arrowFunctionToExpression(\n  this: NodePath<t.ArrowFunctionExpression>,\n  {\n    allowInsertArrow = true,\n    /** @deprecated Use `noNewArrows` instead */\n    specCompliant = false,\n    // TODO(Babel 8): Consider defaulting to `false` for spec compliancy\n    noNewArrows = !specCompliant,\n  }: {\n    allowInsertArrow?: boolean | void;\n    specCompliant?: boolean | void;\n    noNewArrows?: boolean;\n  } = {},\n): NodePath<Exclude<t.Function, t.Method | t.ArrowFunctionExpression>> {\n  if (!this.isArrowFunctionExpression()) {\n    throw (this as NodePath).buildCodeFrameError(\n      \"Cannot convert non-arrow function to a function expression.\",\n    );\n  }\n\n  const { thisBinding, fnPath: fn } = hoistFunctionEnvironment(\n    this,\n    noNewArrows,\n    allowInsertArrow,\n  );\n\n  // @ts-expect-error TS requires explicit fn type annotation\n  fn.ensureBlock();\n  setType(fn, \"FunctionExpression\");\n\n  if (!noNewArrows) {\n    const checkBinding = thisBinding\n      ? null\n      : fn.scope.generateUidIdentifier(\"arrowCheckId\");\n    if (checkBinding) {\n      fn.parentPath.scope.push({\n        id: checkBinding,\n        init: objectExpression([]),\n      });\n    }\n\n    fn.get(\"body\").unshiftContainer(\n      \"body\",\n      expressionStatement(\n        callExpression(this.hub.addHelper(\"newArrowCheck\"), [\n          thisExpression(),\n          checkBinding\n            ? identifier(checkBinding.name)\n            : identifier(thisBinding),\n        ]),\n      ),\n    );\n\n    fn.replaceWith(\n      callExpression(\n        memberExpression(\n          // @ts-expect-error TS can't infer nameFunction returns CallExpression | ArrowFunctionExpression here\n          nameFunction(this, true) || fn.node,\n          identifier(\"bind\"),\n        ),\n        [checkBinding ? identifier(checkBinding.name) : thisExpression()],\n      ),\n    );\n\n    return fn.get(\"callee.object\");\n  }\n\n  return fn;\n}\n\nconst getSuperCallsVisitor = mergeVisitors<{\n  allSuperCalls: NodePath<t.CallExpression>[];\n}>([\n  {\n    CallExpression(child, { allSuperCalls }) {\n      if (!child.get(\"callee\").isSuper()) return;\n      allSuperCalls.push(child);\n    },\n  },\n  environmentVisitor,\n]);\n\n/**\n * Given a function, traverse its contents, and if there are references to \"this\", \"arguments\", \"super\",\n * or \"new.target\", ensure that these references reference the parent environment around this function.\n *\n * @returns `thisBinding`: the name of the injected reference to `this`; for example \"_this\"\n * @returns `fnPath`: the new path to the function node. This is different from the fnPath\n *                    parameter when the function node is wrapped in another node.\n */\nfunction hoistFunctionEnvironment(\n  fnPath: NodePath<t.Function>,\n  // TODO(Babel 8): Consider defaulting to `false` for spec compliancy\n  noNewArrows: boolean | void = true,\n  allowInsertArrow: boolean | void = true,\n): { thisBinding: string; fnPath: NodePath<t.Function> } {\n  let arrowParent;\n  let thisEnvFn: NodePath<t.Function> = fnPath.findParent(p => {\n    if (p.isArrowFunctionExpression()) {\n      arrowParent ??= p;\n      return false;\n    }\n    return (\n      p.isFunction() ||\n      p.isProgram() ||\n      p.isClassProperty({ static: false }) ||\n      p.isClassPrivateProperty({ static: false })\n    );\n  }) as NodePath<t.Function>;\n  const inConstructor = thisEnvFn.isClassMethod({ kind: \"constructor\" });\n\n  if (thisEnvFn.isClassProperty() || thisEnvFn.isClassPrivateProperty()) {\n    if (arrowParent) {\n      thisEnvFn = arrowParent;\n    } else if (allowInsertArrow) {\n      // It's safe to wrap this function in another and not hoist to the\n      // top level because the 'this' binding is constant in class\n      // properties (since 'super()' has already been called), so we don't\n      // need to capture/reassign it at the top level.\n      fnPath.replaceWith(\n        callExpression(\n          arrowFunctionExpression([], toExpression(fnPath.node)),\n          [],\n        ),\n      );\n      thisEnvFn = fnPath.get(\"callee\") as NodePath<t.ArrowFunctionExpression>;\n      fnPath = thisEnvFn.get(\"body\") as NodePath<t.FunctionExpression>;\n    } else {\n      throw fnPath.buildCodeFrameError(\n        \"Unable to transform arrow inside class property\",\n      );\n    }\n  }\n\n  const { thisPaths, argumentsPaths, newTargetPaths, superProps, superCalls } =\n    getScopeInformation(fnPath);\n\n  // Convert all super() calls in the constructor, if super is used in an arrow.\n  if (inConstructor && superCalls.length > 0) {\n    if (!allowInsertArrow) {\n      throw superCalls[0].buildCodeFrameError(\n        \"Unable to handle nested super() usage in arrow\",\n      );\n    }\n    const allSuperCalls: NodePath<t.CallExpression>[] = [];\n    thisEnvFn.traverse(getSuperCallsVisitor, { allSuperCalls });\n    const superBinding = getSuperBinding(thisEnvFn);\n    allSuperCalls.forEach(superCall => {\n      const callee = identifier(superBinding);\n      callee.loc = superCall.node.callee.loc;\n\n      superCall.get(\"callee\").replaceWith(callee);\n    });\n  }\n\n  // Convert all \"arguments\" references in the arrow to point at the alias.\n  if (argumentsPaths.length > 0) {\n    const argumentsBinding = getBinding(thisEnvFn, \"arguments\", () => {\n      const args = () => identifier(\"arguments\");\n      if (thisEnvFn.scope.path.isProgram()) {\n        return conditionalExpression(\n          binaryExpression(\n            \"===\",\n            unaryExpression(\"typeof\", args()),\n            stringLiteral(\"undefined\"),\n          ),\n          thisEnvFn.scope.buildUndefinedNode(),\n          args(),\n        );\n      } else {\n        return args();\n      }\n    });\n\n    argumentsPaths.forEach(argumentsChild => {\n      const argsRef = identifier(argumentsBinding);\n      argsRef.loc = argumentsChild.node.loc;\n\n      argumentsChild.replaceWith(argsRef);\n    });\n  }\n\n  // Convert all \"new.target\" references in the arrow to point at the alias.\n  if (newTargetPaths.length > 0) {\n    const newTargetBinding = getBinding(thisEnvFn, \"newtarget\", () =>\n      metaProperty(identifier(\"new\"), identifier(\"target\")),\n    );\n\n    newTargetPaths.forEach(targetChild => {\n      const targetRef = identifier(newTargetBinding);\n      targetRef.loc = targetChild.node.loc;\n\n      targetChild.replaceWith(targetRef);\n    });\n  }\n\n  // Convert all \"super.prop\" references to point at aliases.\n  if (superProps.length > 0) {\n    if (!allowInsertArrow) {\n      throw superProps[0].buildCodeFrameError(\n        \"Unable to handle nested super.prop usage\",\n      );\n    }\n\n    const flatSuperProps: NodePath<t.MemberExpression>[] = superProps.reduce(\n      (acc, superProp) => acc.concat(standardizeSuperProperty(superProp)),\n      [],\n    );\n\n    flatSuperProps.forEach(superProp => {\n      const key = superProp.node.computed\n        ? \"\"\n        : // @ts-expect-error super property must not contain private name\n          superProp.get(\"property\").node.name;\n\n      const superParentPath = superProp.parentPath;\n\n      const isAssignment = superParentPath.isAssignmentExpression({\n        left: superProp.node,\n      });\n      const isCall = superParentPath.isCallExpression({\n        callee: superProp.node,\n      });\n      const superBinding = getSuperPropBinding(thisEnvFn, isAssignment, key);\n\n      const args: t.Expression[] = [];\n      if (superProp.node.computed) {\n        // SuperProperty must not be a private name\n        args.push(superProp.get(\"property\").node as t.Expression);\n      }\n\n      if (isAssignment) {\n        const value = superParentPath.node.right;\n        args.push(value);\n      }\n\n      const call = callExpression(identifier(superBinding), args);\n\n      if (isCall) {\n        superParentPath.unshiftContainer(\"arguments\", thisExpression());\n        superProp.replaceWith(memberExpression(call, identifier(\"call\")));\n\n        thisPaths.push(\n          superParentPath.get(\"arguments.0\") as NodePath<t.ThisExpression>,\n        );\n      } else if (isAssignment) {\n        // Replace not only the super.prop, but the whole assignment\n        superParentPath.replaceWith(call);\n      } else {\n        superProp.replaceWith(call);\n      }\n    });\n  }\n\n  // Convert all \"this\" references in the arrow to point at the alias.\n  let thisBinding: string | null;\n  if (thisPaths.length > 0 || !noNewArrows) {\n    thisBinding = getThisBinding(thisEnvFn, inConstructor);\n\n    if (\n      noNewArrows ||\n      // In subclass constructors, still need to rewrite because \"this\" can't be bound in spec mode\n      // because it might not have been initialized yet.\n      (inConstructor && hasSuperClass(thisEnvFn))\n    ) {\n      thisPaths.forEach(thisChild => {\n        const thisRef = thisChild.isJSX()\n          ? jsxIdentifier(thisBinding)\n          : identifier(thisBinding);\n\n        thisRef.loc = thisChild.node.loc;\n        thisChild.replaceWith(thisRef);\n      });\n\n      if (!noNewArrows) thisBinding = null;\n    }\n  }\n\n  return { thisBinding, fnPath };\n}\n\ntype LogicalOp = Parameters<typeof logicalExpression>[0];\ntype BinaryOp = Parameters<typeof binaryExpression>[0];\n\nfunction isLogicalOp(op: string): op is LogicalOp {\n  return LOGICAL_OPERATORS.includes(op);\n}\n\nfunction standardizeSuperProperty(\n  superProp: NodePath<t.MemberExpression>,\n):\n  | [NodePath<t.MemberExpression>]\n  | [NodePath<t.MemberExpression>, NodePath<t.MemberExpression>] {\n  if (\n    superProp.parentPath.isAssignmentExpression() &&\n    superProp.parentPath.node.operator !== \"=\"\n  ) {\n    const assignmentPath = superProp.parentPath;\n\n    const op = assignmentPath.node.operator.slice(0, -1) as\n      | LogicalOp\n      | BinaryOp;\n\n    const value = assignmentPath.node.right;\n\n    const isLogicalAssignment = isLogicalOp(op);\n\n    if (superProp.node.computed) {\n      // from: super[foo] **= 4;\n      // to:   super[tmp = foo] = super[tmp] ** 4;\n\n      // from: super[foo] ??= 4;\n      // to:   super[tmp = foo] ?? super[tmp] = 4;\n\n      const tmp = superProp.scope.generateDeclaredUidIdentifier(\"tmp\");\n\n      const object = superProp.node.object;\n      const property = superProp.node.property as t.Expression;\n\n      assignmentPath\n        .get(\"left\")\n        .replaceWith(\n          memberExpression(\n            object,\n            assignmentExpression(\"=\", tmp, property),\n            true /* computed */,\n          ),\n        );\n\n      assignmentPath\n        .get(\"right\")\n        .replaceWith(\n          rightExpression(\n            isLogicalAssignment ? \"=\" : op,\n            memberExpression(object, identifier(tmp.name), true /* computed */),\n            value,\n          ),\n        );\n    } else {\n      // from: super.foo **= 4;\n      // to:   super.foo = super.foo ** 4;\n\n      // from: super.foo ??= 4;\n      // to:   super.foo ?? super.foo = 4;\n\n      const object = superProp.node.object;\n      const property = superProp.node.property as t.Identifier;\n\n      assignmentPath\n        .get(\"left\")\n        .replaceWith(memberExpression(object, property));\n\n      assignmentPath\n        .get(\"right\")\n        .replaceWith(\n          rightExpression(\n            isLogicalAssignment ? \"=\" : op,\n            memberExpression(object, identifier(property.name)),\n            value,\n          ),\n        );\n    }\n\n    if (isLogicalAssignment) {\n      assignmentPath.replaceWith(\n        logicalExpression(\n          op,\n          assignmentPath.node.left as t.MemberExpression,\n          assignmentPath.node.right as t.Expression,\n        ),\n      );\n    } else {\n      assignmentPath.node.operator = \"=\";\n    }\n\n    return [\n      assignmentPath.get(\"left\") as NodePath<t.MemberExpression>,\n      assignmentPath.get(\"right\").get(\"left\"),\n    ];\n  } else if (superProp.parentPath.isUpdateExpression()) {\n    const updateExpr = superProp.parentPath;\n\n    const tmp = superProp.scope.generateDeclaredUidIdentifier(\"tmp\");\n    const computedKey = superProp.node.computed\n      ? superProp.scope.generateDeclaredUidIdentifier(\"prop\")\n      : null;\n\n    const parts: t.Expression[] = [\n      assignmentExpression(\n        \"=\",\n        tmp,\n        memberExpression(\n          superProp.node.object,\n          computedKey\n            ? assignmentExpression(\n                \"=\",\n                computedKey,\n                superProp.node.property as t.Expression,\n              )\n            : superProp.node.property,\n          superProp.node.computed,\n        ),\n      ),\n      assignmentExpression(\n        \"=\",\n        memberExpression(\n          superProp.node.object,\n          computedKey ? identifier(computedKey.name) : superProp.node.property,\n          superProp.node.computed,\n        ),\n        binaryExpression(\n          // map `++` to `+`, and `--` to `-`\n          superProp.parentPath.node.operator[0] as \"+\" | \"-\",\n          identifier(tmp.name),\n          numericLiteral(1),\n        ),\n      ),\n    ];\n\n    if (!superProp.parentPath.node.prefix) {\n      parts.push(identifier(tmp.name));\n    }\n\n    updateExpr.replaceWith(sequenceExpression(parts));\n\n    const left = updateExpr.get(\n      \"expressions.0.right\",\n    ) as NodePath<t.MemberExpression>;\n    const right = updateExpr.get(\n      \"expressions.1.left\",\n    ) as NodePath<t.MemberExpression>;\n    return [left, right];\n  }\n\n  return [superProp];\n\n  function rightExpression(\n    op: BinaryOp | \"=\",\n    left: t.MemberExpression,\n    right: t.Expression,\n  ) {\n    if (op === \"=\") {\n      return assignmentExpression(\"=\", left, right);\n    } else {\n      return binaryExpression(op, left, right);\n    }\n  }\n}\n\nfunction hasSuperClass(thisEnvFn: NodePath<t.Function>) {\n  return (\n    thisEnvFn.isClassMethod() &&\n    !!(thisEnvFn.parentPath.parentPath.node as t.Class).superClass\n  );\n}\n\nconst assignSuperThisVisitor = mergeVisitors<{\n  supers: WeakSet<t.CallExpression>;\n  thisBinding: string;\n}>([\n  {\n    CallExpression(child, { supers, thisBinding }) {\n      if (!child.get(\"callee\").isSuper()) return;\n      if (supers.has(child.node)) return;\n      supers.add(child.node);\n\n      child.replaceWithMultiple([\n        child.node,\n        assignmentExpression(\"=\", identifier(thisBinding), identifier(\"this\")),\n      ]);\n    },\n  },\n  environmentVisitor,\n]);\n\n// Create a binding that evaluates to the \"this\" of the given function.\nfunction getThisBinding(\n  thisEnvFn: NodePath<t.Function>,\n  inConstructor: boolean,\n) {\n  return getBinding(thisEnvFn, \"this\", thisBinding => {\n    if (!inConstructor || !hasSuperClass(thisEnvFn)) return thisExpression();\n\n    thisEnvFn.traverse(assignSuperThisVisitor, {\n      supers: new WeakSet(),\n      thisBinding,\n    });\n  });\n}\n\n// Create a binding for a function that will call \"super()\" with arguments passed through.\nfunction getSuperBinding(thisEnvFn: NodePath<t.Function>) {\n  return getBinding(thisEnvFn, \"supercall\", () => {\n    const argsBinding = thisEnvFn.scope.generateUidIdentifier(\"args\");\n    return arrowFunctionExpression(\n      [restElement(argsBinding)],\n      callExpression(_super(), [spreadElement(identifier(argsBinding.name))]),\n    );\n  });\n}\n\n// Create a binding for a function that will call \"super.foo\" or \"super[foo]\".\nfunction getSuperPropBinding(\n  thisEnvFn: NodePath<t.Function>,\n  isAssignment: boolean,\n  propName: string,\n) {\n  const op = isAssignment ? \"set\" : \"get\";\n\n  return getBinding(thisEnvFn, `superprop_${op}:${propName || \"\"}`, () => {\n    const argsList = [];\n\n    let fnBody;\n    if (propName) {\n      // () => super.foo\n      fnBody = memberExpression(_super(), identifier(propName));\n    } else {\n      const method = thisEnvFn.scope.generateUidIdentifier(\"prop\");\n      // (method) => super[method]\n      argsList.unshift(method);\n      fnBody = memberExpression(\n        _super(),\n        identifier(method.name),\n        true /* computed */,\n      );\n    }\n\n    if (isAssignment) {\n      const valueIdent = thisEnvFn.scope.generateUidIdentifier(\"value\");\n      argsList.push(valueIdent);\n\n      fnBody = assignmentExpression(\"=\", fnBody, identifier(valueIdent.name));\n    }\n\n    return arrowFunctionExpression(argsList, fnBody);\n  });\n}\n\nfunction getBinding(\n  thisEnvFn: NodePath,\n  key: string,\n  init: (name: string) => t.Expression,\n) {\n  const cacheKey = \"binding:\" + key;\n  let data: string | undefined = thisEnvFn.getData(cacheKey);\n  if (!data) {\n    const id = thisEnvFn.scope.generateUidIdentifier(key);\n    data = id.name;\n    thisEnvFn.setData(cacheKey, data);\n\n    thisEnvFn.scope.push({\n      id: id,\n      init: init(data),\n    });\n  }\n\n  return data;\n}\n\ntype ScopeInfo = {\n  thisPaths: NodePath<t.ThisExpression | t.JSXIdentifier>[];\n  superCalls: NodePath<t.CallExpression>[];\n  superProps: NodePath<t.MemberExpression>[];\n  argumentsPaths: NodePath<t.Identifier | t.JSXIdentifier>[];\n  newTargetPaths: NodePath<t.MetaProperty>[];\n};\n\nconst getScopeInformationVisitor = mergeVisitors<ScopeInfo>([\n  {\n    ThisExpression(child, { thisPaths }) {\n      thisPaths.push(child);\n    },\n    JSXIdentifier(child, { thisPaths }) {\n      if (child.node.name !== \"this\") return;\n      if (\n        !child.parentPath.isJSXMemberExpression({ object: child.node }) &&\n        !child.parentPath.isJSXOpeningElement({ name: child.node })\n      ) {\n        return;\n      }\n\n      thisPaths.push(child);\n    },\n    CallExpression(child, { superCalls }) {\n      if (child.get(\"callee\").isSuper()) superCalls.push(child);\n    },\n    MemberExpression(child, { superProps }) {\n      if (child.get(\"object\").isSuper()) superProps.push(child);\n    },\n    Identifier(child, { argumentsPaths }) {\n      if (!child.isReferencedIdentifier({ name: \"arguments\" })) return;\n\n      let curr = child.scope;\n      do {\n        if (curr.hasOwnBinding(\"arguments\")) {\n          curr.rename(\"arguments\");\n          return;\n        }\n        if (curr.path.isFunction() && !curr.path.isArrowFunctionExpression()) {\n          break;\n        }\n      } while ((curr = curr.parent));\n\n      argumentsPaths.push(child);\n    },\n    MetaProperty(child, { newTargetPaths }) {\n      if (!child.get(\"meta\").isIdentifier({ name: \"new\" })) return;\n      if (!child.get(\"property\").isIdentifier({ name: \"target\" })) return;\n\n      newTargetPaths.push(child);\n    },\n  },\n  environmentVisitor,\n]);\n\nfunction getScopeInformation(fnPath: NodePath) {\n  const thisPaths: ScopeInfo[\"thisPaths\"] = [];\n  const argumentsPaths: ScopeInfo[\"argumentsPaths\"] = [];\n  const newTargetPaths: ScopeInfo[\"newTargetPaths\"] = [];\n  const superProps: ScopeInfo[\"superProps\"] = [];\n  const superCalls: ScopeInfo[\"superCalls\"] = [];\n\n  fnPath.traverse(getScopeInformationVisitor, {\n    thisPaths,\n    argumentsPaths,\n    newTargetPaths,\n    superProps,\n    superCalls,\n  });\n\n  return {\n    thisPaths,\n    argumentsPaths,\n    newTargetPaths,\n    superProps,\n    superCalls,\n  };\n}\n"],"mappings":"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"}

package/lib/path/evaluation.js

@@ -219,20 +219,20 @@ function _evaluate(path, state) {
       }
 
       const keyPath = prop.get("key");
-      let key = keyPath;
+      let key;
 
       if (prop.node.computed) {
-        key = key.evaluate();
+        key = keyPath.evaluate();
 
         if (!key.confident) {
           return deopt(key.deopt, state);
         }
 
         key = key.value;
-      } else if (key.isIdentifier()) {
-        key = key.node.name;
+      } else if (keyPath.isIdentifier()) {
+        key = keyPath.node.name;
       } else {
-        key = key.node.value;
+        key = keyPath.node.value;
       }
 
       const valuePath = prop.get("value");
@@ -267,6 +267,11 @@ function _evaluate(path, state) {
         state.confident = leftConfident && (!left || rightConfident);
         if (!state.confident) return;
         return left && right;
+
+      case "??":
+        state.confident = leftConfident && (left != null || rightConfident);
+        if (!state.confident) return;
+        return left != null ? left : right;
     }
   }
 
@@ -406,4 +411,6 @@ function evaluate() {
     deopt: state.deoptPath,
     value: value
   };
-}
+}
+
+//# sourceMappingURL=evaluation.js.map

package/lib/path/evaluation.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["VALID_CALLEES","INVALID_METHODS","isValidCallee","val","includes","isInvalidMethod","evaluateTruthy","res","evaluate","confident","value","deopt","path","state","deoptPath","evaluateCached","node","seen","has","existing","get","resolved","item","set","_evaluate","isSequenceExpression","exprs","length","isStringLiteral","isNumericLiteral","isBooleanLiteral","isNullLiteral","isTemplateLiteral","evaluateQuasis","quasis","isTaggedTemplateExpression","isMemberExpression","object","name","property","isIdentifier","scope","getBinding","quasi","isConditionalExpression","testResult","isExpressionWrapper","parentPath","isCallExpression","callee","isLiteral","type","isReferencedIdentifier","binding","constantViolations","start","end","hasValue","undefined","Infinity","NaN","resolve","isUnaryExpression","prefix","operator","argument","isFunction","isClass","arg","isArrayExpression","arr","elems","elem","elemValue","push","isObjectExpression","obj","props","prop","isObjectMethod","isSpreadElement","keyPath","key","computed","valuePath","isLogicalExpression","wasConfident","left","leftConfident","right","rightConfident","isBinaryExpression","context","func","global","args","map","apply","raw","str","i","cooked","expr","String","Map"],"sources":["../../src/path/evaluation.ts"],"sourcesContent":["import type NodePath from \"./index\";\nimport type * as t from \"@babel/types\";\n\n// This file contains Babels metainterpreter that can evaluate static code.\n\nconst VALID_CALLEES = [\"String\", \"Number\", \"Math\"] as const;\nconst INVALID_METHODS = [\"random\"] as const;\n\nfunction isValidCallee(val: string): val is typeof VALID_CALLEES[number] {\n  return VALID_CALLEES.includes(\n    // @ts-expect-error val is a string\n    val,\n  );\n}\n\nfunction isInvalidMethod(val: string): val is typeof INVALID_METHODS[number] {\n  return INVALID_METHODS.includes(\n    // @ts-expect-error val is a string\n    val,\n  );\n}\n\n/**\n * Walk the input `node` and statically evaluate if it's truthy.\n *\n * Returning `true` when we're sure that the expression will evaluate to a\n * truthy value, `false` if we're sure that it will evaluate to a falsy\n * value and `undefined` if we aren't sure. Because of this please do not\n * rely on coercion when using this method and check with === if it's false.\n *\n * For example do:\n *\n *   if (t.evaluateTruthy(node) === false) falsyLogic();\n *\n * **AND NOT**\n *\n *   if (!t.evaluateTruthy(node)) falsyLogic();\n *\n */\n\nexport function evaluateTruthy(this: NodePath): boolean {\n  const res = this.evaluate();\n  if (res.confident) return !!res.value;\n}\n\ntype State = {\n  confident: boolean;\n  deoptPath: NodePath | null;\n  seen: Map<t.Node, Result>;\n};\n\ntype Result = {\n  resolved: boolean;\n  value?: any;\n};\n/**\n * Deopts the evaluation\n */\nfunction deopt(path: NodePath, state: State) {\n  if (!state.confident) return;\n  state.deoptPath = path;\n  state.confident = false;\n}\n\n/**\n * We wrap the _evaluate method so we can track `seen` nodes, we push an item\n * to the map before we actually evaluate it so we can deopt on self recursive\n * nodes such as:\n *\n *   var g = a ? 1 : 2,\n *       a = g * this.foo\n */\nfunction evaluateCached(path: NodePath, state: State): any {\n  const { node } = path;\n  const { seen } = state;\n\n  if (seen.has(node)) {\n    const existing = seen.get(node);\n    if (existing.resolved) {\n      return existing.value;\n    } else {\n      deopt(path, state);\n      return;\n    }\n  } else {\n    const item: Result = { resolved: false };\n    seen.set(node, item);\n\n    const val = _evaluate(path, state);\n    if (state.confident) {\n      item.resolved = true;\n      item.value = val;\n    }\n    return val;\n  }\n}\n\nfunction _evaluate(path: NodePath, state: State): any {\n  if (!state.confident) return;\n\n  if (path.isSequenceExpression()) {\n    const exprs = path.get(\"expressions\");\n    return evaluateCached(exprs[exprs.length - 1], state);\n  }\n\n  if (\n    path.isStringLiteral() ||\n    path.isNumericLiteral() ||\n    path.isBooleanLiteral()\n  ) {\n    return path.node.value;\n  }\n\n  if (path.isNullLiteral()) {\n    return null;\n  }\n\n  if (path.isTemplateLiteral()) {\n    return evaluateQuasis(path, path.node.quasis, state);\n  }\n\n  if (\n    path.isTaggedTemplateExpression() &&\n    path.get(\"tag\").isMemberExpression()\n  ) {\n    const object = path.get(\"tag.object\") as NodePath;\n    const {\n      // @ts-expect-error todo(flow->ts): possible bug, object is can be any expression and so name might be undefined\n      node: { name },\n    } = object;\n    const property = path.get(\"tag.property\") as NodePath;\n\n    if (\n      object.isIdentifier() &&\n      name === \"String\" &&\n      // todo(flow->ts): was changed from getBinding(name, true)\n      //  should this be hasBinding(name, true) as the binding is never used later?\n      !path.scope.getBinding(name) &&\n      property.isIdentifier() &&\n      property.node.name === \"raw\"\n    ) {\n      return evaluateQuasis(path, path.node.quasi.quasis, state, true);\n    }\n  }\n\n  if (path.isConditionalExpression()) {\n    const testResult = evaluateCached(path.get(\"test\"), state);\n    if (!state.confident) return;\n    if (testResult) {\n      return evaluateCached(path.get(\"consequent\"), state);\n    } else {\n      return evaluateCached(path.get(\"alternate\"), state);\n    }\n  }\n\n  if (path.isExpressionWrapper()) {\n    // TypeCastExpression, ExpressionStatement etc\n    return evaluateCached(path.get(\"expression\"), state);\n  }\n\n  // \"foo\".length\n  if (\n    path.isMemberExpression() &&\n    !path.parentPath.isCallExpression({ callee: path.node })\n  ) {\n    const property = path.get(\"property\");\n    const object = path.get(\"object\");\n\n    if (object.isLiteral() && property.isIdentifier()) {\n      // @ts-expect-error todo(flow->ts): instead of typeof - would it be better to check type of ast node?\n      const value = object.node.value;\n      const type = typeof value;\n      if (type === \"number\" || type === \"string\") {\n        return value[property.node.name];\n      }\n    }\n  }\n\n  if (path.isReferencedIdentifier()) {\n    const binding = path.scope.getBinding(path.node.name);\n\n    if (binding && binding.constantViolations.length > 0) {\n      return deopt(binding.path, state);\n    }\n\n    if (binding && path.node.start < binding.path.node.end) {\n      return deopt(binding.path, state);\n    }\n\n    if (binding?.hasValue) {\n      return binding.value;\n    } else {\n      if (path.node.name === \"undefined\") {\n        return binding ? deopt(binding.path, state) : undefined;\n      } else if (path.node.name === \"Infinity\") {\n        return binding ? deopt(binding.path, state) : Infinity;\n      } else if (path.node.name === \"NaN\") {\n        return binding ? deopt(binding.path, state) : NaN;\n      }\n\n      const resolved = path.resolve();\n      if (resolved === path) {\n        return deopt(path, state);\n      } else {\n        return evaluateCached(resolved, state);\n      }\n    }\n  }\n\n  if (path.isUnaryExpression({ prefix: true })) {\n    if (path.node.operator === \"void\") {\n      // we don't need to evaluate the argument to know what this will return\n      return undefined;\n    }\n\n    const argument = path.get(\"argument\");\n    if (\n      path.node.operator === \"typeof\" &&\n      (argument.isFunction() || argument.isClass())\n    ) {\n      return \"function\";\n    }\n\n    const arg = evaluateCached(argument, state);\n    if (!state.confident) return;\n    switch (path.node.operator) {\n      case \"!\":\n        return !arg;\n      case \"+\":\n        return +arg;\n      case \"-\":\n        return -arg;\n      case \"~\":\n        return ~arg;\n      case \"typeof\":\n        return typeof arg;\n    }\n  }\n\n  if (path.isArrayExpression()) {\n    const arr = [];\n    const elems: Array<NodePath> = path.get(\"elements\");\n    for (const elem of elems) {\n      const elemValue = elem.evaluate();\n\n      if (elemValue.confident) {\n        arr.push(elemValue.value);\n      } else {\n        return deopt(elemValue.deopt, state);\n      }\n    }\n    return arr;\n  }\n\n  if (path.isObjectExpression()) {\n    const obj = {};\n    const props = path.get(\"properties\");\n    for (const prop of props) {\n      if (prop.isObjectMethod() || prop.isSpreadElement()) {\n        return deopt(prop, state);\n      }\n      const keyPath = (prop as NodePath<t.ObjectProperty>).get(\"key\");\n      let key;\n      // @ts-expect-error todo(flow->ts): type refinement issues ObjectMethod and SpreadElement somehow not excluded\n      if (prop.node.computed) {\n        key = keyPath.evaluate();\n        if (!key.confident) {\n          return deopt(key.deopt, state);\n        }\n        key = key.value;\n      } else if (keyPath.isIdentifier()) {\n        key = keyPath.node.name;\n      } else {\n        key = (\n          keyPath.node as t.StringLiteral | t.NumericLiteral | t.BigIntLiteral\n        ).value;\n      }\n      const valuePath = (prop as NodePath<t.ObjectProperty>).get(\"value\");\n      let value = valuePath.evaluate();\n      if (!value.confident) {\n        return deopt(value.deopt, state);\n      }\n      value = value.value;\n      // @ts-expect-error key is any type\n      obj[key] = value;\n    }\n    return obj;\n  }\n\n  if (path.isLogicalExpression()) {\n    // If we are confident that the left side of an && is false, or the left\n    // side of an || is true, we can be confident about the entire expression\n    const wasConfident = state.confident;\n    const left = evaluateCached(path.get(\"left\"), state);\n    const leftConfident = state.confident;\n    state.confident = wasConfident;\n    const right = evaluateCached(path.get(\"right\"), state);\n    const rightConfident = state.confident;\n\n    switch (path.node.operator) {\n      case \"||\":\n        // TODO consider having a \"truthy type\" that doesn't bail on\n        // left uncertainty but can still evaluate to truthy.\n        state.confident = leftConfident && (!!left || rightConfident);\n        if (!state.confident) return;\n\n        return left || right;\n      case \"&&\":\n        state.confident = leftConfident && (!left || rightConfident);\n        if (!state.confident) return;\n\n        return left && right;\n      case \"??\":\n        state.confident = leftConfident && (left != null || rightConfident);\n        if (!state.confident) return;\n\n        return left ?? right;\n    }\n  }\n\n  if (path.isBinaryExpression()) {\n    const left = evaluateCached(path.get(\"left\"), state);\n    if (!state.confident) return;\n    const right = evaluateCached(path.get(\"right\"), state);\n    if (!state.confident) return;\n\n    switch (path.node.operator) {\n      case \"-\":\n        return left - right;\n      case \"+\":\n        return left + right;\n      case \"/\":\n        return left / right;\n      case \"*\":\n        return left * right;\n      case \"%\":\n        return left % right;\n      case \"**\":\n        return left ** right;\n      case \"<\":\n        return left < right;\n      case \">\":\n        return left > right;\n      case \"<=\":\n        return left <= right;\n      case \">=\":\n        return left >= right;\n      case \"==\":\n        return left == right; // eslint-disable-line eqeqeq\n      case \"!=\":\n        return left != right;\n      case \"===\":\n        return left === right;\n      case \"!==\":\n        return left !== right;\n      case \"|\":\n        return left | right;\n      case \"&\":\n        return left & right;\n      case \"^\":\n        return left ^ right;\n      case \"<<\":\n        return left << right;\n      case \">>\":\n        return left >> right;\n      case \">>>\":\n        return left >>> right;\n    }\n  }\n\n  if (path.isCallExpression()) {\n    const callee = path.get(\"callee\");\n    let context;\n    let func;\n\n    // Number(1);\n    if (\n      callee.isIdentifier() &&\n      !path.scope.getBinding(callee.node.name) &&\n      isValidCallee(callee.node.name)\n    ) {\n      func = global[callee.node.name];\n    }\n\n    if (callee.isMemberExpression()) {\n      const object = callee.get(\"object\");\n      const property = callee.get(\"property\");\n\n      // Math.min(1, 2)\n      if (\n        object.isIdentifier() &&\n        property.isIdentifier() &&\n        isValidCallee(object.node.name) &&\n        !isInvalidMethod(property.node.name)\n      ) {\n        context = global[object.node.name];\n        // @ts-expect-error property may not exist in context object\n        func = context[property.node.name];\n      }\n\n      // \"abc\".charCodeAt(4)\n      if (object.isLiteral() && property.isIdentifier()) {\n        // @ts-expect-error todo(flow->ts): consider checking ast node type instead of value type (StringLiteral and NumberLiteral)\n        const type = typeof object.node.value;\n        if (type === \"string\" || type === \"number\") {\n          // @ts-expect-error todo(flow->ts): consider checking ast node type instead of value type\n          context = object.node.value;\n          func = context[property.node.name];\n        }\n      }\n    }\n\n    if (func) {\n      const args = path.get(\"arguments\").map(arg => evaluateCached(arg, state));\n      if (!state.confident) return;\n\n      return func.apply(context, args);\n    }\n  }\n\n  deopt(path, state);\n}\n\nfunction evaluateQuasis(\n  path: NodePath<t.TaggedTemplateExpression | t.TemplateLiteral>,\n  quasis: Array<any>,\n  state: State,\n  raw = false,\n) {\n  let str = \"\";\n\n  let i = 0;\n  const exprs = path.get(\"expressions\");\n\n  for (const elem of quasis) {\n    // not confident, evaluated an expression we don't like\n    if (!state.confident) break;\n\n    // add on element\n    str += raw ? elem.value.raw : elem.value.cooked;\n\n    // add on interpolated expression if it's present\n    const expr = exprs[i++];\n    if (expr) str += String(evaluateCached(expr, state));\n  }\n\n  if (!state.confident) return;\n  return str;\n}\n\n/**\n * Walk the input `node` and statically evaluate it.\n *\n * Returns an object in the form `{ confident, value, deopt }`. `confident`\n * indicates whether or not we had to drop out of evaluating the expression\n * because of hitting an unknown node that we couldn't confidently find the\n * value of, in which case `deopt` is the path of said node.\n *\n * Example:\n *\n *   t.evaluate(parse(\"5 + 5\")) // { confident: true, value: 10 }\n *   t.evaluate(parse(\"!true\")) // { confident: true, value: false }\n *   t.evaluate(parse(\"foo + foo\")) // { confident: false, value: undefined, deopt: NodePath }\n *\n */\n\nexport function evaluate(this: NodePath): {\n  confident: boolean;\n  value: any;\n  deopt?: NodePath;\n} {\n  const state: State = {\n    confident: true,\n    deoptPath: null,\n    seen: new Map(),\n  };\n  let value = evaluateCached(this, state);\n  if (!state.confident) value = undefined;\n\n  return {\n    confident: state.confident,\n    deopt: state.deoptPath,\n    value: value,\n  };\n}\n"],"mappings":"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"}

package/lib/path/family.js

@@ -402,6 +402,8 @@ function getBindingIdentifierPaths(duplicates = false, outerOnly = false) {
   return ids;
 }
 
-function getOuterBindingIdentifierPaths(duplicates) {
+function getOuterBindingIdentifierPaths(duplicates = false) {
   return this.getBindingIdentifierPaths(duplicates, true);
-}
+}
+
+//# sourceMappingURL=family.js.map

package/lib/path/family.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["getBindingIdentifiers","_getBindingIdentifiers","getOuterBindingIdentifiers","_getOuterBindingIdentifiers","isDeclaration","numericLiteral","unaryExpression","NORMAL_COMPLETION","BREAK_COMPLETION","NormalCompletion","path","type","BreakCompletion","getOpposite","key","getSibling","addCompletionRecords","records","context","push","_getCompletionRecords","completionRecordForSwitch","cases","lastNormalCompletions","i","length","casePath","caseCompletions","normalCompletions","breakCompletions","c","normalCompletionToBreak","completions","forEach","replaceBreakStatementInBreakCompletion","reachable","isBreakStatement","label","replaceWith","remove","getStatementListCompletion","paths","canHaveBreak","newContext","inCaseClause","isBlockStatement","shouldPopulateBreak","statementCompletions","every","some","pathCompletions","isVariableDeclaration","isIfStatement","get","isDoExpression","isFor","isWhile","isLabeledStatement","isProgram","isFunction","isTryStatement","isCatchClause","isSwitchStatement","isSwitchCase","getCompletionRecords","map","r","NodePath","parentPath","parent","container","listKey","setContext","getPrevSibling","getNextSibling","getAllNextSiblings","_key","sibling","siblings","node","getAllPrevSiblings","parts","split","_getKey","_getPattern","Array","isArray","_","part","duplicates","getBindingIdentifierPaths","outerOnly","search","ids","Object","create","id","shift","keys","isIdentifier","_ids","name","isExportDeclaration","declaration","isFunctionDeclaration","isFunctionExpression","child","getOuterBindingIdentifierPaths"],"sources":["../../src/path/family.ts"],"sourcesContent":["// This file contains methods responsible for dealing with/retrieving children or siblings.\n\nimport type TraversalContext from \"../context\";\nimport NodePath from \"./index\";\nimport {\n  getBindingIdentifiers as _getBindingIdentifiers,\n  getOuterBindingIdentifiers as _getOuterBindingIdentifiers,\n  isDeclaration,\n  numericLiteral,\n  unaryExpression,\n} from \"@babel/types\";\nimport type * as t from \"@babel/types\";\n\nconst NORMAL_COMPLETION = 0 as const;\nconst BREAK_COMPLETION = 1 as const;\n\ntype Completion = {\n  path: NodePath;\n  type: 0 | 1;\n};\n\ntype CompletionContext = {\n  // whether the current context allows `break` statement. When it allows, we have\n  // to search all the statements for potential `break`\n  canHaveBreak: boolean;\n  // whether the statement is an immediate descendant of a switch case clause\n  inCaseClause: boolean;\n  // whether the `break` statement record should be populated to upper level\n  // when a `break` statement is an immediate descendant of a block statement, e.g.\n  // `{ break }`, it can influence the control flow in the upper levels.\n  shouldPopulateBreak: boolean;\n};\n\nfunction NormalCompletion(path: NodePath) {\n  return { type: NORMAL_COMPLETION, path };\n}\n\nfunction BreakCompletion(path: NodePath) {\n  return { type: BREAK_COMPLETION, path };\n}\n\nexport function getOpposite(this: NodePath): NodePath | null {\n  if (this.key === \"left\") {\n    return this.getSibling(\"right\");\n  } else if (this.key === \"right\") {\n    return this.getSibling(\"left\");\n  }\n  return null;\n}\n\nfunction addCompletionRecords(\n  path: NodePath | null | undefined,\n  records: Completion[],\n  context: CompletionContext,\n): Completion[] {\n  if (path) {\n    records.push(..._getCompletionRecords(path, context));\n  }\n  return records;\n}\n\nfunction completionRecordForSwitch(\n  cases: NodePath<t.SwitchCase>[],\n  records: Completion[],\n  context: CompletionContext,\n): Completion[] {\n  // https://tc39.es/ecma262/#sec-runtime-semantics-caseblockevaluation\n  let lastNormalCompletions: Completion[] = [];\n  for (let i = 0; i < cases.length; i++) {\n    const casePath = cases[i];\n    const caseCompletions = _getCompletionRecords(casePath, context);\n    const normalCompletions = [];\n    const breakCompletions = [];\n    for (const c of caseCompletions) {\n      if (c.type === NORMAL_COMPLETION) {\n        normalCompletions.push(c);\n      }\n      if (c.type === BREAK_COMPLETION) {\n        breakCompletions.push(c);\n      }\n    }\n    if (normalCompletions.length) {\n      lastNormalCompletions = normalCompletions;\n    }\n    records.push(...breakCompletions);\n  }\n  records.push(...lastNormalCompletions);\n  return records;\n}\n\nfunction normalCompletionToBreak(completions: Completion[]) {\n  completions.forEach(c => {\n    c.type = BREAK_COMPLETION;\n  });\n}\n\n/**\n * Determine how we should handle the break statement for break completions\n *\n * @param {Completion[]} completions\n * @param {boolean} reachable Whether the break statement is reachable after\n   we mark the normal completions _before_ the given break completions as the final\n   completions. For example,\n   `{ 0 }; break;` is transformed to `{ return 0 }; break;`, the `break` here is unreachable\n   and thus can be removed without consequences. We may in the future reserve them instead since\n   we do not consistently remove unreachable statements _after_ break\n   `{ var x = 0 }; break;` is transformed to `{ var x = 0 }; return void 0;`, the `break` is reachable\n   because we can not wrap variable declaration under a return statement\n */\nfunction replaceBreakStatementInBreakCompletion(\n  completions: Completion[],\n  reachable: boolean,\n) {\n  completions.forEach(c => {\n    if (c.path.isBreakStatement({ label: null })) {\n      if (reachable) {\n        c.path.replaceWith(unaryExpression(\"void\", numericLiteral(0)));\n      } else {\n        c.path.remove();\n      }\n    }\n  });\n}\n\nfunction getStatementListCompletion(\n  paths: NodePath[],\n  context: CompletionContext,\n): Completion[] {\n  const completions = [];\n  if (context.canHaveBreak) {\n    let lastNormalCompletions = [];\n    for (let i = 0; i < paths.length; i++) {\n      const path = paths[i];\n      const newContext = { ...context, inCaseClause: false };\n      if (\n        path.isBlockStatement() &&\n        (context.inCaseClause || // case test: { break }\n          context.shouldPopulateBreak) // case test: { { break } }\n      ) {\n        newContext.shouldPopulateBreak = true;\n      } else {\n        newContext.shouldPopulateBreak = false;\n      }\n      const statementCompletions = _getCompletionRecords(path, newContext);\n      if (\n        statementCompletions.length > 0 &&\n        // we can stop search `paths` when we have seen a `path` that is\n        // effectively a `break` statement. Examples are\n        // - `break`\n        // - `if (true) { 1; break } else { 2; break }`\n        // - `{ break }```\n        // In other words, the paths after this `path` are unreachable\n        statementCompletions.every(c => c.type === BREAK_COMPLETION)\n      ) {\n        if (\n          lastNormalCompletions.length > 0 &&\n          statementCompletions.every(c =>\n            c.path.isBreakStatement({ label: null }),\n          )\n        ) {\n          // when a break completion has a path as BreakStatement, it must be `{ break }`\n          // whose completion value we can not determine, otherwise it would have been\n          // replaced by `replaceBreakStatementInBreakCompletion`\n          // When we have seen normal completions from the last statement\n          // it is safe to stop populating break and mark normal completions as break\n          normalCompletionToBreak(lastNormalCompletions);\n          completions.push(...lastNormalCompletions);\n          // Declarations have empty completion record, however they can not be nested\n          // directly in return statement, i.e. `return (var a = 1)` is invalid.\n          if (lastNormalCompletions.some(c => c.path.isDeclaration())) {\n            completions.push(...statementCompletions);\n            replaceBreakStatementInBreakCompletion(\n              statementCompletions,\n              /* reachable */ true,\n            );\n          }\n          replaceBreakStatementInBreakCompletion(\n            statementCompletions,\n            /* reachable */ false,\n          );\n        } else {\n          completions.push(...statementCompletions);\n          if (!context.shouldPopulateBreak) {\n            replaceBreakStatementInBreakCompletion(\n              statementCompletions,\n              /* reachable */ true,\n            );\n          }\n        }\n        break;\n      }\n      if (i === paths.length - 1) {\n        completions.push(...statementCompletions);\n      } else {\n        lastNormalCompletions = [];\n        for (let i = 0; i < statementCompletions.length; i++) {\n          const c = statementCompletions[i];\n          if (c.type === BREAK_COMPLETION) {\n            completions.push(c);\n          }\n          if (c.type === NORMAL_COMPLETION) {\n            lastNormalCompletions.push(c);\n          }\n        }\n      }\n    }\n  } else if (paths.length) {\n    // When we are in a context where `break` must not exist, we can skip linear\n    // search on statement lists and assume that the last\n    // non-variable-declaration statement determines the completion.\n    for (let i = paths.length - 1; i >= 0; i--) {\n      const pathCompletions = _getCompletionRecords(paths[i], context);\n      if (\n        pathCompletions.length > 1 ||\n        (pathCompletions.length === 1 &&\n          !pathCompletions[0].path.isVariableDeclaration())\n      ) {\n        completions.push(...pathCompletions);\n        break;\n      }\n    }\n  }\n  return completions;\n}\n\nfunction _getCompletionRecords(\n  path: NodePath,\n  context: CompletionContext,\n): Completion[] {\n  let records: Completion[] = [];\n  if (path.isIfStatement()) {\n    records = addCompletionRecords(path.get(\"consequent\"), records, context);\n    records = addCompletionRecords(path.get(\"alternate\"), records, context);\n  } else if (\n    path.isDoExpression() ||\n    path.isFor() ||\n    path.isWhile() ||\n    path.isLabeledStatement()\n  ) {\n    // @ts-expect-error(flow->ts): todo\n    return addCompletionRecords(path.get(\"body\"), records, context);\n  } else if (path.isProgram() || path.isBlockStatement()) {\n    // @ts-expect-error(flow->ts): todo\n    return getStatementListCompletion(path.get(\"body\"), context);\n  } else if (path.isFunction()) {\n    return _getCompletionRecords(path.get(\"body\"), context);\n  } else if (path.isTryStatement()) {\n    records = addCompletionRecords(path.get(\"block\"), records, context);\n    records = addCompletionRecords(path.get(\"handler\"), records, context);\n  } else if (path.isCatchClause()) {\n    return addCompletionRecords(path.get(\"body\"), records, context);\n  } else if (path.isSwitchStatement()) {\n    return completionRecordForSwitch(path.get(\"cases\"), records, context);\n  } else if (path.isSwitchCase()) {\n    return getStatementListCompletion(path.get(\"consequent\"), {\n      canHaveBreak: true,\n      shouldPopulateBreak: false,\n      inCaseClause: true,\n    });\n  } else if (path.isBreakStatement()) {\n    records.push(BreakCompletion(path));\n  } else {\n    records.push(NormalCompletion(path));\n  }\n\n  return records;\n}\n\n/**\n * Retrieve the completion records of a given path.\n * Note: to ensure proper support on `break` statement, this method\n * will manipulate the AST around the break statement. Do not call the method\n * twice for the same path.\n *\n * @export\n * @param {NodePath} this\n * @returns {NodePath[]} Completion records\n */\nexport function getCompletionRecords(this: NodePath): NodePath[] {\n  const records = _getCompletionRecords(this, {\n    canHaveBreak: false,\n    shouldPopulateBreak: false,\n    inCaseClause: false,\n  });\n  return records.map(r => r.path);\n}\n\nexport function getSibling(this: NodePath, key: string | number): NodePath {\n  return NodePath.get({\n    parentPath: this.parentPath,\n    parent: this.parent,\n    container: this.container,\n    listKey: this.listKey,\n    key: key,\n  }).setContext(this.context);\n}\n\nexport function getPrevSibling(this: NodePath): NodePath {\n  // @ts-expect-error todo(flow->ts) this.key could be a string\n  return this.getSibling(this.key - 1);\n}\n\nexport function getNextSibling(this: NodePath): NodePath {\n  // @ts-expect-error todo(flow->ts) this.key could be a string\n  return this.getSibling(this.key + 1);\n}\n\nexport function getAllNextSiblings(this: NodePath): NodePath[] {\n  // @ts-expect-error todo(flow->ts) this.key could be a string\n  let _key: number = this.key;\n  let sibling = this.getSibling(++_key);\n  const siblings = [];\n  while (sibling.node) {\n    siblings.push(sibling);\n    sibling = this.getSibling(++_key);\n  }\n  return siblings;\n}\n\nexport function getAllPrevSiblings(this: NodePath): NodePath[] {\n  // @ts-expect-error todo(flow->ts) this.key could be a string\n  let _key: number = this.key;\n  let sibling = this.getSibling(--_key);\n  const siblings = [];\n  while (sibling.node) {\n    siblings.push(sibling);\n    sibling = this.getSibling(--_key);\n  }\n  return siblings;\n}\n\n// convert \"1\" to 1 (string index to number index)\ntype MaybeToIndex<T extends string> = T extends `${bigint}` ? number : T;\n\ntype Pattern<Obj extends string, Prop extends string> = `${Obj}.${Prop}`;\n\n// split \"body.body.1\" to [\"body\", \"body\", 1]\ntype Split<P extends string> = P extends Pattern<infer O, infer U>\n  ? [MaybeToIndex<O>, ...Split<U>]\n  : [MaybeToIndex<P>];\n\n// get all K with Node[K] is t.Node | t.Node[]\ntype NodeKeyOf<Node extends t.Node | t.Node[]> = keyof Pick<\n  Node,\n  {\n    [Key in keyof Node]-?: Node[Key] extends t.Node | t.Node[] ? Key : never;\n  }[keyof Node]\n>;\n\n// traverse the Node with tuple path [\"body\", \"body\", 1]\n// Path should be created with Split\ntype Trav<\n  Node extends t.Node | t.Node[],\n  Path extends unknown[],\n> = Path extends [infer K, ...infer R]\n  ? K extends NodeKeyOf<Node>\n    ? R extends []\n      ? Node[K]\n      : // @ts-expect-error ignore since TS is not smart enough\n        Trav<Node[K], R>\n    : never\n  : never;\n\ntype ToNodePath<T> = T extends Array<t.Node | null | undefined>\n  ? Array<NodePath<T[number]>>\n  : T extends t.Node | null | undefined\n  ? NodePath<T>\n  : never;\n\nfunction get<T extends t.Node, K extends keyof T>(\n  this: NodePath<T>,\n  key: K,\n  context?: boolean | TraversalContext,\n): T[K] extends Array<t.Node | null | undefined>\n  ? Array<NodePath<T[K][number]>>\n  : T[K] extends t.Node | null | undefined\n  ? NodePath<T[K]>\n  : never;\n\nfunction get<T extends t.Node, K extends string>(\n  this: NodePath<T>,\n  key: K,\n  context?: boolean | TraversalContext,\n): ToNodePath<Trav<T, Split<K>>>;\n\nfunction get<T extends t.Node>(\n  this: NodePath<T>,\n  key: string,\n  context?: true | TraversalContext,\n): NodePath | NodePath[];\n\nfunction get<T extends t.Node>(\n  this: NodePath<T>,\n  key: string,\n  context: true | TraversalContext = true,\n): NodePath | NodePath[] {\n  if (context === true) context = this.context;\n  const parts = key.split(\".\");\n  if (parts.length === 1) {\n    // \"foo\"\n    // @ts-expect-error key may not index T\n    return this._getKey(key, context);\n  } else {\n    // \"foo.bar\"\n    return this._getPattern(parts, context);\n  }\n}\n\nexport { get };\n\nexport function _getKey<T extends t.Node>(\n  this: NodePath<T>,\n  key: keyof T & string,\n  context?: TraversalContext,\n): NodePath | NodePath[] {\n  const node = this.node;\n  const container = node[key];\n\n  if (Array.isArray(container)) {\n    // requested a container so give them all the paths\n    return container.map((_, i) => {\n      return NodePath.get({\n        listKey: key,\n        parentPath: this,\n        parent: node,\n        container: container,\n        key: i,\n      }).setContext(context);\n    });\n  } else {\n    return NodePath.get({\n      parentPath: this,\n      parent: node,\n      container: node,\n      key: key,\n    }).setContext(context);\n  }\n}\n\nexport function _getPattern(\n  this: NodePath,\n  parts: string[],\n  context?: TraversalContext,\n): NodePath | NodePath[] {\n  let path: NodePath | NodePath[] = this;\n  for (const part of parts) {\n    if (part === \".\") {\n      // @ts-expect-error todo(flow-ts): Can path be an array here?\n      path = path.parentPath;\n    } else {\n      if (Array.isArray(path)) {\n        // @ts-expect-error part may not index path\n        path = path[part];\n      } else {\n        path = path.get(part, context);\n      }\n    }\n  }\n  return path;\n}\n\nfunction getBindingIdentifiers(\n  duplicates: true,\n): Record<string, t.Identifier[]>;\nfunction getBindingIdentifiers(\n  duplicates?: false,\n): Record<string, t.Identifier>;\nfunction getBindingIdentifiers(\n  duplicates: boolean,\n): Record<string, t.Identifier[] | t.Identifier>;\n\nfunction getBindingIdentifiers(\n  this: NodePath,\n  duplicates?: boolean,\n): Record<string, t.Identifier[] | t.Identifier> {\n  return _getBindingIdentifiers(this.node, duplicates);\n}\n\nexport { getBindingIdentifiers };\n\nfunction getOuterBindingIdentifiers(\n  duplicates: true,\n): Record<string, t.Identifier[]>;\nfunction getOuterBindingIdentifiers(\n  duplicates?: false,\n): Record<string, t.Identifier>;\nfunction getOuterBindingIdentifiers(\n  duplicates: boolean,\n): Record<string, t.Identifier[] | t.Identifier>;\n\nfunction getOuterBindingIdentifiers(\n  this: NodePath,\n  duplicates?: boolean,\n): Record<string, t.Identifier[] | t.Identifier> {\n  return _getOuterBindingIdentifiers(this.node, duplicates);\n}\n\nexport { getOuterBindingIdentifiers };\n\nfunction getBindingIdentifierPaths(\n  duplicates: true,\n  outerOnly?: boolean,\n): Record<string, NodePath<t.Identifier>[]>;\nfunction getBindingIdentifierPaths(\n  duplicates: false,\n  outerOnly?: boolean,\n): Record<string, NodePath<t.Identifier>>;\nfunction getBindingIdentifierPaths(\n  duplicates?: boolean,\n  outerOnly?: boolean,\n): Record<string, NodePath<t.Identifier> | NodePath<t.Identifier>[]>;\n\n// original source - https://github.com/babel/babel/blob/main/packages/babel-types/src/retrievers/getBindingIdentifiers.js\n// path.getBindingIdentifiers returns nodes where the following re-implementation returns paths\nfunction getBindingIdentifierPaths(\n  this: NodePath,\n  duplicates: boolean = false,\n  outerOnly: boolean = false,\n): Record<string, NodePath<t.Identifier> | NodePath<t.Identifier>[]> {\n  const path = this;\n  const search = [path];\n  const ids = Object.create(null);\n\n  while (search.length) {\n    const id = search.shift();\n    if (!id) continue;\n    if (!id.node) continue;\n\n    const keys =\n      // @ts-expect-error _getBindingIdentifiers.keys do not cover all node types\n      _getBindingIdentifiers.keys[id.node.type];\n\n    if (id.isIdentifier()) {\n      if (duplicates) {\n        const _ids = (ids[id.node.name] = ids[id.node.name] || []);\n        _ids.push(id);\n      } else {\n        ids[id.node.name] = id;\n      }\n      continue;\n    }\n\n    if (id.isExportDeclaration()) {\n      const declaration = id.get(\"declaration\");\n      if (isDeclaration(declaration)) {\n        search.push(declaration);\n      }\n      continue;\n    }\n\n    if (outerOnly) {\n      if (id.isFunctionDeclaration()) {\n        search.push(id.get(\"id\"));\n        continue;\n      }\n      if (id.isFunctionExpression()) {\n        continue;\n      }\n    }\n\n    if (keys) {\n      for (let i = 0; i < keys.length; i++) {\n        const key = keys[i];\n        const child = id.get(key);\n        if (Array.isArray(child)) {\n          search.push(...child);\n        } else if (child.node) {\n          search.push(child);\n        }\n      }\n    }\n  }\n\n  return ids;\n}\n\nexport { getBindingIdentifierPaths };\n\nfunction getOuterBindingIdentifierPaths(\n  duplicates: true,\n): Record<string, NodePath<t.Identifier>[]>;\nfunction getOuterBindingIdentifierPaths(\n  duplicates?: false,\n): Record<string, NodePath<t.Identifier>>;\nfunction getOuterBindingIdentifierPaths(\n  duplicates?: boolean,\n): Record<string, NodePath<t.Identifier> | NodePath<t.Identifier>[]>;\n\nfunction getOuterBindingIdentifierPaths(\n  this: NodePath,\n  duplicates: boolean = false,\n) {\n  return this.getBindingIdentifierPaths(duplicates, true);\n}\n\nexport { getOuterBindingIdentifierPaths };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAGA;;AACA;;;EACEA,qB,EAAyBC,sB;EACzBC,0B,EAA8BC,2B;EAC9BC,a;EACAC,c;EACAC;;AAIF,MAAMC,iBAAiB,GAAG,CAA1B;AACA,MAAMC,gBAAgB,GAAG,CAAzB;;AAmBA,SAASC,gBAAT,CAA0BC,IAA1B,EAA0C;EACxC,OAAO;IAAEC,IAAI,EAAEJ,iBAAR;IAA2BG;EAA3B,CAAP;AACD;;AAED,SAASE,eAAT,CAAyBF,IAAzB,EAAyC;EACvC,OAAO;IAAEC,IAAI,EAAEH,gBAAR;IAA0BE;EAA1B,CAAP;AACD;;AAEM,SAASG,WAAT,GAAsD;EAC3D,IAAI,KAAKC,GAAL,KAAa,MAAjB,EAAyB;IACvB,OAAO,KAAKC,UAAL,CAAgB,OAAhB,CAAP;EACD,CAFD,MAEO,IAAI,KAAKD,GAAL,KAAa,OAAjB,EAA0B;IAC/B,OAAO,KAAKC,UAAL,CAAgB,MAAhB,CAAP;EACD;;EACD,OAAO,IAAP;AACD;;AAED,SAASC,oBAAT,CACEN,IADF,EAEEO,OAFF,EAGEC,OAHF,EAIgB;EACd,IAAIR,IAAJ,EAAU;IACRO,OAAO,CAACE,IAAR,CAAa,GAAGC,qBAAqB,CAACV,IAAD,EAAOQ,OAAP,CAArC;EACD;;EACD,OAAOD,OAAP;AACD;;AAED,SAASI,yBAAT,CACEC,KADF,EAEEL,OAFF,EAGEC,OAHF,EAIgB;EAEd,IAAIK,qBAAmC,GAAG,EAA1C;;EACA,KAAK,IAAIC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGF,KAAK,CAACG,MAA1B,EAAkCD,CAAC,EAAnC,EAAuC;IACrC,MAAME,QAAQ,GAAGJ,KAAK,CAACE,CAAD,CAAtB;;IACA,MAAMG,eAAe,GAAGP,qBAAqB,CAACM,QAAD,EAAWR,OAAX,CAA7C;;IACA,MAAMU,iBAAiB,GAAG,EAA1B;IACA,MAAMC,gBAAgB,GAAG,EAAzB;;IACA,KAAK,MAAMC,CAAX,IAAgBH,eAAhB,EAAiC;MAC/B,IAAIG,CAAC,CAACnB,IAAF,KAAWJ,iBAAf,EAAkC;QAChCqB,iBAAiB,CAACT,IAAlB,CAAuBW,CAAvB;MACD;;MACD,IAAIA,CAAC,CAACnB,IAAF,KAAWH,gBAAf,EAAiC;QAC/BqB,gBAAgB,CAACV,IAAjB,CAAsBW,CAAtB;MACD;IACF;;IACD,IAAIF,iBAAiB,CAACH,MAAtB,EAA8B;MAC5BF,qBAAqB,GAAGK,iBAAxB;IACD;;IACDX,OAAO,CAACE,IAAR,CAAa,GAAGU,gBAAhB;EACD;;EACDZ,OAAO,CAACE,IAAR,CAAa,GAAGI,qBAAhB;EACA,OAAON,OAAP;AACD;;AAED,SAASc,uBAAT,CAAiCC,WAAjC,EAA4D;EAC1DA,WAAW,CAACC,OAAZ,CAAoBH,CAAC,IAAI;IACvBA,CAAC,CAACnB,IAAF,GAASH,gBAAT;EACD,CAFD;AAGD;;AAeD,SAAS0B,sCAAT,CACEF,WADF,EAEEG,SAFF,EAGE;EACAH,WAAW,CAACC,OAAZ,CAAoBH,CAAC,IAAI;IACvB,IAAIA,CAAC,CAACpB,IAAF,CAAO0B,gBAAP,CAAwB;MAAEC,KAAK,EAAE;IAAT,CAAxB,CAAJ,EAA8C;MAC5C,IAAIF,SAAJ,EAAe;QACbL,CAAC,CAACpB,IAAF,CAAO4B,WAAP,CAAmBhC,eAAe,CAAC,MAAD,EAASD,cAAc,CAAC,CAAD,CAAvB,CAAlC;MACD,CAFD,MAEO;QACLyB,CAAC,CAACpB,IAAF,CAAO6B,MAAP;MACD;IACF;EACF,CARD;AASD;;AAED,SAASC,0BAAT,CACEC,KADF,EAEEvB,OAFF,EAGgB;EACd,MAAMc,WAAW,GAAG,EAApB;;EACA,IAAId,OAAO,CAACwB,YAAZ,EAA0B;IACxB,IAAInB,qBAAqB,GAAG,EAA5B;;IACA,KAAK,IAAIC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGiB,KAAK,CAAChB,MAA1B,EAAkCD,CAAC,EAAnC,EAAuC;MACrC,MAAMd,IAAI,GAAG+B,KAAK,CAACjB,CAAD,CAAlB;MACA,MAAMmB,UAAU,qBAAQzB,OAAR;QAAiB0B,YAAY,EAAE;MAA/B,EAAhB;;MACA,IACElC,IAAI,CAACmC,gBAAL,OACC3B,OAAO,CAAC0B,YAAR,IACC1B,OAAO,CAAC4B,mBAFV,CADF,EAIE;QACAH,UAAU,CAACG,mBAAX,GAAiC,IAAjC;MACD,CAND,MAMO;QACLH,UAAU,CAACG,mBAAX,GAAiC,KAAjC;MACD;;MACD,MAAMC,oBAAoB,GAAG3B,qBAAqB,CAACV,IAAD,EAAOiC,UAAP,CAAlD;;MACA,IACEI,oBAAoB,CAACtB,MAArB,GAA8B,CAA9B,IAOAsB,oBAAoB,CAACC,KAArB,CAA2BlB,CAAC,IAAIA,CAAC,CAACnB,IAAF,KAAWH,gBAA3C,CARF,EASE;QACA,IACEe,qBAAqB,CAACE,MAAtB,GAA+B,CAA/B,IACAsB,oBAAoB,CAACC,KAArB,CAA2BlB,CAAC,IAC1BA,CAAC,CAACpB,IAAF,CAAO0B,gBAAP,CAAwB;UAAEC,KAAK,EAAE;QAAT,CAAxB,CADF,CAFF,EAKE;UAMAN,uBAAuB,CAACR,qBAAD,CAAvB;UACAS,WAAW,CAACb,IAAZ,CAAiB,GAAGI,qBAApB;;UAGA,IAAIA,qBAAqB,CAAC0B,IAAtB,CAA2BnB,CAAC,IAAIA,CAAC,CAACpB,IAAF,CAAON,aAAP,EAAhC,CAAJ,EAA6D;YAC3D4B,WAAW,CAACb,IAAZ,CAAiB,GAAG4B,oBAApB;YACAb,sCAAsC,CACpCa,oBADoC,EAEpB,IAFoB,CAAtC;UAID;;UACDb,sCAAsC,CACpCa,oBADoC,EAEpB,KAFoB,CAAtC;QAID,CA1BD,MA0BO;UACLf,WAAW,CAACb,IAAZ,CAAiB,GAAG4B,oBAApB;;UACA,IAAI,CAAC7B,OAAO,CAAC4B,mBAAb,EAAkC;YAChCZ,sCAAsC,CACpCa,oBADoC,EAEpB,IAFoB,CAAtC;UAID;QACF;;QACD;MACD;;MACD,IAAIvB,CAAC,KAAKiB,KAAK,CAAChB,MAAN,GAAe,CAAzB,EAA4B;QAC1BO,WAAW,CAACb,IAAZ,CAAiB,GAAG4B,oBAApB;MACD,CAFD,MAEO;QACLxB,qBAAqB,GAAG,EAAxB;;QACA,KAAK,IAAIC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGuB,oBAAoB,CAACtB,MAAzC,EAAiDD,CAAC,EAAlD,EAAsD;UACpD,MAAMM,CAAC,GAAGiB,oBAAoB,CAACvB,CAAD,CAA9B;;UACA,IAAIM,CAAC,CAACnB,IAAF,KAAWH,gBAAf,EAAiC;YAC/BwB,WAAW,CAACb,IAAZ,CAAiBW,CAAjB;UACD;;UACD,IAAIA,CAAC,CAACnB,IAAF,KAAWJ,iBAAf,EAAkC;YAChCgB,qBAAqB,CAACJ,IAAtB,CAA2BW,CAA3B;UACD;QACF;MACF;IACF;EACF,CA7ED,MA6EO,IAAIW,KAAK,CAAChB,MAAV,EAAkB;IAIvB,KAAK,IAAID,CAAC,GAAGiB,KAAK,CAAChB,MAAN,GAAe,CAA5B,EAA+BD,CAAC,IAAI,CAApC,EAAuCA,CAAC,EAAxC,EAA4C;MAC1C,MAAM0B,eAAe,GAAG9B,qBAAqB,CAACqB,KAAK,CAACjB,CAAD,CAAN,EAAWN,OAAX,CAA7C;;MACA,IACEgC,eAAe,CAACzB,MAAhB,GAAyB,CAAzB,IACCyB,eAAe,CAACzB,MAAhB,KAA2B,CAA3B,IACC,CAACyB,eAAe,CAAC,CAAD,CAAf,CAAmBxC,IAAnB,CAAwByC,qBAAxB,EAHL,EAIE;QACAnB,WAAW,CAACb,IAAZ,CAAiB,GAAG+B,eAApB;QACA;MACD;IACF;EACF;;EACD,OAAOlB,WAAP;AACD;;AAED,SAASZ,qBAAT,CACEV,IADF,EAEEQ,OAFF,EAGgB;EACd,IAAID,OAAqB,GAAG,EAA5B;;EACA,IAAIP,IAAI,CAAC0C,aAAL,EAAJ,EAA0B;IACxBnC,OAAO,GAAGD,oBAAoB,CAACN,IAAI,CAAC2C,GAAL,CAAS,YAAT,CAAD,EAAyBpC,OAAzB,EAAkCC,OAAlC,CAA9B;IACAD,OAAO,GAAGD,oBAAoB,CAACN,IAAI,CAAC2C,GAAL,CAAS,WAAT,CAAD,EAAwBpC,OAAxB,EAAiCC,OAAjC,CAA9B;EACD,CAHD,MAGO,IACLR,IAAI,CAAC4C,cAAL,MACA5C,IAAI,CAAC6C,KAAL,EADA,IAEA7C,IAAI,CAAC8C,OAAL,EAFA,IAGA9C,IAAI,CAAC+C,kBAAL,EAJK,EAKL;IAEA,OAAOzC,oBAAoB,CAACN,IAAI,CAAC2C,GAAL,CAAS,MAAT,CAAD,EAAmBpC,OAAnB,EAA4BC,OAA5B,CAA3B;EACD,CARM,MAQA,IAAIR,IAAI,CAACgD,SAAL,MAAoBhD,IAAI,CAACmC,gBAAL,EAAxB,EAAiD;IAEtD,OAAOL,0BAA0B,CAAC9B,IAAI,CAAC2C,GAAL,CAAS,MAAT,CAAD,EAAmBnC,OAAnB,CAAjC;EACD,CAHM,MAGA,IAAIR,IAAI,CAACiD,UAAL,EAAJ,EAAuB;IAC5B,OAAOvC,qBAAqB,CAACV,IAAI,CAAC2C,GAAL,CAAS,MAAT,CAAD,EAAmBnC,OAAnB,CAA5B;EACD,CAFM,MAEA,IAAIR,IAAI,CAACkD,cAAL,EAAJ,EAA2B;IAChC3C,OAAO,GAAGD,oBAAoB,CAACN,IAAI,CAAC2C,GAAL,CAAS,OAAT,CAAD,EAAoBpC,OAApB,EAA6BC,OAA7B,CAA9B;IACAD,OAAO,GAAGD,oBAAoB,CAACN,IAAI,CAAC2C,GAAL,CAAS,SAAT,CAAD,EAAsBpC,OAAtB,EAA+BC,OAA/B,CAA9B;EACD,CAHM,MAGA,IAAIR,IAAI,CAACmD,aAAL,EAAJ,EAA0B;IAC/B,OAAO7C,oBAAoB,CAACN,IAAI,CAAC2C,GAAL,CAAS,MAAT,CAAD,EAAmBpC,OAAnB,EAA4BC,OAA5B,CAA3B;EACD,CAFM,MAEA,IAAIR,IAAI,CAACoD,iBAAL,EAAJ,EAA8B;IACnC,OAAOzC,yBAAyB,CAACX,IAAI,CAAC2C,GAAL,CAAS,OAAT,CAAD,EAAoBpC,OAApB,EAA6BC,OAA7B,CAAhC;EACD,CAFM,MAEA,IAAIR,IAAI,CAACqD,YAAL,EAAJ,EAAyB;IAC9B,OAAOvB,0BAA0B,CAAC9B,IAAI,CAAC2C,GAAL,CAAS,YAAT,CAAD,EAAyB;MACxDX,YAAY,EAAE,IAD0C;MAExDI,mBAAmB,EAAE,KAFmC;MAGxDF,YAAY,EAAE;IAH0C,CAAzB,CAAjC;EAKD,CANM,MAMA,IAAIlC,IAAI,CAAC0B,gBAAL,EAAJ,EAA6B;IAClCnB,OAAO,CAACE,IAAR,CAAaP,eAAe,CAACF,IAAD,CAA5B;EACD,CAFM,MAEA;IACLO,OAAO,CAACE,IAAR,CAAaV,gBAAgB,CAACC,IAAD,CAA7B;EACD;;EAED,OAAOO,OAAP;AACD;;AAYM,SAAS+C,oBAAT,GAA0D;EAC/D,MAAM/C,OAAO,GAAGG,qBAAqB,CAAC,IAAD,EAAO;IAC1CsB,YAAY,EAAE,KAD4B;IAE1CI,mBAAmB,EAAE,KAFqB;IAG1CF,YAAY,EAAE;EAH4B,CAAP,CAArC;;EAKA,OAAO3B,OAAO,CAACgD,GAAR,CAAYC,CAAC,IAAIA,CAAC,CAACxD,IAAnB,CAAP;AACD;;AAEM,SAASK,UAAT,CAAoCD,GAApC,EAAoE;EACzE,OAAOqD,cAAA,CAASd,GAAT,CAAa;IAClBe,UAAU,EAAE,KAAKA,UADC;IAElBC,MAAM,EAAE,KAAKA,MAFK;IAGlBC,SAAS,EAAE,KAAKA,SAHE;IAIlBC,OAAO,EAAE,KAAKA,OAJI;IAKlBzD,GAAG,EAAEA;EALa,CAAb,EAMJ0D,UANI,CAMO,KAAKtD,OANZ,CAAP;AAOD;;AAEM,SAASuD,cAAT,GAAkD;EAEvD,OAAO,KAAK1D,UAAL,CAAgB,KAAKD,GAAL,GAAW,CAA3B,CAAP;AACD;;AAEM,SAAS4D,cAAT,GAAkD;EAEvD,OAAO,KAAK3D,UAAL,CAAgB,KAAKD,GAAL,GAAW,CAA3B,CAAP;AACD;;AAEM,SAAS6D,kBAAT,GAAwD;EAE7D,IAAIC,IAAY,GAAG,KAAK9D,GAAxB;EACA,IAAI+D,OAAO,GAAG,KAAK9D,UAAL,CAAgB,EAAE6D,IAAlB,CAAd;EACA,MAAME,QAAQ,GAAG,EAAjB;;EACA,OAAOD,OAAO,CAACE,IAAf,EAAqB;IACnBD,QAAQ,CAAC3D,IAAT,CAAc0D,OAAd;IACAA,OAAO,GAAG,KAAK9D,UAAL,CAAgB,EAAE6D,IAAlB,CAAV;EACD;;EACD,OAAOE,QAAP;AACD;;AAEM,SAASE,kBAAT,GAAwD;EAE7D,IAAIJ,IAAY,GAAG,KAAK9D,GAAxB;EACA,IAAI+D,OAAO,GAAG,KAAK9D,UAAL,CAAgB,EAAE6D,IAAlB,CAAd;EACA,MAAME,QAAQ,GAAG,EAAjB;;EACA,OAAOD,OAAO,CAACE,IAAf,EAAqB;IACnBD,QAAQ,CAAC3D,IAAT,CAAc0D,OAAd;IACAA,OAAO,GAAG,KAAK9D,UAAL,CAAgB,EAAE6D,IAAlB,CAAV;EACD;;EACD,OAAOE,QAAP;AACD;;AA8DD,SAASzB,GAAT,CAEEvC,GAFF,EAGEI,OAAgC,GAAG,IAHrC,EAIyB;EACvB,IAAIA,OAAO,KAAK,IAAhB,EAAsBA,OAAO,GAAG,KAAKA,OAAf;EACtB,MAAM+D,KAAK,GAAGnE,GAAG,CAACoE,KAAJ,CAAU,GAAV,CAAd;;EACA,IAAID,KAAK,CAACxD,MAAN,KAAiB,CAArB,EAAwB;IAGtB,OAAO,KAAK0D,OAAL,CAAarE,GAAb,EAAkBI,OAAlB,CAAP;EACD,CAJD,MAIO;IAEL,OAAO,KAAKkE,WAAL,CAAiBH,KAAjB,EAAwB/D,OAAxB,CAAP;EACD;AACF;;AAIM,SAASiE,OAAT,CAELrE,GAFK,EAGLI,OAHK,EAIkB;EACvB,MAAM6D,IAAI,GAAG,KAAKA,IAAlB;EACA,MAAMT,SAAS,GAAGS,IAAI,CAACjE,GAAD,CAAtB;;EAEA,IAAIuE,KAAK,CAACC,OAAN,CAAchB,SAAd,CAAJ,EAA8B;IAE5B,OAAOA,SAAS,CAACL,GAAV,CAAc,CAACsB,CAAD,EAAI/D,CAAJ,KAAU;MAC7B,OAAO2C,cAAA,CAASd,GAAT,CAAa;QAClBkB,OAAO,EAAEzD,GADS;QAElBsD,UAAU,EAAE,IAFM;QAGlBC,MAAM,EAAEU,IAHU;QAIlBT,SAAS,EAAEA,SAJO;QAKlBxD,GAAG,EAAEU;MALa,CAAb,EAMJgD,UANI,CAMOtD,OANP,CAAP;IAOD,CARM,CAAP;EASD,CAXD,MAWO;IACL,OAAOiD,cAAA,CAASd,GAAT,CAAa;MAClBe,UAAU,EAAE,IADM;MAElBC,MAAM,EAAEU,IAFU;MAGlBT,SAAS,EAAES,IAHO;MAIlBjE,GAAG,EAAEA;IAJa,CAAb,EAKJ0D,UALI,CAKOtD,OALP,CAAP;EAMD;AACF;;AAEM,SAASkE,WAAT,CAELH,KAFK,EAGL/D,OAHK,EAIkB;EACvB,IAAIR,IAA2B,GAAG,IAAlC;;EACA,KAAK,MAAM8E,IAAX,IAAmBP,KAAnB,EAA0B;IACxB,IAAIO,IAAI,KAAK,GAAb,EAAkB;MAEhB9E,IAAI,GAAGA,IAAI,CAAC0D,UAAZ;IACD,CAHD,MAGO;MACL,IAAIiB,KAAK,CAACC,OAAN,CAAc5E,IAAd,CAAJ,EAAyB;QAEvBA,IAAI,GAAGA,IAAI,CAAC8E,IAAD,CAAX;MACD,CAHD,MAGO;QACL9E,IAAI,GAAGA,IAAI,CAAC2C,GAAL,CAASmC,IAAT,EAAetE,OAAf,CAAP;MACD;IACF;EACF;;EACD,OAAOR,IAAP;AACD;;AAYD,SAASV,qBAAT,CAEEyF,UAFF,EAGiD;EAC/C,OAAOxF,sBAAsB,CAAC,KAAK8E,IAAN,EAAYU,UAAZ,CAA7B;AACD;;AAcD,SAASvF,0BAAT,CAEEuF,UAFF,EAGiD;EAC/C,OAAOtF,2BAA2B,CAAC,KAAK4E,IAAN,EAAYU,UAAZ,CAAlC;AACD;;AAmBD,SAASC,yBAAT,CAEED,UAAmB,GAAG,KAFxB,EAGEE,SAAkB,GAAG,KAHvB,EAIqE;EACnE,MAAMjF,IAAI,GAAG,IAAb;EACA,MAAMkF,MAAM,GAAG,CAAClF,IAAD,CAAf;EACA,MAAMmF,GAAG,GAAGC,MAAM,CAACC,MAAP,CAAc,IAAd,CAAZ;;EAEA,OAAOH,MAAM,CAACnE,MAAd,EAAsB;IACpB,MAAMuE,EAAE,GAAGJ,MAAM,CAACK,KAAP,EAAX;IACA,IAAI,CAACD,EAAL,EAAS;IACT,IAAI,CAACA,EAAE,CAACjB,IAAR,EAAc;IAEd,MAAMmB,IAAI,GAERjG,sBAAsB,CAACiG,IAAvB,CAA4BF,EAAE,CAACjB,IAAH,CAAQpE,IAApC,CAFF;;IAIA,IAAIqF,EAAE,CAACG,YAAH,EAAJ,EAAuB;MACrB,IAAIV,UAAJ,EAAgB;QACd,MAAMW,IAAI,GAAIP,GAAG,CAACG,EAAE,CAACjB,IAAH,CAAQsB,IAAT,CAAH,GAAoBR,GAAG,CAACG,EAAE,CAACjB,IAAH,CAAQsB,IAAT,CAAH,IAAqB,EAAvD;;QACAD,IAAI,CAACjF,IAAL,CAAU6E,EAAV;MACD,CAHD,MAGO;QACLH,GAAG,CAACG,EAAE,CAACjB,IAAH,CAAQsB,IAAT,CAAH,GAAoBL,EAApB;MACD;;MACD;IACD;;IAED,IAAIA,EAAE,CAACM,mBAAH,EAAJ,EAA8B;MAC5B,MAAMC,WAAW,GAAGP,EAAE,CAAC3C,GAAH,CAAO,aAAP,CAApB;;MACA,IAAIjD,aAAa,CAACmG,WAAD,CAAjB,EAAgC;QAC9BX,MAAM,CAACzE,IAAP,CAAYoF,WAAZ;MACD;;MACD;IACD;;IAED,IAAIZ,SAAJ,EAAe;MACb,IAAIK,EAAE,CAACQ,qBAAH,EAAJ,EAAgC;QAC9BZ,MAAM,CAACzE,IAAP,CAAY6E,EAAE,CAAC3C,GAAH,CAAO,IAAP,CAAZ;QACA;MACD;;MACD,IAAI2C,EAAE,CAACS,oBAAH,EAAJ,EAA+B;QAC7B;MACD;IACF;;IAED,IAAIP,IAAJ,EAAU;MACR,KAAK,IAAI1E,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAG0E,IAAI,CAACzE,MAAzB,EAAiCD,CAAC,EAAlC,EAAsC;QACpC,MAAMV,GAAG,GAAGoF,IAAI,CAAC1E,CAAD,CAAhB;QACA,MAAMkF,KAAK,GAAGV,EAAE,CAAC3C,GAAH,CAAOvC,GAAP,CAAd;;QACA,IAAIuE,KAAK,CAACC,OAAN,CAAcoB,KAAd,CAAJ,EAA0B;UACxBd,MAAM,CAACzE,IAAP,CAAY,GAAGuF,KAAf;QACD,CAFD,MAEO,IAAIA,KAAK,CAAC3B,IAAV,EAAgB;UACrBa,MAAM,CAACzE,IAAP,CAAYuF,KAAZ;QACD;MACF;IACF;EACF;;EAED,OAAOb,GAAP;AACD;;AAcD,SAASc,8BAAT,CAEElB,UAAmB,GAAG,KAFxB,EAGE;EACA,OAAO,KAAKC,yBAAL,CAA+BD,UAA/B,EAA2C,IAA3C,CAAP;AACD"}

package/lib/path/generated/asserts.js

@@ -1,5 +1,3 @@
-"use strict";
 
-var t = require("@babel/types");
 
-var _index = require("../index");
+//# sourceMappingURL=asserts.js.map