v7

node_modules/object-inspect/test/bigint.js

@@ -0,0 +1,30 @@
+var inspect = require('../');
+var test = require('tape');
+
+test('bigint', { skip: typeof BigInt === 'undefined' }, function (t) {
+  t.test('primitives', function (st) {
+    st.plan(3);
+
+    st.equal(inspect(BigInt(-256)), '-256n');
+    st.equal(inspect(BigInt(0)), '0n');
+    st.equal(inspect(BigInt(256)), '256n');
+  });
+
+  t.test('objects', function (st) {
+    st.plan(3);
+
+    st.equal(inspect(Object(BigInt(-256))), 'Object(-256n)');
+    st.equal(inspect(Object(BigInt(0))), 'Object(0n)');
+    st.equal(inspect(Object(BigInt(256))), 'Object(256n)');
+  });
+
+  t.test('syntactic primitives', function (st) {
+    st.plan(3);
+
+    st.equal(inspect(Function('return -256n')()), '-256n');
+    st.equal(inspect(Function('return 0n')()), '0n');
+    st.equal(inspect(Function('return 256n')()), '256n');
+  });
+
+  t.end();
+});

node_modules/object-inspect/test/browser/dom.js

@@ -0,0 +1,15 @@
+var inspect = require('../../');
+var test = require('tape');
+
+test('dom element', function (t) {
+    t.plan(1);
+    
+    var d = document.createElement('div');
+    d.setAttribute('id', 'beep');
+    d.innerHTML = '<b>wooo</b><i>iiiii</i>';
+    
+    t.equal(
+        inspect([ d, { a: 3, b : 4, c: [5,6,[7,[8,[9]]]] } ]),
+        '[ <div id="beep">...</div>, { a: 3, b: 4, c: [ 5, 6, [ 7, [ 8, [Object] ] ] ] } ]'
+    );
+});

node_modules/object-inspect/test/circular.js

@@ -0,0 +1,9 @@
+var inspect = require('../');
+var test = require('tape');
+
+test('circular', function (t) {
+    t.plan(1);
+    var obj = { a: 1, b: [3,4] };
+    obj.c = obj;
+    t.equal(inspect(obj), '{ a: 1, b: [ 3, 4 ], c: [Circular] }');
+});

node_modules/object-inspect/test/deep.js

@@ -0,0 +1,9 @@
+var inspect = require('../');
+var test = require('tape');
+
+test('deep', function (t) {
+    t.plan(2);
+    var obj = [ [ [ [ [ [ 500 ] ] ] ] ] ];
+    t.equal(inspect(obj), '[ [ [ [ [ [Object] ] ] ] ] ]');
+    t.equal(inspect(obj, { depth: 2 }), '[ [ [Object] ] ]');
+});

node_modules/object-inspect/test/element.js

@@ -0,0 +1,53 @@
+var inspect = require('../');
+var test = require('tape');
+
+test('element', function (t) {
+    t.plan(3);
+    var elem = {
+        nodeName: 'div',
+        attributes: [ { name: 'class', value: 'row' } ],
+        getAttribute: function (key) {},
+        childNodes: []
+    };
+    var obj = [ 1, elem, 3 ];
+    t.deepEqual(inspect(obj), '[ 1, <div class="row"></div>, 3 ]');
+    t.deepEqual(inspect(obj, { quoteStyle: 'single' }), "[ 1, <div class='row'></div>, 3 ]");
+    t.deepEqual(inspect(obj, { quoteStyle: 'double' }), '[ 1, <div class="row"></div>, 3 ]');
+});
+    
+test('element no attr', function (t) {
+    t.plan(1);
+    var elem = {
+        nodeName: 'div',
+        getAttribute: function (key) {},
+        childNodes: []
+    };
+    var obj = [ 1, elem, 3 ];
+    t.deepEqual(inspect(obj), '[ 1, <div></div>, 3 ]');
+});
+
+test('element with contents', function (t) {
+    t.plan(1);
+    var elem = {
+        nodeName: 'div',
+        getAttribute: function (key) {},
+        childNodes: [ { nodeName: 'b' } ]
+    };
+    var obj = [ 1, elem, 3 ];
+    t.deepEqual(inspect(obj), '[ 1, <div>...</div>, 3 ]');
+});
+
+test('element instance', function (t) {
+    t.plan(1);
+    var h = global.HTMLElement;
+    global.HTMLElement = function (name, attr) {
+        this.nodeName = name;
+        this.attributes = attr;
+    };
+    global.HTMLElement.prototype.getAttribute = function () {};
+    
+    var elem = new(global.HTMLElement)('div', []);
+    var obj = [ 1, elem, 3 ];
+    t.deepEqual(inspect(obj), '[ 1, <div></div>, 3 ]');
+    global.HTMLElement = h;
+});

