FM / lib

/var/www/cobraambalaj/node_modules/@babel/traverse/lib/

/var/www/cobraambalaj/node_modules/@babel/traverse/lib

Name	Size	Mode	Actions
path/	-	0755	rm
scope/	-	0755	rm
cache.js	488	0644	edit dl rm
context.js	4065	0644	edit dl rm
hub.js	345	0644	edit dl rm
index.js	3825	0644	edit dl rm
types.js	1103	0644	edit dl rm
visitors.js	6786	0644	edit dl rm

Edit: /var/www/cobraambalaj/node_modules/@babel/traverse/lib/context.js (4065B)

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;

var _path = _interopRequireDefault(require("./path"));

var t = _interopRequireWildcard(require("@babel/types"));

function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

const testing = process.env.NODE_ENV === "test";

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 = t.VISITOR_KEYS[node.type];
    if (!(keys == null ? void 0 : keys.length)) return false;

for (const key of keys) {
      if (node[key]) return true;
    }

return false;
  }

create(node, obj, key, listKey) {
    return _path.default.get({
      parentPath: this.parentPath,
      parent: node,
      container: obj,
      key: key,
      listKey
    });
  }

maybeQueue(path, notPriority) {
    if (this.trap) {
      throw new Error("Infinite cycle detected");
    }

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;

for (const path of queue) {
      path.resync();

if (path.contexts.length === 0 || path.contexts[path.contexts.length - 1] !== this) {
        path.pushContext(this);
      }

if (path.key === null) continue;

if (testing && queue.length >= 10000) {
        this.trap = true;
      }

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 (const path of queue) {
      path.popContext();
    }

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;

cmd: