starlight-apk/NebulaShell
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

chore: disable delete confirmation in VS Code explorer

Browse Source 
Disable the confirmation dialog when deleting files in the VS Code explorer to streamline the development workflow and reduce friction during file management operations.
This commit is contained in:
Falck
2026-04-25 15:56:37 +08:00
parent c998f8beda
commit e5d578a849
947 changed files with 114025 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

58
website/node_modules/object-inspect/test/bigint.js generated vendored Normal file
View File

@@ -0,0 +1,58 @@
'use strict';
var inspect = require('../');
var test = require('tape');
var hasToStringTag = require('has-tostringtag/shams')();
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);
/* eslint-disable no-new-func */
st.equal(inspect(Function('return -256n')()), '-256n');
st.equal(inspect(Function('return 0n')()), '0n');
st.equal(inspect(Function('return 256n')()), '256n');
});
t.test('toStringTag', { skip: !hasToStringTag }, function (st) {
st.plan(1);
var faker = {};
faker[Symbol.toStringTag] = 'BigInt';
st.equal(
inspect(faker),
'{ [Symbol(Symbol.toStringTag)]: \'BigInt\' }',
'object lying about being a BigInt inspects as an object'
);
});
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();
});

15
website/node_modules/object-inspect/test/browser/dom.js generated vendored Normal file
View File

@@ -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] ] ] ] } ]'
);
});

16
website/node_modules/object-inspect/test/circular.js generated vendored Normal file
View File

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

12
website/node_modules/object-inspect/test/deep.js generated vendored Normal file
View File

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

53
website/node_modules/object-inspect/test/element.js generated vendored Normal file
View File

@@ -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) { return 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) { return 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) { return 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;
});

48
website/node_modules/object-inspect/test/err.js generated vendored Normal file
View File

@@ -0,0 +1,48 @@
var test = require('tape');
var ErrorWithCause = require('error-cause/Error');
var inspect = require('../');
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 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,
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 }',
'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(', ') + ' ]');
});

29
website/node_modules/object-inspect/test/fakes.js generated vendored Normal file
View File

@@ -0,0 +1,29 @@
'use strict';
var inspect = require('../');
var test = require('tape');
var hasToStringTag = require('has-tostringtag/shams')();
var forEach = require('for-each');
test('fakes', { skip: !hasToStringTag }, function (t) {
forEach([
'Array',
'Boolean',
'Date',
'Error',
'Number',
'RegExp',
'String'
], function (expected) {
var faker = {};
faker[Symbol.toStringTag] = expected;
t.equal(
inspect(faker),
'{ [Symbol(Symbol.toStringTag)]: \'' + expected + '\' }',
'faker masquerading as ' + expected + ' is not shown as one'
);
});
t.end();
});

76
website/node_modules/object-inspect/test/fn.js generated vendored Normal file
View File

@@ -0,0 +1,76 @@
var inspect = require('../');
var test = require('tape');
var arrow = require('make-arrow-function')();
var functionsHaveConfigurableNames = require('functions-have-names').functionsHaveConfigurableNames();
test('function', function (t) {
t.plan(1);
var obj = [1, 2, function f(n) { return 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 toStr() { return 'function xxx () {}'; };
var obj = [1, 2, f, 4];
t.equal(inspect(obj), '[ 1, 2, [Function (anonymous)] { toString: [Function: toStr] }, 4 ]');
});
test('anon function', function (t) {
var f = (function () {
return function () {};
}());
var obj = [1, 2, f, 4];
t.equal(inspect(obj), '[ 1, 2, [Function (anonymous)], 4 ]');
t.end();
});
test('arrow function', { skip: !arrow }, function (t) {
t.equal(inspect(arrow), '[Function (anonymous)]');
t.end();
});
test('truly nameless function', { skip: !arrow || !functionsHaveConfigurableNames }, function (t) {
function f() {}
Object.defineProperty(f, 'name', { value: false });
t.equal(f.name, false);
t.equal(
inspect(f),
'[Function: f]',
'named function with falsy `.name` does not hide its original name'
);
function g() {}
Object.defineProperty(g, 'name', { value: true });
t.equal(g.name, true);
t.equal(
inspect(g),
'[Function: true]',
'named function with truthy `.name` hides its original name'
);
var anon = function () {}; // eslint-disable-line func-style
Object.defineProperty(anon, 'name', { value: null });
t.equal(anon.name, null);
t.equal(
inspect(anon),
'[Function (anonymous)]',
'anon function with falsy `.name` does not hide its anonymity'
);
var anon2 = function () {}; // eslint-disable-line func-style
Object.defineProperty(anon2, 'name', { value: 1 });
t.equal(anon2.name, 1);
t.equal(
inspect(anon2),
'[Function: 1]',
'anon function with truthy `.name` hides its anonymity'
);
t.end();
});

17
website/node_modules/object-inspect/test/global.js generated vendored Normal file
View File

@@ -0,0 +1,17 @@
'use strict';
var inspect = require('../');
var test = require('tape');
var globalThis = require('globalthis')();
test('global object', function (t) {
/* eslint-env browser */
var expected = typeof window === 'undefined' ? 'globalThis' : 'Window';
t.equal(
inspect([globalThis]),
'[ { [object ' + expected + '] } ]'
);
t.end();
});

15
website/node_modules/object-inspect/test/has.js generated vendored Normal file
View File

@@ -0,0 +1,15 @@
'use strict';
var inspect = require('../');
var test = require('tape');
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
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 }));
t.equal(inspect(arr), '[ 1, , 3 ]');
});