node_modules/object-inspect/test/err.js

@@ -0,0 +1,29 @@
+var inspect = require('../');
+var test = require('tape');
+
+test('type error', function (t) {
+    t.plan(1);
+    var aerr = new TypeError;
+    aerr.foo = 555;
+    aerr.bar = [1,2,3];
+    
+    var berr = new TypeError('tuv');
+    berr.baz = 555;
+    
+    var cerr = new SyntaxError;
+    cerr.message = 'whoa';
+    cerr['a-b'] = 5;
+    
+    var obj = [
+        new TypeError,
+        new TypeError('xxx'),
+        aerr, berr, cerr
+    ];
+    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 }'
+    ].join(', ') + ' ]');
+});

node_modules/object-inspect/test/fn.js

@@ -0,0 +1,28 @@
+var inspect = require('../');
+var test = require('tape');
+
+test('function', function (t) {
+    t.plan(1);
+    var obj = [ 1, 2, function f (n) {}, 4 ];
+    t.equal(inspect(obj), '[ 1, 2, [Function: f], 4 ]');
+});
+
+test('function name', function (t) {
+    t.plan(1);
+    var f = (function () {
+      return function () {};
+    }());
+    f.toString = function () { return 'function xxx () {}' };
+    var obj = [ 1, 2, f, 4 ];
+    t.equal(inspect(obj), '[ 1, 2, [Function: xxx], 4 ]');
+});
+
+test('anon function', function (t) {
+    var f = (function () {
+      return function () {};
+    }());
+    var obj = [ 1, 2, f, 4 ];
+    t.equal(inspect(obj), '[ 1, 2, [Function], 4 ]');
+
+    t.end();
+});

node_modules/object-inspect/test/has.js

@@ -0,0 +1,31 @@
+var inspect = require('../');
+var test = require('tape');
+
+var withoutProperty = function (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;
+        }
+    }
+};
+
+test('when Object#hasOwnProperty is deleted', function (t) {
+    t.plan(1);
+    var arr = [1, , 3];
+    Array.prototype[1] = 2; // this is needed to account for "in" vs "hasOwnProperty"
+    withoutProperty(Object.prototype, 'hasOwnProperty', function () {
+        t.equal(inspect(arr), '[ 1, , 3 ]');
+    });
+	delete Array.prototype[1];
+});

node_modules/object-inspect/test/holes.js

@@ -0,0 +1,15 @@
+var test = require('tape');
+var inspect = require('../');
+
+var xs = [ 'a', 'b' ];
+xs[5] = 'f';
+xs[7] = 'j';
+xs[8] = 'k';
+
+test('holes', function (t) {
+    t.plan(1);
+    t.equal(
+        inspect(xs),
+        "[ 'a', 'b', , , , 'f', , 'j', 'k' ]"
+    );
+});

node_modules/object-inspect/test/inspect.js

@@ -0,0 +1,8 @@
+var inspect = require('../');
+var test = require('tape');
+
+test('inspect', function (t) {
+    t.plan(1);
+    var obj = [ { inspect: function () { return '!XYZ¡' } }, [] ];
+    t.equal(inspect(obj), '[ !XYZ¡, [] ]');
+});

node_modules/object-inspect/test/lowbyte.js

