cwchristerw/musix-oss
1
0
Fork 0
mirror of https://github.com/musix-org/musix-oss synced 2025-11-04 00:29:32 +00:00
Code Activity

Updated everything

Browse Source
This commit is contained in:
MatteZ02
2019-09-15 09:18:33 +03:00
parent 9d7e55b5ee
commit e4e99d76c9
1064 changed files with 277 additions and 171372 deletions
Download Patch File Download Diff File Expand all files Collapse all files

49
node_modules/jsprim/CHANGES.md generated vendored
View File

@@ -1,49 +0,0 @@
# Changelog
## not yet released
None yet.
## v1.4.1 (2017-08-02)
* #21 Update verror dep
* #22 Update extsprintf dependency
* #23 update contribution guidelines
## v1.4.0 (2017-03-13)
* #7 Add parseInteger() function for safer number parsing
## v1.3.1 (2016-09-12)
* #13 Incompatible with webpack
## v1.3.0 (2016-06-22)
* #14 add safer version of hasOwnProperty()
* #15 forEachKey() should ignore inherited properties
## v1.2.2 (2015-10-15)
* #11 NPM package shouldn't include any code that does `require('JSV')`
* #12 jsl.node.conf missing definition for "module"
## v1.2.1 (2015-10-14)
* #8 odd date parsing behaviour
## v1.2.0 (2015-10-13)
* #9 want function for returning RFC1123 dates
## v1.1.0 (2015-09-02)
* #6 a new suite of hrtime manipulation routines: `hrtimeAdd()`,
`hrtimeAccum()`, `hrtimeNanosec()`, `hrtimeMicrosec()` and
`hrtimeMillisec()`.
## v1.0.0 (2015-09-01)
First tracked release. Includes everything in previous releases, plus:
* #4 want function for merging objects

19
node_modules/jsprim/CONTRIBUTING.md generated vendored
View File