15
website/node_modules/object-inspect/test/holes.js generated vendored Normal file
View File

@@ -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' ]"
);
});

271
website/node_modules/object-inspect/test/indent-option.js generated vendored Normal file
View File

@@ -0,0 +1,271 @@
var test = require('tape');
var forEach = require('for-each');
var inspect = require('../');
test('bad indent options', function (t) {
forEach([
undefined,
true,
false,
-1,
1.2,
Infinity,
-Infinity,
NaN
], function (indent) {
t['throws'](
function () { inspect('', { indent: indent }); },
TypeError,
inspect(indent) + ' is invalid'
);
});
t.end();
});
test('simple object with indent', function (t) {
t.plan(2);
var obj = { a: 1, b: 2 };
var expectedSpaces = [
'{',
' a: 1,',
' b: 2',
'}'
].join('\n');
var expectedTabs = [
'{',
' a: 1,',
' b: 2',
'}'
].join('\n');
t.equal(inspect(obj, { indent: 2 }), expectedSpaces, 'two');
t.equal(inspect(obj, { indent: '\t' }), expectedTabs, 'tabs');
});
test('two deep object with indent', function (t) {
t.plan(2);
var obj = { a: 1, b: { c: 3, d: 4 } };
var expectedSpaces = [
'{',
' a: 1,',
' b: {',
' c: 3,',
' d: 4',
' }',
'}'
].join('\n');
var expectedTabs = [
'{',
' a: 1,',
' b: {',
' c: 3,',
' d: 4',
' }',
'}'
].join('\n');
t.equal(inspect(obj, { indent: 2 }), expectedSpaces, 'two');
t.equal(inspect(obj, { indent: '\t' }), expectedTabs, 'tabs');
});
test('simple array with all single line elements', function (t) {
t.plan(2);
var obj = [1, 2, 3, 'asdf\nsdf'];
var expected = '[ 1, 2, 3, \'asdf\\nsdf\' ]';
t.equal(inspect(obj, { indent: 2 }), expected, 'two');
t.equal(inspect(obj, { indent: '\t' }), expected, 'tabs');
});
test('array with complex elements', function (t) {
t.plan(2);
var obj = [1, { a: 1, b: { c: 1 } }, 'asdf\nsdf'];
var expectedSpaces = [
'[',
' 1,',
' {',
' a: 1,',
' b: {',
' c: 1',
' }',
' },',
' \'asdf\\nsdf\'',
']'
].join('\n');
var expectedTabs = [
'[',
' 1,',
' {',
' a: 1,',
' b: {',
' c: 1',
' }',
' },',
' \'asdf\\nsdf\'',
']'
].join('\n');
t.equal(inspect(obj, { indent: 2 }), expectedSpaces, 'two');
t.equal(inspect(obj, { indent: '\t' }), expectedTabs, 'tabs');
});
test('values', function (t) {
t.plan(2);
var obj = [{}, [], { 'a-b': 5 }];
var expectedSpaces = [
'[',
' {},',
' [],',
' {',
' \'a-b\': 5',
' }',
']'
].join('\n');
var expectedTabs = [
'[',
' {},',
' [],',
' {',
' \'a-b\': 5',
' }',
']'
].join('\n');
t.equal(inspect(obj, { indent: 2 }), expectedSpaces, 'two');
t.equal(inspect(obj, { indent: '\t' }), expectedTabs, 'tabs');
});
test('Map', { skip: typeof Map !== 'function' }, function (t) {
var map = new Map();
map.set({ a: 1 }, ['b']);
map.set(3, NaN);
var expectedStringSpaces = [
'Map (2) {',
' { a: 1 } => [ \'b\' ],',
' 3 => NaN',
'}'
].join('\n');
var expectedStringTabs = [
'Map (2) {',
' { a: 1 } => [ \'b\' ],',
' 3 => NaN',
'}'
].join('\n');
var expectedStringTabsDoubleQuotes = [
'Map (2) {',
' { a: 1 } => [ "b" ],',
' 3 => NaN',
'}'
].join('\n');
t.equal(
inspect(map, { indent: 2 }),
expectedStringSpaces,
'Map keys are not indented (two)'
);
t.equal(
inspect(map, { indent: '\t' }),
expectedStringTabs,
'Map keys are not indented (tabs)'
);
t.equal(
inspect(map, { indent: '\t', quoteStyle: 'double' }),
expectedStringTabsDoubleQuotes,
'Map keys are not indented (tabs + double quotes)'
);
t.equal(inspect(new Map(), { indent: 2 }), 'Map (0) {}', 'empty Map should show as empty (two)');
t.equal(inspect(new Map(), { indent: '\t' }), 'Map (0) {}', 'empty Map should show as empty (tabs)');
var nestedMap = new Map();
nestedMap.set(nestedMap, map);
var expectedNestedSpaces = [
'Map (1) {',
' [Circular] => Map (2) {',
' { a: 1 } => [ \'b\' ],',
' 3 => NaN',
' }',
'}'
].join('\n');
var expectedNestedTabs = [
'Map (1) {',
' [Circular] => Map (2) {',
' { a: 1 } => [ \'b\' ],',
' 3 => NaN',
' }',
'}'
].join('\n');
t.equal(inspect(nestedMap, { indent: 2 }), expectedNestedSpaces, 'Map containing a Map should work (two)');
t.equal(inspect(nestedMap, { indent: '\t' }), expectedNestedTabs, 'Map containing a Map should work (tabs)');
t.end();
});
test('Set', { skip: typeof Set !== 'function' }, function (t) {
var set = new Set();
set.add({ a: 1 });
set.add(['b']);
var expectedStringSpaces = [
'Set (2) {',
' {',
' a: 1',
' },',
' [ \'b\' ]',
'}'
].join('\n');
var expectedStringTabs = [
'Set (2) {',
' {',
' a: 1',
' },',
' [ \'b\' ]',
'}'
].join('\n');
t.equal(inspect(set, { indent: 2 }), expectedStringSpaces, 'new Set([{ a: 1 }, ["b"]]) should show size and contents (two)');
t.equal(inspect(set, { indent: '\t' }), expectedStringTabs, 'new Set([{ a: 1 }, ["b"]]) should show size and contents (tabs)');
t.equal(inspect(new Set(), { indent: 2 }), 'Set (0) {}', 'empty Set should show as empty (two)');
t.equal(inspect(new Set(), { indent: '\t' }), 'Set (0) {}', 'empty Set should show as empty (tabs)');
var nestedSet = new Set();
nestedSet.add(set);
nestedSet.add(nestedSet);
var expectedNestedSpaces = [
'Set (2) {',
' Set (2) {',
' {',
' a: 1',
' },',
' [ \'b\' ]',
' },',
' [Circular]',
'}'
].join('\n');
var expectedNestedTabs = [
'Set (2) {',
' Set (2) {',
' {',
' a: 1',
' },',
' [ \'b\' ]',
' },',
' [Circular]',
'}'
].join('\n');
t.equal(inspect(nestedSet, { indent: 2 }), expectedNestedSpaces, 'Set containing a Set should work (two)');
t.equal(inspect(nestedSet, { indent: '\t' }), expectedNestedTabs, 'Set containing a Set should work (tabs)');
t.end();
});