@@ -0,0 +1,12 @@
+var test = require('tape');
+var inspect = require('../');
+
+var obj = { x: 'a\r\nb', y: '\5! \x1f \022' };
+
+test('interpolate low bytes', function (t) {
+    t.plan(1);
+    t.equal(
+        inspect(obj),
+        "{ x: 'a\\r\\nb', y: '\\x05! \\x1f \\x12' }"
+    );
+});

node_modules/object-inspect/test/number.js

@@ -0,0 +1,12 @@
+var inspect = require('../');
+var test = require('tape');
+
+test('negative zero', function (t) {
+    t.equal(inspect(0), '0', 'inspect(0) === "0"');
+    t.equal(inspect(Object(0)), 'Object(0)', 'inspect(Object(0)) === "Object(0)"');
+
+    t.equal(inspect(-0), '-0', 'inspect(-0) === "-0"');
+    t.equal(inspect(Object(-0)), 'Object(-0)', 'inspect(Object(-0)) === "Object(-0)"');
+
+    t.end();
+});

node_modules/object-inspect/test/quoteStyle.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var inspect = require('../');
+var test = require('tape');
+
+test('quoteStyle option', function (t) {
+    t['throws'](function () { inspect(null, { quoteStyle: false }); }, 'false is not a valid value');
+    t['throws'](function () { inspect(null, { quoteStyle: true }); }, 'true is not a valid value');
+    t['throws'](function () { inspect(null, { quoteStyle: '' }); }, '"" is not a valid value');
+    t['throws'](function () { inspect(null, { quoteStyle: {} }); }, '{} is not a valid value');
+    t['throws'](function () { inspect(null, { quoteStyle: [] }); }, '[] is not a valid value');
+    t['throws'](function () { inspect(null, { quoteStyle: 42 }); }, '42 is not a valid value');
+    t['throws'](function () { inspect(null, { quoteStyle: NaN }); }, 'NaN is not a valid value');
+    t['throws'](function () { inspect(null, { quoteStyle: function () {} }); }, 'a function is not a valid value');
+
+    t.end();
+});

node_modules/object-inspect/test/undef.js

@@ -0,0 +1,12 @@
+var test = require('tape');
+var inspect = require('../');
+
+var obj = { a: 1, b: [ 3, 4, undefined, null ], c: undefined, d: null };
+
+test('undef and null', function (t) {
+    t.plan(1);
+    t.equal(
+        inspect(obj),
+        '{ a: 1, b: [ 3, 4, undefined, null ], c: undefined, d: null }'
+    );
+});

node_modules/object-inspect/test/values.js

