Something went wrong. Try again.
[READ-ONLY] Mirror of https://github.com/glacials/splits-io. a speedrunning data store and analysis engine splits.io
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736/* * 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);}