139
website/node_modules/object-inspect/test/inspect.js generated vendored Normal file
View File

@@ -0,0 +1,139 @@
var test = require('tape');
var hasSymbols = require('has-symbols/shams')();
var utilInspect = require('../util.inspect');
var repeat = require('string.prototype.repeat');
var inspect = require('..');
test('inspect', function (t) {
t.plan(5);
var obj = [{ inspect: function xyzInspect() { return '!XYZ¡'; } }, []];
var stringResult = '[ !XYZ¡, [] ]';
var falseResult = '[ { inspect: [Function: xyzInspect] }, [] ]';
t.equal(inspect(obj), stringResult);
t.equal(inspect(obj, { customInspect: true }), stringResult);
t.equal(inspect(obj, { customInspect: 'symbol' }), falseResult);
t.equal(inspect(obj, { customInspect: false }), falseResult);
t['throws'](
function () { inspect(obj, { customInspect: 'not a boolean or "symbol"' }); },
TypeError,
'`customInspect` must be a boolean or the string "symbol"'
);
});
test('inspect custom symbol', { skip: !hasSymbols || !utilInspect || !utilInspect.custom }, function (t) {
t.plan(4);
var obj = { inspect: function stringInspect() { return 'string'; } };
obj[utilInspect.custom] = function custom() { return 'symbol'; };
var symbolResult = '[ symbol, [] ]';
var stringResult = '[ string, [] ]';
var falseResult = '[ { inspect: [Function: stringInspect]' + (utilInspect.custom ? ', [' + inspect(utilInspect.custom) + ']: [Function: custom]' : '') + ' }, [] ]';
var symbolStringFallback = utilInspect.custom ? symbolResult : stringResult;
var symbolFalseFallback = utilInspect.custom ? symbolResult : falseResult;
t.equal(inspect([obj, []]), symbolStringFallback);
t.equal(inspect([obj, []], { customInspect: true }), symbolStringFallback);
t.equal(inspect([obj, []], { customInspect: 'symbol' }), symbolFalseFallback);
t.equal(inspect([obj, []], { customInspect: false }), falseResult);
});
test('symbols', { skip: !hasSymbols }, function (t) {
t.plan(2);
var obj = { a: 1 };
obj[Symbol('test')] = 2;
obj[Symbol.iterator] = 3;
Object.defineProperty(obj, Symbol('non-enum'), {
enumerable: false,
value: 4
});
if (typeof Symbol.iterator === 'symbol') {
t.equal(inspect(obj), '{ a: 1, [Symbol(test)]: 2, [Symbol(Symbol.iterator)]: 3 }', 'object with symbols');
t.equal(inspect([obj, []]), '[ { a: 1, [Symbol(test)]: 2, [Symbol(Symbol.iterator)]: 3 }, [] ]', 'object with symbols in array');
} else {
// symbol sham key ordering is unreliable
t.match(
inspect(obj),
/^(?:{ a: 1, \[Symbol\(test\)\]: 2, \[Symbol\(Symbol.iterator\)\]: 3 }|{ a: 1, \[Symbol\(Symbol.iterator\)\]: 3, \[Symbol\(test\)\]: 2 })$/,
'object with symbols (nondeterministic symbol sham key ordering)'
);
t.match(
inspect([obj, []]),
/^\[ (?:{ a: 1, \[Symbol\(test\)\]: 2, \[Symbol\(Symbol.iterator\)\]: 3 }|{ a: 1, \[Symbol\(Symbol.iterator\)\]: 3, \[Symbol\(test\)\]: 2 }), \[\] \]$/,
'object with symbols in array (nondeterministic symbol sham key ordering)'
);
}
});
test('maxStringLength', function (t) {
t['throws'](
function () { inspect('', { maxStringLength: -1 }); },
TypeError,
'maxStringLength must be >= 0, or Infinity, not negative'
);
var str = repeat('a', 1e8);
t.equal(
inspect([str], { maxStringLength: 10 }),
'[ \'aaaaaaaaaa\'... 99999990 more characters ]',
'maxStringLength option limits output'
);
t.equal(
inspect(['f'], { maxStringLength: null }),
'[ \'\'... 1 more character ]',
'maxStringLength option accepts `null`'
);
t.equal(
inspect([str], { maxStringLength: Infinity }),
'[ \'' + str + '\' ]',
'maxStringLength option accepts ∞'
);
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();
});

