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;