Bump eslint-plugin-import to avoid vulnerability in dependency

node_modules/object-inspect/test/bigint.js

@@ -2,7 +2,7 @@
 
 var inspect = require('../');
 var test = require('tape');
-var hasSymbols = require('has-symbols/shams')();
+var hasToStringTag = require('has-tostringtag/shams')();
 
 test('bigint', { skip: typeof BigInt === 'undefined' }, function (t) {
     t.test('primitives', function (st) {
@@ -30,7 +30,7 @@ test('bigint', { skip: typeof BigInt === 'undefined' }, function (t) {
         st.equal(inspect(Function('return 256n')()), '256n');
     });
 
-    t.test('toStringTag', { skip: !hasSymbols || typeof Symbol.toStringTag === 'undefined' }, function (st) {
+    t.test('toStringTag', { skip: !hasToStringTag }, function (st) {
         st.plan(1);
 
         var faker = {};
@@ -42,5 +42,17 @@ test('bigint', { skip: typeof BigInt === 'undefined' }, function (t) {
         );
     });
 
+    t.test('numericSeparator', function (st) {
+        st.equal(inspect(BigInt(0), { numericSeparator: false }), '0n', '0n, numericSeparator false');
+        st.equal(inspect(BigInt(0), { numericSeparator: true }), '0n', '0n, numericSeparator true');
+
+        st.equal(inspect(BigInt(1234), { numericSeparator: false }), '1234n', '1234n, numericSeparator false');
+        st.equal(inspect(BigInt(1234), { numericSeparator: true }), '1_234n', '1234n, numericSeparator true');
+        st.equal(inspect(BigInt(-1234), { numericSeparator: false }), '-1234n', '1234n, numericSeparator false');
+        st.equal(inspect(BigInt(-1234), { numericSeparator: true }), '-1_234n', '1234n, numericSeparator true');
+
+        st.end();
+    });
+
     t.end();
 });

node_modules/object-inspect/test/err.js

@@ -1,5 +1,7 @@
-var inspect = require('../');
 var test = require('tape');
+var ErrorWithCause = require('error-cause/Error');
+
+var inspect = require('../');
 
 test('type error', function (t) {
     t.plan(1);
@@ -14,18 +16,33 @@ test('type error', function (t) {
     cerr.message = 'whoa';
     cerr['a-b'] = 5;
 
+    var withCause = new ErrorWithCause('foo', { cause: 'bar' });
+    var withCausePlus = new ErrorWithCause('foo', { cause: 'bar' });
+    withCausePlus.foo = 'bar';
+    var withUndefinedCause = new ErrorWithCause('foo', { cause: undefined });
+    var withEnumerableCause = new Error('foo');
+    withEnumerableCause.cause = 'bar';
+
     var obj = [
         new TypeError(),
         new TypeError('xxx'),
         aerr,
         berr,
-        cerr
+        cerr,
+        withCause,
+        withCausePlus,
+        withUndefinedCause,
+        withEnumerableCause
     ];
     t.equal(inspect(obj), '[ ' + [
         '[TypeError]',
         '[TypeError: xxx]',
         '{ [TypeError] foo: 555, bar: [ 1, 2, 3 ] }',
         '{ [TypeError: tuv] baz: 555 }',
-        '{ [SyntaxError: whoa] message: \'whoa\', \'a-b\': 5 }'
+        '{ [SyntaxError: whoa] message: \'whoa\', \'a-b\': 5 }',
+        'cause' in Error.prototype ? '[Error: foo]' : '{ [Error: foo] [cause]: \'bar\' }',
+        '{ [Error: foo] ' + ('cause' in Error.prototype ? '' : '[cause]: \'bar\', ') + 'foo: \'bar\' }',
+        'cause' in Error.prototype ? '[Error: foo]' : '{ [Error: foo] [cause]: undefined }',
+        '{ [Error: foo] cause: \'bar\' }'
     ].join(', ') + ' ]');
 });

node_modules/object-inspect/test/fakes.js

@@ -2,10 +2,10 @@
 
 var inspect = require('../');
 var test = require('tape');
-var hasSymbols = require('has-symbols/shams')();
+var hasToStringTag = require('has-tostringtag/shams')();
 var forEach = require('for-each');
 
-test('fakes', { skip: !hasSymbols || typeof Symbol.toStringTag === 'undefined' }, function (t) {
+test('fakes', { skip: !hasToStringTag }, function (t) {
     forEach([
         'Array',
         'Boolean',

node_modules/object-inspect/test/has.js

@@ -1,34 +1,15 @@
+'use strict';
+
 var inspect = require('../');
 var test = require('tape');
-
-function withoutProperty(object, property, fn) {
-    var original;
-    if (Object.getOwnPropertyDescriptor) {
-        original = Object.getOwnPropertyDescriptor(object, property);
-    } else {
-        original = object[property];
-    }
-    delete object[property];
-    try {
-        fn();
-    } finally {
-        if (Object.getOwnPropertyDescriptor) {
-            Object.defineProperty(object, property, original);
-        } else {
-            object[property] = original;
-        }
-    }
-}
+var mockProperty = require('mock-property');
 
 test('when Object#hasOwnProperty is deleted', function (t) {
     t.plan(1);
     var arr = [1, , 3]; // eslint-disable-line no-sparse-arrays
 
-    // eslint-disable-next-line no-extend-native
-    Array.prototype[1] = 2; // this is needed to account for "in" vs "hasOwnProperty"
+    t.teardown(mockProperty(Array.prototype, 1, { value: 2 })); // this is needed to account for "in" vs "hasOwnProperty"
+    t.teardown(mockProperty(Object.prototype, 'hasOwnProperty', { 'delete': true }));
 
-    withoutProperty(Object.prototype, 'hasOwnProperty', function () {
-        t.equal(inspect(arr), '[ 1, , 3 ]');
-    });
-    delete Array.prototype[1];
+    t.equal(inspect(arr), '[ 1, , 3 ]');
 });

node_modules/object-inspect/test/inspect.js

@@ -100,3 +100,40 @@ test('maxStringLength', function (t) {
 
     t.end();
 });
+
+test('inspect options', { skip: !utilInspect.custom }, function (t) {
+    var obj = {};
+    obj[utilInspect.custom] = function () {
+        return JSON.stringify(arguments);
+    };
+    t.equal(
+        inspect(obj),
+        utilInspect(obj, { depth: 5 }),
+        'custom symbols will use node\'s inspect'
+    );
+    t.equal(
+        inspect(obj, { depth: 2 }),
+        utilInspect(obj, { depth: 2 }),
+        'a reduced depth will be passed to node\'s inspect'
+    );
+    t.equal(
+        inspect({ d1: obj }, { depth: 3 }),
+        '{ d1: ' + utilInspect(obj, { depth: 2 }) + ' }',
+        'deep objects will receive a reduced depth'
+    );
+    t.equal(
+        inspect({ d1: obj }, { depth: 1 }),
+        '{ d1: [Object] }',
+        'unlike nodejs inspect, customInspect will not be used once the depth is exceeded.'
+    );
+    t.end();
+});
+
+test('inspect URL', { skip: typeof URL === 'undefined' }, function (t) {
+    t.match(
+        inspect(new URL('https://nodejs.org')),
+        /nodejs\.org/, // Different environments stringify it differently
+        'url can be inspected'
+    );
+    t.end();
+});

node_modules/object-inspect/test/number.js

@@ -1,5 +1,8 @@
-var inspect = require('../');
 var test = require('tape');
+var v = require('es-value-fixtures');
+var forEach = require('for-each');
+
+var inspect = require('../');
 
 test('negative zero', function (t) {
     t.equal(inspect(0), '0', 'inspect(0) === "0"');
@@ -10,3 +13,46 @@ test('negative zero', function (t) {
 
     t.end();
 });
+
+test('numericSeparator', function (t) {
+    forEach(v.nonBooleans, function (nonBoolean) {
+        t['throws'](
+            function () { inspect(true, { numericSeparator: nonBoolean }); },
+            TypeError,
+            inspect(nonBoolean) + ' is not a boolean'
+        );
+    });
+
+    t.test('3 digit numbers', function (st) {
+        var failed = false;
+        for (var i = -999; i < 1000; i += 1) {
+            var actual = inspect(i);
+            var actualSepNo = inspect(i, { numericSeparator: false });
+            var actualSepYes = inspect(i, { numericSeparator: true });
+            var expected = String(i);
+            if (actual !== expected || actualSepNo !== expected || actualSepYes !== expected) {
+                failed = true;
+                t.equal(actual, expected);
+                t.equal(actualSepNo, expected);
+                t.equal(actualSepYes, expected);
+            }
+        }
+
+        st.notOk(failed, 'all 3 digit numbers passed');
+
+        st.end();
+    });
+
+    t.equal(inspect(1e3), '1000', '1000');
+    t.equal(inspect(1e3, { numericSeparator: false }), '1000', '1000, numericSeparator false');
+    t.equal(inspect(1e3, { numericSeparator: true }), '1_000', '1000, numericSeparator true');
+    t.equal(inspect(-1e3), '-1000', '-1000');
+    t.equal(inspect(-1e3, { numericSeparator: false }), '-1000', '-1000, numericSeparator false');
+    t.equal(inspect(-1e3, { numericSeparator: true }), '-1_000', '-1000, numericSeparator true');
+
+    t.equal(inspect(1234.5678, { numericSeparator: true }), '1_234.567_8', 'fractional numbers get separators');
+    t.equal(inspect(1234.56789, { numericSeparator: true }), '1_234.567_89', 'fractional numbers get separators');
+    t.equal(inspect(1234.567891, { numericSeparator: true }), '1_234.567_891', 'fractional numbers get separators');
+
+    t.end();
+});

node_modules/object-inspect/test/toStringTag.js

@@ -1,11 +1,11 @@
 'use strict';
 
 var test = require('tape');
-var hasSymbols = require('has-symbols/shams')();
+var hasToStringTag = require('has-tostringtag/shams')();
 
 var inspect = require('../');
 
-test('Symbol.toStringTag', { skip: !hasSymbols || typeof Symbol.toStringTag === 'undefined' }, function (t) {
+test('Symbol.toStringTag', { skip: !hasToStringTag }, function (t) {
     t.plan(4);
 
     var obj = { a: 1 };

node_modules/object-inspect/test/values.js

@@ -2,7 +2,9 @@
 
 var inspect = require('../');
 var test = require('tape');
+var mockProperty = require('mock-property');
 var hasSymbols = require('has-symbols/shams')();
+var hasToStringTag = require('has-tostringtag/shams')();
 
 test('values', function (t) {
     t.plan(1);
@@ -22,10 +24,9 @@ test('arrays with properties', function (t) {
 
 test('has', function (t) {
     t.plan(1);
-    var has = Object.prototype.hasOwnProperty;
-    delete Object.prototype.hasOwnProperty;
+    t.teardown(mockProperty(Object.prototype, 'hasOwnProperty', { 'delete': true }));
+
     t.equal(inspect({ a: 1, b: 2 }), '{ a: 1, b: 2 }');
-    Object.prototype.hasOwnProperty = has; // eslint-disable-line no-extend-native
 });
 
 test('indexOf seen', function (t) {
@@ -76,7 +77,7 @@ test('symbols', { skip: !hasSymbols }, function (t) {
         t.equal(inspect(Object(sym)), 'Object(Symbol(foo))', 'Object(Symbol("foo")) should be "Object(Symbol(foo))"');
     }
 
-    t.test('toStringTag', { skip: !hasSymbols || typeof Symbol.toStringTag === 'undefined' }, function (st) {
+    t.test('toStringTag', { skip: !hasToStringTag }, function (st) {
         st.plan(1);
 
         var faker = {};