actions/upload-google-play
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Updating NPM dependencies

Browse Source
This commit is contained in:
Drew Heavner
2020-11-11 13:30:52 +00:00
committed by GitHub
parent 7a6fb66c63
commit bd487ef324
9068 changed files with 1400893 additions and 587661 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
node_modules/json-bigint/.npmignore generated vendored
View File

@@ -1,16 +0,0 @@
lib-cov
*.seed
*.log
*.csv
*.dat
*.out
*.pid
*.gz
.*.swp
node_modules
pids
logs
results
npm-debug.log

4
node_modules/json-bigint/.travis.yml generated vendored
View File

@@ -1,4 +0,0 @@
language: node_js
node_js:
- "0.10"
- "0.11"

155
node_modules/json-bigint/README.md generated vendored
View File

@@ -1,11 +1,12 @@
json-bigint
===========
# json-bigint
[![Build Status](https://secure.travis-ci.org/sidorares/json-bigint.png)](http://travis-ci.org/sidorares/json-bigint)
[![NPM](https://nodei.co/npm/json-bigint.png?downloads=true&stars=true)](https://nodei.co/npm/json-bigint/)
JSON.parse/stringify with bigints support. Based on Douglas Crockford [JSON.js](https://github.com/douglascrockford/JSON-js) package and [bignumber.js](https://github.com/MikeMcl/bignumber.js) library.
Native `Bigint` was added to JS recently, so we added an option to leverage it instead of `bignumber.js`. However, the parsing with native `BigInt` is kept an option for backward compability.
While most JSON parsers assume numeric values have same precision restrictions as IEEE 754 double, JSON specification _does not_ say anything about number precision. Any floating point number in decimal (optionally scientific) notation is valid JSON value. It's a good idea to serialize values which might fall out of IEEE 754 integer precision as strings in your JSON api, but `{ "value" : 9223372036854775807}`, for example, is still a valid RFC4627 JSON string, and in most JS runtimes the result of `JSON.parse` is this object: `{ value: 9223372036854776000 }`
==========
@@ -19,15 +20,15 @@ var json = '{ "value" : 9223372036854775807, "v2": 123 }';
console.log('Input:', json);
console.log('');
console.log('node.js bult-in JSON:')
console.log('node.js built-in JSON:');
var r = JSON.parse(json);
console.log('JSON.parse(input).value : ', r.value.toString());
console.log('JSON.stringify(JSON.parse(input)):', JSON.stringify(r));
console.log('\n\nbig number JSON:');
var r1 = JSONbig.parse(json);
console.log('JSON.parse(input).value : ', r1.value.toString());
console.log('JSON.stringify(JSON.parse(input)):', JSONbig.stringify(r1));
console.log('JSONbig.parse(input).value : ', r1.value.toString());
console.log('JSONbig.stringify(JSONbig.parse(input)):', JSONbig.stringify(r1));
```
Output:
@@ -35,44 +36,52 @@ Output:
```
Input: { "value" : 9223372036854775807, "v2": 123 }
node.js bult-in JSON:
node.js built-in JSON:
JSON.parse(input).value : 9223372036854776000
JSON.stringify(JSON.parse(input)): {"value":9223372036854776000,"v2":123}
big number JSON:
JSON.parse(input).value : 9223372036854775807
JSON.stringify(JSON.parse(input)): {"value":9223372036854775807,"v2":123}
JSONbig.parse(input).value : 9223372036854775807
JSONbig.stringify(JSONbig.parse(input)): {"value":9223372036854775807,"v2":123}
```
### Options
The behaviour of the parser is somewhat configurable through 'options'
#### options.strict, boolean, default false
Specifies the parsing should be "strict" towards reporting duplicate-keys in the parsed string.
The default follows what is allowed in standard json and resembles the behavior of JSON.parse, but overwrites any previous values with the last one assigned to the duplicate-key.
Setting options.strict = true will fail-fast on such duplicate-key occurances and thus warn you upfront of possible lost information.
example:
```js
var JSONbig = require('json-bigint');
var JSONstrict = require('json-bigint')({"strict": true});
var JSONstrict = require('json-bigint')({ strict: true });
var dupkeys = '{ "dupkey": "value 1", "dupkey": "value 2"}';
console.log('\n\nDuplicate Key test with both lenient and strict JSON parsing');
console.log('Input:', dupkeys);
var works = JSONbig.parse(dupkeys);
console.log('JSON.parse(dupkeys).dupkey: %s', works.dupkey);
var fails = "will stay like this";
var fails = 'will stay like this';
try {
fails = JSONstrict.parse(dupkeys);
console.log('ERROR!! Should never get here');
fails = JSONstrict.parse(dupkeys);
console.log('ERROR!! Should never get here');
} catch (e) {
console.log('Succesfully catched expected exception on duplicate keys: %j', e);
console.log(
'Succesfully catched expected exception on duplicate keys: %j',
e
);
}
```
Output
```
Duplicate Key test with big number JSON
Input: { "dupkey": "value 1", "dupkey": "value 2"}
@@ -82,24 +91,30 @@ Succesfully catched expected exception on duplicate keys: {"name":"SyntaxError",
```
#### options.storeAsString, boolean, default false
Specifies if BigInts should be stored in the object as a string, rather than the default BigNumber.
Note that this is a dangerous behavior as it breaks the default functionality of being able to convert back-and-forth without data type changes (as this will convert all BigInts to be-and-stay strings).
example:
```js
var JSONbig = require('json-bigint');
var JSONbigString = require('json-bigint')({"storeAsString": true});
var JSONbigString = require('json-bigint')({ storeAsString: true });
var key = '{ "key": 1234567890123456789 }';
console.log('\n\nStoring the BigInt as a string, instead of a BigNumber');
console.log('Input:', key);
var withInt = JSONbig.parse(key);
var withString = JSONbigString.parse(key);
console.log('Default type: %s, With option type: %s', typeof withInt.key, typeof withString.key);
console.log(
'Default type: %s, With option type: %s',
typeof withInt.key,
typeof withString.key
);
```
Output
```
Storing the BigInt as a string, instead of a BigNumber
Input: { "key": 1234567890123456789 }
@@ -107,11 +122,119 @@ Default type: object, With option type: string
```
#### options.useNativeBigInt, boolean, default false
Specifies if parser uses native BigInt instead of bignumber.js
example:
```js
var JSONbig = require('json-bigint');
var JSONbigNative = require('json-bigint')({ useNativeBigInt: true });
var key = '{ "key": 993143214321423154315154321 }';
console.log(`\n\nStoring the Number as native BigInt, instead of a BigNumber`);
console.log('Input:', key);
var normal = JSONbig.parse(key);
var nativeBigInt = JSONbigNative.parse(key);
console.log(
'Default type: %s, With option type: %s',
typeof normal.key,
typeof nativeBigInt.key
);
```
Output
```
Storing the Number as native BigInt, instead of a BigNumber
Input: { "key": 993143214321423154315154321 }
Default type: object, With option type: bigint
```
#### options.alwaysParseAsBig, boolean, default false
Specifies if all numbers should be stored as BigNumber.
Note that this is a dangerous behavior as it breaks the default functionality of being able to convert back-and-forth without data type changes (as this will convert all Number to be-and-stay BigNumber)
example:
```js
var JSONbig = require('json-bigint');
var JSONbigAlways = require('json-bigint')({ alwaysParseAsBig: true });
var key = '{ "key": 123 }'; // there is no need for BigNumber by default, but we're forcing it
console.log(`\n\nStoring the Number as a BigNumber, instead of a Number`);
console.log('Input:', key);
var normal = JSONbig.parse(key);
var always = JSONbigAlways.parse(key);
console.log(
'Default type: %s, With option type: %s',
typeof normal.key,
typeof always.key
);
```
Output
```
Storing the Number as a BigNumber, instead of a Number
Input: { "key": 123 }
Default type: number, With option type: object
```
If you want to force all numbers to be parsed as native `BigInt`
(you probably do! Otherwise any calulations become a real headache):
```js
var JSONbig = require('json-bigint')({
alwaysParseAsBig: true,
useNativeBigInt: true,
});
```
#### options.protoAction, boolean, default: "error". Possible values: "error", "ignore", "preserve"
#### options.constructorAction, boolean, default: "error". Possible values: "error", "ignore", "preserve"
Controls how `__proto__` and `constructor` properties are treated. If set to "error" they are not allowed and
parse() call will throw an error. If set to "ignore" the prroperty and it;s value is skipped from parsing and object building.
If set to "preserve" the `__proto__` property is set. One should be extra careful and make sure any other library consuming generated data
is not vulnerable to prototype poisoning attacks.
example:
```js
var JSONbigAlways = require('json-bigint')({ protoAction: 'ignore' });
const user = JSONbig.parse('{ "__proto__": { "admin": true }, "id": 12345 }');
// => result is { id: 12345 }
```
### Links:
- [RFC4627: The application/json Media Type for JavaScript Object Notation (JSON)](http://www.ietf.org/rfc/rfc4627.txt)
- [Re: \[Json\] Limitations on number size?](http://www.ietf.org/mail-archive/web/json/current/msg00297.html)
- [Is there any proper way to parse JSON with large numbers? (long, bigint, int64)](http://stackoverflow.com/questions/18755125/node-js-is-there-any-proper-way-to-parse-json-with-large-numbers-long-bigint)
- [What is JavaScript's Max Int? What's the highest Integer value a Number can go to without losing precision?](http://stackoverflow.com/questions/307179/what-is-javascripts-max-int-whats-the-highest-integer-value-a-number-can-go-t)
- [Large numbers erroneously rounded in Javascript](http://stackoverflow.com/questions/1379934/large-numbers-erroneously-rounded-in-javascript)
### Note on native BigInt support
#### Stringifying
Full support out-of-the-box, stringifies BigInts as pure numbers (no quotes, no `n`)
#### Limitations
- Roundtrip operations
`s === JSONbig.stringify(JSONbig.parse(s))` but
`o !== JSONbig.parse(JSONbig.stringify(o))`
when `o` has a value with something like `123n`.
`JSONbig` stringify `123n` as `123`, which becomes `number` (aka `123` not `123n`) by default when being reparsed.
There is currently no consistent way to deal with this issue, so we decided to leave it, handling this specific case is then up to users.

641
node_modules/json-bigint/lib/parse.js generated vendored
View File

@@ -1,4 +1,12 @@
var BigNumber = null;
// regexpxs extracted from
// (c) BSD-3-Clause
// https://github.com/fastify/secure-json-parse/graphs/contributors and https://github.com/hapijs/bourne/graphs/contributors
const suspectProtoRx = /(?:_|\\u005[Ff])(?:_|\\u005[Ff])(?:p|\\u0070)(?:r|\\u0072)(?:o|\\u006[Ff])(?:t|\\u0074)(?:o|\\u006[Ff])(?:_|\\u005[Ff])(?:_|\\u005[Ff])/;
const suspectConstructorRx = /(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)/;
/*
json_parse.js
2012-06-20
@@ -62,323 +70,374 @@ var BigNumber = null;
*/
var json_parse = function (options) {
"use strict";
'use strict';
// This is a function that can parse a JSON text, producing a JavaScript
// data structure. It is a simple, recursive descent parser. It does not use
// eval or regular expressions, so it can be used as a model for implementing
// a JSON parser in other languages.
// This is a function that can parse a JSON text, producing a JavaScript
// data structure. It is a simple, recursive descent parser. It does not use
// eval or regular expressions, so it can be used as a model for implementing
// a JSON parser in other languages.
// We are defining the function inside of another function to avoid creating
// global variables.
// We are defining the function inside of another function to avoid creating
// global variables.
// Default options one can override by passing options to the parse()
var _options = {
strict: false, // not being strict means do not generate syntax errors for "duplicate key"
storeAsString: false, // toggles whether the values should be stored as BigNumber (default) or a string
alwaysParseAsBig: false, // toggles whether all numbers should be Big
useNativeBigInt: false, // toggles whether to use native BigInt instead of bignumber.js
protoAction: 'error',
constructorAction: 'error',
};
// Default options one can override by passing options to the parse()
var _options = {
"strict": false, // not being strict means do not generate syntax errors for "duplicate key"
"storeAsString": false // toggles whether the values should be stored as BigNumber (default) or a string
};
// If there are options, then use them to override the default _options
if (options !== undefined && options !== null) {
if (options.strict === true) {
_options.strict = true;
}
if (options.storeAsString === true) {
_options.storeAsString = true;
}
_options.alwaysParseAsBig =
options.alwaysParseAsBig === true ? options.alwaysParseAsBig : false;
_options.useNativeBigInt =
options.useNativeBigInt === true ? options.useNativeBigInt : false;
// If there are options, then use them to override the default _options
if (options !== undefined && options !== null) {
if (options.strict === true) {
_options.strict = true;
}
if (options.storeAsString === true) {
_options.storeAsString = true;
}
if (typeof options.constructorAction !== 'undefined') {
if (
options.constructorAction === 'error' ||
options.constructorAction === 'ignore' ||
options.constructorAction === 'preserve'
) {
_options.constructorAction = options.constructorAction;
} else {
throw new Error(
`Incorrect value for constructorAction option, must be "error", "ignore" or undefined but passed ${options.constructorAction}`
);
}
}
if (typeof options.protoAction !== 'undefined') {
if (
options.protoAction === 'error' ||
options.protoAction === 'ignore' ||
options.protoAction === 'preserve'
) {
_options.protoAction = options.protoAction;
} else {
throw new Error(
`Incorrect value for protoAction option, must be "error", "ignore" or undefined but passed ${options.protoAction}`
);
}
}
}
var at, // The index of the current character
ch, // The current character
escapee = {
'"': '"',
'\\': '\\',
'/': '/',
b: '\b',
f: '\f',
n: '\n',
r: '\r',
t: '\t'
},
text,
var at, // The index of the current character
ch, // The current character
escapee = {
'"': '"',
'\\': '\\',
'/': '/',
b: '\b',
f: '\f',
n: '\n',
r: '\r',
t: '\t',
},
text,
error = function (m) {
// Call error when something is wrong.
error = function (m) {
throw {
name: 'SyntaxError',
message: m,
at: at,
text: text,
};
},
next = function (c) {
// If a c parameter is provided, verify that it matches the current character.
// Call error when something is wrong.
if (c && c !== ch) {
error("Expected '" + c + "' instead of '" + ch + "'");
}
throw {
name: 'SyntaxError',
message: m,
at: at,
text: text
};
},
// Get the next character. When there are no more characters,
// return the empty string.
next = function (c) {
ch = text.charAt(at);
at += 1;
return ch;
},
number = function () {
// Parse a number value.
// If a c parameter is provided, verify that it matches the current character.
var number,
string = '';
if (c && c !== ch) {
error("Expected '" + c + "' instead of '" + ch + "'");
}
if (ch === '-') {
string = '-';
next('-');
}
while (ch >= '0' && ch <= '9') {
string += ch;
next();
}
if (ch === '.') {
string += '.';
while (next() && ch >= '0' && ch <= '9') {
string += ch;
}
}
if (ch === 'e' || ch === 'E') {
string += ch;
next();
if (ch === '-' || ch === '+') {
string += ch;
next();
}
while (ch >= '0' && ch <= '9') {
string += ch;
next();
}
}
number = +string;
if (!isFinite(number)) {
error('Bad number');
} else {
if (BigNumber == null) BigNumber = require('bignumber.js');
//if (number > 9007199254740992 || number < -9007199254740992)
// Bignumber has stricter check: everything with length > 15 digits disallowed
if (string.length > 15)
return _options.storeAsString
? string
: _options.useNativeBigInt
? BigInt(string)
: new BigNumber(string);
else
return !_options.alwaysParseAsBig
? number
: _options.useNativeBigInt
? BigInt(number)
: new BigNumber(number);
}
},
string = function () {
// Parse a string value.
// Get the next character. When there are no more characters,
// return the empty string.
var hex,
i,
string = '',
uffff;
ch = text.charAt(at);
at += 1;
return ch;
},
// When parsing for string values, we must look for " and \ characters.
number = function () {
// Parse a number value.
var number,
string = '';
if (ch === '-') {
string = '-';
next('-');
}
while (ch >= '0' && ch <= '9') {
string += ch;
next();
}
if (ch === '.') {
string += '.';
while (next() && ch >= '0' && ch <= '9') {
string += ch;
if (ch === '"') {
var startAt = at;
while (next()) {
if (ch === '"') {
if (at - 1 > startAt) string += text.substring(startAt, at - 1);
next();
return string;
}
if (ch === '\\') {
if (at - 1 > startAt) string += text.substring(startAt, at - 1);
next();
if (ch === 'u') {
uffff = 0;
for (i = 0; i < 4; i += 1) {
hex = parseInt(next(), 16);
if (!isFinite(hex)) {
break;
}
}
if (ch === 'e' || ch === 'E') {
string += ch;
next();
if (ch === '-' || ch === '+') {
string += ch;
next();
}
while (ch >= '0' && ch <= '9') {
string += ch;
next();
}
}
number = +string;
if (!isFinite(number)) {
error("Bad number");
uffff = uffff * 16 + hex;
}
string += String.fromCharCode(uffff);
} else if (typeof escapee[ch] === 'string') {
string += escapee[ch];
} else {
if (BigNumber == null)
BigNumber = require('bignumber.js');
//if (number > 9007199254740992 || number < -9007199254740992)
// Bignumber has stricter check: everything with length > 15 digits disallowed
if (string.length > 15)
return (_options.storeAsString === true) ? string : new BigNumber(string);
return number;
break;
}
},
string = function () {
// Parse a string value.
var hex,
i,
string = '',
uffff;
// When parsing for string values, we must look for " and \ characters.
if (ch === '"') {
while (next()) {
if (ch === '"') {
next();
return string;
}
if (ch === '\\') {
next();
if (ch === 'u') {
uffff = 0;
for (i = 0; i < 4; i += 1) {
hex = parseInt(next(), 16);
if (!isFinite(hex)) {
break;
}
uffff = uffff * 16 + hex;
}
string += String.fromCharCode(uffff);
} else if (typeof escapee[ch] === 'string') {
string += escapee[ch];
} else {
break;
}
} else {
string += ch;
}
}
}
error("Bad string");
},
white = function () {
// Skip whitespace.
while (ch && ch <= ' ') {
next();
}
},
word = function () {
// true, false, or null.
switch (ch) {
case 't':
next('t');
next('r');
next('u');
next('e');
return true;
case 'f':
next('f');
next('a');
next('l');
next('s');
next('e');
return false;
case 'n':
next('n');
next('u');
next('l');
next('l');
return null;
}
error("Unexpected '" + ch + "'");
},
value, // Place holder for the value function.
array = function () {
// Parse an array value.
var array = [];
if (ch === '[') {
next('[');
white();
if (ch === ']') {
next(']');
return array; // empty array
}
while (ch) {
array.push(value());
white();
if (ch === ']') {
next(']');
return array;
}
next(',');
white();
}
}
error("Bad array");
},
object = function () {
// Parse an object value.
var key,
object = {};
if (ch === '{') {
next('{');
white();
if (ch === '}') {
next('}');
return object; // empty object
}
while (ch) {
key = string();
white();
next(':');
if (_options.strict === true && Object.hasOwnProperty.call(object, key)) {
error('Duplicate key "' + key + '"');
}
object[key] = value();
white();
if (ch === '}') {
next('}');
return object;
}
next(',');
white();
}
}
error("Bad object");
};
value = function () {
// Parse a JSON value. It could be an object, an array, a string, a number,
// or a word.
white();
switch (ch) {
case '{':
return object();
case '[':
return array();
case '"':
return string();
case '-':
return number();
default:
return ch >= '0' && ch <= '9' ? number() : word();
startAt = at;
}
}
}
error('Bad string');
},
white = function () {
// Skip whitespace.
while (ch && ch <= ' ') {
next();
}
},
word = function () {
// true, false, or null.
switch (ch) {
case 't':
next('t');
next('r');
next('u');
next('e');
return true;
case 'f':
next('f');
next('a');
next('l');
next('s');
next('e');
return false;
case 'n':
next('n');
next('u');
next('l');
next('l');
return null;
}
error("Unexpected '" + ch + "'");
},
value, // Place holder for the value function.
array = function () {
// Parse an array value.
var array = [];
if (ch === '[') {
next('[');
white();
if (ch === ']') {
next(']');
return array; // empty array
}
while (ch) {
array.push(value());
white();
if (ch === ']') {
next(']');
return array;
}
next(',');
white();
}
}
error('Bad array');
},
object = function () {
// Parse an object value.
var key,
object = Object.create(null);
if (ch === '{') {
next('{');
white();
if (ch === '}') {
next('}');
return object; // empty object
}
while (ch) {
key = string();
white();
next(':');
if (
_options.strict === true &&
Object.hasOwnProperty.call(object, key)
) {
error('Duplicate key "' + key + '"');
}
if (suspectProtoRx.test(key) === true) {
if (_options.protoAction === 'error') {
error('Object contains forbidden prototype property');
} else if (_options.protoAction === 'ignore') {
value();
} else {
object[key] = value();
}
} else if (suspectConstructorRx.test(key) === true) {
if (_options.constructorAction === 'error') {
error('Object contains forbidden constructor property');
} else if (_options.constructorAction === 'ignore') {
value();
} else {
object[key] = value();
}
} else {
object[key] = value();
}
white();
if (ch === '}') {
next('}');
return object;
}
next(',');
white();
}
}
error('Bad object');
};
// Return the json_parse function. It will have access to all of the above
// functions and variables.
value = function () {
// Parse a JSON value. It could be an object, an array, a string, a number,
// or a word.
return function (source, reviver) {
var result;
white();
switch (ch) {
case '{':
return object();
case '[':
return array();
case '"':
return string();
case '-':
return number();
default:
return ch >= '0' && ch <= '9' ? number() : word();
}
};
text = source + '';
at = 0;
ch = ' ';
result = value();
white();
if (ch) {
error("Syntax error");
}
// Return the json_parse function. It will have access to all of the above
// functions and variables.
// If there is a reviver function, we recursively walk the new structure,
// passing each name/value pair to the reviver function for possible
// transformation, starting with a temporary root object that holds the result
// in an empty key. If there is not a reviver function, we simply return the
// result.
return function (source, reviver) {
var result;
return typeof reviver === 'function'
? (function walk(holder, key) {
var k, v, value = holder[key];
if (value && typeof value === 'object') {
Object.keys(value).forEach(function(k) {
v = walk(value, k);
if (v !== undefined) {
value[k] = v;
} else {
delete value[k];
}
});
}
return reviver.call(holder, key, value);
}({'': result}, ''))
: result;
};
}
text = source + '';
at = 0;
ch = ' ';
result = value();
white();
if (ch) {
error('Syntax error');
}
// If there is a reviver function, we recursively walk the new structure,
// passing each name/value pair to the reviver function for possible
// transformation, starting with a temporary root object that holds the result
// in an empty key. If there is not a reviver function, we simply return the
// result.
return typeof reviver === 'function'
? (function walk(holder, key) {
var k,
v,
value = holder[key];
if (value && typeof value === 'object') {
Object.keys(value).forEach(function (k) {
v = walk(value, k);
if (v !== undefined) {
value[k] = v;
} else {
delete value[k];
}
});
}
return reviver.call(holder, key, value);
})({ '': result }, '')
: result;
};
};
module.exports = json_parse;

1
node_modules/json-bigint/lib/stringify.js generated vendored
View File

@@ -249,6 +249,7 @@ var JSON = module.exports;
case 'boolean':
case 'null':
case 'bigint':
// If the value is a boolean or null, convert it to a string. Note:
// typeof null does not produce 'null'. The case is included here in

33
node_modules/json-bigint/package.json generated vendored
View File

@@ -1,27 +1,27 @@
{
"_from": "json-bigint@^0.3.0",
"_id": "json-bigint@0.3.0",
"_from": "json-bigint@^1.0.0",
"_id": "json-bigint@1.0.0",
"_inBundle": false,
"_integrity": "sha1-DM2RLEuCcNBfBW+9E4FLU9OCWx4=",
"_integrity": "sha512-SiPv/8VpZuWbvLSMtTDU8hEfrZWg/mH/nV/b4o0CYbSxu1UIQPLdwKOCIyLQX+VIPO5vrLX3i8qtqFyhdPSUSQ==",
"_location": "/json-bigint",
"_phantomChildren": {},
"_requested": {
"type": "range",
"registry": true,
"raw": "json-bigint@^0.3.0",
"raw": "json-bigint@^1.0.0",
"name": "json-bigint",
"escapedName": "json-bigint",
"rawSpec": "^0.3.0",
"rawSpec": "^1.0.0",
"saveSpec": null,
"fetchSpec": "^0.3.0"
"fetchSpec": "^1.0.0"
},
"_requiredBy": [
"/gcp-metadata"
],
"_resolved": "https://registry.npmjs.org/json-bigint/-/json-bigint-0.3.0.tgz",
"_shasum": "0ccd912c4b8270d05f056fbd13814b53d3825b1e",
"_spec": "json-bigint@^0.3.0",
"_where": "/Users/drew.heavner/Documents/Github/upload-google-play/node_modules/gcp-metadata",
"_resolved": "https://registry.npmjs.org/json-bigint/-/json-bigint-1.0.0.tgz",
"_shasum": "ae547823ac0cad8398667f8cd9ef4730f5b01ff1",
"_spec": "json-bigint@^1.0.0",
"_where": "/home/codespace/workspace/upload-google-play/node_modules/gcp-metadata",
"author": {
"name": "Andrey Sidorov",
"email": "sidorares@yandex.ru"
@@ -31,14 +31,19 @@
},
"bundleDependencies": false,
"dependencies": {
"bignumber.js": "^7.0.0"
"bignumber.js": "^9.0.0"
},
"deprecated": false,
"description": "JSON.parse with bigints support",
"devDependencies": {
"chai": "~1.9.1",
"mocha": "~1.20.1"
"chai": "4.2.0",
"mocha": "8.0.1"
},
"files": [
"index.js",
"lib/parse.js",
"lib/stringify.js"
],
"homepage": "https://github.com/sidorares/json-bigint#readme",
"keywords": [
"JSON",
@@ -57,5 +62,5 @@
"scripts": {
"test": "./node_modules/mocha/bin/mocha -R spec --check-leaks test/*-test.js"
},
"version": "0.3.0"
"version": "1.0.0"
}

31
node_modules/json-bigint/test/bigint-test.js generated vendored
View File

@@ -1,31 +0,0 @@
var mocha = require('mocha')
, assert = require('chai').assert
, expect = require('chai').expect
, BigNumber = require('bignumber.js')
;
describe("Testing bigint support", function(){
var input = '{"big":9223372036854775807,"small":123}';
it("Should show classic JSON.parse lacks bigint support", function(done){
var obj = JSON.parse(input);
expect(obj.small.toString(), "string from small int").to.equal("123");
expect(obj.big.toString(), "string from big int").to.not.equal("9223372036854775807");
var output = JSON.stringify(obj);
expect(output).to.not.equal(input);
done();
});
it("Should show JSNbig does support bigint parse/stringify roundtrip", function(done){
var JSONbig = require('../index');
var obj = JSONbig.parse(input);
expect(obj.small.toString(), "string from small int").to.equal("123");
expect(obj.big.toString(), "string from big int").to.equal("9223372036854775807");
expect(obj.big, "instanceof big int").to.be.instanceof(BigNumber);
var output = JSONbig.stringify(obj);
expect(output).to.equal(input);
done();
});
});

34
node_modules/json-bigint/test/strict-option-test.js generated vendored
View File

@@ -1,34 +0,0 @@
var mocha = require('mocha')
, assert = require('chai').assert
, expect = require('chai').expect
;
describe("Testing 'strict' option", function(){
var dupkeys = '{ "dupkey": "value 1", "dupkey": "value 2"}';
it("Should show that duplicate keys just get overwritten by default", function(done){
var JSONbig = require('../index');
var result = "before";
function tryParse() {
result = JSONbig.parse(dupkeys);
}
expect(tryParse).to.not.throw("anything");
expect(result.dupkey).to.equal("value 2");
done();
});
it("Should show that the 'strict' option will fail-fast on duplicate keys", function(done){
var JSONstrict = require('../index')({"strict": true});
var result = "before";
function tryParse() {
result = JSONstrict.parse(dupkeys);
}
expect(tryParse).to.throw({
name: 'SyntaxError',
message: 'Duplicate key "dupkey"',
at: 33,
text: '{ "dupkey": "value 1", "dupkey": "value 2"}'
});
expect(result).to.equal("before");
done();
});
});

21
node_modules/json-bigint/test/string-option-test.js generated vendored
View File

@@ -1,21 +0,0 @@
var mocha = require('mocha')
, assert = require('chai').assert
, expect = require('chai').expect
;
describe("Testing 'storeAsString' option", function(){
var key = '{ "key": 12345678901234567 }';
it("Should show that the key is of type object", function(done){
var JSONbig = require('../index');
var result = JSONbig.parse(key);
expect(typeof result.key).to.equal("object");
done();
});
it("Should show that key is of type string, when storeAsString option is true", function(done){
var JSONstring = require('../index')({"storeAsString": true});
var result = JSONstring.parse(key);
expect(typeof result.key).to.equal("string");
done();
});
});