@@ -1,19 +0,0 @@
# Contributing
This repository uses [cr.joyent.us](https://cr.joyent.us) (Gerrit) for new
changes. Anyone can submit changes. To get started, see the [cr.joyent.us user
guide](https://github.com/joyent/joyent-gerrit/blob/master/docs/user/README.md).
This repo does not use GitHub pull requests.
See the [Joyent Engineering
Guidelines](https://github.com/joyent/eng/blob/master/docs/index.md) for general
best practices expected in this repository.
Contributions should be "make prepush" clean. The "prepush" target runs the
"check" target, which requires these separate tools:
* https://github.com/davepacheco/jsstyle
* https://github.com/davepacheco/javascriptlint
If you're changing something non-trivial or user-facing, you may want to submit
an issue first.

19
node_modules/jsprim/LICENSE generated vendored
View File

@@ -1,19 +0,0 @@
Copyright (c) 2012, Joyent, Inc. All rights reserved.
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

287
node_modules/jsprim/README.md generated vendored
View File

@@ -1,287 +0,0 @@
# jsprim: utilities for primitive JavaScript types
This module provides miscellaneous facilities for working with strings,
numbers, dates, and objects and arrays of these basic types.
### deepCopy(obj)
Creates a deep copy of a primitive type, object, or array of primitive types.
### deepEqual(obj1, obj2)
Returns whether two objects are equal.
### isEmpty(obj)
Returns true if the given object has no properties and false otherwise. This
is O(1) (unlike `Object.keys(obj).length === 0`, which is O(N)).
### hasKey(obj, key)
Returns true if the given object has an enumerable, non-inherited property
called `key`. [For information on enumerability and ownership of properties, see
the MDN
documentation.](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Enumerability_and_ownership_of_properties)
### forEachKey(obj, callback)
Like Array.forEach, but iterates enumerable, owned properties of an object
rather than elements of an array. Equivalent to:
for (var key in obj) {
if (Object.prototype.hasOwnProperty.call(obj, key)) {
callback(key, obj[key]);
}
}
### flattenObject(obj, depth)
Flattens an object up to a given level of nesting, returning an array of arrays
of length "depth + 1", where the first "depth" elements correspond to flattened
columns and the last element contains the remaining object . For example:
flattenObject({
'I': {
'A': {
'i': {
'datum1': [ 1, 2 ],
'datum2': [ 3, 4 ]
},
'ii': {
'datum1': [ 3, 4 ]
}
},
'B': {
'i': {
'datum1': [ 5, 6 ]
},
'ii': {
'datum1': [ 7, 8 ],
'datum2': [ 3, 4 ],
},
'iii': {
}
}
},
'II': {
'A': {
'i': {
'datum1': [ 1, 2 ],
'datum2': [ 3, 4 ]
}
}
}
}, 3)
becomes:
[
[ 'I', 'A', 'i', { 'datum1': [ 1, 2 ], 'datum2': [ 3, 4 ] } ],
[ 'I', 'A', 'ii', { 'datum1': [ 3, 4 ] } ],
[ 'I', 'B', 'i', { 'datum1': [ 5, 6 ] } ],
[ 'I', 'B', 'ii', { 'datum1': [ 7, 8 ], 'datum2': [ 3, 4 ] } ],
[ 'I', 'B', 'iii', {} ],
[ 'II', 'A', 'i', { 'datum1': [ 1, 2 ], 'datum2': [ 3, 4 ] } ]
]
This function is strict: "depth" must be a non-negative integer and "obj" must
be a non-null object with at least "depth" levels of nesting under all keys.
### flattenIter(obj, depth, func)
This is similar to `flattenObject` except that instead of returning an array,
this function invokes `func(entry)` for each `entry` in the array that
`flattenObject` would return. `flattenIter(obj, depth, func)` is logically
equivalent to `flattenObject(obj, depth).forEach(func)`. Importantly, this
version never constructs the full array. Its memory usage is O(depth) rather
than O(n) (where `n` is the number of flattened elements).
There's another difference between `flattenObject` and `flattenIter` that's
related to the special case where `depth === 0`. In this case, `flattenObject`
omits the array wrapping `obj` (which is regrettable).
### pluck(obj, key)
Fetch nested property "key" from object "obj", traversing objects as needed.
For example, `pluck(obj, "foo.bar.baz")` is roughly equivalent to
`obj.foo.bar.baz`, except that:
1. If traversal fails, the resulting value is undefined, and no error is
thrown. For example, `pluck({}, "foo.bar")` is just undefined.
2. If "obj" has property "key" directly (without traversing), the
corresponding property is returned. For example,
`pluck({ 'foo.bar': 1 }, 'foo.bar')` is 1, not undefined. This is also
true recursively, so `pluck({ 'a': { 'foo.bar': 1 } }, 'a.foo.bar')` is
also 1, not undefined.
### randElt(array)
Returns an element from "array" selected uniformly at random. If "array" is
empty, throws an Error.
### startsWith(str, prefix)
Returns true if the given string starts with the given prefix and false
otherwise.
### endsWith(str, suffix)
Returns true if the given string ends with the given suffix and false
otherwise.
### parseInteger(str, options)
Parses the contents of `str` (a string) as an integer. On success, the integer
value is returned (as a number). On failure, an error is **returned** describing
why parsing failed.
By default, leading and trailing whitespace characters are not allowed, nor are
trailing characters that are not part of the numeric representation. This
behaviour can be toggled by using the options below. The empty string (`''`) is
not considered valid input. If the return value cannot be precisely represented
as a number (i.e., is smaller than `Number.MIN_SAFE_INTEGER` or larger than
`Number.MAX_SAFE_INTEGER`), an error is returned. Additionally, the string
`'-0'` will be parsed as the integer `0`, instead of as the IEEE floating point
value `-0`.
This function accepts both upper and lowercase characters for digits, similar to
`parseInt()`, `Number()`, and [strtol(3C)](https://illumos.org/man/3C/strtol).
The following may be specified in `options`:
Option | Type | Default | Meaning
------------------ | ------- | ------- | ---------------------------
base | number | 10 | numeric base (radix) to use, in the range 2 to 36
allowSign | boolean | true | whether to interpret any leading `+` (positive) and `-` (negative) characters
allowImprecise | boolean | false | whether to accept values that may have lost precision (past `MAX_SAFE_INTEGER` or below `MIN_SAFE_INTEGER`)
allowPrefix | boolean | false | whether to interpret the prefixes `0b` (base 2), `0o` (base 8), `0t` (base 10), or `0x` (base 16)
allowTrailing | boolean | false | whether to ignore trailing characters
trimWhitespace | boolean | false | whether to trim any leading or trailing whitespace/line terminators
leadingZeroIsOctal | boolean | false | whether a leading zero indicates octal
Note that if `base` is unspecified, and `allowPrefix` or `leadingZeroIsOctal`
are, then the leading characters can change the default base from 10. If `base`
is explicitly specified and `allowPrefix` is true, then the prefix will only be
accepted if it matches the specified base. `base` and `leadingZeroIsOctal`
cannot be used together.
**Context:** It's tricky to parse integers with JavaScript's built-in facilities
for several reasons:
- `parseInt()` and `Number()` by default allow the base to be specified in the
input string by a prefix (e.g., `0x` for hex).
- `parseInt()` allows trailing nonnumeric characters.
- `Number(str)` returns 0 when `str` is the empty string (`''`).
- Both functions return incorrect values when the input string represents a
valid integer outside the range of integers that can be represented precisely.
Specifically, `parseInt('9007199254740993')` returns 9007199254740992.
- Both functions always accept `-` and `+` signs before the digit.
- Some older JavaScript engines always interpret a leading 0 as indicating
octal, which can be surprising when parsing input from users who expect a
leading zero to be insignificant.
While each of these may be desirable in some contexts, there are also times when
none of them are wanted. `parseInteger()` grants greater control over what
input's permissible.
### iso8601(date)
Converts a Date object to an ISO8601 date string of the form
"YYYY-MM-DDTHH:MM:SS.sssZ". This format is not customizable.
### parseDateTime(str)
Parses a date expressed as a string, as either a number of milliseconds since
the epoch or any string format that Date accepts, giving preference to the
former where these two sets overlap (e.g., strings containing small numbers).
### hrtimeDiff(timeA, timeB)
Given two hrtime readings (as from Node's `process.hrtime()`), where timeA is
later than timeB, compute the difference and return that as an hrtime. It is
illegal to invoke this for a pair of times where timeB is newer than timeA.
### hrtimeAdd(timeA, timeB)
Add two hrtime intervals (as from Node's `process.hrtime()`), returning a new
hrtime interval array. This function does not modify either input argument.
### hrtimeAccum(timeA, timeB)
Add two hrtime intervals (as from Node's `process.hrtime()`), storing the
result in `timeA`. This function overwrites (and returns) the first argument
passed in.
### hrtimeNanosec(timeA), hrtimeMicrosec(timeA), hrtimeMillisec(timeA)
This suite of functions converts a hrtime interval (as from Node's
`process.hrtime()`) into a scalar number of nanoseconds, microseconds or
milliseconds. Results are truncated, as with `Math.floor()`.
### validateJsonObject(schema, object)
Uses JSON validation (via JSV) to validate the given object against the given
schema. On success, returns null. On failure, *returns* (does not throw) a
useful Error object.
### extraProperties(object, allowed)
Check an object for unexpected properties. Accepts the object to check, and an
array of allowed property name strings. If extra properties are detected, an
array of extra property names is returned. If no properties other than those
in the allowed list are present on the object, the returned array will be of
zero length.
### mergeObjects(provided, overrides, defaults)
Merge properties from objects "provided", "overrides", and "defaults". The
intended use case is for functions that accept named arguments in an "args"
object, but want to provide some default values and override other values. In
that case, "provided" is what the caller specified, "overrides" are what the
function wants to override, and "defaults" contains default values.
The function starts with the values in "defaults", overrides them with the
values in "provided", and then overrides those with the values in "overrides".
For convenience, any of these objects may be falsey, in which case they will be
ignored. The input objects are never modified, but properties in the returned
object are not deep-copied.
For example:
mergeObjects(undefined, { 'objectMode': true }, { 'highWaterMark': 0 })
returns:
{ 'objectMode': true, 'highWaterMark': 0 }
For another example:
mergeObjects(
{ 'highWaterMark': 16, 'objectMode': 7 }, /* from caller */
{ 'objectMode': true }, /* overrides */
{ 'highWaterMark': 0 }); /* default */
returns:
{ 'objectMode': true, 'highWaterMark': 16 }
# Contributing
See separate [contribution guidelines](CONTRIBUTING.md).

735
node_modules/jsprim/lib/jsprim.js generated vendored
View File

@@ -1,735 +0,0 @@
/*
* lib/jsprim.js: utilities for primitive JavaScript types
*/
var mod_assert = require('assert-plus');
var mod_util = require('util');
var mod_extsprintf = require('extsprintf');
var mod_verror = require('verror');
var mod_jsonschema = require('json-schema');
/*
* Public interface
*/
exports.deepCopy = deepCopy;
exports.deepEqual = deepEqual;
exports.isEmpty = isEmpty;
exports.hasKey = hasKey;
exports.forEachKey = forEachKey;
exports.pluck = pluck;
exports.flattenObject = flattenObject;
exports.flattenIter = flattenIter;
exports.validateJsonObject = validateJsonObjectJS;
exports.validateJsonObjectJS = validateJsonObjectJS;
exports.randElt = randElt;
exports.extraProperties = extraProperties;
exports.mergeObjects = mergeObjects;
exports.startsWith = startsWith;
exports.endsWith = endsWith;
exports.parseInteger = parseInteger;
exports.iso8601 = iso8601;
exports.rfc1123 = rfc1123;
exports.parseDateTime = parseDateTime;
exports.hrtimediff = hrtimeDiff;
exports.hrtimeDiff = hrtimeDiff;
exports.hrtimeAccum = hrtimeAccum;
exports.hrtimeAdd = hrtimeAdd;
exports.hrtimeNanosec = hrtimeNanosec;
exports.hrtimeMicrosec = hrtimeMicrosec;
exports.hrtimeMillisec = hrtimeMillisec;
/*
* Deep copy an acyclic *basic* Javascript object. This only handles basic
* scalars (strings, numbers, booleans) and arbitrarily deep arrays and objects
* containing these. This does *not* handle instances of other classes.
*/
function deepCopy(obj)
{
var ret, key;
var marker = '__deepCopy';
if (obj && obj[marker])
throw (new Error('attempted deep copy of cyclic object'));
if (obj && obj.constructor == Object) {
ret = {};
obj[marker] = true;
for (key in obj) {
if (key == marker)
continue;
ret[key] = deepCopy(obj[key]);
}
delete (obj[marker]);
return (ret);
}
if (obj && obj.constructor == Array) {
ret = [];
obj[marker] = true;
for (key = 0; key < obj.length; key++)
ret.push(deepCopy(obj[key]));
delete (obj[marker]);
return (ret);
}
/*
* It must be a primitive type -- just return it.
*/
return (obj);
}
function deepEqual(obj1, obj2)
{
if (typeof (obj1) != typeof (obj2))
return (false);
if (obj1 === null || obj2 === null || typeof (obj1) != 'object')
return (obj1 === obj2);
if (obj1.constructor != obj2.constructor)
return (false);
var k;
for (k in obj1) {
if (!obj2.hasOwnProperty(k))
return (false);
if (!deepEqual(obj1[k], obj2[k]))
return (false);
}
for (k in obj2) {
if (!obj1.hasOwnProperty(k))
return (false);
}
return (true);
}
function isEmpty(obj)
{
var key;
for (key in obj)
return (false);
return (true);
}
function hasKey(obj, key)
{
mod_assert.equal(typeof (key), 'string');
return (Object.prototype.hasOwnProperty.call(obj, key));
}
function forEachKey(obj, callback)
{
for (var key in obj) {
if (hasKey(obj, key)) {
callback(key, obj[key]);
}
}
}
function pluck(obj, key)
{
mod_assert.equal(typeof (key), 'string');
return (pluckv(obj, key));
}
function pluckv(obj, key)
{
if (obj === null || typeof (obj) !== 'object')
return (undefined);
if (obj.hasOwnProperty(key))
return (obj[key]);
var i = key.indexOf('.');
if (i == -1)
return (undefined);
var key1 = key.substr(0, i);
if (!obj.hasOwnProperty(key1))
return (undefined);
return (pluckv(obj[key1], key.substr(i + 1)));
}
/*
* Invoke callback(row) for each entry in the array that would be returned by
* flattenObject(data, depth). This is just like flattenObject(data,
* depth).forEach(callback), except that the intermediate array is never
* created.
*/
function flattenIter(data, depth, callback)
{
doFlattenIter(data, depth, [], callback);
}
function doFlattenIter(data, depth, accum, callback)
{
var each;
var key;
if (depth === 0) {
each = accum.slice(0);
each.push(data);
callback(each);
return;
}
mod_assert.ok(data !== null);
mod_assert.equal(typeof (data), 'object');
mod_assert.equal(typeof (depth), 'number');
mod_assert.ok(depth >= 0);
for (key in data) {
each = accum.slice(0);
each.push(key);
doFlattenIter(data[key], depth - 1, each, callback);
}
}
function flattenObject(data, depth)
{
if (depth === 0)
return ([ data ]);
mod_assert.ok(data !== null);
mod_assert.equal(typeof (data), 'object');
mod_assert.equal(typeof (depth), 'number');
mod_assert.ok(depth >= 0);
var rv = [];
var key;
for (key in data) {
flattenObject(data[key], depth - 1).forEach(function (p) {
rv.push([ key ].concat(p));
});
}
return (rv);
}
function startsWith(str, prefix)
{
return (str.substr(0, prefix.length) == prefix);
}
function endsWith(str, suffix)
{
return (str.substr(
str.length - suffix.length, suffix.length) == suffix);
}
function iso8601(d)
{
if (typeof (d) == 'number')
d = new Date(d);
mod_assert.ok(d.constructor === Date);
return (mod_extsprintf.sprintf('%4d-%02d-%02dT%02d:%02d:%02d.%03dZ',
d.getUTCFullYear(), d.getUTCMonth() + 1, d.getUTCDate(),
d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds(),
d.getUTCMilliseconds()));
}
var RFC1123_MONTHS = [
'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
var RFC1123_DAYS = [
'Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
function rfc1123(date) {
return (mod_extsprintf.sprintf('%s, %02d %s %04d %02d:%02d:%02d GMT',
RFC1123_DAYS[date.getUTCDay()], date.getUTCDate(),
RFC1123_MONTHS[date.getUTCMonth()], date.getUTCFullYear(),
date.getUTCHours(), date.getUTCMinutes(),
date.getUTCSeconds()));
}
/*
* Parses a date expressed as a string, as either a number of milliseconds since
* the epoch or any string format that Date accepts, giving preference to the
* former where these two sets overlap (e.g., small numbers).
*/
function parseDateTime(str)
{
/*
* This is irritatingly implicit, but significantly more concise than
* alternatives. The "+str" will convert a string containing only a
* number directly to a Number, or NaN for other strings. Thus, if the
* conversion succeeds, we use it (this is the milliseconds-since-epoch
* case). Otherwise, we pass the string directly to the Date
* constructor to parse.
*/
var numeric = +str;
if (!isNaN(numeric)) {
return (new Date(numeric));
} else {
return (new Date(str));
}
}
/*
* Number.*_SAFE_INTEGER isn't present before node v0.12, so we hardcode
* the ES6 definitions here, while allowing for them to someday be higher.
*/
var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;
var MIN_SAFE_INTEGER = Number.MIN_SAFE_INTEGER || -9007199254740991;
/*
* Default options for parseInteger().
*/
var PI_DEFAULTS = {
base: 10,
allowSign: true,
allowPrefix: false,
allowTrailing: false,
allowImprecise: false,
trimWhitespace: false,
leadingZeroIsOctal: false
};
var CP_0 = 0x30;
var CP_9 = 0x39;
var CP_A = 0x41;
var CP_B = 0x42;
var CP_O = 0x4f;
var CP_T = 0x54;
var CP_X = 0x58;
var CP_Z = 0x5a;
var CP_a = 0x61;
var CP_b = 0x62;
var CP_o = 0x6f;
var CP_t = 0x74;
var CP_x = 0x78;
var CP_z = 0x7a;
var PI_CONV_DEC = 0x30;
var PI_CONV_UC = 0x37;
var PI_CONV_LC = 0x57;
/*
* A stricter version of parseInt() that provides options for changing what
* is an acceptable string (for example, disallowing trailing characters).
*/
function parseInteger(str, uopts)
{
mod_assert.string(str, 'str');
mod_assert.optionalObject(uopts, 'options');
var baseOverride = false;
var options = PI_DEFAULTS;
if (uopts) {
baseOverride = hasKey(uopts, 'base');
options = mergeObjects(options, uopts);
mod_assert.number(options.base, 'options.base');
mod_assert.ok(options.base >= 2, 'options.base >= 2');
mod_assert.ok(options.base <= 36, 'options.base <= 36');
mod_assert.bool(options.allowSign, 'options.allowSign');
mod_assert.bool(options.allowPrefix, 'options.allowPrefix');
mod_assert.bool(options.allowTrailing,
'options.allowTrailing');
mod_assert.bool(options.allowImprecise,
'options.allowImprecise');
mod_assert.bool(options.trimWhitespace,
'options.trimWhitespace');
mod_assert.bool(options.leadingZeroIsOctal,
'options.leadingZeroIsOctal');
if (options.leadingZeroIsOctal) {
mod_assert.ok(!baseOverride,
'"base" and "leadingZeroIsOctal" are ' +
'mutually exclusive');
}
}
var c;
var pbase = -1;
var base = options.base;
var start;
var mult = 1;
var value = 0;
var idx = 0;
var len = str.length;
/* Trim any whitespace on the left side. */
if (options.trimWhitespace) {
while (idx < len && isSpace(str.charCodeAt(idx))) {
++idx;
}
}
/* Check the number for a leading sign. */
if (options.allowSign) {
if (str[idx] === '-') {
idx += 1;
mult = -1;
} else if (str[idx] === '+') {
idx += 1;
}
}
/* Parse the base-indicating prefix if there is one. */
if (str[idx] === '0') {
if (options.allowPrefix) {
pbase = prefixToBase(str.charCodeAt(idx + 1));
if (pbase !== -1 && (!baseOverride || pbase === base)) {
base = pbase;
idx += 2;
}
}
if (pbase === -1 && options.leadingZeroIsOctal) {
base = 8;
}
}
/* Parse the actual digits. */
for (start = idx; idx < len; ++idx) {
c = translateDigit(str.charCodeAt(idx));
if (c !== -1 && c < base) {
value *= base;
value += c;
} else {
break;
}
}
/* If we didn't parse any digits, we have an invalid number. */
if (start === idx) {
return (new Error('invalid number: ' + JSON.stringify(str)));
}
/* Trim any whitespace on the right side. */
if (options.trimWhitespace) {
while (idx < len && isSpace(str.charCodeAt(idx))) {
++idx;
}
}
/* Check for trailing characters. */
if (idx < len && !options.allowTrailing) {
return (new Error('trailing characters after number: ' +
JSON.stringify(str.slice(idx))));
}
/* If our value is 0, we return now, to avoid returning -0. */
if (value === 0) {
return (0);
}
/* Calculate our final value. */
var result = value * mult;
/*
* If the string represents a value that cannot be precisely represented
* by JavaScript, then we want to check that:
*
* - We never increased the value past MAX_SAFE_INTEGER
* - We don't make the result negative and below MIN_SAFE_INTEGER
*
* Because we only ever increment the value during parsing, there's no
* chance of moving past MAX_SAFE_INTEGER and then dropping below it
* again, losing precision in the process. This means that we only need
* to do our checks here, at the end.
*/
if (!options.allowImprecise &&
(value > MAX_SAFE_INTEGER || result < MIN_SAFE_INTEGER)) {
return (new Error('number is outside of the supported range: ' +
JSON.stringify(str.slice(start, idx))));
}
return (result);
}
/*
* Interpret a character code as a base-36 digit.
*/
function translateDigit(d)
{
if (d >= CP_0 && d <= CP_9) {
/* '0' to '9' -> 0 to 9 */
return (d - PI_CONV_DEC);
} else if (d >= CP_A && d <= CP_Z) {
/* 'A' - 'Z' -> 10 to 35 */
return (d - PI_CONV_UC);
} else if (d >= CP_a && d <= CP_z) {
/* 'a' - 'z' -> 10 to 35 */
return (d - PI_CONV_LC);
} else {
/* Invalid character code */
return (-1);
}
}
/*
* Test if a value matches the ECMAScript definition of trimmable whitespace.
*/
function isSpace(c)
{
return (c === 0x20) ||
(c >= 0x0009 && c <= 0x000d) ||
(c === 0x00a0) ||
(c === 0x1680) ||
(c === 0x180e) ||
(c >= 0x2000 && c <= 0x200a) ||
(c === 0x2028) ||
(c === 0x2029) ||
(c === 0x202f) ||
(c === 0x205f) ||
(c === 0x3000) ||
(c === 0xfeff);
}
/*
* Determine which base a character indicates (e.g., 'x' indicates hex).
*/
function prefixToBase(c)
{
if (c === CP_b || c === CP_B) {
/* 0b/0B (binary) */
return (2);
} else if (c === CP_o || c === CP_O) {
/* 0o/0O (octal) */
return (8);
} else if (c === CP_t || c === CP_T) {
/* 0t/0T (decimal) */
return (10);
} else if (c === CP_x || c === CP_X) {
/* 0x/0X (hexadecimal) */
return (16);
} else {
/* Not a meaningful character */
return (-1);
}
}
function validateJsonObjectJS(schema, input)
{
var report = mod_jsonschema.validate(input, schema);
if (report.errors.length === 0)
return (null);
/* Currently, we only do anything useful with the first error. */
var error = report.errors[0];
/* The failed property is given by a URI with an irrelevant prefix. */
var propname = error['property'];
var reason = error['message'].toLowerCase();
var i, j;
/*
* There's at least one case where the property error message is
* confusing at best. We work around this here.
*/
if ((i = reason.indexOf('the property ')) != -1 &&
(j = reason.indexOf(' is not defined in the schema and the ' +
'schema does not allow additional properties')) != -1) {
i += 'the property '.length;
if (propname === '')
propname = reason.substr(i, j - i);
else
propname = propname + '.' + reason.substr(i, j - i);
reason = 'unsupported property';
}
var rv = new mod_verror.VError('property "%s": %s', propname, reason);
rv.jsv_details = error;
return (rv);
}
function randElt(arr)
{
mod_assert.ok(Array.isArray(arr) && arr.length > 0,
'randElt argument must be a non-empty array');
return (arr[Math.floor(Math.random() * arr.length)]);
}
function assertHrtime(a)
{
mod_assert.ok(a[0] >= 0 && a[1] >= 0,
'negative numbers not allowed in hrtimes');
mod_assert.ok(a[1] < 1e9, 'nanoseconds column overflow');
}
/*
* Compute the time elapsed between hrtime readings A and B, where A is later
* than B. hrtime readings come from Node's process.hrtime(). There is no
* defined way to represent negative deltas, so it's illegal to diff B from A
* where the time denoted by B is later than the time denoted by A. If this
* becomes valuable, we can define a representation and extend the
* implementation to support it.
*/
function hrtimeDiff(a, b)
{
assertHrtime(a);
assertHrtime(b);
mod_assert.ok(a[0] > b[0] || (a[0] == b[0] && a[1] >= b[1]),
'negative differences not allowed');
var rv = [ a[0] - b[0], 0 ];
if (a[1] >= b[1]) {
rv[1] = a[1] - b[1];
} else {
rv[0]--;
rv[1] = 1e9 - (b[1] - a[1]);
}
return (rv);
}
/*
* Convert a hrtime reading from the array format returned by Node's
* process.hrtime() into a scalar number of nanoseconds.
*/
function hrtimeNanosec(a)
{
assertHrtime(a);
return (Math.floor(a[0] * 1e9 + a[1]));
}
/*
* Convert a hrtime reading from the array format returned by Node's
* process.hrtime() into a scalar number of microseconds.
*/
function hrtimeMicrosec(a)
{
assertHrtime(a);
return (Math.floor(a[0] * 1e6 + a[1] / 1e3));
}
/*
* Convert a hrtime reading from the array format returned by Node's
* process.hrtime() into a scalar number of milliseconds.
*/
function hrtimeMillisec(a)
{
assertHrtime(a);
return (Math.floor(a[0] * 1e3 + a[1] / 1e6));
}
/*
* Add two hrtime readings A and B, overwriting A with the result of the
* addition. This function is useful for accumulating several hrtime intervals
* into a counter. Returns A.
*/
function hrtimeAccum(a, b)
{
assertHrtime(a);
assertHrtime(b);
/*
* Accumulate the nanosecond component.
*/
a[1] += b[1];
if (a[1] >= 1e9) {
/*
* The nanosecond component overflowed, so carry to the seconds
* field.
*/
a[0]++;
a[1] -= 1e9;
}
/*
* Accumulate the seconds component.
*/
a[0] += b[0];
return (a);
}
/*
* Add two hrtime readings A and B, returning the result as a new hrtime array.
* Does not modify either input argument.
*/
function hrtimeAdd(a, b)
{
assertHrtime(a);
var rv = [ a[0], a[1] ];
return (hrtimeAccum(rv, b));
}
/*
* Check an object for unexpected properties. Accepts the object to check, and
* an array of allowed property names (strings). Returns an array of key names
* that were found on the object, but did not appear in the list of allowed
* properties. If no properties were found, the returned array will be of
* zero length.
*/
function extraProperties(obj, allowed)
{
mod_assert.ok(typeof (obj) === 'object' && obj !== null,
'obj argument must be a non-null object');
mod_assert.ok(Array.isArray(allowed),
'allowed argument must be an array of strings');
for (var i = 0; i < allowed.length; i++) {
mod_assert.ok(typeof (allowed[i]) === 'string',
'allowed argument must be an array of strings');
}
return (Object.keys(obj).filter(function (key) {
return (allowed.indexOf(key) === -1);
}));
}
/*
* Given three sets of properties "provided" (may be undefined), "overrides"
* (required), and "defaults" (may be undefined), construct an object containing
* the union of these sets with "overrides" overriding "provided", and
* "provided" overriding "defaults". None of the input objects are modified.
*/
function mergeObjects(provided, overrides, defaults)
{
var rv, k;
rv = {};
if (defaults) {
for (k in defaults)
rv[k] = defaults[k];
}
if (provided) {
for (k in provided)
rv[k] = provided[k];
}
if (overrides) {
for (k in overrides)
rv[k] = overrides[k];
}
return (rv);
}

49
node_modules/jsprim/package.json generated vendored
View File

@@ -1,49 +0,0 @@
{
"_from": "jsprim@^1.2.2",
"_id": "jsprim@1.4.1",
"_inBundle": false,
"_integrity": "sha1-MT5mvB5cwG5Di8G3SZwuXFastqI=",
"_location": "/jsprim",
"_phantomChildren": {},
"_requested": {
"type": "range",
"registry": true,
"raw": "jsprim@^1.2.2",
"name": "jsprim",
"escapedName": "jsprim",
"rawSpec": "^1.2.2",
"saveSpec": null,
"fetchSpec": "^1.2.2"
},
"_requiredBy": [
"/http-signature"
],
"_resolved": "https://registry.npmjs.org/jsprim/-/jsprim-1.4.1.tgz",
"_shasum": "313e66bc1e5cc06e438bc1b7499c2e5c56acb6a2",
"_spec": "jsprim@^1.2.2",
"_where": "C:\\Users\\matia\\Bot Files\\node_modules\\http-signature",
"bugs": {
"url": "https://github.com/joyent/node-jsprim/issues"
},
"bundleDependencies": false,
"dependencies": {
"assert-plus": "1.0.0",
"extsprintf": "1.3.0",
"json-schema": "0.2.3",
"verror": "1.10.0"
},
"deprecated": false,
"description": "utilities for primitive JavaScript types",
"engines": [
"node >=0.6.0"
],
"homepage": "https://github.com/joyent/node-jsprim#readme",
"license": "MIT",
"main": "./lib/jsprim.js",
"name": "jsprim",
"repository": {
"type": "git",
"url": "git://github.com/joyent/node-jsprim.git"
},
"version": "1.4.1"
}