botversion-sdk 2.2.3 → 2.3.0

package/scanner-sdk/node_modules/@babel/traverse/lib/context.js

@@ -0,0 +1,125 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _index = require("./path/index.js");
+var _t = require("@babel/types");
+var _context = require("./path/context.js");
+var _hub = require("./hub.js");
+const {
+  VISITOR_KEYS
+} = _t;
+class TraversalContext {
+  constructor(scope, opts, state, parentPath) {
+    this.queue = null;
+    this.priorityQueue = null;
+    this.parentPath = parentPath;
+    this.scope = scope;
+    this.state = state;
+    this.opts = opts;
+  }
+  shouldVisit(node) {
+    const opts = this.opts;
+    if (opts.enter || opts.exit) return true;
+    if (opts[node.type]) return true;
+    const keys = VISITOR_KEYS[node.type];
+    if (!(keys != null && keys.length)) return false;
+    for (const key of keys) {
+      if (node[key]) {
+        return true;
+      }
+    }
+    return false;
+  }
+  create(node, container, key, listKey) {
+    const {
+      parentPath
+    } = this;
+    const hub = parentPath == null ? node.type === "Program" || node.type === "File" ? new _hub.default() : undefined : parentPath.hub;
+    return _index.default.get({
+      parentPath,
+      parent: node,
+      container,
+      key: key,
+      listKey,
+      hub
+    });
+  }
+  maybeQueue(path, notPriority) {
+    if (this.queue) {
+      if (notPriority) {
+        this.queue.push(path);
+      } else {
+        this.priorityQueue.push(path);
+      }
+    }
+  }
+  visitMultiple(container, parent, listKey) {
+    if (container.length === 0) return false;
+    const queue = [];
+    for (let key = 0; key < container.length; key++) {
+      const node = container[key];
+      if (node && this.shouldVisit(node)) {
+        queue.push(this.create(parent, container, key, listKey));
+      }
+    }
+    return this.visitQueue(queue);
+  }
+  visitSingle(node, key) {
+    if (this.shouldVisit(node[key])) {
+      return this.visitQueue([this.create(node, node, key)]);
+    } else {
+      return false;
+    }
+  }
+  visitQueue(queue) {
+    this.queue = queue;
+    this.priorityQueue = [];
+    const visited = new WeakSet();
+    let stop = false;
+    let visitIndex = 0;
+    for (; visitIndex < queue.length;) {
+      const path = queue[visitIndex];
+      visitIndex++;
+      _context.resync.call(path);
+      if (path.contexts.length === 0 || path.contexts[path.contexts.length - 1] !== this) {
+        _context.pushContext.call(path, this);
+      }
+      if (path.key === null) continue;
+      const {
+        node
+      } = path;
+      if (visited.has(node)) continue;
+      if (node) visited.add(node);
+      if (path.visit()) {
+        stop = true;
+        break;
+      }
+      if (this.priorityQueue.length) {
+        stop = this.visitQueue(this.priorityQueue);
+        this.priorityQueue = [];
+        this.queue = queue;
+        if (stop) break;
+      }
+    }
+    for (let i = 0; i < visitIndex; i++) {
+      _context.popContext.call(queue[i]);
+    }
+    this.queue = null;
+    return stop;
+  }
+  visit(node, key) {
+    const nodes = node[key];
+    if (!nodes) return false;
+    if (Array.isArray(nodes)) {
+      return this.visitMultiple(nodes, node, key);
+    } else {
+      return this.visitSingle(node, key);
+    }
+  }
+}
+exports.default = TraversalContext;
+
+//# sourceMappingURL=context.js.map