@@ -0,0 +1,136 @@
+var inspect = require('../');
+var test = require('tape');
+
+test('values', function (t) {
+    t.plan(1);
+    var obj = [ {}, [], { 'a-b': 5 } ];
+    t.equal(inspect(obj), '[ {}, [], { \'a-b\': 5 } ]');
+});
+
+test('arrays with properties', function (t) {
+   t.plan(1);
+   var arr = [3];
+   arr.foo = 'bar';
+   var obj = [1, 2, arr];
+   obj.baz = 'quux';
+   obj.index = -1;
+   t.equal(inspect(obj), '[ 1, 2, [ 3, foo: \'bar\' ], baz: \'quux\', index: -1 ]');
+});
+
+test('has', function (t) {
+    t.plan(1);
+    var has = Object.prototype.hasOwnProperty;
+    delete Object.prototype.hasOwnProperty;
+    t.equal(inspect({ a: 1, b: 2 }), '{ a: 1, b: 2 }');
+    Object.prototype.hasOwnProperty = has;
+});
+
+test('indexOf seen', function (t) {
+    t.plan(1);
+    var xs = [ 1, 2, 3, {} ];
+    xs.push(xs);
+    
+    var seen = [];
+    seen.indexOf = undefined;
+    
+    t.equal(
+        inspect(xs, {}, 0, seen),
+        '[ 1, 2, 3, {}, [Circular] ]'
+    );
+});
+
+test('seen seen', function (t) {
+    t.plan(1);
+    var xs = [ 1, 2, 3 ];
+    
+    var seen = [ xs ];
+    seen.indexOf = undefined;
+    
+    t.equal(
+        inspect(xs, {}, 0, seen),
+        '[Circular]'
+    );
+});
+
+test('seen seen seen', function (t) {
+    t.plan(1);
+    var xs = [ 1, 2, 3 ];
+    
+    var seen = [ 5, xs ];
+    seen.indexOf = undefined;
+    
+    t.equal(
+        inspect(xs, {}, 0, seen),
+        '[Circular]'
+    );
+});
+
+test('symbols', { skip: typeof Symbol !== 'function' }, function (t) {
+    var sym = Symbol('foo');
+    t.equal(inspect(sym), 'Symbol(foo)', 'Symbol("foo") should be "Symbol(foo)"');
+    t.equal(inspect(Object(sym)), 'Object(Symbol(foo))', 'Object(Symbol("foo")) should be "Object(Symbol(foo))"');
+    t.end();
+});
+
+test('Map', { skip: typeof Map !== 'function' }, function (t) {
+    var map = new Map();
+    map.set({ a: 1 }, ['b']);
+    map.set(3, NaN);
+    var expectedString = 'Map (2) {' + inspect({ a: 1 }) + ' => ' + inspect(['b']) + ', 3 => NaN}';
+    t.equal(inspect(map), expectedString, 'new Map([[{ a: 1 }, ["b"]], [3, NaN]]) should show size and contents');
+    t.equal(inspect(new Map()), 'Map (0) {}', 'empty Map should show as empty');
+
+    var nestedMap = new Map();
+    nestedMap.set(nestedMap, map);
+    t.equal(inspect(nestedMap), 'Map (1) {[Circular] => ' + expectedString + '}', 'Map containing a Map should work');
+
+    t.end();
+});
+
+test('Set', { skip: typeof Set !== 'function' }, function (t) {
+    var set = new Set();
+    set.add({ a: 1 });
+    set.add(['b']);
+    var expectedString = 'Set (2) {' + inspect({ a: 1 }) + ', ' + inspect(['b']) + '}';
+    t.equal(inspect(set), expectedString, 'new Set([{ a: 1 }, ["b"]]) should show size and contents');
+    t.equal(inspect(new Set()), 'Set (0) {}', 'empty Set should show as empty');
+
+    var nestedSet = new Set();
+    nestedSet.add(set);
+    nestedSet.add(nestedSet);
+    t.equal(inspect(nestedSet), 'Set (2) {' + expectedString + ', [Circular]}', 'Set containing a Set should work');
+
+    t.end();
+});
+
+test('Strings', function (t) {
+    var str = 'abc';
+
+    t.equal(inspect(str), "'" + str + "'", 'primitive string shows as such');
+    t.equal(inspect(str, { quoteStyle: 'single' }), "'" + str + "'", 'primitive string shows as such, single quoted');
+    t.equal(inspect(str, { quoteStyle: 'double' }), '"' + str + '"', 'primitive string shows as such, double quoted');
+    t.equal(inspect(Object(str)), 'Object(' + inspect(str) + ')', 'String object shows as such');
+    t.equal(inspect(Object(str), { quoteStyle: 'single' }), 'Object(' + inspect(str, { quoteStyle: 'single' }) + ')', 'String object shows as such, single quoted');
+    t.equal(inspect(Object(str), { quoteStyle: 'double' }), 'Object(' + inspect(str, { quoteStyle: 'double' }) + ')', 'String object shows as such, double quoted');
+
+    t.end();
+});
+
+test('Numbers', function (t) {
+    var num = 42;
+
+    t.equal(inspect(num), String(num), 'primitive number shows as such');
+    t.equal(inspect(Object(num)), 'Object(' + inspect(num) + ')', 'Number object shows as such');
+
+    t.end();
+});
+
+test('Booleans', function (t) {
+    t.equal(inspect(true), String(true), 'primitive true shows as such');
+    t.equal(inspect(Object(true)), 'Object(' + inspect(true) + ')', 'Boolean object true shows as such');
+
+    t.equal(inspect(false), String(false), 'primitive false shows as such');
+    t.equal(inspect(Object(false)), 'Object(' + inspect(false) + ')', 'Boolean false object shows as such');
+
+    t.end();
+});