How to use babel-helper-mark-eval-scopes - 7 common examples

exit(path, { opts: { 
                // set defaults
                optimizeRawSize = false, keepFnName = false, keepClassName = false, keepFnArgs = false, tdz = false } = {} } = {}) {
                    (traverse.clearCache || traverse.cache.clear)();
                    path.scope.crawl();
                    markEvalScopes(path);
                    // We need to run this plugin in isolation.
                    path.traverse(main, {
                        functionToBindings: new Map(),
                        optimizeRawSize,
                        keepFnName,
                        keepClassName,
                        keepFnArgs,
                        tdz
                    });
                }
            }

enter(path) {
        if (path.isProgram()) {
          return;
        }

        if (hasEval(path.scope)) {
          return;
        }

        const { scope } = path;

        // if the scope is created by a function, we obtain its
        // parameter list
        const canRemoveParams = path.isFunction() && path.node.kind !== "set";
        const paramsList = canRemoveParams ? path.get("params") : [];

        for (let i = paramsList.length - 1; i >= 0; i--) {
          const param = paramsList[i];

          if (param.isIdentifier()) {
            const binding = scope.bindings[param.node.name];
            if (!binding) continue;

mangleScope(scope) {
      const mangler = this;
      const { scopeTracker } = mangler;

      // Unsafe Scope
      if (!mangler.eval && hasEval(scope)) {
        return;
      }

      // Already visited
      // This is because for a function, in Babel, the function and
      // the function body's BlockStatement has the same scope, and will
      // be visited twice by the Scopable handler, and we want to mangle
      // it only once
      if (mangler.visitedScopes.has(scope)) {
        return;
      }
      mangler.visitedScopes.add(scope);

      const bindings = scopeTracker.bindings.get(scope);
      const names = [...bindings.keys()];

enter(path) {
                if (path.isProgram()) {
                    return;
                }
                if (hasEval(path.scope)) {
                    return;
                }
                const { scope } = path;
                // if the scope is created by a function, we obtain its
                // parameter list
                const canRemoveParams = path.isFunction() && path.node.kind !== "set";
                const paramsList = canRemoveParams ? path.get("params") : [];
                for (let i = paramsList.length - 1; i >= 0; i--) {
                    const param = paramsList[i];
                    if (param.isIdentifier()) {
                        const binding = scope.bindings[param.node.name];
                        if (!binding)
                            continue;
                        if (binding.referenced) {
                            // when the first binding is referenced (right to left)
                            // exit without marking anything after this

path,
          {
            opts: {
              // set defaults
              optimizeRawSize = false,
              keepFnName = false,
              keepClassName = false,
              keepFnArgs = false,
              tdz = false
            } = {}
          } = {}
        ) {
          (traverse.clearCache || traverse.cache.clear)();
          path.scope.crawl();

          markEvalScopes(path);

          // We need to run this plugin in isolation.
          path.traverse(main, {
            functionToBindings: new Map(),
            optimizeRawSize,
            keepFnName,
            keepClassName,
            keepFnArgs,
            tdz
          });
        }
      }

collect() {
      const mangler = this;
      const { scopeTracker } = mangler;

      scopeTracker.addScope(this.program.scope);

      /**
       * Same usage as in DCE, whichever runs first
       */
      if (!isEvalScopesMarked(mangler.program)) {
        markEvalScopes(mangler.program);
      }

      /**
       * The visitors to be used in traversal.
       *
       * Note: BFS traversal supports only the `enter` handlers, `exit`
       * handlers are simply dropped without Errors
       *
       * Collects items defined in the ScopeTracker
       */
      const collectVisitor = {
        Scopable({ scope }) {
          scopeTracker.addScope(scope);

          // Collect bindings defined in the scope
          Object.keys(scope.bindings).forEach(name => {

collect() {
      const mangler = this;
      const { scopeTracker } = mangler;

      scopeTracker.addScope(this.program.scope);

      /**
       * Same usage as in DCE, whichever runs first
       */
      if (!isEvalScopesMarked(mangler.program)) {
        markEvalScopes(mangler.program);
      }

      /**
       * The visitors to be used in traversal.
       *
       * Note: BFS traversal supports only the `enter` handlers, `exit`
       * handlers are simply dropped without Errors
       *
       * Collects items defined in the ScopeTracker
       */
      const collectVisitor = {
        Scopable({ scope }) {
          scopeTracker.addScope(scope);

          // Collect bindings defined in the scope