package/scanner-sdk/node_modules/@babel/traverse/lib/context.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_index","require","_t","_context","_hub","VISITOR_KEYS","TraversalContext","constructor","scope","opts","state","parentPath","queue","priorityQueue","shouldVisit","node","enter","exit","type","keys","length","key","create","container","listKey","hub","Hub","undefined","NodePath","get","parent","maybeQueue","path","notPriority","push","visitMultiple","visitQueue","visitSingle","visited","WeakSet","stop","visitIndex","resync","call","contexts","pushContext","has","add","visit","i","popContext","nodes","Array","isArray","exports","default"],"sources":["../src/context.ts"],"sourcesContent":["import NodePath from \"./path/index.ts\";\nimport { VISITOR_KEYS } from \"@babel/types\";\nimport type Scope from \"./scope/index.ts\";\nimport type { ExplodedTraverseOptions } from \"./index.ts\";\nimport type * as t from \"@babel/types\";\nimport type { Visitor } from \"./types.ts\";\nimport { popContext, pushContext, resync } from \"./path/context.ts\";\nimport Hub from \"./hub.ts\";\n\nexport default class TraversalContext<S = unknown> {\n  constructor(\n    scope: Scope | null | undefined,\n    opts: ExplodedTraverseOptions<S>,\n    state: S,\n    parentPath: NodePath | undefined,\n  ) {\n    this.parentPath = parentPath;\n    this.scope = scope;\n    this.state = state;\n    this.opts = opts;\n  }\n\n  declare parentPath: NodePath | undefined;\n  declare scope: Scope | null | undefined;\n  declare state: S;\n  declare opts: ExplodedTraverseOptions<S>;\n  queue: NodePath[] | null = null;\n  priorityQueue: 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: 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    const { parentPath } = this;\n    const hub =\n      parentPath == null\n        ? node.type === \"Program\" || node.type === \"File\"\n          ? new Hub()\n          : undefined\n        : parentPath.hub;\n\n    // We don't need to `.setContext()` here, since `.visitQueue()` already\n    // calls `.pushContext`.\n    return NodePath.get({\n      parentPath,\n      parent: node,\n      container,\n      key: key,\n      listKey,\n      hub,\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: NodePath[]): boolean {\n    // set queue\n    this.queue = queue;\n    this.priorityQueue = [];\n\n    const visited = new WeakSet();\n    let stop = false;\n    let visitIndex = 0;\n\n    // visit the queue\n    for (; visitIndex < queue.length; ) {\n      const path = queue[visitIndex];\n      visitIndex++;\n      resync.call(path);\n\n      // this path no longer belongs to the tree\n      if (process.env.BABEL_8_BREAKING && path.key === null) continue;\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        pushContext.call(path, this);\n      }\n\n      // this path no longer belongs to the tree\n      if (!process.env.BABEL_8_BREAKING && 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    // pop contexts\n    for (let i = 0; i < visitIndex; i++) {\n      if (process.env.BABEL_8_BREAKING && queue[i].key === null) continue;\n      popContext.call(queue[i]);\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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","ignoreList":[]}

package/scanner-sdk/node_modules/@babel/traverse/lib/hub.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+class Hub {
+  getCode() {}
+  getScope() {}
+  addHelper() {
+    throw new Error("Helpers are not supported by the default hub.");
+  }
+  buildError(node, msg, Error = TypeError) {
+    return new Error(msg);
+  }
+}
+exports.default = Hub;
+
+//# sourceMappingURL=hub.js.map

package/scanner-sdk/node_modules/@babel/traverse/lib/hub.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Hub","getCode","getScope","addHelper","Error","buildError","node","msg","TypeError","exports","default"],"sources":["../src/hub.ts"],"sourcesContent":["import type Scope from \"./scope/index.ts\";\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 (msg: string) => 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(\n    node: Node,\n    msg: string,\n    Error: new (msg: string) => Error = TypeError,\n  ): Error {\n    return new Error(msg);\n  }\n}\n"],"mappings":";;;;;;AAUe,MAAMA,GAAG,CAAyB;EAC/CC,OAAOA,CAAA,EAAG,CAAC;EAEXC,QAAQA,CAAA,EAAG,CAAC;EAEZC,SAASA,CAAA,EAAG;IACV,MAAM,IAAIC,KAAK,CAAC,+CAA+C,CAAC;EAClE;EAEAC,UAAUA,CACRC,IAAU,EACVC,GAAW,EACXH,KAAiC,GAAGI,SAAS,EACtC;IACP,OAAO,IAAIJ,KAAK,CAACG,GAAG,CAAC;EACvB;AACF;AAACE,OAAA,CAAAC,OAAA,GAAAV,GAAA","ignoreList":[]}

package/scanner-sdk/node_modules/@babel/traverse/lib/index.js

@@ -0,0 +1,87 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Hub", {
+  enumerable: true,
+  get: function () {
+    return _hub.default;
+  }
+});
+Object.defineProperty(exports, "NodePath", {
+  enumerable: true,
+  get: function () {
+    return _index.default;
+  }
+});
+Object.defineProperty(exports, "Scope", {
+  enumerable: true,
+  get: function () {
+    return _index2.default;
+  }
+});
+exports.visitors = exports.default = void 0;
+require("./path/context.js");
+var visitors = require("./visitors.js");
+exports.visitors = visitors;
+var _t = require("@babel/types");
+var cache = require("./cache.js");
+var _traverseNode = require("./traverse-node.js");
+var _index = require("./path/index.js");
+var _index2 = require("./scope/index.js");
+var _hub = require("./hub.js");
+const {
+  VISITOR_KEYS,
+  removeProperties,
+  traverseFast
+} = _t;
+function traverse(parent, opts = {}, scope, state, parentPath, visitSelf) {
+  if (!parent) return;
+  if (!opts.noScope && !scope) {
+    if (parent.type !== "Program" && parent.type !== "File") {
+      throw new Error("You must pass a scope and parentPath unless traversing a Program/File. " + `Instead of that you tried to traverse a ${parent.type} node without ` + "passing scope and parentPath.");
+    }
+  }
+  if (!parentPath && visitSelf) {
+    throw new Error("visitSelf can only be used when providing a NodePath.");
+  }
+  if (!VISITOR_KEYS[parent.type]) {
+    return;
+  }
+  visitors.explode(opts);
+  (0, _traverseNode.traverseNode)(parent, opts, scope, state, parentPath, undefined, visitSelf);
+}
+var _default = exports.default = traverse;
+traverse.visitors = visitors;
+traverse.verify = visitors.verify;
+traverse.explode = visitors.explode;
+traverse.cheap = function (node, enter) {
+  traverseFast(node, enter);
+  return;
+};
+traverse.node = function (node, opts, scope, state, path, skipKeys) {
+  (0, _traverseNode.traverseNode)(node, opts, scope, state, path, skipKeys);
+};
+traverse.clearNode = function (node, opts) {
+  removeProperties(node, opts);
+};
+traverse.removeProperties = function (tree, opts) {
+  traverseFast(tree, traverse.clearNode, opts);
+  return tree;
+};
+traverse.hasType = function (tree, type, denylistTypes) {
+  if (denylistTypes != null && denylistTypes.includes(tree.type)) return false;
+  if (tree.type === type) return true;
+  return traverseFast(tree, function (node) {
+    if (denylistTypes != null && denylistTypes.includes(node.type)) {
+      return traverseFast.skip;
+    }
+    if (node.type === type) {
+      return traverseFast.stop;
+    }
+  });
+};
+traverse.cache = cache;
+
+//# sourceMappingURL=index.js.map

package/scanner-sdk/node_modules/@babel/traverse/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["require","visitors","exports","_t","cache","_traverseNode","_index","_index2","_hub","VISITOR_KEYS","removeProperties","traverseFast","traverse","parent","opts","scope","state","parentPath","visitSelf","noScope","type","Error","explode","traverseNode","undefined","_default","default","verify","cheap","node","enter","path","skipKeys","clearNode","tree","hasType","denylistTypes","includes","skip","stop"],"sources":["../src/index.ts"],"sourcesContent":["import \"./path/context.ts\"; // We have some cycles, this ensures correct order to avoid TDZ\nimport * as visitors from \"./visitors.ts\";\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.ts\";\nimport type NodePath from \"./path/index.ts\";\nimport type { default as Scope, Binding } from \"./scope/index.ts\";\nimport type { ExplodedVisitor, Visitor, VisitorBase } from \"./types.ts\";\nimport { traverseNode } from \"./traverse-node.ts\";\n\nexport type { ExplodedVisitor, Visitor, VisitorBase, Binding };\nexport { default as NodePath } from \"./path/index.ts\";\nexport { default as Scope, type BindingKind } from \"./scope/index.ts\";\nexport { default as Hub } from \"./hub.ts\";\nexport type { HubInterface } from \"./hub.ts\";\nexport type { VisitWrapper } from \"./visitors.ts\";\n\nexport { visitors };\n\nexport type TraverseOptions<S = t.Node> = {\n  scope?: Scope;\n  noScope?: boolean;\n  denylist?: string[];\n  shouldSkip?: (node: NodePath) => boolean;\n} & Visitor<S>;\n\nexport type ExplodedTraverseOptions<S = t.Node> = TraverseOptions<S> &\n  ExplodedVisitor<S>;\n\nfunction traverse<S>(\n  parent: t.Node,\n  opts: TraverseOptions<S>,\n  scope: Scope | null | undefined,\n  state: S,\n  parentPath?: NodePath,\n  visitSelf?: boolean,\n): void;\n\nfunction traverse(\n  parent: t.Node,\n  opts: TraverseOptions,\n  scope?: Scope | null,\n  state?: any,\n  parentPath?: NodePath,\n  visitSelf?: boolean,\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 | null,\n  state?: any,\n  parentPath?: NodePath,\n  visitSelf?: boolean,\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 (!parentPath && visitSelf) {\n    throw new Error(\"visitSelf can only be used when providing a NodePath.\");\n  }\n\n  if (!VISITOR_KEYS[parent.type]) {\n    return;\n  }\n\n  visitors.explode(opts as Visitor);\n\n  traverseNode(\n    parent,\n    opts as ExplodedVisitor,\n    scope,\n    state,\n    parentPath,\n    /* skipKeys */ undefined,\n    visitSelf,\n  );\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  traverseFast(node, enter);\n  return;\n};\n\ntraverse.node = function (\n  node: t.Node,\n  opts: ExplodedTraverseOptions,\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\ntraverse.removeProperties = function (\n  tree: t.Node,\n  opts?: RemovePropertiesOptions,\n) {\n  traverseFast(tree, traverse.clearNode, opts);\n  return tree;\n};\n\ntraverse.hasType = function (\n  tree: t.Node,\n  type: t.Node[\"type\"],\n  denylistTypes?: 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  return traverseFast(tree, function (node) {\n    if (denylistTypes?.includes(node.type)) {\n      return traverseFast.skip;\n    }\n    if (node.type === type) {\n      return traverseFast.stop;\n    }\n  });\n};\n\ntraverse.cache = cache;\n"],"mappings":"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","ignoreList":[]}