12
website/node_modules/object-inspect/test/lowbyte.js generated vendored Normal file
View File

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

58
website/node_modules/object-inspect/test/number.js generated vendored Normal file
View File

@@ -0,0 +1,58 @@
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"');
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();
});
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();
});

26
website/node_modules/object-inspect/test/quoteStyle.js generated vendored Normal file
View File

@@ -0,0 +1,26 @@
'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.equal(inspect('"', { quoteStyle: 'single' }), '\'"\'', 'double quote, quoteStyle: "single"');
t.equal(inspect('"', { quoteStyle: 'double' }), '"\\""', 'double quote, quoteStyle: "double"');
t.equal(inspect('\'', { quoteStyle: 'single' }), '\'\\\'\'', 'single quote, quoteStyle: "single"');
t.equal(inspect('\'', { quoteStyle: 'double' }), '"\'"', 'single quote, quoteStyle: "double"');
t.equal(inspect('`', { quoteStyle: 'single' }), '\'`\'', 'backtick, quoteStyle: "single"');
t.equal(inspect('`', { quoteStyle: 'double' }), '"`"', 'backtick, quoteStyle: "double"');
t.end();
});

40
website/node_modules/object-inspect/test/toStringTag.js generated vendored Normal file
View File

@@ -0,0 +1,40 @@
'use strict';
var test = require('tape');
var hasToStringTag = require('has-tostringtag/shams')();
var inspect = require('../');
test('Symbol.toStringTag', { skip: !hasToStringTag }, function (t) {
t.plan(4);
var obj = { a: 1 };
t.equal(inspect(obj), '{ a: 1 }', 'object, no Symbol.toStringTag');
obj[Symbol.toStringTag] = 'foo';
t.equal(inspect(obj), '{ a: 1, [Symbol(Symbol.toStringTag)]: \'foo\' }', 'object with Symbol.toStringTag');
t.test('null objects', { skip: 'toString' in { __proto__: null } }, function (st) {
st.plan(2);
var dict = { __proto__: null, a: 1 };
st.equal(inspect(dict), '[Object: null prototype] { a: 1 }', 'null object with Symbol.toStringTag');
dict[Symbol.toStringTag] = 'Dict';
st.equal(inspect(dict), '[Dict: null prototype] { a: 1, [Symbol(Symbol.toStringTag)]: \'Dict\' }', 'null object with Symbol.toStringTag');
});
t.test('instances', function (st) {
st.plan(4);
function C() {
this.a = 1;
}
st.equal(Object.prototype.toString.call(new C()), '[object Object]', 'instance, no toStringTag, Object.prototype.toString');
st.equal(inspect(new C()), 'C { a: 1 }', 'instance, no toStringTag');
C.prototype[Symbol.toStringTag] = 'Class!';
st.equal(Object.prototype.toString.call(new C()), '[object Class!]', 'instance, with toStringTag, Object.prototype.toString');
st.equal(inspect(new C()), 'C [Class!] { a: 1 }', 'instance, with toStringTag');
});
});

