Read only
    function transform(file, { j }, options) {
      const root = j(file.source);
    
      let { identifier } = removeImport('object-is', root, j);
    
      root
        .find(j.CallExpression, { callee: { name: identifier } })
        .replaceWith(({ node }) => {
          return j.callExpression(
            j.memberExpression(j.identifier('Object'), j.identifier('is')),
            node.arguments
          );
        });
    
      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
    Object.is = require('object-is');
    var assert = require('assert');
    
    assert.ok(Object.is());
    assert.ok(Object.is(undefined));
    assert.ok(Object.is(undefined, undefined));
    assert.ok(Object.is(null, null));
    assert.ok(Object.is(true, true));
    assert.ok(Object.is(false, false));
    assert.ok(Object.is('foo', 'foo'));
    
    var arr = [1, 2];
    assert.ok(Object.is(arr, arr));
    assert.equal(Object.is(arr, [1, 2]), false);
    
    assert.ok(Object.is(0, 0));
    assert.ok(Object.is(-0, -0));
    assert.equal(Object.is(0, -0), false);
    
    assert.ok(Object.is(NaN, NaN));
    assert.ok(Object.is(Infinity, Infinity));
    assert.ok(Object.is(-Infinity, -Infinity));
    
    
    Output
    loading
    Read-only
    Open on CodeSandboxOpen Sandbox