package/scanner-sdk/node_modules/@babel/traverse/lib/path/ancestry.js

@@ -0,0 +1,139 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.find = find;
+exports.findParent = findParent;
+exports.getAncestry = getAncestry;
+exports.getDeepestCommonAncestorFrom = getDeepestCommonAncestorFrom;
+exports.getEarliestCommonAncestorFrom = getEarliestCommonAncestorFrom;
+exports.getFunctionParent = getFunctionParent;
+exports.getStatementParent = getStatementParent;
+exports.inType = inType;
+exports.isAncestor = isAncestor;
+exports.isDescendant = isDescendant;
+var _t = require("@babel/types");
+const {
+  VISITOR_KEYS
+} = _t;
+function findParent(callback) {
+  let path = this;
+  while (path = path.parentPath) {
+    if (callback(path)) return path;
+  }
+  return null;
+}
+function find(callback) {
+  let path = this;
+  do {
+    if (callback(path)) return path;
+  } while (path = path.parentPath);
+  return null;
+}
+function getFunctionParent() {
+  return this.findParent(p => p.isFunction());
+}
+function getStatementParent() {
+  let path = this;
+  do {
+    if (!path.parentPath || Array.isArray(path.container) && path.isStatement()) {
+      break;
+    } else {
+      path = path.parentPath;
+    }
+  } while (path);
+  if (path && (path.isProgram() || path.isFile())) {
+    throw new Error("File/Program node, we can't possibly find a statement parent to this");
+  }
+  return path;
+}
+function getEarliestCommonAncestorFrom(paths) {
+  return this.getDeepestCommonAncestorFrom(paths, function (deepest, i, ancestries) {
+    let earliest;
+    const keys = VISITOR_KEYS[deepest.type];
+    for (const ancestry of ancestries) {
+      const path = ancestry[i + 1];
+      if (!earliest) {
+        earliest = path;
+        continue;
+      }
+      if (path.listKey && earliest.listKey === path.listKey) {
+        if (path.key < earliest.key) {
+          earliest = path;
+          continue;
+        }
+      }
+      const earliestKeyIndex = keys.indexOf(earliest.parentKey);
+      const currentKeyIndex = keys.indexOf(path.parentKey);
+      if (earliestKeyIndex > currentKeyIndex) {
+        earliest = path;
+      }
+    }
+    return earliest;
+  });
+}
+function getDeepestCommonAncestorFrom(paths, filter) {
+  if (!paths.length) {
+    return this;
+  }
+  if (paths.length === 1) {
+    return paths[0];
+  }
+  let minDepth = Infinity;
+  let lastCommonIndex, lastCommon;
+  const ancestries = paths.map(path => {
+    const ancestry = [];
+    do {
+      ancestry.unshift(path);
+    } while ((path = path.parentPath) && path !== this);
+    if (ancestry.length < minDepth) {
+      minDepth = ancestry.length;
+    }
+    return ancestry;
+  });
+  const first = ancestries[0];
+  depthLoop: for (let i = 0; i < minDepth; i++) {
+    const shouldMatch = first[i];
+    for (const ancestry of ancestries) {
+      if (ancestry[i] !== shouldMatch) {
+        break depthLoop;
+      }
+    }
+    lastCommonIndex = i;
+    lastCommon = shouldMatch;
+  }
+  if (lastCommon) {
+    if (filter) {
+      return filter(lastCommon, lastCommonIndex, ancestries);
+    } else {
+      return lastCommon;
+    }
+  } else {
+    throw new Error("Couldn't find intersection");
+  }
+}
+function getAncestry() {
+  let path = this;
+  const paths = [];
+  do {
+    paths.push(path);
+  } while (path = path.parentPath);
+  return paths;
+}
+function isAncestor(maybeDescendant) {
+  return maybeDescendant.isDescendant(this);
+}
+function isDescendant(maybeAncestor) {
+  return !!this.findParent(parent => parent === maybeAncestor);
+}
+function inType(...candidateTypes) {
+  let path = this;
+  while (path) {
+    if (candidateTypes.includes(path.node.type)) return true;
+    path = path.parentPath;
+  }
+  return false;
+}
+
+//# sourceMappingURL=ancestry.js.map