12
website/node_modules/object-inspect/test/undef.js generated vendored Normal file
View File

@@ -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 }'
);
});

261
website/node_modules/object-inspect/test/values.js generated vendored Normal file
View File

@@ -0,0 +1,261 @@
'use strict';
var inspect = require('../');
var test = require('tape');
var mockProperty = require('mock-property');
var hasSymbols = require('has-symbols/shams')();
var hasToStringTag = require('has-tostringtag/shams')();
var forEach = require('for-each');
var semver = require('semver');
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);
t.teardown(mockProperty(Object.prototype, 'hasOwnProperty', { 'delete': true }));
t.equal(inspect({ a: 1, b: 2 }), '{ a: 1, b: 2 }');
});
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: !hasSymbols }, function (t) {
var sym = Symbol('foo');
t.equal(inspect(sym), 'Symbol(foo)', 'Symbol("foo") should be "Symbol(foo)"');
if (typeof sym === 'symbol') {
// Symbol shams are incapable of differentiating boxed from unboxed symbols
t.equal(inspect(Object(sym)), 'Object(Symbol(foo))', 'Object(Symbol("foo")) should be "Object(Symbol(foo))"');
}
t.test('toStringTag', { skip: !hasToStringTag }, function (st) {
st.plan(1);
var faker = {};
faker[Symbol.toStringTag] = 'Symbol';
st.equal(
inspect(faker),
'{ [Symbol(Symbol.toStringTag)]: \'Symbol\' }',
'object lying about being a Symbol inspects as an object'
);
});
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('WeakMap', { skip: typeof WeakMap !== 'function' }, function (t) {
var map = new WeakMap();
map.set({ a: 1 }, ['b']);
var expectedString = 'WeakMap { ? }';
t.equal(inspect(map), expectedString, 'new WeakMap([[{ a: 1 }, ["b"]]]) should not show size or contents');
t.equal(inspect(new WeakMap()), 'WeakMap { ? }', 'empty WeakMap should not show as empty');
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('WeakSet', { skip: typeof WeakSet !== 'function' }, function (t) {
var map = new WeakSet();
map.add({ a: 1 });
var expectedString = 'WeakSet { ? }';
t.equal(inspect(map), expectedString, 'new WeakSet([{ a: 1 }]) should not show size or contents');
t.equal(inspect(new WeakSet()), 'WeakSet { ? }', 'empty WeakSet should not show as empty');
t.end();
});
test('WeakRef', { skip: typeof WeakRef !== 'function' }, function (t) {
var ref = new WeakRef({ a: 1 });
var expectedString = 'WeakRef { ? }';
t.equal(inspect(ref), expectedString, 'new WeakRef({ a: 1 }) should not show contents');
t.end();
});
test('FinalizationRegistry', { skip: typeof FinalizationRegistry !== 'function' }, function (t) {
var registry = new FinalizationRegistry(function () {});
var expectedString = 'FinalizationRegistry [FinalizationRegistry] {}';
t.equal(inspect(registry), expectedString, 'new FinalizationRegistry(function () {}) should work normallys');
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();
});
test('Date', function (t) {
var now = new Date();
t.equal(inspect(now), String(now), 'Date shows properly');
t.equal(inspect(new Date(NaN)), 'Invalid Date', 'Invalid Date shows properly');
t.end();
});
test('RegExps', function (t) {
t.equal(inspect(/a/g), '/a/g', 'regex shows properly');
t.equal(inspect(new RegExp('abc', 'i')), '/abc/i', 'new RegExp shows properly');
var match = 'abc abc'.match(/[ab]+/);
delete match.groups; // for node < 10
t.equal(inspect(match), '[ \'ab\', index: 0, input: \'abc abc\' ]', 'RegExp match object shows properly');
t.end();
});
test('Proxies', { skip: typeof Proxy !== 'function' || !hasToStringTag }, function (t) {
var target = { proxy: true };
var fake = new Proxy(target, { has: function () { return false; } });
// needed to work around a weird difference in node v6.0 - v6.4 where non-present properties are not logged
var isNode60 = semver.satisfies(process.version, '6.0 - 6.4');
forEach([
'Boolean',
'Number',
'String',
'Symbol',
'Date'
], function (tag) {
target[Symbol.toStringTag] = tag;
t.equal(
inspect(fake),
'{ ' + (isNode60 ? '' : 'proxy: true, ') + '[Symbol(Symbol.toStringTag)]: \'' + tag + '\' }',
'Proxy for + ' + tag + ' shows as the target, which has no slots'
);
});
t.end();
});
test('fakers', { skip: !hasToStringTag }, function (t) {
var target = { proxy: false };
forEach([
'Boolean',
'Number',
'String',
'Symbol',
'Date'
], function (tag) {
target[Symbol.toStringTag] = tag;
t.equal(
inspect(target),
'{ proxy: false, [Symbol(Symbol.toStringTag)]: \'' + tag + '\' }',
'Object pretending to be ' + tag + ' does not trick us'
);
});
t.end();
});