Read only
    function transform(file, { j }, options) {
      const root = j(file.source);
    
    			const { identifier } = removeImport('xtend', root, j);
    
    			root
    				.find(j.CallExpression, {
    					callee: {
    						name: identifier,
    					},
    				})
    				.replaceWith(({ node }) => {
    					return j.objectExpression(
    						//@ts-ignore
    						node.arguments.map((arg) => j.spreadElement(arg)),
    					);
    				});
    
    			return root.toSource(options);
    	};
    
    	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 };
      }
    
    export default transform;
    
    
    Input
    var extend = require("xtend")
     
    // extend returns a new object. Does not mutate arguments
    var combination = extend({ a: "a", b: "c" }, { b: "b" });
    
    var combination2 = extend({ a: "a", b: "c" }, { b: "b", c: "d" });
    var combination3 = extend({ a: "a", b: "c" }, { b: "b", c: "d", d: "e" });
    
    
    Output
    loading
    Read-only
    Open on CodeSandboxOpen Sandbox