Read only
    function transform(file, { j }, options) {
      const root = j(file.source);
      let dirtyFlag = false;
    
      const { identifier } = removeImport("array.of", root, j);
    
      root
        .find(j.CallExpression, {
          callee: { name: identifier },
        })
        .forEach((p) => {
          dirtyFlag = true;
          j(p).replaceWith(
            j.callExpression(
              j.memberExpression(j.identifier("Array"), j.identifier("of")),
              p.value.arguments
            )
          );
        });
    
      return dirtyFlag ? root.toSource(options) : file.source;
    }
    
    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 assert = require('assert');
    var arrayOf = require('array.of');
    
    assert.deepEqual(arrayOf(1, 2, 3), [1, 2, 3]);
    
    if (!Array.of) {
    	arrayOf.shim();
    }
    
    assert.deepEqual(Array.of(1, 2, 3), [1, 2, 3]);
    
    
    Output
    loading
    Read-only
    Open on CodeSandboxOpen Sandbox