locizify 5.3.2 → 5.3.3

package/example/node_modules/object-inspect/readme.markdown

@@ -0,0 +1,86 @@
+# object-inspect <sup>[![Version Badge][2]][1]</sup>
+
+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 = '<b>wooo</b><i>iiiii</i>';
+
+console.log(inspect([ d, { a: 3, b : 4, c: [5,6,[7,[8,[9]]]] } ]));
+```
+
+output:
+
+```
+[ <div id="beep">...</div>, { 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`.
+  - `numericSeparator`: must be a boolean, if present. Default `false`. If `true`, all numbers will be printed with numeric separators (eg, `1234.5678` will be printed as `'1_234.567_8'`)
+
+# 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

package/example/node_modules/object-inspect/test/bigint.js

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

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

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

package/example/node_modules/object-inspect/test/circular.js

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

package/example/node_modules/object-inspect/test/deep.js

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

package/example/node_modules/object-inspect/test/element.js

@@ -0,0 +1,53 @@
+var inspect = require('../');
+var test = require('tape');
+
+test('element', function (t) {
+    t.plan(3);
+    var elem = {
+        nodeName: 'div',
+        attributes: [{ name: 'class', value: 'row' }],
+        getAttribute: function (key) { 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;
+});

package/example/node_modules/object-inspect/test/err.js

@@ -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 }',
+        '{ [Error: foo] [cause]: \'bar\' }',
+        '{ [Error: foo] [cause]: \'bar\', foo: \'bar\' }',
+        '{ [Error: foo] [cause]: undefined }',
+        '{ [Error: foo] cause: \'bar\' }'
+    ].join(', ') + ' ]');
+});

package/example/node_modules/object-inspect/test/fakes.js

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

package/example/node_modules/object-inspect/test/fn.js

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

package/example/node_modules/object-inspect/test/has.js

@@ -0,0 +1,34 @@
+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];
+});

package/example/node_modules/object-inspect/test/holes.js

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