function transform(file, { j }, options) {
  const root = j(file.source);
	let { identifier } = removeImport('object-keys', root, j);

	// Replace `$identifier(obj)` with `Object.keys(obj)`
	root
		.find(j.CallExpression, {
			callee: {
				name: identifier,
			},
		})
		.replaceWith(({ node }) => {
			return j.callExpression(
				j.memberExpression(j.identifier('Object'), j.identifier('keys')),
				node.arguments,
			);
		});

	// Remove recommended usage of `var keys = Object.keys || require("object-keys")`
	const logicalExpressionRequire = root.find(j.VariableDeclarator, {
		init: {
			type: 'LogicalExpression',
			left: {
				object: {
					name: 'Object',
				},
				property: {
					name: 'keys',
				},
			},
			right: {
				callee: {
					name: 'require',
				},
				arguments: [
					{
						value: 'object-keys',
					},
				],
			},
		},
	});

	identifier =
		logicalExpressionRequire.paths().length > 0
			? logicalExpressionRequire.get().node.id.name
			: null;

	logicalExpressionRequire.remove();

	// Replace `$identifier(obj)` with `Object.keys(obj)`
	root
		.find(j.CallExpression, {
			callee: {
				name: identifier,
			},
		})
		.replaceWith(({ node }) => {
			return j.callExpression(
				j.memberExpression(j.identifier('Object'), j.identifier('keys')),
				node.arguments,
			);
		});

	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 };
}