Read only
    function transform(file, { j }, options) {
      const root = j(file.source);
    
      const { identifier } = removeImport('is-even', root, j);
    
      root
        .find(j.CallExpression, {
          callee: {
            type: 'Identifier',
            name: identifier
          }
        })
        .forEach((path) => {
          const argument = path.node.arguments[0];
          const newExpression = j.binaryExpression(
            '===',
            j.binaryExpression(
              '%',
              // @ts-expect-error
              j.literal(argument.value),
              j.literal(2)
            ),
            j.literal(0)
          );
          const wrappedExpression = j.parenthesizedExpression(newExpression);
          j(path).replaceWith(wrappedExpression);
        });
    
      return root.toSource(options);
    }
    
    export default transform;
    
    function removeImport(name, root, j) {
      // Find the import or require statement for 'is-boolean-object'
      const importDeclaration = root.find(j.ImportDeclaration, {
        source: {
          value: name
        }
      });
    
      const requireDeclaration = root
        .find(j.CallExpression, {
          callee: {
            name: 'require'
          },
          arguments: [
            {
              value: name
            }
          ]
        })
        .closest(j.VariableDeclarator);
    
      // Require statements without declarations like `Object.is = require("object-is");`
      const requireAssignment = root.find(j.AssignmentExpression, {
        operator: '=',
        right: {
          callee: {
            name: 'require'
          },
          arguments: [
            {
              value: name
            }
          ]
        }
      });
    
      // Side effect requires statements like `require("error-cause/auto");`
      const sideEffectRequireExpression = root.find(j.ExpressionStatement, {
        expression: {
          callee: {
            name: 'require'
          },
          arguments: [
            {
              value: name
            }
          ]
        }
      });
    
      // Return the identifier name, e.g. 'fn' in `import { fn } from 'is-boolean-object'`
      // or `var fn = require('is-boolean-object')`
      const identifier =
        importDeclaration.paths().length > 0
          ? importDeclaration.get().node.specifiers[0].local.name
          : requireDeclaration.paths().length > 0
            ? requireDeclaration.find(j.Identifier).get().node.name
            : requireAssignment.paths().length > 0
              ? requireAssignment.find(j.Identifier).get().node.name
              : null;
    
      importDeclaration.remove();
      requireDeclaration.remove();
      requireAssignment.remove();
      sideEffectRequireExpression.remove();
    
      const dirtyFlag =
        importDeclaration.length > 0 ||
        requireDeclaration.length > 0 ||
        requireAssignment.length > 0 ||
        sideEffectRequireExpression.length > 0;
    
      return { identifier, dirtyFlag };
    }
    
    
    Input
    var isEven = require('is-even');
     
    isEven(0);
    //=> true
    isEven('1');
    //=> false
    isEven(2);
    //=> true
    isEven('3');
    //=> false
    Output
    loading
    Read-only
    Open on CodeSandboxOpen Sandbox