package/scanner-sdk/node_modules/@babel/traverse/lib/path/ancestry.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_t","require","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","includes","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.ts\";\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: 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);\n        if (earliestKeyIndex > currentKeyIndex) {\n          // key appears before so it's earlier\n          earliest = path;\n        }\n      }\n\n      // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion\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: 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      // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion\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): 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    if (candidateTypes.includes(path.node.type)) return true;\n    path = path.parentPath;\n  }\n\n  return false;\n}\n"],"mappings":"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","ignoreList":[]}

package/scanner-sdk/node_modules/@babel/traverse/lib/path/comments.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addComment = addComment;
+exports.addComments = addComments;
+exports.shareCommentsWithSiblings = shareCommentsWithSiblings;
+var _t = require("@babel/types");
+const {
+  addComment: _addComment,
+  addComments: _addComments
+} = _t;
+function shareCommentsWithSiblings() {
+  if (typeof this.key === "string") return;
+  const node = this.node;
+  if (!node) return;
+  const trailing = node.trailingComments;
+  const leading = node.leadingComments;
+  if (!trailing && !leading) return;
+  const prev = this.getSibling(this.key - 1);
+  const next = this.getSibling(this.key + 1);
+  const hasPrev = Boolean(prev.node);
+  const hasNext = Boolean(next.node);
+  if (hasPrev) {
+    if (leading) {
+      prev.addComments("trailing", removeIfExisting(leading, prev.node.trailingComments));
+    }
+    if (trailing && !hasNext) prev.addComments("trailing", trailing);
+  }
+  if (hasNext) {
+    if (trailing) {
+      next.addComments("leading", removeIfExisting(trailing, next.node.leadingComments));
+    }
+    if (leading && !hasPrev) next.addComments("leading", leading);
+  }
+}
+function removeIfExisting(list, toRemove) {
+  if (!(toRemove != null && toRemove.length)) return list;
+  const set = new Set(toRemove);
+  return list.filter(el => {
+    return !set.has(el);
+  });
+}
+function addComment(type, content, line) {
+  _addComment(this.node, type, content, line);
+}
+function addComments(type, comments) {
+  _addComments(this.node, type, comments);
+}
+
+//# sourceMappingURL=comments.js.map

package/scanner-sdk/node_modules/@babel/traverse/lib/path/comments.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_t","require","addComment","_addComment","addComments","_addComments","shareCommentsWithSiblings","key","node","trailing","trailingComments","leading","leadingComments","prev","getSibling","next","hasPrev","Boolean","hasNext","removeIfExisting","list","toRemove","length","set","Set","filter","el","has","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.ts\";\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\n  if (hasPrev) {\n    if (leading) {\n      prev.addComments(\n        \"trailing\",\n        removeIfExisting(leading, prev.node.trailingComments),\n      );\n    }\n    if (trailing && !hasNext) prev.addComments(\"trailing\", trailing);\n  }\n  if (hasNext) {\n    if (trailing) {\n      next.addComments(\n        \"leading\",\n        removeIfExisting(trailing, next.node.leadingComments),\n      );\n    }\n    if (leading && !hasPrev) next.addComments(\"leading\", leading);\n  }\n}\n\nfunction removeIfExisting<T>(list: T[], toRemove?: T[] | null): T[] {\n  if (!toRemove?.length) return list;\n  const set = new Set(toRemove);\n  return list.filter(el => {\n    return !set.has(el);\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,IAAAA,EAAA,GAAAC,OAAA;AAGsB;EAFpBC,UAAU,EAAIC,WAAW;EACzBC,WAAW,EAAIC;AAAY,IAAAL,EAAA;AAOtB,SAASM,yBAAyBA,CAAA,EAAiB;EAExD,IAAI,OAAO,IAAI,CAACC,GAAG,KAAK,QAAQ,EAAE;EAElC,MAAMC,IAAI,GAAG,IAAI,CAACA,IAAI;EACtB,IAAI,CAACA,IAAI,EAAE;EAEX,MAAMC,QAAQ,GAAGD,IAAI,CAACE,gBAAgB;EACtC,MAAMC,OAAO,GAAGH,IAAI,CAACI,eAAe;EACpC,IAAI,CAACH,QAAQ,IAAI,CAACE,OAAO,EAAE;EAE3B,MAAME,IAAI,GAAG,IAAI,CAACC,UAAU,CAAC,IAAI,CAACP,GAAG,GAAI,CAAC,CAAC;EAC3C,MAAMQ,IAAI,GAAG,IAAI,CAACD,UAAU,CAAC,IAAI,CAACP,GAAG,GAAI,CAAC,CAAC;EAC3C,MAAMS,OAAO,GAAGC,OAAO,CAACJ,IAAI,CAACL,IAAI,CAAC;EAClC,MAAMU,OAAO,GAAGD,OAAO,CAACF,IAAI,CAACP,IAAI,CAAC;EAElC,IAAIQ,OAAO,EAAE;IACX,IAAIL,OAAO,EAAE;MACXE,IAAI,CAACT,WAAW,CACd,UAAU,EACVe,gBAAgB,CAACR,OAAO,EAAEE,IAAI,CAACL,IAAI,CAACE,gBAAgB,CACtD,CAAC;IACH;IACA,IAAID,QAAQ,IAAI,CAACS,OAAO,EAAEL,IAAI,CAACT,WAAW,CAAC,UAAU,EAAEK,QAAQ,CAAC;EAClE;EACA,IAAIS,OAAO,EAAE;IACX,IAAIT,QAAQ,EAAE;MACZM,IAAI,CAACX,WAAW,CACd,SAAS,EACTe,gBAAgB,CAACV,QAAQ,EAAEM,IAAI,CAACP,IAAI,CAACI,eAAe,CACtD,CAAC;IACH;IACA,IAAID,OAAO,IAAI,CAACK,OAAO,EAAED,IAAI,CAACX,WAAW,CAAC,SAAS,EAAEO,OAAO,CAAC;EAC/D;AACF;AAEA,SAASQ,gBAAgBA,CAAIC,IAAS,EAAEC,QAAqB,EAAO;EAClE,IAAI,EAACA,QAAQ,YAARA,QAAQ,CAAEC,MAAM,GAAE,OAAOF,IAAI;EAClC,MAAMG,GAAG,GAAG,IAAIC,GAAG,CAACH,QAAQ,CAAC;EAC7B,OAAOD,IAAI,CAACK,MAAM,CAACC,EAAE,IAAI;IACvB,OAAO,CAACH,GAAG,CAACI,GAAG,CAACD,EAAE,CAAC;EACrB,CAAC,CAAC;AACJ;AAEO,SAASxB,UAAUA,CAExB0B,IAA4B,EAC5BC,OAAe,EACfC,IAAc,EACd;EACA3B,WAAW,CAAC,IAAI,CAACK,IAAI,EAAEoB,IAAI,EAAEC,OAAO,EAAEC,IAAI,CAAC;AAC7C;AAMO,SAAS1B,WAAWA,CAEzBwB,IAA4B,EAC5BG,QAAqB,EACrB;EACA1B,YAAY,CAAC,IAAI,CAACG,IAAI,EAAEoB,IAAI,EAAEG,QAAQ,CAAC;AACzC","ignoreList":[]}