pax_global_header 0000666 0000000 0000000 00000000064 14073115252 0014512 g ustar 00root root 0000000 0000000 52 comment=dcee6edfd0e216ab0139242668079bff6310fcf0
object-inspect-1.11.0/ 0000775 0000000 0000000 00000000000 14073115252 0014503 5 ustar 00root root 0000000 0000000 object-inspect-1.11.0/.eslintignore 0000664 0000000 0000000 00000000012 14073115252 0017177 0 ustar 00root root 0000000 0000000 coverage/
object-inspect-1.11.0/.eslintrc 0000664 0000000 0000000 00000003115 14073115252 0016327 0 ustar 00root root 0000000 0000000 {
"root": true,
"extends": "@ljharb",
"rules": {
"complexity": 0,
"func-style": [2, "declaration"],
"indent": [2, 4],
"max-lines": 1,
"max-lines-per-function": 1,
"max-params": [2, 4],
"max-statements": 0,
"max-statements-per-line": [2, { "max": 2 }],
"no-magic-numbers": 0,
"no-param-reassign": 1,
"operator-linebreak": [2, "before"],
"strict": 0, // TODO
},
"globals": {
"BigInt": false,
"WeakSet": false,
"WeakMap": false,
},
"overrides": [
{
"files": ["test/**", "test-*", "example/**"],
"rules": {
"array-bracket-newline": 0,
"id-length": 0,
"max-params": 0,
"max-statements": 0,
"max-statements-per-line": 0,
"object-curly-newline": 0,
"sort-keys": 0,
},
},
{
"files": ["example/**"],
"rules": {
"no-console": 0,
},
},
{
"files": ["test/browser/**"],
"env": {
"browser": true,
},
},
{
"files": ["test/bigint*"],
"rules": {
"new-cap": [2, { "capIsNewExceptions": ["BigInt"] }],
},
},
{
"files": "index.js",
"globals": {
"HTMLElement": false,
},
"rules": {
"no-use-before-define": 1,
},
},
],
}
object-inspect-1.11.0/.github/ 0000775 0000000 0000000 00000000000 14073115252 0016043 5 ustar 00root root 0000000 0000000 object-inspect-1.11.0/.github/FUNDING.yml 0000664 0000000 0000000 00000001111 14073115252 0017652 0 ustar 00root root 0000000 0000000 # These are supported funding model platforms
github: [ljharb]
patreon: # Replace with a single Patreon username
open_collective: # Replace with a single Open Collective username
ko_fi: # Replace with a single Ko-fi username
tidelift: npm/object-inspect
community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
liberapay: # Replace with a single Liberapay username
issuehunt: # Replace with a single IssueHunt username
otechie: # Replace with a single Otechie username
custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']
object-inspect-1.11.0/.github/workflows/ 0000775 0000000 0000000 00000000000 14073115252 0020100 5 ustar 00root root 0000000 0000000 object-inspect-1.11.0/.github/workflows/node-4+.yml 0000664 0000000 0000000 00000003011 14073115252 0021757 0 ustar 00root root 0000000 0000000 name: 'Tests: node.js'
on: [pull_request, push]
jobs:
matrix:
runs-on: ubuntu-latest
outputs:
latest: ${{ steps.set-matrix.outputs.requireds }}
minors: ${{ steps.set-matrix.outputs.optionals }}
steps:
- uses: ljharb/actions/node/matrix@main
id: set-matrix
with:
preset: '>=4'
latest:
needs: [matrix]
name: 'latest minors'
runs-on: ubuntu-latest
strategy:
fail-fast: false
matrix: ${{ fromJson(needs.matrix.outputs.latest) }}
steps:
- uses: actions/checkout@v2
- uses: ljharb/actions/node/install@main
name: 'nvm install ${{ matrix.node-version }} && npm install'
with:
node-version: ${{ matrix.node-version }}
- run: npm run tests-only
- uses: codecov/codecov-action@v1
minors:
needs: [matrix, latest]
name: 'non-latest minors'
continue-on-error: true
if: ${{ !github.head_ref || !startsWith(github.head_ref, 'renovate') }}
runs-on: ubuntu-latest
strategy:
fail-fast: false
matrix: ${{ fromJson(needs.matrix.outputs.minors) }}
steps:
- uses: actions/checkout@v2
- uses: ljharb/actions/node/install@main
name: 'nvm install ${{ matrix.node-version }} && npm install'
with:
node-version: ${{ matrix.node-version }}
- run: npm run tests-only
- uses: codecov/codecov-action@v1
node:
name: 'node 4+'
needs: [latest, minors]
runs-on: ubuntu-latest
steps:
- run: 'echo tests completed'
object-inspect-1.11.0/.github/workflows/node-iojs.yml 0000664 0000000 0000000 00000003465 14073115252 0022522 0 ustar 00root root 0000000 0000000 name: 'Tests: node.js (io.js)'
on: [pull_request, push]
jobs:
matrix:
runs-on: ubuntu-latest
outputs:
latest: ${{ steps.set-matrix.outputs.requireds }}
minors: ${{ steps.set-matrix.outputs.optionals }}
steps:
- uses: ljharb/actions/node/matrix@main
id: set-matrix
with:
versionsAsRoot: true
preset: 'iojs'
latest:
needs: [matrix]
name: 'latest minors'
runs-on: ubuntu-latest
strategy:
fail-fast: false
matrix:
node-version: ${{ fromJson(needs.matrix.outputs.latest) }}
command:
- 'tests-only'
- 'test:corejs'
steps:
- uses: actions/checkout@v2
- uses: ljharb/actions/node/install@main
name: 'nvm install ${{ matrix.node-version }} && npm install'
with:
node-version: ${{ matrix.node-version }}
skip-ls-check: true
- run: npm run ${{ matrix.command }}
- uses: codecov/codecov-action@v1
minors:
needs: [matrix, latest]
name: 'non-latest minors'
continue-on-error: true
if: ${{ !github.head_ref || !startsWith(github.head_ref, 'renovate') }}
runs-on: ubuntu-latest
strategy:
fail-fast: false
matrix:
node-version: ${{ fromJson(needs.matrix.outputs.minors) }}
command:
- 'tests-only'
- 'test:corejs'
steps:
- uses: actions/checkout@v2
- uses: ljharb/actions/node/install@main
name: 'nvm install ${{ matrix.node-version }} && npm install'
with:
node-version: ${{ matrix.node-version }}
skip-ls-check: true
- run: npm run ${{ matrix.command }}
- uses: codecov/codecov-action@v1
node:
name: 'io.js'
needs: [latest, minors]
runs-on: ubuntu-latest
steps:
- run: 'echo tests completed'
object-inspect-1.11.0/.github/workflows/node-pretest.yml 0000664 0000000 0000000 00000001102 14073115252 0023226 0 ustar 00root root 0000000 0000000 name: 'Tests: pretest/posttest'
on: [pull_request, push]
jobs:
pretest:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- uses: ljharb/actions/node/install@main
name: 'nvm install lts/* && npm install'
with:
node-version: 'lts/*'
- run: npm run pretest
posttest:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- uses: ljharb/actions/node/install@main
name: 'nvm install lts/* && npm install'
with:
node-version: 'lts/*'
- run: npm run posttest
object-inspect-1.11.0/.github/workflows/node-zero.yml 0000664 0000000 0000000 00000004033 14073115252 0022525 0 ustar 00root root 0000000 0000000 name: 'Tests: node.js (0.x)'
on: [pull_request, push]
jobs:
matrix:
runs-on: ubuntu-latest
outputs:
stable: ${{ steps.set-matrix.outputs.requireds }}
unstable: ${{ steps.set-matrix.outputs.optionals }}
steps:
- uses: ljharb/actions/node/matrix@main
id: set-matrix
with:
versionsAsRoot: true
preset: '0.x'
stable:
needs: [matrix]
name: 'stable minors'
runs-on: ubuntu-latest
strategy:
fail-fast: false
matrix:
node-version: ${{ fromJson(needs.matrix.outputs.stable) }}
command:
- 'tests-only'
- 'test:corejs'
steps:
- uses: actions/checkout@v2
- uses: ljharb/actions/node/install@main
name: 'nvm install ${{ matrix.node-version }} && npm install'
with:
node-version: ${{ matrix.node-version }}
cache-node-modules-key: node_modules-${{ github.workflow }}-${{ github.action }}-${{ github.run_id }}
skip-ls-check: true
- run: npm run ${{ matrix.command }}
- uses: codecov/codecov-action@v1
unstable:
needs: [matrix, stable]
name: 'unstable minors'
continue-on-error: true
if: ${{ !github.head_ref || !startsWith(github.head_ref, 'renovate') }}
runs-on: ubuntu-latest
strategy:
fail-fast: false
matrix:
node-version: ${{ fromJson(needs.matrix.outputs.unstable) }}
command:
- 'tests-only'
- 'test:corejs'
steps:
- uses: actions/checkout@v2
- uses: ljharb/actions/node/install@main
name: 'nvm install ${{ matrix.node-version }} && npm install'
with:
node-version: ${{ matrix.node-version }}
cache-node-modules-key: node_modules-${{ github.workflow }}-${{ github.action }}-${{ github.run_id }}
skip-ls-check: true
- run: npm run ${{ matrix.command }}
- uses: codecov/codecov-action@v1
node:
name: 'node 0.x'
needs: [stable, unstable]
runs-on: ubuntu-latest
steps:
- run: 'echo tests completed'
object-inspect-1.11.0/.github/workflows/rebase.yml 0000664 0000000 0000000 00000000401 14073115252 0022057 0 ustar 00root root 0000000 0000000 name: Automatic Rebase
on: [pull_request_target]
jobs:
_:
name: "Automatic Rebase"
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- uses: ljharb/rebase@master
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
object-inspect-1.11.0/.github/workflows/require-allow-edits.yml 0000664 0000000 0000000 00000000301 14073115252 0024513 0 ustar 00root root 0000000 0000000 name: Require “Allow Edits”
on: [pull_request_target]
jobs:
_:
name: "Require “Allow Edits”"
runs-on: ubuntu-latest
steps:
- uses: ljharb/require-allow-edits@main
object-inspect-1.11.0/.gitignore 0000664 0000000 0000000 00000000215 14073115252 0016471 0 ustar 00root root 0000000 0000000 # gitignore
node_modules
# Only apps should have lockfiles
npm-shrinkwrap.json
package-lock.json
yarn.lock
# Coverage
coverage
.nyc_output
object-inspect-1.11.0/.npmignore 0000664 0000000 0000000 00000000263 14073115252 0016503 0 ustar 00root root 0000000 0000000 # gitignore
node_modules
# Only apps should have lockfiles
npm-shrinkwrap.json
package-lock.json
yarn.lock
# Coverage
coverage
.nyc_output
.github/workflows
./test-core-js.js
object-inspect-1.11.0/.npmrc 0000664 0000000 0000000 00000000023 14073115252 0015616 0 ustar 00root root 0000000 0000000 package-lock=false
object-inspect-1.11.0/.nycrc 0000664 0000000 0000000 00000000354 14073115252 0015624 0 ustar 00root root 0000000 0000000 {
"all": true,
"check-coverage": false,
"instrumentation": false,
"sourceMap": false,
"reporter": ["text-summary", "text", "html", "json"],
"exclude": [
"coverage",
"example",
"test",
"test-core-js.js"
]
}
object-inspect-1.11.0/LICENSE 0000664 0000000 0000000 00000002057 14073115252 0015514 0 ustar 00root root 0000000 0000000 MIT License
Copyright (c) 2013 James Halliday
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
object-inspect-1.11.0/example/ 0000775 0000000 0000000 00000000000 14073115252 0016136 5 ustar 00root root 0000000 0000000 object-inspect-1.11.0/example/all.js 0000664 0000000 0000000 00000000607 14073115252 0017247 0 ustar 00root root 0000000 0000000 'use strict';
var inspect = require('../');
var Buffer = require('safer-buffer').Buffer;
var holes = ['a', 'b'];
holes[4] = 'e';
holes[6] = 'g';
var obj = {
a: 1,
b: [3, 4, undefined, null],
c: undefined,
d: null,
e: {
regex: /^x/i,
buf: Buffer.from('abc'),
holes: holes
},
now: new Date()
};
obj.self = obj;
console.log(inspect(obj));
object-inspect-1.11.0/example/circular.js 0000664 0000000 0000000 00000000164 14073115252 0020301 0 ustar 00root root 0000000 0000000 'use strict';
var inspect = require('../');
var obj = { a: 1, b: [3, 4] };
obj.c = obj;
console.log(inspect(obj));
object-inspect-1.11.0/example/fn.js 0000664 0000000 0000000 00000000176 14073115252 0017103 0 ustar 00root root 0000000 0000000 'use strict';
var inspect = require('../');
var obj = [1, 2, function f(n) { return n + 5; }, 4];
console.log(inspect(obj));
object-inspect-1.11.0/example/inspect.js 0000664 0000000 0000000 00000000373 14073115252 0020144 0 ustar 00root root 0000000 0000000 'use strict';
/* eslint-env browser */
var inspect = require('../');
var d = document.createElement('div');
d.setAttribute('id', 'beep');
d.innerHTML = 'woooiiiii';
console.log(inspect([d, { a: 3, b: 4, c: [5, 6, [7, [8, [9]]]] }]));
object-inspect-1.11.0/index.js 0000664 0000000 0000000 00000040052 14073115252 0016151 0 ustar 00root root 0000000 0000000 var hasMap = typeof Map === 'function' && Map.prototype;
var mapSizeDescriptor = Object.getOwnPropertyDescriptor && hasMap ? Object.getOwnPropertyDescriptor(Map.prototype, 'size') : null;
var mapSize = hasMap && mapSizeDescriptor && typeof mapSizeDescriptor.get === 'function' ? mapSizeDescriptor.get : null;
var mapForEach = hasMap && Map.prototype.forEach;
var hasSet = typeof Set === 'function' && Set.prototype;
var setSizeDescriptor = Object.getOwnPropertyDescriptor && hasSet ? Object.getOwnPropertyDescriptor(Set.prototype, 'size') : null;
var setSize = hasSet && setSizeDescriptor && typeof setSizeDescriptor.get === 'function' ? setSizeDescriptor.get : null;
var setForEach = hasSet && Set.prototype.forEach;
var hasWeakMap = typeof WeakMap === 'function' && WeakMap.prototype;
var weakMapHas = hasWeakMap ? WeakMap.prototype.has : null;
var hasWeakSet = typeof WeakSet === 'function' && WeakSet.prototype;
var weakSetHas = hasWeakSet ? WeakSet.prototype.has : null;
var hasWeakRef = typeof WeakRef === 'function' && WeakRef.prototype;
var weakRefDeref = hasWeakRef ? WeakRef.prototype.deref : null;
var booleanValueOf = Boolean.prototype.valueOf;
var objectToString = Object.prototype.toString;
var functionToString = Function.prototype.toString;
var match = String.prototype.match;
var bigIntValueOf = typeof BigInt === 'function' ? BigInt.prototype.valueOf : null;
var gOPS = Object.getOwnPropertySymbols;
var symToString = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol' ? Symbol.prototype.toString : null;
var hasShammedSymbols = typeof Symbol === 'function' && typeof Symbol.iterator === 'object';
var isEnumerable = Object.prototype.propertyIsEnumerable;
var gPO = (typeof Reflect === 'function' ? Reflect.getPrototypeOf : Object.getPrototypeOf) || (
[].__proto__ === Array.prototype // eslint-disable-line no-proto
? function (O) {
return O.__proto__; // eslint-disable-line no-proto
}
: null
);
var inspectCustom = require('./util.inspect').custom;
var inspectSymbol = inspectCustom && isSymbol(inspectCustom) ? inspectCustom : null;
var toStringTag = typeof Symbol === 'function' && typeof Symbol.toStringTag !== 'undefined' ? Symbol.toStringTag : null;
module.exports = function inspect_(obj, options, depth, seen) {
var opts = options || {};
if (has(opts, 'quoteStyle') && (opts.quoteStyle !== 'single' && opts.quoteStyle !== 'double')) {
throw new TypeError('option "quoteStyle" must be "single" or "double"');
}
if (
has(opts, 'maxStringLength') && (typeof opts.maxStringLength === 'number'
? opts.maxStringLength < 0 && opts.maxStringLength !== Infinity
: opts.maxStringLength !== null
)
) {
throw new TypeError('option "maxStringLength", if provided, must be a positive integer, Infinity, or `null`');
}
var customInspect = has(opts, 'customInspect') ? opts.customInspect : true;
if (typeof customInspect !== 'boolean' && customInspect !== 'symbol') {
throw new TypeError('option "customInspect", if provided, must be `true`, `false`, or `\'symbol\'`');
}
if (
has(opts, 'indent')
&& opts.indent !== null
&& opts.indent !== '\t'
&& !(parseInt(opts.indent, 10) === opts.indent && opts.indent > 0)
) {
throw new TypeError('options "indent" must be "\\t", an integer > 0, or `null`');
}
if (typeof obj === 'undefined') {
return 'undefined';
}
if (obj === null) {
return 'null';
}
if (typeof obj === 'boolean') {
return obj ? 'true' : 'false';
}
if (typeof obj === 'string') {
return inspectString(obj, opts);
}
if (typeof obj === 'number') {
if (obj === 0) {
return Infinity / obj > 0 ? '0' : '-0';
}
return String(obj);
}
if (typeof obj === 'bigint') {
return String(obj) + 'n';
}
var maxDepth = typeof opts.depth === 'undefined' ? 5 : opts.depth;
if (typeof depth === 'undefined') { depth = 0; }
if (depth >= maxDepth && maxDepth > 0 && typeof obj === 'object') {
return isArray(obj) ? '[Array]' : '[Object]';
}
var indent = getIndent(opts, depth);
if (typeof seen === 'undefined') {
seen = [];
} else if (indexOf(seen, obj) >= 0) {
return '[Circular]';
}
function inspect(value, from, noIndent) {
if (from) {
seen = seen.slice();
seen.push(from);
}
if (noIndent) {
var newOpts = {
depth: opts.depth
};
if (has(opts, 'quoteStyle')) {
newOpts.quoteStyle = opts.quoteStyle;
}
return inspect_(value, newOpts, depth + 1, seen);
}
return inspect_(value, opts, depth + 1, seen);
}
if (typeof obj === 'function') {
var name = nameOf(obj);
var keys = arrObjKeys(obj, inspect);
return '[Function' + (name ? ': ' + name : ' (anonymous)') + ']' + (keys.length > 0 ? ' { ' + keys.join(', ') + ' }' : '');
}
if (isSymbol(obj)) {
var symString = hasShammedSymbols ? String(obj).replace(/^(Symbol\(.*\))_[^)]*$/, '$1') : symToString.call(obj);
return typeof obj === 'object' && !hasShammedSymbols ? markBoxed(symString) : symString;
}
if (isElement(obj)) {
var s = '<' + String(obj.nodeName).toLowerCase();
var attrs = obj.attributes || [];
for (var i = 0; i < attrs.length; i++) {
s += ' ' + attrs[i].name + '=' + wrapQuotes(quote(attrs[i].value), 'double', opts);
}
s += '>';
if (obj.childNodes && obj.childNodes.length) { s += '...'; }
s += '';
return s;
}
if (isArray(obj)) {
if (obj.length === 0) { return '[]'; }
var xs = arrObjKeys(obj, inspect);
if (indent && !singleLineValues(xs)) {
return '[' + indentedJoin(xs, indent) + ']';
}
return '[ ' + xs.join(', ') + ' ]';
}
if (isError(obj)) {
var parts = arrObjKeys(obj, inspect);
if (parts.length === 0) { return '[' + String(obj) + ']'; }
return '{ [' + String(obj) + '] ' + parts.join(', ') + ' }';
}
if (typeof obj === 'object' && customInspect) {
if (inspectSymbol && typeof obj[inspectSymbol] === 'function') {
return obj[inspectSymbol]();
} else if (customInspect !== 'symbol' && typeof obj.inspect === 'function') {
return obj.inspect();
}
}
if (isMap(obj)) {
var mapParts = [];
mapForEach.call(obj, function (value, key) {
mapParts.push(inspect(key, obj, true) + ' => ' + inspect(value, obj));
});
return collectionOf('Map', mapSize.call(obj), mapParts, indent);
}
if (isSet(obj)) {
var setParts = [];
setForEach.call(obj, function (value) {
setParts.push(inspect(value, obj));
});
return collectionOf('Set', setSize.call(obj), setParts, indent);
}
if (isWeakMap(obj)) {
return weakCollectionOf('WeakMap');
}
if (isWeakSet(obj)) {
return weakCollectionOf('WeakSet');
}
if (isWeakRef(obj)) {
return weakCollectionOf('WeakRef');
}
if (isNumber(obj)) {
return markBoxed(inspect(Number(obj)));
}
if (isBigInt(obj)) {
return markBoxed(inspect(bigIntValueOf.call(obj)));
}
if (isBoolean(obj)) {
return markBoxed(booleanValueOf.call(obj));
}
if (isString(obj)) {
return markBoxed(inspect(String(obj)));
}
if (!isDate(obj) && !isRegExp(obj)) {
var ys = arrObjKeys(obj, inspect);
var isPlainObject = gPO ? gPO(obj) === Object.prototype : obj instanceof Object || obj.constructor === Object;
var protoTag = obj instanceof Object ? '' : 'null prototype';
var stringTag = !isPlainObject && toStringTag && Object(obj) === obj && toStringTag in obj ? toStr(obj).slice(8, -1) : protoTag ? 'Object' : '';
var constructorTag = isPlainObject || typeof obj.constructor !== 'function' ? '' : obj.constructor.name ? obj.constructor.name + ' ' : '';
var tag = constructorTag + (stringTag || protoTag ? '[' + [].concat(stringTag || [], protoTag || []).join(': ') + '] ' : '');
if (ys.length === 0) { return tag + '{}'; }
if (indent) {
return tag + '{' + indentedJoin(ys, indent) + '}';
}
return tag + '{ ' + ys.join(', ') + ' }';
}
return String(obj);
};
function wrapQuotes(s, defaultStyle, opts) {
var quoteChar = (opts.quoteStyle || defaultStyle) === 'double' ? '"' : "'";
return quoteChar + s + quoteChar;
}
function quote(s) {
return String(s).replace(/"/g, '"');
}
function isArray(obj) { return toStr(obj) === '[object Array]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }
function isDate(obj) { return toStr(obj) === '[object Date]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }
function isRegExp(obj) { return toStr(obj) === '[object RegExp]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }
function isError(obj) { return toStr(obj) === '[object Error]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }
function isString(obj) { return toStr(obj) === '[object String]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }
function isNumber(obj) { return toStr(obj) === '[object Number]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }
function isBoolean(obj) { return toStr(obj) === '[object Boolean]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }
// Symbol and BigInt do have Symbol.toStringTag by spec, so that can't be used to eliminate false positives
function isSymbol(obj) {
if (hasShammedSymbols) {
return obj && typeof obj === 'object' && obj instanceof Symbol;
}
if (typeof obj === 'symbol') {
return true;
}
if (!obj || typeof obj !== 'object' || !symToString) {
return false;
}
try {
symToString.call(obj);
return true;
} catch (e) {}
return false;
}
function isBigInt(obj) {
if (!obj || typeof obj !== 'object' || !bigIntValueOf) {
return false;
}
try {
bigIntValueOf.call(obj);
return true;
} catch (e) {}
return false;
}
var hasOwn = Object.prototype.hasOwnProperty || function (key) { return key in this; };
function has(obj, key) {
return hasOwn.call(obj, key);
}
function toStr(obj) {
return objectToString.call(obj);
}
function nameOf(f) {
if (f.name) { return f.name; }
var m = match.call(functionToString.call(f), /^function\s*([\w$]+)/);
if (m) { return m[1]; }
return null;
}
function indexOf(xs, x) {
if (xs.indexOf) { return xs.indexOf(x); }
for (var i = 0, l = xs.length; i < l; i++) {
if (xs[i] === x) { return i; }
}
return -1;
}
function isMap(x) {
if (!mapSize || !x || typeof x !== 'object') {
return false;
}
try {
mapSize.call(x);
try {
setSize.call(x);
} catch (s) {
return true;
}
return x instanceof Map; // core-js workaround, pre-v2.5.0
} catch (e) {}
return false;
}
function isWeakMap(x) {
if (!weakMapHas || !x || typeof x !== 'object') {
return false;
}
try {
weakMapHas.call(x, weakMapHas);
try {
weakSetHas.call(x, weakSetHas);
} catch (s) {
return true;
}
return x instanceof WeakMap; // core-js workaround, pre-v2.5.0
} catch (e) {}
return false;
}
function isWeakRef(x) {
if (!weakRefDeref || !x || typeof x !== 'object') {
return false;
}
try {
weakRefDeref.call(x);
return true;
} catch (e) {}
return false;
}
function isSet(x) {
if (!setSize || !x || typeof x !== 'object') {
return false;
}
try {
setSize.call(x);
try {
mapSize.call(x);
} catch (m) {
return true;
}
return x instanceof Set; // core-js workaround, pre-v2.5.0
} catch (e) {}
return false;
}
function isWeakSet(x) {
if (!weakSetHas || !x || typeof x !== 'object') {
return false;
}
try {
weakSetHas.call(x, weakSetHas);
try {
weakMapHas.call(x, weakMapHas);
} catch (s) {
return true;
}
return x instanceof WeakSet; // core-js workaround, pre-v2.5.0
} catch (e) {}
return false;
}
function isElement(x) {
if (!x || typeof x !== 'object') { return false; }
if (typeof HTMLElement !== 'undefined' && x instanceof HTMLElement) {
return true;
}
return typeof x.nodeName === 'string' && typeof x.getAttribute === 'function';
}
function inspectString(str, opts) {
if (str.length > opts.maxStringLength) {
var remaining = str.length - opts.maxStringLength;
var trailer = '... ' + remaining + ' more character' + (remaining > 1 ? 's' : '');
return inspectString(str.slice(0, opts.maxStringLength), opts) + trailer;
}
// eslint-disable-next-line no-control-regex
var s = str.replace(/(['\\])/g, '\\$1').replace(/[\x00-\x1f]/g, lowbyte);
return wrapQuotes(s, 'single', opts);
}
function lowbyte(c) {
var n = c.charCodeAt(0);
var x = {
8: 'b',
9: 't',
10: 'n',
12: 'f',
13: 'r'
}[n];
if (x) { return '\\' + x; }
return '\\x' + (n < 0x10 ? '0' : '') + n.toString(16).toUpperCase();
}
function markBoxed(str) {
return 'Object(' + str + ')';
}
function weakCollectionOf(type) {
return type + ' { ? }';
}
function collectionOf(type, size, entries, indent) {
var joinedEntries = indent ? indentedJoin(entries, indent) : entries.join(', ');
return type + ' (' + size + ') {' + joinedEntries + '}';
}
function singleLineValues(xs) {
for (var i = 0; i < xs.length; i++) {
if (indexOf(xs[i], '\n') >= 0) {
return false;
}
}
return true;
}
function getIndent(opts, depth) {
var baseIndent;
if (opts.indent === '\t') {
baseIndent = '\t';
} else if (typeof opts.indent === 'number' && opts.indent > 0) {
baseIndent = Array(opts.indent + 1).join(' ');
} else {
return null;
}
return {
base: baseIndent,
prev: Array(depth + 1).join(baseIndent)
};
}
function indentedJoin(xs, indent) {
if (xs.length === 0) { return ''; }
var lineJoiner = '\n' + indent.prev + indent.base;
return lineJoiner + xs.join(',' + lineJoiner) + '\n' + indent.prev;
}
function arrObjKeys(obj, inspect) {
var isArr = isArray(obj);
var xs = [];
if (isArr) {
xs.length = obj.length;
for (var i = 0; i < obj.length; i++) {
xs[i] = has(obj, i) ? inspect(obj[i], obj) : '';
}
}
var syms = typeof gOPS === 'function' ? gOPS(obj) : [];
var symMap;
if (hasShammedSymbols) {
symMap = {};
for (var k = 0; k < syms.length; k++) {
symMap['$' + syms[k]] = syms[k];
}
}
for (var key in obj) { // eslint-disable-line no-restricted-syntax
if (!has(obj, key)) { continue; } // eslint-disable-line no-restricted-syntax, no-continue
if (isArr && String(Number(key)) === key && key < obj.length) { continue; } // eslint-disable-line no-restricted-syntax, no-continue
if (hasShammedSymbols && symMap['$' + key] instanceof Symbol) {
// this is to prevent shammed Symbols, which are stored as strings, from being included in the string key section
continue; // eslint-disable-line no-restricted-syntax, no-continue
} else if ((/[^\w$]/).test(key)) {
xs.push(inspect(key, obj) + ': ' + inspect(obj[key], obj));
} else {
xs.push(key + ': ' + inspect(obj[key], obj));
}
}
if (typeof gOPS === 'function') {
for (var j = 0; j < syms.length; j++) {
if (isEnumerable.call(obj, syms[j])) {
xs.push('[' + inspect(syms[j]) + ']: ' + inspect(obj[syms[j]], obj));
}
}
}
return xs;
}
object-inspect-1.11.0/package.json 0000664 0000000 0000000 00000003366 14073115252 0017001 0 ustar 00root root 0000000 0000000 {
"name": "object-inspect",
"version": "1.11.0",
"description": "string representations of objects in node and the browser",
"main": "index.js",
"devDependencies": {
"@ljharb/eslint-config": "^17.6.0",
"aud": "^1.1.5",
"core-js": "^2.6.12",
"eslint": "^7.30.0",
"for-each": "^0.3.3",
"functions-have-names": "^1.2.2",
"make-arrow-function": "^1.2.0",
"nyc": "^10.3.2",
"safe-publish-latest": "^1.1.4",
"string.prototype.repeat": "^1.0.0",
"tape": "^5.2.2"
},
"scripts": {
"prepublish": "not-in-publish || npm run prepublishOnly",
"prepublishOnly": "safe-publish-latest",
"pretest": "npm run lint",
"lint": "eslint .",
"test": "npm run tests-only && npm run test:corejs",
"tests-only": "nyc tape 'test/*.js'",
"test:corejs": "nyc tape test-core-js.js 'test/*.js'",
"posttest": "npx aud --production"
},
"testling": {
"files": [
"test/*.js",
"test/browser/*.js"
],
"browsers": [
"ie/6..latest",
"chrome/latest",
"firefox/latest",
"safari/latest",
"opera/latest",
"iphone/latest",
"ipad/latest",
"android/latest"
]
},
"repository": {
"type": "git",
"url": "git://github.com/inspect-js/object-inspect.git"
},
"homepage": "https://github.com/inspect-js/object-inspect",
"keywords": [
"inspect",
"util.inspect",
"object",
"stringify",
"pretty"
],
"author": {
"name": "James Halliday",
"email": "mail@substack.net",
"url": "http://substack.net"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
},
"license": "MIT",
"browser": {
"./util.inspect.js": false
},
"greenkeeper": {
"ignore": [
"nyc",
"core-js"
]
}
}
object-inspect-1.11.0/readme.markdown 0000664 0000000 0000000 00000005272 14073115252 0017512 0 ustar 00root root 0000000 0000000 # object-inspect [![Version Badge][2]][1]
string representations of objects in node and the browser
[![github actions][actions-image]][actions-url]
[![coverage][codecov-image]][codecov-url]
[![dependency status][5]][6]
[![dev dependency status][7]][8]
[![License][license-image]][license-url]
[![Downloads][downloads-image]][downloads-url]
[![npm badge][11]][1]
# example
## circular
``` js
var inspect = require('object-inspect');
var obj = { a: 1, b: [3,4] };
obj.c = obj;
console.log(inspect(obj));
```
## dom element
``` js
var inspect = require('object-inspect');
var d = document.createElement('div');
d.setAttribute('id', 'beep');
d.innerHTML = 'woooiiiii';
console.log(inspect([ d, { a: 3, b : 4, c: [5,6,[7,[8,[9]]]] } ]));
```
output:
```
[ ...
, { a: 3, b: 4, c: [ 5, 6, [ 7, [ 8, [ ... ] ] ] ] } ]
```
# methods
``` js
var inspect = require('object-inspect')
```
## var s = inspect(obj, opts={})
Return a string `s` with the string representation of `obj` up to a depth of `opts.depth`.
Additional options:
- `quoteStyle`: must be "single" or "double", if present. Default `'single'` for strings, `'double'` for HTML elements.
- `maxStringLength`: must be `0`, a positive integer, `Infinity`, or `null`, if present. Default `Infinity`.
- `customInspect`: When `true`, a custom inspect method function will be invoked (either undere the `util.inspect.custom` symbol, or the `inspect` property). When the string `'symbol'`, only the symbol method will be invoked. Default `true`.
- `indent`: must be "\t", `null`, or a positive integer. Default `null`.
# install
With [npm](https://npmjs.org) do:
```
npm install object-inspect
```
# license
MIT
[1]: https://npmjs.org/package/object-inspect
[2]: https://versionbadg.es/inspect-js/object-inspect.svg
[5]: https://david-dm.org/inspect-js/object-inspect.svg
[6]: https://david-dm.org/inspect-js/object-inspect
[7]: https://david-dm.org/inspect-js/object-inspect/dev-status.svg
[8]: https://david-dm.org/inspect-js/object-inspect#info=devDependencies
[11]: https://nodei.co/npm/object-inspect.png?downloads=true&stars=true
[license-image]: https://img.shields.io/npm/l/object-inspect.svg
[license-url]: LICENSE
[downloads-image]: https://img.shields.io/npm/dm/object-inspect.svg
[downloads-url]: https://npm-stat.com/charts.html?package=object-inspect
[codecov-image]: https://codecov.io/gh/inspect-js/object-inspect/branch/main/graphs/badge.svg
[codecov-url]: https://app.codecov.io/gh/inspect-js/object-inspect/
[actions-image]: https://img.shields.io/endpoint?url=https://github-actions-badge-u3jn4tfpocch.runkit.sh/inspect-js/object-inspect
[actions-url]: https://github.com/inspect-js/object-inspect/actions
object-inspect-1.11.0/test-core-js.js 0000664 0000000 0000000 00000001026 14073115252 0017357 0 ustar 00root root 0000000 0000000 'use strict';
require('core-js');
var inspect = require('./');
var test = require('tape');
test('Maps', function (t) {
t.equal(inspect(new Map([[1, 2]])), 'Map (1) {1 => 2}');
t.end();
});
test('WeakMaps', function (t) {
t.equal(inspect(new WeakMap([[{}, 2]])), 'WeakMap { ? }');
t.end();
});
test('Sets', function (t) {
t.equal(inspect(new Set([[1, 2]])), 'Set (1) {[ 1, 2 ]}');
t.end();
});
test('WeakSets', function (t) {
t.equal(inspect(new WeakSet([[1, 2]])), 'WeakSet { ? }');
t.end();
});
object-inspect-1.11.0/test/ 0000775 0000000 0000000 00000000000 14073115252 0015462 5 ustar 00root root 0000000 0000000 object-inspect-1.11.0/test/bigint.js 0000664 0000000 0000000 00000002551 14073115252 0017277 0 ustar 00root root 0000000 0000000 'use strict';
var inspect = require('../');
var test = require('tape');
var hasSymbols = require('has-symbols/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: !hasSymbols || typeof Symbol.toStringTag === 'undefined' }, 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.end();
});
object-inspect-1.11.0/test/browser/ 0000775 0000000 0000000 00000000000 14073115252 0017145 5 ustar 00root root 0000000 0000000 object-inspect-1.11.0/test/browser/dom.js 0000664 0000000 0000000 00000000640 14073115252 0020262 0 ustar 00root root 0000000 0000000 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 = 'woooiiiii';
t.equal(
inspect([d, { a: 3, b: 4, c: [5, 6, [7, [8, [9]]]] }]),
'[ ...
, { a: 3, b: 4, c: [ 5, 6, [ 7, [ 8, [Object] ] ] ] } ]'
);
});
object-inspect-1.11.0/test/circular.js 0000664 0000000 0000000 00000000703 14073115252 0017624 0 ustar 00root root 0000000 0000000 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] } }');
});
object-inspect-1.11.0/test/deep.js 0000664 0000000 0000000 00000000620 14073115252 0016733 0 ustar 00root root 0000000 0000000 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] ] ] ]');
});
object-inspect-1.11.0/test/element.js 0000664 0000000 0000000 00000003047 14073115252 0017455 0 ustar 00root root 0000000 0000000 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, , 3 ]');
t.deepEqual(inspect(obj, { quoteStyle: 'single' }), "[ 1, , 3 ]");
t.deepEqual(inspect(obj, { quoteStyle: 'double' }), '[ 1, , 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, , 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, ...
, 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, , 3 ]');
global.HTMLElement = h;
});
object-inspect-1.11.0/test/err.js 0000664 0000000 0000000 00000001322 14073115252 0016606 0 ustar 00root root 0000000 0000000 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(', ') + ' ]');
});
object-inspect-1.11.0/test/fakes.js 0000664 0000000 0000000 00000001314 14073115252 0017110 0 ustar 00root root 0000000 0000000 'use strict';
var inspect = require('../');
var test = require('tape');
var hasSymbols = require('has-symbols/shams')();
var forEach = require('for-each');
test('fakes', { skip: !hasSymbols || typeof Symbol.toStringTag === 'undefined' }, 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();
});
object-inspect-1.11.0/test/fn.js 0000664 0000000 0000000 00000004263 14073115252 0016430 0 ustar 00root root 0000000 0000000 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();
});
object-inspect-1.11.0/test/has.js 0000664 0000000 0000000 00000001732 14073115252 0016576 0 ustar 00root root 0000000 0000000 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;
}
}
}
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"
withoutProperty(Object.prototype, 'hasOwnProperty', function () {
t.equal(inspect(arr), '[ 1, , 3 ]');
});
delete Array.prototype[1];
});
object-inspect-1.11.0/test/holes.js 0000664 0000000 0000000 00000000377 14073115252 0017141 0 ustar 00root root 0000000 0000000 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' ]"
);
});
object-inspect-1.11.0/test/indent-option.js 0000664 0000000 0000000 00000014751 14073115252 0020617 0 ustar 00root root 0000000 0000000 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();
});
object-inspect-1.11.0/test/inspect.js 0000664 0000000 0000000 00000007375 14073115252 0017501 0 ustar 00root root 0000000 0000000 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();
});
object-inspect-1.11.0/test/lowbyte.js 0000664 0000000 0000000 00000000414 14073115252 0017504 0 ustar 00root root 0000000 0000000 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' }"
);
});
object-inspect-1.11.0/test/number.js 0000664 0000000 0000000 00000000613 14073115252 0017310 0 ustar 00root root 0000000 0000000 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();
});
object-inspect-1.11.0/test/quoteStyle.js 0000664 0000000 0000000 00000001645 14073115252 0020204 0 ustar 00root root 0000000 0000000 '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();
});
object-inspect-1.11.0/test/toStringTag.js 0000664 0000000 0000000 00000003053 14073115252 0020266 0 ustar 00root root 0000000 0000000 'use strict';
var test = require('tape');
var hasSymbols = require('has-symbols/shams')();
var inspect = require('../');
test('Symbol.toStringTag', { skip: !hasSymbols || typeof Symbol.toStringTag === 'undefined' }, 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');
});
});
object-inspect-1.11.0/test/undef.js 0000664 0000000 0000000 00000000456 14073115252 0017126 0 ustar 00root root 0000000 0000000 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 }'
);
});
object-inspect-1.11.0/test/values.js 0000664 0000000 0000000 00000015624 14073115252 0017327 0 ustar 00root root 0000000 0000000 'use strict';
var inspect = require('../');
var test = require('tape');
var hasSymbols = require('has-symbols/shams')();
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; // eslint-disable-line no-extend-native
});
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: !hasSymbols || typeof Symbol.toStringTag === 'undefined' }, 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();
});
object-inspect-1.11.0/util.inspect.js 0000664 0000000 0000000 00000000052 14073115252 0017457 0 ustar 00root root 0000000 0000000 module.exports = require('util').inspect;