[#94] Backend

https://project.mdnd-it.cc/work_packages/94

SerpentRace_Backend/node_modules/z-schema/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Martin Zagora and other contributors
+https://github.com/zaggino/z-schema/graphs/contributors
+
+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.

SerpentRace_Backend/node_modules/z-schema/README.md

@@ -0,0 +1,605 @@
+# z-schema validator
+
+[![npm version](https://badge.fury.io/js/z-schema.svg)](http://badge.fury.io/js/z-schema)
+[![bower version](https://badge.fury.io/bo/z-schema.svg)](http://badge.fury.io/bo/z-schema)
+[![build status](https://travis-ci.org/zaggino/z-schema.svg?branch=master)](https://travis-ci.org/zaggino/z-schema)
+[![coverage status](https://coveralls.io/repos/zaggino/z-schema/badge.svg)](https://coveralls.io/r/zaggino/z-schema)
+
+[![Greenkeeper badge](https://badges.greenkeeper.io/zaggino/z-schema.svg)](https://greenkeeper.io/)
+[![dependencies Status](https://david-dm.org/zaggino/z-schema/status.svg)](https://david-dm.org/zaggino/z-schema)
+[![devDependencies Status](https://david-dm.org/zaggino/z-schema/dev-status.svg)](https://david-dm.org/zaggino/z-schema?type=dev)
+[![optionalDependencies Status](https://david-dm.org/zaggino/z-schema/optional-status.svg)](https://david-dm.org/zaggino/z-schema?type=optional)
+
+[![NPM](https://nodei.co/npm/z-schema.png?downloads=true&downloadRank=true)](https://nodei.co/npm/z-schema/)
+
+- version 3.0 runs also in the browsers now, run tests yourself [here](https://rawgit.com/zaggino/z-schema/master/test/SpecRunner.html)
+
+# Topics
+
+- [Usage](#usage)
+- [Features](#features)
+- [Options](#options)
+- [Benchmarks](#benchmarks)
+- [Contributors](#contributors)
+
+# Usage
+
+Validator will try to perform sync validation when possible for speed, but supports async callbacks when they are necessary.
+
+## Development:
+
+These repository has several submodules and should be cloned as follows:
+>git clone **--recursive** https://github.com/zaggino/z-schema.git
+
+## CLI:
+
+```
+npm install --global z-schema
+z-schema --help
+z-schema mySchema.json
+z-schema mySchema.json myJson.json
+z-schema --strictMode mySchema.json myJson.json
+```
+
+## NodeJS:
+
+```javascript
+var ZSchema = require("z-schema");
+var options = ... // see below for possible option values
+var validator = new ZSchema(options);
+```
+
+## Sync mode:
+
+```javascript
+var valid = validator.validate(json, schema);
+// this will return a native error object with name and message
+var error = validator.getLastError();
+// this will return an array of validation errors encountered
+var errors = validator.getLastErrors();
+...
+```
+
+## Async mode:
+
+```javascript
+validator.validate(json, schema, function (err, valid) {
+    ...
+});
+```
+
+## Browser:
+
+```html
+<script type="text/javascript" src="../dist/ZSchema-browser-min.js"></script>
+<script type="text/javascript">
+	var validator = new ZSchema();
+	var valid = validator.validate("string", { "type": "string" });
+	console.log(valid);
+</script>
+```
+
+## Remote references and schemas:
+
+In case you have some remote references in your schemas, you have to download those schemas before using validator.
+Otherwise you'll get ```UNRESOLVABLE_REFERENCE``` error when trying to compile a schema.
+
+```javascript
+var validator = new ZSchema();
+var json = {};
+var schema = { "$ref": "http://json-schema.org/draft-04/schema#" };
+
+var valid = validator.validate(json, schema);
+var errors = validator.getLastErrors();
+// valid === false
+// errors.length === 1
+// errors[0].code === "UNRESOLVABLE_REFERENCE"
+
+var requiredUrl = "http://json-schema.org/draft-04/schema";
+request(requiredUrl, function (error, response, body) {
+
+    validator.setRemoteReference(requiredUrl, JSON.parse(body));
+
+    var valid = validator.validate(json, schema);
+    var errors = validator.getLastErrors();
+    // valid === true
+    // errors === undefined
+
+}
+```
+
+If you're able to load schemas synchronously, you can use `ZSchema.setSchemaReader` feature:
+
+```javascript
+ZSchema.setSchemaReader(function (uri) {
+    var someFilename = path.resolve(__dirname, "..", "schemas", uri + ".json");
+    return JSON.parse(fs.readFileSync(someFilename, "utf8"));
+});
+```
+
+# Features
+
+- [Validate against subschema](#validate-against-subschema)
+- [Compile arrays of schemas and use references between them](#compile-arrays-of-schemas-and-use-references-between-them)
+- [Register a custom format](#register-a-custom-format)
+- [Automatic downloading of remote schemas](#automatic-downloading-of-remote-schemas)
+- [Prefill default values to object using format](#prefill-default-values-to-object-using-format)
+- [Define a custom timeout for all async operations](#asynctimeout)
+- [Disallow validation of empty arrays as arrays](#noemptyarrays)
+- [Disallow validation of empty strings as strings](#noemptystrings)
+- [Disallow schemas that don't have a type specified](#notypeless)
+- [Disallow schemas that contain unrecognized keywords and are not validated by parent schemas](#noextrakeywords)
+- [Assume additionalItems/additionalProperties are defined in schemas as false](#assumeadditional)
+- [Force additionalItems/additionalProperties to be defined in schemas](#forceadditional)
+- [Force items to be defined in array type schemas](#forceitems)
+- [Force minItems to be defined in array type schemas](#forceminitems)
+- [Force maxItems to be defined in array type schemas](#forcemaxitems)
+- [Force minLength to be defined in string type schemas](#forceminlength)
+- [Force maxLength to be defined in string type schemas](#forcemaxlength)
+- [Force properties or patternProperties to be defined in object type schemas](#forceproperties)
+- [Ignore remote references to schemas that are not cached or resolvable](#ignoreunresolvablereferences)
+- [Ignore case mismatch when validating enum values](#enumCaseInsensitiveComparison)
+- [Only allow strictly absolute URIs to be used in schemas](#stricturis)
+- [Turn on z-schema strict mode](#strictmode)
+- [Set validator to collect as many errors as possible](#breakonfirsterror)
+- [Report paths in errors as arrays so they can be processed easier](#reportpathasarray)
+
+## Validate against subschema
+
+In case you don't want to split your schema into multiple schemas using reference for any reason, you can use option schemaPath when validating:
+
+```javascript
+var valid = validator.validate(cars, schema, { schemaPath: "definitions.car.definitions.cars" });
+```
+
+See more details in the [test](/test/spec/schemaPathSpec.js).
+
+## Compile arrays of schemas and use references between them
+
+You can use validator to compile an array of schemas that have references between them and then validate against one of those schemas:
+
+```javascript
+var schemas = [
+    {
+        id: "personDetails",
+        type: "object",
+        properties: {
+            firstName: { type: "string" },
+            lastName: { type: "string" }
+        },
+        required: ["firstName", "lastName"]
+    },
+    {
+        id: "addressDetails",
+        type: "object",
+        properties: {
+            street: { type: "string" },
+            city: { type: "string" }
+        },
+        required: ["street", "city"]
+    },
+    {
+        id: "personWithAddress",
+        allOf: [
+            { $ref: "personDetails" },
+            { $ref: "addressDetails" }
+        ]
+    }
+];
+
+var data = {
+    firstName: "Martin",
+    lastName: "Zagora",
+    street: "George St",
+    city: "Sydney"
+};
+
+var validator = new ZSchema();
+
+// compile & validate schemas first, z-schema will automatically handle array
+var allSchemasValid = validator.validateSchema(schemas);
+// allSchemasValid === true
+
+// now validate our data against the last schema
+var valid = validator.validate(data, schemas[2]);
+// valid === true
+```
+
+## Register a custom format
+
+You can register any format of your own. Your sync validator function should always respond with a boolean:
+
+```javascript
+ZSchema.registerFormat("xstring", function (str) {
+    return str === "xxx";
+});
+```
+
+Async format validators are also supported, they should accept two arguments, value and a callback to which they need to respond:
+
+```javascript
+ZSchema.registerFormat("xstring", function (str, callback) {
+    setTimeout(function () {
+        callback(str === "xxx");
+    }, 1);
+});
+```
+## Helper method to check the formats that have been registered
+```javascript
+var registeredFormats = ZSchema.getRegisteredFormats();
+//registeredFormats will now contain an array of all formats that have been registered with z-schema
+```
+## Automatic downloading of remote schemas
+
+Automatic downloading of remote schemas was removed from version ```3.x``` but is still possible with a bit of extra code,
+see [this test](test/spec/AutomaticSchemaLoadingSpec.js) for more information on this.
+
+## Prefill default values to object using format
+
+Using format, you can pre-fill values of your choosing into the objects like this:
+
+```javascript
+ZSchema.registerFormat("fillHello", function (obj) {
+    obj.hello = "world";
+    return true;
+});
+
+var data = {};
+
+var schema = {
+    "type": "object",
+    "format": "fillHello"
+};
+
+validator.validate(data, schema);
+// data.hello === "world"
+```
+
+# Options
+
+## asyncTimeout
+
+Defines a time limit, which should be used when waiting for async tasks like async format validators to perform their validation,
+before the validation fails with an ```ASYNC_TIMEOUT``` error.
+
+```javascript
+var validator = new ZSchema({
+    asyncTimeout: 2000
+});
+```
+
+## noEmptyArrays
+
+When true, validator will assume that minimum count of items in any ```array``` is 1, except when ```minItems: 0``` is explicitly defined.
+
+```javascript
+var validator = new ZSchema({
+    noEmptyArrays: true
+});
+```
+
+## noEmptyStrings
+
+When true, validator will assume that minimum length of any string to pass type ```string``` validation is 1, except when ```minLength: 0``` is explicitly defined.
+
+```javascript
+var validator = new ZSchema({
+    noEmptyStrings: true
+});
+```
+
+## noTypeless
+
+When true, validator will fail validation for schemas that don't specify a ```type``` of object that they expect.
+
+```javascript
+var validator = new ZSchema({
+    noTypeless: true
+});
+```
+
+## noExtraKeywords
+
+When true, validator will fail for schemas that use keywords not defined in JSON Schema specification and doesn't provide a parent schema in ```$schema``` property to validate the schema.
+
+```javascript
+var validator = new ZSchema({
+    noExtraKeywords: true
+});
+```
+
+## assumeAdditional
+
+When true, validator assumes that additionalItems/additionalProperties are defined as false so you don't have to manually fix all your schemas.
+
+```javascript
+var validator = new ZSchema({
+    assumeAdditional: true
+});
+```
+
+When an array, validator assumes that additionalItems/additionalProperties are defined as false, but allows some properties to pass.
+
+```javascript
+var validator = new ZSchema({
+    assumeAdditional: ["$ref"]
+});
+```
+
+## forceAdditional
+
+When true, validator doesn't validate schemas where additionalItems/additionalProperties should be defined to either true or false.
+
+```javascript
+var validator = new ZSchema({
+    forceAdditional: true
+});
+```
+
+## forceItems
+
+When true, validator doesn't validate schemas where ```items``` are not defined for ```array``` type schemas.
+This is to avoid passing anything through an array definition.
+
+```javascript
+var validator = new ZSchema({
+    forceItems: true
+});
+```
+
+## forceMinItems
+
+When true, validator doesn't validate schemas where ```minItems``` is not defined for ```array``` type schemas.
+This is to avoid passing zero-length arrays which application doesn't expect to handle.
+
+```javascript
+var validator = new ZSchema({
+    forceMinItems: true
+});
+```
+
+## forceMaxItems
+
+When true, validator doesn't validate schemas where ```maxItems``` is not defined for ```array``` type schemas.
+This is to avoid passing arrays with unlimited count of elements which application doesn't expect to handle.
+
+```javascript
+var validator = new ZSchema({
+    forceMaxItems: true
+});
+```
+
+## forceMinLength
+
+When true, validator doesn't validate schemas where ```minLength``` is not defined for ```string``` type schemas.
+This is to avoid passing zero-length strings which application doesn't expect to handle.
+
+```javascript
+var validator = new ZSchema({
+    forceMinLength: true
+});
+```
+
+
+## forceMaxLength
+
+When true, validator doesn't validate schemas where ```maxLength``` is not defined for ```string``` type schemas.
+This is to avoid passing extremly large strings which application doesn't expect to handle.
+
+```javascript
+var validator = new ZSchema({
+    forceMaxLength: true
+});
+```
+
+## forceProperties
+
+When true, validator doesn't validate schemas where ```properties``` or ```patternProperties``` is not defined for ```object``` type schemas.
+This is to avoid having objects with unexpected properties in application.
+
+```javascript
+var validator = new ZSchema({
+    forceProperties: true
+});
+```
+
+## ignoreUnresolvableReferences
+
+When true, validator doesn't end with error when a remote reference is unreachable. **This setting is not recommended in production outside of testing.**
+
+```javascript
+var validator = new ZSchema({
+    ignoreUnresolvableReferences: true
+});
+```
+## enumCaseInsensitiveComparison
+
+When true, validator will return a ```ENUM_CASE_MISMATCH``` when the enum values mismatch only in case.
+
+```javascript
+var validator = new ZSchema({
+    enumCaseInsensitiveComparison: true
+});
+```
+
+## strictUris
+
+When true, all strings of format ```uri``` must be an absolute URIs and not only URI references. See more details in [this issue](https://github.com/zaggino/z-schema/issues/18).
+
+```javascript
+var validator = new ZSchema({
+    strictUris: true
+});
+```
+
+## strictMode
+
+Strict mode of z-schema is currently equal to the following:
+
+```javascript
+if (this.options.strictMode === true) {
+    this.options.forceAdditional  = true;
+    this.options.forceItems       = true;
+    this.options.forceMaxLength   = true;
+    this.options.forceProperties  = true;
+    this.options.noExtraKeywords  = true;
+    this.options.noTypeless       = true;
+    this.options.noEmptyStrings   = true;
+    this.options.noEmptyArrays    = true;
+}
+```
+
+```javascript
+var validator = new ZSchema({
+    strictMode: true
+});
+```
+
+## breakOnFirstError
+
+default: `false`<br />
+When true, will stop validation after the first error is found:
+
+```javascript
+var validator = new ZSchema({
+    breakOnFirstError: true
+});
+```
+
+## reportPathAsArray
+
+Report error paths as an array of path segments instead of a string:
+
+```javascript
+var validator = new ZSchema({
+    reportPathAsArray: true
+});
+```
+
+## ignoreUnknownFormats
+
+By default, z-schema reports all unknown formats, formats not defined by JSON Schema and not registered using
+`ZSchema.registerFormat`, as an error.  But the
+[JSON Schema specification](http://json-schema.org/latest/json-schema-validation.html#anchor106) says that validator
+implementations *"they SHOULD offer an option to disable validation"* for `format`.  That being said, setting this
+option to `true` will disable treating unknown formats as errlrs
+
+```javascript
+var validator = new ZSchema({
+    ignoreUnknownFormats: true
+});
+```
+
+## includeErrors
+
+By default, z-schema reports all errors. If interested only in a subset of the errors, passing the option `includeErrors` to `validate` will perform validations only for those errors.
+
+```javascript
+var validator = new ZSchema();
+// will only execute validation for "INVALID_TYPE" error.
+validator.validate(json, schema, {includeErrors: ["INVALID_TYPE"]});
+```
+
+## customValidator
+
+**Warning**: Use only if know what you are doing. Always consider using [custom format](#register-a-custom-format) before using this option.
+
+Register function to be called as part of validation process on every subshema encounter during validation.
+
+Let's make a real-life example with this feature.
+Imagine you have number of transactions:
+```json
+{
+    "fromId": 1034834329,
+    "toId": 1034834543,
+    "amount": 200
+}
+```
+So you write the schema:
+```json
+{
+    "type": "object",
+    "properties": {
+        "fromId": {
+            "type": "integer"
+        },
+        "toId": {
+            "type": "integer"
+        },
+        "amount": {
+            "type": "number"
+        }
+    }
+}
+```
+But how to check that `fromId` and `toId` are never equal.
+In JSON Schema Draft4 there is no possibility to do this.
+Actually, it's easy to just write validation code for such simple payloads.
+But what if you have to do the same check for many objects in different places of JSON payload.
+One solution is to add custom keyword `uniqueProperties` with array of property names as a value. So in our schema we would need to add:
+```json
+"uniqueProperties": [
+    "fromId",
+    "toId"
+]
+```
+To teach `z-schema` about this new keyword we need to write handler for it:
+```javascript
+function customValidatorFn(report, schema, json) {
+    // check if our custom property is present
+    if (Array.isArray(schema.uniqueProperties)) {
+        var seenValues = [];
+        schema.uniqueProperties.forEach(function (prop) {
+            var value = json[prop];
+            if (typeof value !== 'undefined') {
+                if (seenValues.indexOf(value) !== -1) {
+                    // report error back to z-schema core
+                    report.addCustomError("NON_UNIQUE_PROPERTY_VALUE",
+                        "Property \"{0}\" has non-unique value: {1}",
+                        [prop, value], null, schema.description);
+                }
+                seenValues.push(value)
+            }
+        });
+    }
+}
+
+var validator = new ZSchema({
+    // register our custom validator inside z-schema
+    customValidator: customValidatorFn
+});
+```
+Let's test it:
+```javascript
+var data = {
+    fromId: 1034834346,
+    toId: 1034834346,
+    amount: 50
+};
+
+validator.validate(data, schema);
+console.log(validator.getLastErrors())
+//[ { code: 'NON_UNIQUE_PROPERTY_VALUE',
+//    params: [ 'toId', 1034834346 ],
+//    message: 'Property "toId" has non-unique value: 1034834346',
+//    path: '#/',
+//    schemaId: undefined } ]
+```
+**Note:** before creating your own keywords you should consider all compatibility issues.
+
+# Benchmarks
+
+So how does it compare to version 2.x and others?
+
+**NOTE: these tests are purely orientational, they don't consider extra features any of the validator may support and implement**
+
+[rawgithub.com/zaggino/z-schema/master/benchmark/results.html](https://rawgithub.com/zaggino/z-schema/master/benchmark/results.html)
+
+# Contributors
+
+Thanks for contributing to:
+
+- [Jeremy Whitlock](https://github.com/whitlockjc)
+- [Oleksiy Krivoshey](https://github.com/oleksiyk)
+
+and to everyone submitting [issues](https://github.com/zaggino/z-schema/issues) on GitHub

SerpentRace_Backend/node_modules/z-schema/bin/z-schema

@@ -0,0 +1,169 @@
+#!/usr/bin/env node
+
+// set default exitCode for node 0.10
+process.exitCode = 0;
+
+var fs      = require("fs");
+var path    = require("path");
+var program = require("commander");
+var request = require("https").request;
+var package = require("./../package.json");
+var ZSchema = require("./../src/ZSchema");
+
+program
+  .version(package.version)
+  .usage("[options] <schema> <json1?> <json2?> <json3?>")
+  .option("--asyncTimeout <n>", "default timeout for all async tasks", parseInt)
+  .option("--forceAdditional", "force additionalProperties and additionalItems to be defined on \"object\" and \"array\" types")
+  .option("--assumeAdditional", "assume additionalProperties and additionalItems are defined as \"false\" where appropriate")
+  .option("--forceItems", "force items to be defined on \"array\" types")
+  .option("--forceMinItems", "force minItems to be defined on \"array\" types")
+  .option("--forceMaxItems", "force maxItems to be defined on \"array\" types")
+  .option("--forceMinLength", "force minLength to be defined on \"string\" types")
+  .option("--forceMaxLength", "force maxLength to be defined on \"string\" types")  
+  .option("--forceProperties", "force properties or patternProperties to be defined on \"object\" types")
+  .option("--ignoreUnresolvableReferences", "ignore references that cannot be resolved (remote schemas)")
+  .option("--noExtraKeywords", "disallow usage of keywords that this validator can't handle")
+  .option("--noTypeless", "disallow usage of schema's without \"type\" defined")
+  .option("--noEmptyStrings", "disallow zero length strings in validated objects")
+  .option("--noEmptyArrays", "disallow zero length arrays in validated objects")
+  .option("--strictUris", "forces \"uri\" format to be in fully rfc3986 compliant")
+  .option("--strictMode", "turn on some of the above")
+  .option("--reportPathAsArray", "report error paths as an array of path segments to get to the offending node")
+  .option("--breakOnFirstError", "stops validation as soon as an error is found, true by default but can be turned off")
+  .option("--pedanticCheck", "check if schema follow best practices and common sence")
+  .option("--ignoreUnknownFormats", "ignore unknown formats (do not report them as an error)")
+  .parse(process.argv);
+  
+var options = {};  
+var defaultOptions = ZSchema.getDefaultOptions();
+
+for (var key in defaultOptions) {
+    if (program[key]) {
+        options[key] = program[key];
+    }
+}
+
+if (!program.args.length) {
+  program.help();
+}
+
+function readJson(fileName) {
+    var ret;
+    try {
+        ret = fs.readFileSync(fileName, { encoding: "utf8" });
+    } catch (e) {
+        console.error(e);
+        throw new Error("Couldn't read the file: " + fileName);
+    }
+    try {
+        ret = JSON.parse(ret);
+    } catch (e) {
+        console.error(e);
+        throw new Error("Couldn't parse the file as JSON: " + fileName);
+    }
+    return ret;
+}
+
+var validator = new ZSchema(options);
+var schemaFilePath = program.args.shift();
+var schema = readJson(schemaFilePath);
+
+function validateWithAutomaticDownloads(filePath, data, schema, callback) {
+
+    var lastResult;
+
+    function finish() {
+        callback(validator.getLastErrors(), lastResult);
+    }
+
+    function validate() {
+
+        if (data !== undefined) {
+            lastResult = validator.validate(data, schema);
+        } else {
+            lastResult = validator.validateSchema(schema);
+        }
+        
+        // console.log(lastResult);
+        // console.log(JSON.stringify(validator.getLastErrors(), null, 4));
+
+        var missingReferences = validator.getMissingRemoteReferences();
+        if (missingReferences.length > 0) {
+            var finished = 0;
+            missingReferences.forEach(function (url) {
+                var urlString = "request: " + url + " - ";
+
+                if (url.match(/^https?:/)) {
+                    request(url, function (response) {
+                        var body = "";
+                        response.on("data", function (chunk) { data += chunk; });
+                        response.on("end", function () {
+
+                            console.log(urlString + response.statusCode);
+
+                            validator.setRemoteReference(url, JSON.parse(body));
+                            finished++;
+                            if (finished === missingReferences.length) {
+                                validate();
+                            }
+                        });
+                    }).on("error", function (error) {
+                        console.error(urlString);
+                        console.error(error);
+                        process.exit(1);
+                    });
+                } else {
+                    // FUTURE: maybe else if (isFile(url)) later
+                    var referencePath = path.resolve(process.cwd(), path.dirname(filePath), url);
+                    var reference = readJson(referencePath);
+                    validator.setRemoteReference(url, reference);
+                    finished++;
+                    if (finished === missingReferences.length) {
+                        validate();
+                    }
+                }
+            });
+        } else {
+            finish();
+        }
+
+    }
+
+    validate();
+
+}
+
+var i = 0;
+function validateJsons() {
+    if (program.args.length === 0) {
+        process.exit(process.exitCode);
+        return;
+    }
+    i++;
+    
+    var filePath = program.args.shift();
+    var json = readJson(filePath);
+    validateWithAutomaticDownloads(filePath, json, schema, function (errs, isValid) {    
+        if (!isValid) {
+            console.log(JSON.stringify(validator.getLastErrors(), null, 4));
+            console.log("json #" + i + " validation failed");
+            process.exitCode = 1;
+        } else {
+            console.log("json #" + i + " validation passed");
+        }
+        validateJsons();
+    });
+}
+
+// validate schema
+validateWithAutomaticDownloads(schemaFilePath, undefined, schema, function (errs, isValid) {
+    if (!isValid) {
+        console.log(JSON.stringify(validator.getLastErrors(), null, 4));
+        console.log("schema validation failed");
+        process.exit(1);
+    } else {
+        console.log("schema validation passed");
+        validateJsons();
+    }    
+});

SerpentRace_Backend/node_modules/z-schema/index.d.ts

@@ -0,0 +1,175 @@
+// Type definitions for z-schema v3.16.0
+// Project: https://github.com/zaggino/z-schema
+// Definitions by: pgonzal <https://github.com/pgonzal>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+declare namespace Validator {
+    export interface Options {
+        asyncTimeout?: number;
+        forceAdditional?: boolean;
+        assumeAdditional?: boolean;
+        forceItems?: boolean;
+        forceMinItems?: boolean;
+        forceMaxItems?: boolean;
+        forceMinLength?: boolean;
+        forceMaxLength?: boolean;
+        forceProperties?: boolean;
+        ignoreUnresolvableReferences?: boolean;
+        noExtraKeywords?: boolean;
+        noTypeless?: boolean;
+        noEmptyStrings?: boolean;
+        noEmptyArrays?: boolean;
+        strictUris?: boolean;
+        strictMode?: boolean;
+        reportPathAsArray?: boolean;
+        breakOnFirstError?: boolean;
+        pedanticCheck?: boolean;
+        ignoreUnknownFormats?: boolean;
+        customValidator?: (report: Report, schema: any, json: any) => void;
+    }
+
+    export interface SchemaError extends Error {
+        /**
+         * Implements the Error.name contract.  The value is always "z-schema validation error".
+         */
+        name: string;
+
+        /**
+         * An identifier indicating the type of error.
+         * Example: "JSON_OBJECT_VALIDATION_FAILED"
+         */
+        message: string;
+
+        /**
+         * Returns details for each error that occurred during validation.
+         * See Options.breakOnFirstError.
+         */
+        details: SchemaErrorDetail[];
+    }
+
+    export interface SchemaErrorDetail {
+        /**
+         * Example: "Expected type string but found type array"
+         */
+        message: string;
+        /**
+         * An error identifier that can be used to format a custom error message.
+         * Example: "INVALID_TYPE"
+         */
+        code: string;
+        /**
+         * Format parameters that can be used to format a custom error message.
+         * Example: ["string","array"]
+         */
+        params: Array<string>;
+        /**
+         * A JSON path indicating the location of the error.
+         * Example: "#/projects/1"
+         */
+        path: string;
+        /**
+         * The schema rule description, which is included for certain errors where
+         * this information is useful (e.g. to describe a constraint).
+         */
+        description: string;
+
+        /**
+         * Returns details for sub-schemas that failed to match.  For example, if the schema
+         * uses the "oneOf" constraint to accept several alternative possibilities, each
+         * alternative will have its own inner detail object explaining why it failed to match.
+         */
+        inner: SchemaErrorDetail[];
+    }
+
+    export const schemaSymbol: unique symbol
+
+    export const jsonSymbol: unique symbol
+}
+
+declare class Validator {
+    public lastReport: Report | undefined;
+
+    /**
+     * Register a custom format.
+     *
+     * @param name - name of the custom format
+     * @param validatorFunction - custom format validator function.
+     *   Returns `true` if `value` matches the custom format.
+     */
+    public static registerFormat(formatName: string, validatorFunction: (value: any) => boolean): void;
+
+    /**
+     * Unregister a format.
+     *
+     * @param name - name of the custom format
+     */
+    public static unregisterFormat(name: string): void;
+
+    /**
+     * Get the list of all registered formats.
+     *
+     * Both the names of the burned-in formats and the custom format names are
+     * returned by this function.
+     *
+     * @returns {string[]} the list of all registered format names.
+     */
+    public static getRegisteredFormats(): string[];
+
+    public static getDefaultOptions(): Validator.Options;
+
+    constructor(options: Validator.Options);
+
+    /**
+     * @param schema - JSON object representing schema
+     * @returns {boolean} true if schema is valid.
+     */
+    validateSchema(schema: any): boolean;
+
+    /**
+     * @param json - either a JSON string or a parsed JSON object
+     * @param schema - the JSON object representing the schema
+     * @returns true if json matches schema
+     */
+    validate(json: any, schema: any): boolean;
+
+    /**
+     * @param json - either a JSON string or a parsed JSON object
+     * @param schema - the JSON object representing the schema
+     */
+    validate(json: any, schema: any, callback: (err: any, valid: boolean) => void): void;
+
+    /**
+     * Returns an Error object for the most recent failed validation, or null if the validation was successful.
+     */
+    getLastError(): Validator.SchemaError;
+
+    /**
+     * Returns the error details for the most recent validation, or undefined if the validation was successful.
+     * This is the same list as the SchemaError.details property.
+     */
+    getLastErrors(): Validator.SchemaErrorDetail[];
+}
+
+/**
+ * Basic representation of the Report class -- just enough to support customValidator
+ */
+declare class Report {
+    errors: Validator.SchemaErrorDetail[];
+
+    /**
+     * Returns whether the validation did pass
+     */
+    isValid(): boolean;
+
+    /**
+     * @param errorCode - a string representing the code for the custom error, e.g. INVALID_VALUE_SET
+     * @param errorMessage - string with the message to be returned in the error
+     * @param params - an array of relevant params for the error, e.g. [fieldName, fieldValue]
+     * @param subReports - sub-schema involved in the error
+     * @param schemaDescription - description from the schema used in the validation
+     * Adds custom error to the errors array in the validation instance and sets valid to false if it is not already set as false
+     */
+    addCustomError: (errorCode: string, errorMessage: string, params: string[], subReports: string, schemaDescription: string) => void;
+}
+
+export = Validator;

SerpentRace_Backend/node_modules/z-schema/node_modules/commander/LICENSE

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2011 TJ Holowaychuk <tj@vision-media.ca>
+
+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.

SerpentRace_Backend/node_modules/z-schema/node_modules/commander/esm.mjs

@@ -0,0 +1,16 @@
+import commander from './index.js';
+
+// wrapper to provide named exports for ESM.
+export const {
+  program,
+  createCommand,
+  createArgument,
+  createOption,
+  CommanderError,
+  InvalidArgumentError,
+  InvalidOptionArgumentError, // deprecated old name
+  Command,
+  Argument,
+  Option,
+  Help
+} = commander;

SerpentRace_Backend/node_modules/z-schema/node_modules/commander/index.js

@@ -0,0 +1,27 @@
+const { Argument } = require('./lib/argument.js');
+const { Command } = require('./lib/command.js');
+const { CommanderError, InvalidArgumentError } = require('./lib/error.js');
+const { Help } = require('./lib/help.js');
+const { Option } = require('./lib/option.js');
+
+// @ts-check
+
+/**
+ * Expose the root command.
+ */
+
+exports = module.exports = new Command();
+exports.program = exports; // More explicit access to global command.
+// Implicit export of createArgument, createCommand, and createOption.
+
+/**
+ * Expose classes
+ */
+
+exports.Argument = Argument;
+exports.Command = Command;
+exports.CommanderError = CommanderError;
+exports.Help = Help;
+exports.InvalidArgumentError = InvalidArgumentError;
+exports.InvalidOptionArgumentError = InvalidArgumentError; // Deprecated
+exports.Option = Option;

SerpentRace_Backend/node_modules/z-schema/node_modules/commander/lib/argument.js

@@ -0,0 +1,147 @@
+const { InvalidArgumentError } = require('./error.js');
+
+// @ts-check
+
+class Argument {
+  /**
+   * Initialize a new command argument with the given name and description.
+   * The default is that the argument is required, and you can explicitly
+   * indicate this with <> around the name. Put [] around the name for an optional argument.
+   *
+   * @param {string} name
+   * @param {string} [description]
+   */
+
+  constructor(name, description) {
+    this.description = description || '';
+    this.variadic = false;
+    this.parseArg = undefined;
+    this.defaultValue = undefined;
+    this.defaultValueDescription = undefined;
+    this.argChoices = undefined;
+
+    switch (name[0]) {
+      case '<': // e.g. <required>
+        this.required = true;
+        this._name = name.slice(1, -1);
+        break;
+      case '[': // e.g. [optional]
+        this.required = false;
+        this._name = name.slice(1, -1);
+        break;
+      default:
+        this.required = true;
+        this._name = name;
+        break;
+    }
+
+    if (this._name.length > 3 && this._name.slice(-3) === '...') {
+      this.variadic = true;
+      this._name = this._name.slice(0, -3);
+    }
+  }
+
+  /**
+   * Return argument name.
+   *
+   * @return {string}
+   */
+
+  name() {
+    return this._name;
+  }
+
+  /**
+   * @api private
+   */
+
+  _concatValue(value, previous) {
+    if (previous === this.defaultValue || !Array.isArray(previous)) {
+      return [value];
+    }
+
+    return previous.concat(value);
+  }
+
+  /**
+   * Set the default value, and optionally supply the description to be displayed in the help.
+   *
+   * @param {any} value
+   * @param {string} [description]
+   * @return {Argument}
+   */
+
+  default(value, description) {
+    this.defaultValue = value;
+    this.defaultValueDescription = description;
+    return this;
+  }
+
+  /**
+   * Set the custom handler for processing CLI command arguments into argument values.
+   *
+   * @param {Function} [fn]
+   * @return {Argument}
+   */
+
+  argParser(fn) {
+    this.parseArg = fn;
+    return this;
+  }
+
+  /**
+   * Only allow argument value to be one of choices.
+   *
+   * @param {string[]} values
+   * @return {Argument}
+   */
+
+  choices(values) {
+    this.argChoices = values.slice();
+    this.parseArg = (arg, previous) => {
+      if (!this.argChoices.includes(arg)) {
+        throw new InvalidArgumentError(`Allowed choices are ${this.argChoices.join(', ')}.`);
+      }
+      if (this.variadic) {
+        return this._concatValue(arg, previous);
+      }
+      return arg;
+    };
+    return this;
+  }
+
+  /**
+   * Make argument required.
+   */
+  argRequired() {
+    this.required = true;
+    return this;
+  }
+
+  /**
+   * Make argument optional.
+   */
+  argOptional() {
+    this.required = false;
+    return this;
+  }
+}
+
+/**
+ * Takes an argument and returns its human readable equivalent for help usage.
+ *
+ * @param {Argument} arg
+ * @return {string}
+ * @api private
+ */
+
+function humanReadableArgName(arg) {
+  const nameOutput = arg.name() + (arg.variadic === true ? '...' : '');
+
+  return arg.required
+    ? '<' + nameOutput + '>'
+    : '[' + nameOutput + ']';
+}
+
+exports.Argument = Argument;
+exports.humanReadableArgName = humanReadableArgName;

SerpentRace_Backend/node_modules/z-schema/node_modules/commander/lib/error.js

@@ -0,0 +1,45 @@
+// @ts-check
+
+/**
+ * CommanderError class
+ * @class
+ */
+class CommanderError extends Error {
+  /**
+   * Constructs the CommanderError class
+   * @param {number} exitCode suggested exit code which could be used with process.exit
+   * @param {string} code an id string representing the error
+   * @param {string} message human-readable description of the error
+   * @constructor
+   */
+  constructor(exitCode, code, message) {
+    super(message);
+    // properly capture stack trace in Node.js
+    Error.captureStackTrace(this, this.constructor);
+    this.name = this.constructor.name;
+    this.code = code;
+    this.exitCode = exitCode;
+    this.nestedError = undefined;
+  }
+}
+
+/**
+ * InvalidArgumentError class
+ * @class
+ */
+class InvalidArgumentError extends CommanderError {
+  /**
+   * Constructs the InvalidArgumentError class
+   * @param {string} [message] explanation of why argument is invalid
+   * @constructor
+   */
+  constructor(message) {
+    super(1, 'commander.invalidArgument', message);
+    // properly capture stack trace in Node.js
+    Error.captureStackTrace(this, this.constructor);
+    this.name = this.constructor.name;
+  }
+}
+
+exports.CommanderError = CommanderError;
+exports.InvalidArgumentError = InvalidArgumentError;

SerpentRace_Backend/node_modules/z-schema/node_modules/commander/lib/help.js

@@ -0,0 +1,461 @@
+const { humanReadableArgName } = require('./argument.js');
+
+/**
+ * TypeScript import types for JSDoc, used by Visual Studio Code IntelliSense and `npm run typescript-checkJS`
+ * https://www.typescriptlang.org/docs/handbook/jsdoc-supported-types.html#import-types
+ * @typedef { import("./argument.js").Argument } Argument
+ * @typedef { import("./command.js").Command } Command
+ * @typedef { import("./option.js").Option } Option
+ */
+
+// @ts-check
+
+// Although this is a class, methods are static in style to allow override using subclass or just functions.
+class Help {
+  constructor() {
+    this.helpWidth = undefined;
+    this.sortSubcommands = false;
+    this.sortOptions = false;
+    this.showGlobalOptions = false;
+  }
+
+  /**
+   * Get an array of the visible subcommands. Includes a placeholder for the implicit help command, if there is one.
+   *
+   * @param {Command} cmd
+   * @returns {Command[]}
+   */
+
+  visibleCommands(cmd) {
+    const visibleCommands = cmd.commands.filter(cmd => !cmd._hidden);
+    if (cmd._hasImplicitHelpCommand()) {
+      // Create a command matching the implicit help command.
+      const [, helpName, helpArgs] = cmd._helpCommandnameAndArgs.match(/([^ ]+) *(.*)/);
+      const helpCommand = cmd.createCommand(helpName)
+        .helpOption(false);
+      helpCommand.description(cmd._helpCommandDescription);
+      if (helpArgs) helpCommand.arguments(helpArgs);
+      visibleCommands.push(helpCommand);
+    }
+    if (this.sortSubcommands) {
+      visibleCommands.sort((a, b) => {
+        // @ts-ignore: overloaded return type
+        return a.name().localeCompare(b.name());
+      });
+    }
+    return visibleCommands;
+  }
+
+  /**
+   * Compare options for sort.
+   *
+   * @param {Option} a
+   * @param {Option} b
+   * @returns number
+   */
+  compareOptions(a, b) {
+    const getSortKey = (option) => {
+      // WYSIWYG for order displayed in help. Short used for comparison if present. No special handling for negated.
+      return option.short ? option.short.replace(/^-/, '') : option.long.replace(/^--/, '');
+    };
+    return getSortKey(a).localeCompare(getSortKey(b));
+  }
+
+  /**
+   * Get an array of the visible options. Includes a placeholder for the implicit help option, if there is one.
+   *
+   * @param {Command} cmd
+   * @returns {Option[]}
+   */
+
+  visibleOptions(cmd) {
+    const visibleOptions = cmd.options.filter((option) => !option.hidden);
+    // Implicit help
+    const showShortHelpFlag = cmd._hasHelpOption && cmd._helpShortFlag && !cmd._findOption(cmd._helpShortFlag);
+    const showLongHelpFlag = cmd._hasHelpOption && !cmd._findOption(cmd._helpLongFlag);
+    if (showShortHelpFlag || showLongHelpFlag) {
+      let helpOption;
+      if (!showShortHelpFlag) {
+        helpOption = cmd.createOption(cmd._helpLongFlag, cmd._helpDescription);
+      } else if (!showLongHelpFlag) {
+        helpOption = cmd.createOption(cmd._helpShortFlag, cmd._helpDescription);
+      } else {
+        helpOption = cmd.createOption(cmd._helpFlags, cmd._helpDescription);
+      }
+      visibleOptions.push(helpOption);
+    }
+    if (this.sortOptions) {
+      visibleOptions.sort(this.compareOptions);
+    }
+    return visibleOptions;
+  }
+
+  /**
+   * Get an array of the visible global options. (Not including help.)
+   *
+   * @param {Command} cmd
+   * @returns {Option[]}
+   */
+
+  visibleGlobalOptions(cmd) {
+    if (!this.showGlobalOptions) return [];
+
+    const globalOptions = [];
+    for (let parentCmd = cmd.parent; parentCmd; parentCmd = parentCmd.parent) {
+      const visibleOptions = parentCmd.options.filter((option) => !option.hidden);
+      globalOptions.push(...visibleOptions);
+    }
+    if (this.sortOptions) {
+      globalOptions.sort(this.compareOptions);
+    }
+    return globalOptions;
+  }
+
+  /**
+   * Get an array of the arguments if any have a description.
+   *
+   * @param {Command} cmd
+   * @returns {Argument[]}
+   */
+
+  visibleArguments(cmd) {
+    // Side effect! Apply the legacy descriptions before the arguments are displayed.
+    if (cmd._argsDescription) {
+      cmd._args.forEach(argument => {
+        argument.description = argument.description || cmd._argsDescription[argument.name()] || '';
+      });
+    }
+
+    // If there are any arguments with a description then return all the arguments.
+    if (cmd._args.find(argument => argument.description)) {
+      return cmd._args;
+    }
+    return [];
+  }
+
+  /**
+   * Get the command term to show in the list of subcommands.
+   *
+   * @param {Command} cmd
+   * @returns {string}
+   */
+
+  subcommandTerm(cmd) {
+    // Legacy. Ignores custom usage string, and nested commands.
+    const args = cmd._args.map(arg => humanReadableArgName(arg)).join(' ');
+    return cmd._name +
+      (cmd._aliases[0] ? '|' + cmd._aliases[0] : '') +
+      (cmd.options.length ? ' [options]' : '') + // simplistic check for non-help option
+      (args ? ' ' + args : '');
+  }
+
+  /**
+   * Get the option term to show in the list of options.
+   *
+   * @param {Option} option
+   * @returns {string}
+   */
+
+  optionTerm(option) {
+    return option.flags;
+  }
+
+  /**
+   * Get the argument term to show in the list of arguments.
+   *
+   * @param {Argument} argument
+   * @returns {string}
+   */
+
+  argumentTerm(argument) {
+    return argument.name();
+  }
+
+  /**
+   * Get the longest command term length.
+   *
+   * @param {Command} cmd
+   * @param {Help} helper
+   * @returns {number}
+   */
+
+  longestSubcommandTermLength(cmd, helper) {
+    return helper.visibleCommands(cmd).reduce((max, command) => {
+      return Math.max(max, helper.subcommandTerm(command).length);
+    }, 0);
+  }
+
+  /**
+   * Get the longest option term length.
+   *
+   * @param {Command} cmd
+   * @param {Help} helper
+   * @returns {number}
+   */
+
+  longestOptionTermLength(cmd, helper) {
+    return helper.visibleOptions(cmd).reduce((max, option) => {
+      return Math.max(max, helper.optionTerm(option).length);
+    }, 0);
+  }
+
+  /**
+   * Get the longest global option term length.
+   *
+   * @param {Command} cmd
+   * @param {Help} helper
+   * @returns {number}
+   */
+
+  longestGlobalOptionTermLength(cmd, helper) {
+    return helper.visibleGlobalOptions(cmd).reduce((max, option) => {
+      return Math.max(max, helper.optionTerm(option).length);
+    }, 0);
+  }
+
+  /**
+   * Get the longest argument term length.
+   *
+   * @param {Command} cmd
+   * @param {Help} helper
+   * @returns {number}
+   */
+
+  longestArgumentTermLength(cmd, helper) {
+    return helper.visibleArguments(cmd).reduce((max, argument) => {
+      return Math.max(max, helper.argumentTerm(argument).length);
+    }, 0);
+  }
+
+  /**
+   * Get the command usage to be displayed at the top of the built-in help.
+   *
+   * @param {Command} cmd
+   * @returns {string}
+   */
+
+  commandUsage(cmd) {
+    // Usage
+    let cmdName = cmd._name;
+    if (cmd._aliases[0]) {
+      cmdName = cmdName + '|' + cmd._aliases[0];
+    }
+    let parentCmdNames = '';
+    for (let parentCmd = cmd.parent; parentCmd; parentCmd = parentCmd.parent) {
+      parentCmdNames = parentCmd.name() + ' ' + parentCmdNames;
+    }
+    return parentCmdNames + cmdName + ' ' + cmd.usage();
+  }
+
+  /**
+   * Get the description for the command.
+   *
+   * @param {Command} cmd
+   * @returns {string}
+   */
+
+  commandDescription(cmd) {
+    // @ts-ignore: overloaded return type
+    return cmd.description();
+  }
+
+  /**
+   * Get the subcommand summary to show in the list of subcommands.
+   * (Fallback to description for backwards compatibility.)
+   *
+   * @param {Command} cmd
+   * @returns {string}
+   */
+
+  subcommandDescription(cmd) {
+    // @ts-ignore: overloaded return type
+    return cmd.summary() || cmd.description();
+  }
+
+  /**
+   * Get the option description to show in the list of options.
+   *
+   * @param {Option} option
+   * @return {string}
+   */
+
+  optionDescription(option) {
+    const extraInfo = [];
+
+    if (option.argChoices) {
+      extraInfo.push(
+        // use stringify to match the display of the default value
+        `choices: ${option.argChoices.map((choice) => JSON.stringify(choice)).join(', ')}`);
+    }
+    if (option.defaultValue !== undefined) {
+      // default for boolean and negated more for programmer than end user,
+      // but show true/false for boolean option as may be for hand-rolled env or config processing.
+      const showDefault = option.required || option.optional ||
+        (option.isBoolean() && typeof option.defaultValue === 'boolean');
+      if (showDefault) {
+        extraInfo.push(`default: ${option.defaultValueDescription || JSON.stringify(option.defaultValue)}`);
+      }
+    }
+    // preset for boolean and negated are more for programmer than end user
+    if (option.presetArg !== undefined && option.optional) {
+      extraInfo.push(`preset: ${JSON.stringify(option.presetArg)}`);
+    }
+    if (option.envVar !== undefined) {
+      extraInfo.push(`env: ${option.envVar}`);
+    }
+    if (extraInfo.length > 0) {
+      return `${option.description} (${extraInfo.join(', ')})`;
+    }
+
+    return option.description;
+  }
+
+  /**
+   * Get the argument description to show in the list of arguments.
+   *
+   * @param {Argument} argument
+   * @return {string}
+   */
+
+  argumentDescription(argument) {
+    const extraInfo = [];
+    if (argument.argChoices) {
+      extraInfo.push(
+        // use stringify to match the display of the default value
+        `choices: ${argument.argChoices.map((choice) => JSON.stringify(choice)).join(', ')}`);
+    }
+    if (argument.defaultValue !== undefined) {
+      extraInfo.push(`default: ${argument.defaultValueDescription || JSON.stringify(argument.defaultValue)}`);
+    }
+    if (extraInfo.length > 0) {
+      const extraDescripton = `(${extraInfo.join(', ')})`;
+      if (argument.description) {
+        return `${argument.description} ${extraDescripton}`;
+      }
+      return extraDescripton;
+    }
+    return argument.description;
+  }
+
+  /**
+   * Generate the built-in help text.
+   *
+   * @param {Command} cmd
+   * @param {Help} helper
+   * @returns {string}
+   */
+
+  formatHelp(cmd, helper) {
+    const termWidth = helper.padWidth(cmd, helper);
+    const helpWidth = helper.helpWidth || 80;
+    const itemIndentWidth = 2;
+    const itemSeparatorWidth = 2; // between term and description
+    function formatItem(term, description) {
+      if (description) {
+        const fullText = `${term.padEnd(termWidth + itemSeparatorWidth)}${description}`;
+        return helper.wrap(fullText, helpWidth - itemIndentWidth, termWidth + itemSeparatorWidth);
+      }
+      return term;
+    }
+    function formatList(textArray) {
+      return textArray.join('\n').replace(/^/gm, ' '.repeat(itemIndentWidth));
+    }
+
+    // Usage
+    let output = [`Usage: ${helper.commandUsage(cmd)}`, ''];
+
+    // Description
+    const commandDescription = helper.commandDescription(cmd);
+    if (commandDescription.length > 0) {
+      output = output.concat([commandDescription, '']);
+    }
+
+    // Arguments
+    const argumentList = helper.visibleArguments(cmd).map((argument) => {
+      return formatItem(helper.argumentTerm(argument), helper.argumentDescription(argument));
+    });
+    if (argumentList.length > 0) {
+      output = output.concat(['Arguments:', formatList(argumentList), '']);
+    }
+
+    // Options
+    const optionList = helper.visibleOptions(cmd).map((option) => {
+      return formatItem(helper.optionTerm(option), helper.optionDescription(option));
+    });
+    if (optionList.length > 0) {
+      output = output.concat(['Options:', formatList(optionList), '']);
+    }
+
+    if (this.showGlobalOptions) {
+      const globalOptionList = helper.visibleGlobalOptions(cmd).map((option) => {
+        return formatItem(helper.optionTerm(option), helper.optionDescription(option));
+      });
+      if (globalOptionList.length > 0) {
+        output = output.concat(['Global Options:', formatList(globalOptionList), '']);
+      }
+    }
+
+    // Commands
+    const commandList = helper.visibleCommands(cmd).map((cmd) => {
+      return formatItem(helper.subcommandTerm(cmd), helper.subcommandDescription(cmd));
+    });
+    if (commandList.length > 0) {
+      output = output.concat(['Commands:', formatList(commandList), '']);
+    }
+
+    return output.join('\n');
+  }
+
+  /**
+   * Calculate the pad width from the maximum term length.
+   *
+   * @param {Command} cmd
+   * @param {Help} helper
+   * @returns {number}
+   */
+
+  padWidth(cmd, helper) {
+    return Math.max(
+      helper.longestOptionTermLength(cmd, helper),
+      helper.longestGlobalOptionTermLength(cmd, helper),
+      helper.longestSubcommandTermLength(cmd, helper),
+      helper.longestArgumentTermLength(cmd, helper)
+    );
+  }
+
+  /**
+   * Wrap the given string to width characters per line, with lines after the first indented.
+   * Do not wrap if insufficient room for wrapping (minColumnWidth), or string is manually formatted.
+   *
+   * @param {string} str
+   * @param {number} width
+   * @param {number} indent
+   * @param {number} [minColumnWidth=40]
+   * @return {string}
+   *
+   */
+
+  wrap(str, width, indent, minColumnWidth = 40) {
+    // Detect manually wrapped and indented strings by searching for line breaks
+    // followed by multiple spaces/tabs.
+    if (str.match(/[\n]\s+/)) return str;
+    // Do not wrap if not enough room for a wrapped column of text (as could end up with a word per line).
+    const columnWidth = width - indent;
+    if (columnWidth < minColumnWidth) return str;
+
+    const leadingStr = str.slice(0, indent);
+    const columnText = str.slice(indent);
+
+    const indentString = ' '.repeat(indent);
+    const regex = new RegExp('.{1,' + (columnWidth - 1) + '}([\\s\u200B]|$)|[^\\s\u200B]+?([\\s\u200B]|$)', 'g');
+    const lines = columnText.match(regex) || [];
+    return leadingStr + lines.map((line, i) => {
+      if (line.slice(-1) === '\n') {
+        line = line.slice(0, line.length - 1);
+      }
+      return ((i > 0) ? indentString : '') + line.trimRight();
+    }).join('\n');
+  }
+}
+
+exports.Help = Help;

SerpentRace_Backend/node_modules/z-schema/node_modules/commander/lib/option.js

@@ -0,0 +1,326 @@
+const { InvalidArgumentError } = require('./error.js');
+
+// @ts-check
+
+class Option {
+  /**
+   * Initialize a new `Option` with the given `flags` and `description`.
+   *
+   * @param {string} flags
+   * @param {string} [description]
+   */
+
+  constructor(flags, description) {
+    this.flags = flags;
+    this.description = description || '';
+
+    this.required = flags.includes('<'); // A value must be supplied when the option is specified.
+    this.optional = flags.includes('['); // A value is optional when the option is specified.
+    // variadic test ignores <value,...> et al which might be used to describe custom splitting of single argument
+    this.variadic = /\w\.\.\.[>\]]$/.test(flags); // The option can take multiple values.
+    this.mandatory = false; // The option must have a value after parsing, which usually means it must be specified on command line.
+    const optionFlags = splitOptionFlags(flags);
+    this.short = optionFlags.shortFlag;
+    this.long = optionFlags.longFlag;
+    this.negate = false;
+    if (this.long) {
+      this.negate = this.long.startsWith('--no-');
+    }
+    this.defaultValue = undefined;
+    this.defaultValueDescription = undefined;
+    this.presetArg = undefined;
+    this.envVar = undefined;
+    this.parseArg = undefined;
+    this.hidden = false;
+    this.argChoices = undefined;
+    this.conflictsWith = [];
+    this.implied = undefined;
+  }
+
+  /**
+   * Set the default value, and optionally supply the description to be displayed in the help.
+   *
+   * @param {any} value
+   * @param {string} [description]
+   * @return {Option}
+   */
+
+  default(value, description) {
+    this.defaultValue = value;
+    this.defaultValueDescription = description;
+    return this;
+  }
+
+  /**
+   * Preset to use when option used without option-argument, especially optional but also boolean and negated.
+   * The custom processing (parseArg) is called.
+   *
+   * @example
+   * new Option('--color').default('GREYSCALE').preset('RGB');
+   * new Option('--donate [amount]').preset('20').argParser(parseFloat);
+   *
+   * @param {any} arg
+   * @return {Option}
+   */
+
+  preset(arg) {
+    this.presetArg = arg;
+    return this;
+  }
+
+  /**
+   * Add option name(s) that conflict with this option.
+   * An error will be displayed if conflicting options are found during parsing.
+   *
+   * @example
+   * new Option('--rgb').conflicts('cmyk');
+   * new Option('--js').conflicts(['ts', 'jsx']);
+   *
+   * @param {string | string[]} names
+   * @return {Option}
+   */
+
+  conflicts(names) {
+    this.conflictsWith = this.conflictsWith.concat(names);
+    return this;
+  }
+
+  /**
+   * Specify implied option values for when this option is set and the implied options are not.
+   *
+   * The custom processing (parseArg) is not called on the implied values.
+   *
+   * @example
+   * program
+   *   .addOption(new Option('--log', 'write logging information to file'))
+   *   .addOption(new Option('--trace', 'log extra details').implies({ log: 'trace.txt' }));
+   *
+   * @param {Object} impliedOptionValues
+   * @return {Option}
+   */
+  implies(impliedOptionValues) {
+    this.implied = Object.assign(this.implied || {}, impliedOptionValues);
+    return this;
+  }
+
+  /**
+   * Set environment variable to check for option value.
+   *
+   * An environment variable is only used if when processed the current option value is
+   * undefined, or the source of the current value is 'default' or 'config' or 'env'.
+   *
+   * @param {string} name
+   * @return {Option}
+   */
+
+  env(name) {
+    this.envVar = name;
+    return this;
+  }
+
+  /**
+   * Set the custom handler for processing CLI option arguments into option values.
+   *
+   * @param {Function} [fn]
+   * @return {Option}
+   */
+
+  argParser(fn) {
+    this.parseArg = fn;
+    return this;
+  }
+
+  /**
+   * Whether the option is mandatory and must have a value after parsing.
+   *
+   * @param {boolean} [mandatory=true]
+   * @return {Option}
+   */
+
+  makeOptionMandatory(mandatory = true) {
+    this.mandatory = !!mandatory;
+    return this;
+  }
+
+  /**
+   * Hide option in help.
+   *
+   * @param {boolean} [hide=true]
+   * @return {Option}
+   */
+
+  hideHelp(hide = true) {
+    this.hidden = !!hide;
+    return this;
+  }
+
+  /**
+   * @api private
+   */
+
+  _concatValue(value, previous) {
+    if (previous === this.defaultValue || !Array.isArray(previous)) {
+      return [value];
+    }
+
+    return previous.concat(value);
+  }
+
+  /**
+   * Only allow option value to be one of choices.
+   *
+   * @param {string[]} values
+   * @return {Option}
+   */
+
+  choices(values) {
+    this.argChoices = values.slice();
+    this.parseArg = (arg, previous) => {
+      if (!this.argChoices.includes(arg)) {
+        throw new InvalidArgumentError(`Allowed choices are ${this.argChoices.join(', ')}.`);
+      }
+      if (this.variadic) {
+        return this._concatValue(arg, previous);
+      }
+      return arg;
+    };
+    return this;
+  }
+
+  /**
+   * Return option name.
+   *
+   * @return {string}
+   */
+
+  name() {
+    if (this.long) {
+      return this.long.replace(/^--/, '');
+    }
+    return this.short.replace(/^-/, '');
+  }
+
+  /**
+   * Return option name, in a camelcase format that can be used
+   * as a object attribute key.
+   *
+   * @return {string}
+   * @api private
+   */
+
+  attributeName() {
+    return camelcase(this.name().replace(/^no-/, ''));
+  }
+
+  /**
+   * Check if `arg` matches the short or long flag.
+   *
+   * @param {string} arg
+   * @return {boolean}
+   * @api private
+   */
+
+  is(arg) {
+    return this.short === arg || this.long === arg;
+  }
+
+  /**
+   * Return whether a boolean option.
+   *
+   * Options are one of boolean, negated, required argument, or optional argument.
+   *
+   * @return {boolean}
+   * @api private
+   */
+
+  isBoolean() {
+    return !this.required && !this.optional && !this.negate;
+  }
+}
+
+/**
+ * This class is to make it easier to work with dual options, without changing the existing
+ * implementation. We support separate dual options for separate positive and negative options,
+ * like `--build` and `--no-build`, which share a single option value. This works nicely for some
+ * use cases, but is tricky for others where we want separate behaviours despite
+ * the single shared option value.
+ */
+class DualOptions {
+  /**
+   * @param {Option[]} options
+   */
+  constructor(options) {
+    this.positiveOptions = new Map();
+    this.negativeOptions = new Map();
+    this.dualOptions = new Set();
+    options.forEach(option => {
+      if (option.negate) {
+        this.negativeOptions.set(option.attributeName(), option);
+      } else {
+        this.positiveOptions.set(option.attributeName(), option);
+      }
+    });
+    this.negativeOptions.forEach((value, key) => {
+      if (this.positiveOptions.has(key)) {
+        this.dualOptions.add(key);
+      }
+    });
+  }
+
+  /**
+   * Did the value come from the option, and not from possible matching dual option?
+   *
+   * @param {any} value
+   * @param {Option} option
+   * @returns {boolean}
+   */
+  valueFromOption(value, option) {
+    const optionKey = option.attributeName();
+    if (!this.dualOptions.has(optionKey)) return true;
+
+    // Use the value to deduce if (probably) came from the option.
+    const preset = this.negativeOptions.get(optionKey).presetArg;
+    const negativeValue = (preset !== undefined) ? preset : false;
+    return option.negate === (negativeValue === value);
+  }
+}
+
+/**
+ * Convert string from kebab-case to camelCase.
+ *
+ * @param {string} str
+ * @return {string}
+ * @api private
+ */
+
+function camelcase(str) {
+  return str.split('-').reduce((str, word) => {
+    return str + word[0].toUpperCase() + word.slice(1);
+  });
+}
+
+/**
+ * Split the short and long flag out of something like '-m,--mixed <value>'
+ *
+ * @api private
+ */
+
+function splitOptionFlags(flags) {
+  let shortFlag;
+  let longFlag;
+  // Use original very loose parsing to maintain backwards compatibility for now,
+  // which allowed for example unintended `-sw, --short-word` [sic].
+  const flagParts = flags.split(/[ |,]+/);
+  if (flagParts.length > 1 && !/^[[<]/.test(flagParts[1])) shortFlag = flagParts.shift();
+  longFlag = flagParts.shift();
+  // Add support for lone short flag without significantly changing parsing!
+  if (!shortFlag && /^-[^-]$/.test(longFlag)) {
+    shortFlag = longFlag;
+    longFlag = undefined;
+  }
+  return { shortFlag, longFlag };
+}
+
+exports.Option = Option;
+exports.splitOptionFlags = splitOptionFlags;
+exports.DualOptions = DualOptions;

SerpentRace_Backend/node_modules/z-schema/node_modules/commander/lib/suggestSimilar.js

@@ -0,0 +1,100 @@
+const maxDistance = 3;
+
+function editDistance(a, b) {
+  // https://en.wikipedia.org/wiki/Damerau–Levenshtein_distance
+  // Calculating optimal string alignment distance, no substring is edited more than once.
+  // (Simple implementation.)
+
+  // Quick early exit, return worst case.
+  if (Math.abs(a.length - b.length) > maxDistance) return Math.max(a.length, b.length);
+
+  // distance between prefix substrings of a and b
+  const d = [];
+
+  // pure deletions turn a into empty string
+  for (let i = 0; i <= a.length; i++) {
+    d[i] = [i];
+  }
+  // pure insertions turn empty string into b
+  for (let j = 0; j <= b.length; j++) {
+    d[0][j] = j;
+  }
+
+  // fill matrix
+  for (let j = 1; j <= b.length; j++) {
+    for (let i = 1; i <= a.length; i++) {
+      let cost = 1;
+      if (a[i - 1] === b[j - 1]) {
+        cost = 0;
+      } else {
+        cost = 1;
+      }
+      d[i][j] = Math.min(
+        d[i - 1][j] + 1, // deletion
+        d[i][j - 1] + 1, // insertion
+        d[i - 1][j - 1] + cost // substitution
+      );
+      // transposition
+      if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
+        d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + 1);
+      }
+    }
+  }
+
+  return d[a.length][b.length];
+}
+
+/**
+ * Find close matches, restricted to same number of edits.
+ *
+ * @param {string} word
+ * @param {string[]} candidates
+ * @returns {string}
+ */
+
+function suggestSimilar(word, candidates) {
+  if (!candidates || candidates.length === 0) return '';
+  // remove possible duplicates
+  candidates = Array.from(new Set(candidates));
+
+  const searchingOptions = word.startsWith('--');
+  if (searchingOptions) {
+    word = word.slice(2);
+    candidates = candidates.map(candidate => candidate.slice(2));
+  }
+
+  let similar = [];
+  let bestDistance = maxDistance;
+  const minSimilarity = 0.4;
+  candidates.forEach((candidate) => {
+    if (candidate.length <= 1) return; // no one character guesses
+
+    const distance = editDistance(word, candidate);
+    const length = Math.max(word.length, candidate.length);
+    const similarity = (length - distance) / length;
+    if (similarity > minSimilarity) {
+      if (distance < bestDistance) {
+        // better edit distance, throw away previous worse matches
+        bestDistance = distance;
+        similar = [candidate];
+      } else if (distance === bestDistance) {
+        similar.push(candidate);
+      }
+    }
+  });
+
+  similar.sort((a, b) => a.localeCompare(b));
+  if (searchingOptions) {
+    similar = similar.map(candidate => `--${candidate}`);
+  }
+
+  if (similar.length > 1) {
+    return `\n(Did you mean one of ${similar.join(', ')}?)`;
+  }
+  if (similar.length === 1) {
+    return `\n(Did you mean ${similar[0]}?)`;
+  }
+  return '';
+}
+
+exports.suggestSimilar = suggestSimilar;

SerpentRace_Backend/node_modules/z-schema/node_modules/commander/package-support.json

@@ -0,0 +1,16 @@
+{
+  "versions": [
+    {
+      "version": "*",
+      "target": {
+        "node": "supported"
+      },
+      "response": {
+        "type": "time-permitting"
+      },
+      "backing": {
+        "npm-funding": true
+      }
+    }
+  ]
+}

SerpentRace_Backend/node_modules/z-schema/node_modules/commander/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "commander",
+  "version": "9.5.0",
+  "description": "the complete solution for node.js command-line programs",
+  "keywords": [
+    "commander",
+    "command",
+    "option",
+    "parser",
+    "cli",
+    "argument",
+    "args",
+    "argv"
+  ],
+  "author": "TJ Holowaychuk <tj@vision-media.ca>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tj/commander.js.git"
+  },
+  "scripts": {
+    "lint": "npm run lint:javascript && npm run lint:typescript",
+    "lint:javascript": "eslint index.js esm.mjs \"lib/*.js\" \"tests/**/*.js\"",
+    "lint:typescript": "eslint typings/*.ts tests/*.ts",
+    "test": "jest && npm run test-typings",
+    "test-esm": "node --experimental-modules ./tests/esm-imports-test.mjs",
+    "test-typings": "tsd",
+    "typescript-checkJS": "tsc --allowJS --checkJS index.js lib/*.js --noEmit",
+    "test-all": "npm run test && npm run lint && npm run typescript-checkJS && npm run test-esm"
+  },
+  "files": [
+    "index.js",
+    "lib/*.js",
+    "esm.mjs",
+    "typings/index.d.ts",
+    "package-support.json"
+  ],
+  "type": "commonjs",
+  "main": "./index.js",
+  "exports": {
+    ".": {
+      "types": "./typings/index.d.ts",
+      "require": "./index.js",
+      "import": "./esm.mjs"
+    },
+    "./esm.mjs": "./esm.mjs"
+  },
+  "devDependencies": {
+    "@types/jest": "^28.1.4",
+    "@types/node": "^16.11.15",
+    "@typescript-eslint/eslint-plugin": "^5.30.6",
+    "@typescript-eslint/parser": "^5.30.6",
+    "eslint": "^8.19.0",
+    "eslint-config-standard": "^17.0.0",
+    "eslint-config-standard-with-typescript": "^22.0.0",
+    "eslint-plugin-import": "^2.25.3",
+    "eslint-plugin-jest": "^26.5.3",
+    "eslint-plugin-n": "^15.2.4",
+    "eslint-plugin-promise": "^6.0.0",
+    "jest": "^28.1.2",
+    "ts-jest": "^28.0.5",
+    "tsd": "^0.22.0",
+    "typescript": "^4.7.4"
+  },
+  "types": "typings/index.d.ts",
+  "jest": {
+    "testEnvironment": "node",
+    "collectCoverage": true,
+    "transform": {
+      "^.+\\.tsx?$": "ts-jest"
+    },
+    "testPathIgnorePatterns": [
+      "/node_modules/"
+    ]
+  },
+  "engines": {
+    "node": "^12.20.0 || >=14"
+  },
+  "support": true
+}

SerpentRace_Backend/node_modules/z-schema/node_modules/commander/typings/index.d.ts

@@ -0,0 +1,891 @@
+// Type definitions for commander
+// Original definitions by: Alan Agius <https://github.com/alan-agius4>, Marcelo Dezem <https://github.com/mdezem>, vvakame <https://github.com/vvakame>, Jules Randolph <https://github.com/sveinburne>
+
+// Using method rather than property for method-signature-style, to document method overloads separately. Allow either.
+/* eslint-disable @typescript-eslint/method-signature-style */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+export class CommanderError extends Error {
+  code: string;
+  exitCode: number;
+  message: string;
+  nestedError?: string;
+
+  /**
+   * Constructs the CommanderError class
+   * @param exitCode - suggested exit code which could be used with process.exit
+   * @param code - an id string representing the error
+   * @param message - human-readable description of the error
+   * @constructor
+   */
+  constructor(exitCode: number, code: string, message: string);
+}
+
+export class InvalidArgumentError extends CommanderError {
+  /**
+   * Constructs the InvalidArgumentError class
+   * @param message - explanation of why argument is invalid
+   * @constructor
+   */
+  constructor(message: string);
+}
+export { InvalidArgumentError as InvalidOptionArgumentError }; // deprecated old name
+
+export interface ErrorOptions { // optional parameter for error()
+  /** an id string representing the error */
+  code?: string;
+  /** suggested exit code which could be used with process.exit */
+  exitCode?: number;
+}
+
+export class Argument {
+  description: string;
+  required: boolean;
+  variadic: boolean;
+
+  /**
+   * Initialize a new command argument with the given name and description.
+   * The default is that the argument is required, and you can explicitly
+   * indicate this with <> around the name. Put [] around the name for an optional argument.
+   */
+  constructor(arg: string, description?: string);
+
+  /**
+   * Return argument name.
+   */
+  name(): string;
+
+  /**
+   * Set the default value, and optionally supply the description to be displayed in the help.
+   */
+  default(value: unknown, description?: string): this;
+
+  /**
+   * Set the custom handler for processing CLI command arguments into argument values.
+   */
+  argParser<T>(fn: (value: string, previous: T) => T): this;
+
+  /**
+   * Only allow argument value to be one of choices.
+   */
+  choices(values: readonly string[]): this;
+
+  /**
+   * Make argument required.
+   */
+  argRequired(): this;
+
+  /**
+   * Make argument optional.
+   */
+  argOptional(): this;
+}
+
+export class Option {
+  flags: string;
+  description: string;
+
+  required: boolean; // A value must be supplied when the option is specified.
+  optional: boolean; // A value is optional when the option is specified.
+  variadic: boolean;
+  mandatory: boolean; // The option must have a value after parsing, which usually means it must be specified on command line.
+  optionFlags: string;
+  short?: string;
+  long?: string;
+  negate: boolean;
+  defaultValue?: any;
+  defaultValueDescription?: string;
+  parseArg?: <T>(value: string, previous: T) => T;
+  hidden: boolean;
+  argChoices?: string[];
+
+  constructor(flags: string, description?: string);
+
+  /**
+   * Set the default value, and optionally supply the description to be displayed in the help.
+   */
+  default(value: unknown, description?: string): this;
+
+  /**
+   * Preset to use when option used without option-argument, especially optional but also boolean and negated.
+   * The custom processing (parseArg) is called.
+   *
+   * @example
+   * ```ts
+   * new Option('--color').default('GREYSCALE').preset('RGB');
+   * new Option('--donate [amount]').preset('20').argParser(parseFloat);
+   * ```
+   */
+  preset(arg: unknown): this;
+
+  /**
+   * Add option name(s) that conflict with this option.
+   * An error will be displayed if conflicting options are found during parsing.
+   *
+   * @example
+   * ```ts
+   * new Option('--rgb').conflicts('cmyk');
+   * new Option('--js').conflicts(['ts', 'jsx']);
+   * ```
+   */
+  conflicts(names: string | string[]): this;
+
+  /**
+   * Specify implied option values for when this option is set and the implied options are not.
+   *
+   * The custom processing (parseArg) is not called on the implied values.
+   *
+   * @example
+   * program
+   *   .addOption(new Option('--log', 'write logging information to file'))
+   *   .addOption(new Option('--trace', 'log extra details').implies({ log: 'trace.txt' }));
+   */
+  implies(optionValues: OptionValues): this;
+
+  /**
+   * Set environment variable to check for option value.
+   *
+   * An environment variables is only used if when processed the current option value is
+   * undefined, or the source of the current value is 'default' or 'config' or 'env'.
+   */
+  env(name: string): this;
+
+  /**
+   * Calculate the full description, including defaultValue etc.
+   */
+  fullDescription(): string;
+
+  /**
+   * Set the custom handler for processing CLI option arguments into option values.
+   */
+  argParser<T>(fn: (value: string, previous: T) => T): this;
+
+  /**
+   * Whether the option is mandatory and must have a value after parsing.
+   */
+  makeOptionMandatory(mandatory?: boolean): this;
+
+  /**
+   * Hide option in help.
+   */
+  hideHelp(hide?: boolean): this;
+
+  /**
+   * Only allow option value to be one of choices.
+   */
+  choices(values: readonly string[]): this;
+
+  /**
+   * Return option name.
+   */
+  name(): string;
+
+  /**
+   * Return option name, in a camelcase format that can be used
+   * as a object attribute key.
+   */
+  attributeName(): string;
+
+  /**
+   * Return whether a boolean option.
+   *
+   * Options are one of boolean, negated, required argument, or optional argument.
+   */
+  isBoolean(): boolean;
+}
+
+export class Help {
+  /** output helpWidth, long lines are wrapped to fit */
+  helpWidth?: number;
+  sortSubcommands: boolean;
+  sortOptions: boolean;
+  showGlobalOptions: boolean;
+
+  constructor();
+
+  /** Get the command term to show in the list of subcommands. */
+  subcommandTerm(cmd: Command): string;
+  /** Get the command summary to show in the list of subcommands. */
+  subcommandDescription(cmd: Command): string;
+  /** Get the option term to show in the list of options. */
+  optionTerm(option: Option): string;
+  /** Get the option description to show in the list of options. */
+  optionDescription(option: Option): string;
+  /** Get the argument term to show in the list of arguments. */
+  argumentTerm(argument: Argument): string;
+  /** Get the argument description to show in the list of arguments. */
+  argumentDescription(argument: Argument): string;
+
+  /** Get the command usage to be displayed at the top of the built-in help. */
+  commandUsage(cmd: Command): string;
+  /** Get the description for the command. */
+  commandDescription(cmd: Command): string;
+
+  /** Get an array of the visible subcommands. Includes a placeholder for the implicit help command, if there is one. */
+  visibleCommands(cmd: Command): Command[];
+  /** Get an array of the visible options. Includes a placeholder for the implicit help option, if there is one. */
+  visibleOptions(cmd: Command): Option[];
+  /** Get an array of the visible global options. (Not including help.) */
+  visibleGlobalOptions(cmd: Command): Option[];
+  /** Get an array of the arguments which have descriptions. */
+  visibleArguments(cmd: Command): Argument[];
+
+  /** Get the longest command term length. */
+  longestSubcommandTermLength(cmd: Command, helper: Help): number;
+  /** Get the longest option term length. */
+  longestOptionTermLength(cmd: Command, helper: Help): number;
+  /** Get the longest global option term length. */
+  longestGlobalOptionTermLength(cmd: Command, helper: Help): number;
+  /** Get the longest argument term length. */
+  longestArgumentTermLength(cmd: Command, helper: Help): number;
+  /** Calculate the pad width from the maximum term length. */
+  padWidth(cmd: Command, helper: Help): number;
+
+  /**
+   * Wrap the given string to width characters per line, with lines after the first indented.
+   * Do not wrap if insufficient room for wrapping (minColumnWidth), or string is manually formatted.
+   */
+  wrap(str: string, width: number, indent: number, minColumnWidth?: number): string;
+
+  /** Generate the built-in help text. */
+  formatHelp(cmd: Command, helper: Help): string;
+}
+export type HelpConfiguration = Partial<Help>;
+
+export interface ParseOptions {
+  from: 'node' | 'electron' | 'user';
+}
+export interface HelpContext { // optional parameter for .help() and .outputHelp()
+  error: boolean;
+}
+export interface AddHelpTextContext { // passed to text function used with .addHelpText()
+  error: boolean;
+  command: Command;
+}
+export interface OutputConfiguration {
+  writeOut?(str: string): void;
+  writeErr?(str: string): void;
+  getOutHelpWidth?(): number;
+  getErrHelpWidth?(): number;
+  outputError?(str: string, write: (str: string) => void): void;
+
+}
+
+export type AddHelpTextPosition = 'beforeAll' | 'before' | 'after' | 'afterAll';
+export type HookEvent = 'preSubcommand' | 'preAction' | 'postAction';
+export type OptionValueSource = 'default' | 'config' | 'env' | 'cli' | 'implied';
+
+export interface OptionValues {
+  [key: string]: any;
+}
+
+export class Command {
+  args: string[];
+  processedArgs: any[];
+  commands: Command[];
+  parent: Command | null;
+
+  constructor(name?: string);
+
+  /**
+   * Set the program version to `str`.
+   *
+   * This method auto-registers the "-V, --version" flag
+   * which will print the version number when passed.
+   *
+   * You can optionally supply the  flags and description to override the defaults.
+   */
+  version(str: string, flags?: string, description?: string): this;
+
+  /**
+   * Define a command, implemented using an action handler.
+   *
+   * @remarks
+   * The command description is supplied using `.description`, not as a parameter to `.command`.
+   *
+   * @example
+   * ```ts
+   * program
+   *   .command('clone <source> [destination]')
+   *   .description('clone a repository into a newly created directory')
+   *   .action((source, destination) => {
+   *     console.log('clone command called');
+   *   });
+   * ```
+   *
+   * @param nameAndArgs - command name and arguments, args are  `<required>` or `[optional]` and last may also be `variadic...`
+   * @param opts - configuration options
+   * @returns new command
+   */
+  command(nameAndArgs: string, opts?: CommandOptions): ReturnType<this['createCommand']>;
+  /**
+   * Define a command, implemented in a separate executable file.
+   *
+   * @remarks
+   * The command description is supplied as the second parameter to `.command`.
+   *
+   * @example
+   * ```ts
+   *  program
+   *    .command('start <service>', 'start named service')
+   *    .command('stop [service]', 'stop named service, or all if no name supplied');
+   * ```
+   *
+   * @param nameAndArgs - command name and arguments, args are  `<required>` or `[optional]` and last may also be `variadic...`
+   * @param description - description of executable command
+   * @param opts - configuration options
+   * @returns `this` command for chaining
+   */
+  command(nameAndArgs: string, description: string, opts?: ExecutableCommandOptions): this;
+
+  /**
+   * Factory routine to create a new unattached command.
+   *
+   * See .command() for creating an attached subcommand, which uses this routine to
+   * create the command. You can override createCommand to customise subcommands.
+   */
+  createCommand(name?: string): Command;
+
+  /**
+   * Add a prepared subcommand.
+   *
+   * See .command() for creating an attached subcommand which inherits settings from its parent.
+   *
+   * @returns `this` command for chaining
+   */
+  addCommand(cmd: Command, opts?: CommandOptions): this;
+
+  /**
+   * Factory routine to create a new unattached argument.
+   *
+   * See .argument() for creating an attached argument, which uses this routine to
+   * create the argument. You can override createArgument to return a custom argument.
+   */
+  createArgument(name: string, description?: string): Argument;
+
+  /**
+   * Define argument syntax for command.
+   *
+   * The default is that the argument is required, and you can explicitly
+   * indicate this with <> around the name. Put [] around the name for an optional argument.
+   *
+   * @example
+   * ```
+   * program.argument('<input-file>');
+   * program.argument('[output-file]');
+   * ```
+   *
+   * @returns `this` command for chaining
+   */
+  argument<T>(flags: string, description: string, fn: (value: string, previous: T) => T, defaultValue?: T): this;
+  argument(name: string, description?: string, defaultValue?: unknown): this;
+
+  /**
+   * Define argument syntax for command, adding a prepared argument.
+   *
+   * @returns `this` command for chaining
+   */
+  addArgument(arg: Argument): this;
+
+  /**
+   * Define argument syntax for command, adding multiple at once (without descriptions).
+   *
+   * See also .argument().
+   *
+   * @example
+   * ```
+   * program.arguments('<cmd> [env]');
+   * ```
+   *
+   * @returns `this` command for chaining
+   */
+  arguments(names: string): this;
+
+  /**
+   * Override default decision whether to add implicit help command.
+   *
+   * @example
+   * ```
+   * addHelpCommand() // force on
+   * addHelpCommand(false); // force off
+   * addHelpCommand('help [cmd]', 'display help for [cmd]'); // force on with custom details
+   * ```
+   *
+   * @returns `this` command for chaining
+   */
+  addHelpCommand(enableOrNameAndArgs?: string | boolean, description?: string): this;
+
+  /**
+   * Add hook for life cycle event.
+   */
+  hook(event: HookEvent, listener: (thisCommand: Command, actionCommand: Command) => void | Promise<void>): this;
+
+  /**
+   * Register callback to use as replacement for calling process.exit.
+   */
+  exitOverride(callback?: (err: CommanderError) => never | void): this;
+
+  /**
+   * Display error message and exit (or call exitOverride).
+   */
+  error(message: string, errorOptions?: ErrorOptions): never;
+
+  /**
+   * You can customise the help with a subclass of Help by overriding createHelp,
+   * or by overriding Help properties using configureHelp().
+   */
+  createHelp(): Help;
+
+  /**
+   * You can customise the help by overriding Help properties using configureHelp(),
+   * or with a subclass of Help by overriding createHelp().
+   */
+  configureHelp(configuration: HelpConfiguration): this;
+  /** Get configuration */
+  configureHelp(): HelpConfiguration;
+
+  /**
+   * The default output goes to stdout and stderr. You can customise this for special
+   * applications. You can also customise the display of errors by overriding outputError.
+   *
+   * The configuration properties are all functions:
+   * ```
+   * // functions to change where being written, stdout and stderr
+   * writeOut(str)
+   * writeErr(str)
+   * // matching functions to specify width for wrapping help
+   * getOutHelpWidth()
+   * getErrHelpWidth()
+   * // functions based on what is being written out
+   * outputError(str, write) // used for displaying errors, and not used for displaying help
+   * ```
+   */
+  configureOutput(configuration: OutputConfiguration): this;
+  /** Get configuration */
+  configureOutput(): OutputConfiguration;
+
+  /**
+   * Copy settings that are useful to have in common across root command and subcommands.
+   *
+   * (Used internally when adding a command using `.command()` so subcommands inherit parent settings.)
+   */
+  copyInheritedSettings(sourceCommand: Command): this;
+
+  /**
+   * Display the help or a custom message after an error occurs.
+   */
+  showHelpAfterError(displayHelp?: boolean | string): this;
+
+  /**
+   * Display suggestion of similar commands for unknown commands, or options for unknown options.
+   */
+  showSuggestionAfterError(displaySuggestion?: boolean): this;
+
+  /**
+   * Register callback `fn` for the command.
+   *
+   * @example
+   * ```
+   * program
+   *   .command('serve')
+   *   .description('start service')
+   *   .action(function() {
+   *     // do work here
+   *   });
+   * ```
+   *
+   * @returns `this` command for chaining
+   */
+  action(fn: (...args: any[]) => void | Promise<void>): this;
+
+  /**
+   * Define option with `flags`, `description` and optional
+   * coercion `fn`.
+   *
+   * The `flags` string contains the short and/or long flags,
+   * separated by comma, a pipe or space. The following are all valid
+   * all will output this way when `--help` is used.
+   *
+   *     "-p, --pepper"
+   *     "-p|--pepper"
+   *     "-p --pepper"
+   *
+   * @example
+   * ```
+   * // simple boolean defaulting to false
+   *  program.option('-p, --pepper', 'add pepper');
+   *
+   *  --pepper
+   *  program.pepper
+   *  // => Boolean
+   *
+   *  // simple boolean defaulting to true
+   *  program.option('-C, --no-cheese', 'remove cheese');
+   *
+   *  program.cheese
+   *  // => true
+   *
+   *  --no-cheese
+   *  program.cheese
+   *  // => false
+   *
+   *  // required argument
+   *  program.option('-C, --chdir <path>', 'change the working directory');
+   *
+   *  --chdir /tmp
+   *  program.chdir
+   *  // => "/tmp"
+   *
+   *  // optional argument
+   *  program.option('-c, --cheese [type]', 'add cheese [marble]');
+   * ```
+   *
+   * @returns `this` command for chaining
+   */
+  option(flags: string, description?: string, defaultValue?: string | boolean | string[]): this;
+  option<T>(flags: string, description: string, fn: (value: string, previous: T) => T, defaultValue?: T): this;
+  /** @deprecated since v7, instead use choices or a custom function */
+  option(flags: string, description: string, regexp: RegExp, defaultValue?: string | boolean | string[]): this;
+
+  /**
+   * Define a required option, which must have a value after parsing. This usually means
+   * the option must be specified on the command line. (Otherwise the same as .option().)
+   *
+   * The `flags` string contains the short and/or long flags, separated by comma, a pipe or space.
+   */
+  requiredOption(flags: string, description?: string, defaultValue?: string | boolean | string[]): this;
+  requiredOption<T>(flags: string, description: string, fn: (value: string, previous: T) => T, defaultValue?: T): this;
+  /** @deprecated since v7, instead use choices or a custom function */
+  requiredOption(flags: string, description: string, regexp: RegExp, defaultValue?: string | boolean | string[]): this;
+
+  /**
+   * Factory routine to create a new unattached option.
+   *
+   * See .option() for creating an attached option, which uses this routine to
+   * create the option. You can override createOption to return a custom option.
+   */
+
+  createOption(flags: string, description?: string): Option;
+
+  /**
+   * Add a prepared Option.
+   *
+   * See .option() and .requiredOption() for creating and attaching an option in a single call.
+   */
+  addOption(option: Option): this;
+
+  /**
+   * Whether to store option values as properties on command object,
+   * or store separately (specify false). In both cases the option values can be accessed using .opts().
+   *
+   * @returns `this` command for chaining
+   */
+  storeOptionsAsProperties<T extends OptionValues>(): this & T;
+  storeOptionsAsProperties<T extends OptionValues>(storeAsProperties: true): this & T;
+  storeOptionsAsProperties(storeAsProperties?: boolean): this;
+
+  /**
+   * Retrieve option value.
+   */
+  getOptionValue(key: string): any;
+
+  /**
+   * Store option value.
+   */
+  setOptionValue(key: string, value: unknown): this;
+
+  /**
+   * Store option value and where the value came from.
+   */
+  setOptionValueWithSource(key: string, value: unknown, source: OptionValueSource): this;
+
+  /**
+   * Get source of option value.
+   */
+  getOptionValueSource(key: string): OptionValueSource | undefined;
+
+  /**
+    * Get source of option value. See also .optsWithGlobals().
+   */
+  getOptionValueSourceWithGlobals(key: string): OptionValueSource | undefined;
+
+  /**
+   * Alter parsing of short flags with optional values.
+   *
+   * @example
+   * ```
+   * // for `.option('-f,--flag [value]'):
+   * .combineFlagAndOptionalValue(true)  // `-f80` is treated like `--flag=80`, this is the default behaviour
+   * .combineFlagAndOptionalValue(false) // `-fb` is treated like `-f -b`
+   * ```
+   *
+   * @returns `this` command for chaining
+   */
+  combineFlagAndOptionalValue(combine?: boolean): this;
+
+  /**
+   * Allow unknown options on the command line.
+   *
+   * @returns `this` command for chaining
+   */
+  allowUnknownOption(allowUnknown?: boolean): this;
+
+  /**
+   * Allow excess command-arguments on the command line. Pass false to make excess arguments an error.
+   *
+   * @returns `this` command for chaining
+   */
+  allowExcessArguments(allowExcess?: boolean): this;
+
+  /**
+   * Enable positional options. Positional means global options are specified before subcommands which lets
+   * subcommands reuse the same option names, and also enables subcommands to turn on passThroughOptions.
+   *
+   * The default behaviour is non-positional and global options may appear anywhere on the command line.
+   *
+   * @returns `this` command for chaining
+   */
+  enablePositionalOptions(positional?: boolean): this;
+
+  /**
+   * Pass through options that come after command-arguments rather than treat them as command-options,
+   * so actual command-options come before command-arguments. Turning this on for a subcommand requires
+   * positional options to have been enabled on the program (parent commands).
+   *
+   * The default behaviour is non-positional and options may appear before or after command-arguments.
+   *
+   * @returns `this` command for chaining
+   */
+  passThroughOptions(passThrough?: boolean): this;
+
+  /**
+   * Parse `argv`, setting options and invoking commands when defined.
+   *
+   * The default expectation is that the arguments are from node and have the application as argv[0]
+   * and the script being run in argv[1], with user parameters after that.
+   *
+   * @example
+   * ```
+   * program.parse(process.argv);
+   * program.parse(); // implicitly use process.argv and auto-detect node vs electron conventions
+   * program.parse(my-args, { from: 'user' }); // just user supplied arguments, nothing special about argv[0]
+   * ```
+   *
+   * @returns `this` command for chaining
+   */
+  parse(argv?: readonly string[], options?: ParseOptions): this;
+
+  /**
+   * Parse `argv`, setting options and invoking commands when defined.
+   *
+   * Use parseAsync instead of parse if any of your action handlers are async. Returns a Promise.
+   *
+   * The default expectation is that the arguments are from node and have the application as argv[0]
+   * and the script being run in argv[1], with user parameters after that.
+   *
+   * @example
+   * ```
+   * program.parseAsync(process.argv);
+   * program.parseAsync(); // implicitly use process.argv and auto-detect node vs electron conventions
+   * program.parseAsync(my-args, { from: 'user' }); // just user supplied arguments, nothing special about argv[0]
+   * ```
+   *
+   * @returns Promise
+   */
+  parseAsync(argv?: readonly string[], options?: ParseOptions): Promise<this>;
+
+  /**
+   * Parse options from `argv` removing known options,
+   * and return argv split into operands and unknown arguments.
+   *
+   *     argv => operands, unknown
+   *     --known kkk op => [op], []
+   *     op --known kkk => [op], []
+   *     sub --unknown uuu op => [sub], [--unknown uuu op]
+   *     sub -- --unknown uuu op => [sub --unknown uuu op], []
+   */
+  parseOptions(argv: string[]): ParseOptionsResult;
+
+  /**
+   * Return an object containing local option values as key-value pairs
+   */
+  opts<T extends OptionValues>(): T;
+
+  /**
+   * Return an object containing merged local and global option values as key-value pairs.
+   */
+  optsWithGlobals<T extends OptionValues>(): T;
+
+  /**
+   * Set the description.
+   *
+   * @returns `this` command for chaining
+   */
+
+  description(str: string): this;
+  /** @deprecated since v8, instead use .argument to add command argument with description */
+  description(str: string, argsDescription: {[argName: string]: string}): this;
+  /**
+   * Get the description.
+   */
+  description(): string;
+
+  /**
+   * Set the summary. Used when listed as subcommand of parent.
+   *
+   * @returns `this` command for chaining
+   */
+
+  summary(str: string): this;
+  /**
+   * Get the summary.
+   */
+  summary(): string;
+
+  /**
+   * Set an alias for the command.
+   *
+   * You may call more than once to add multiple aliases. Only the first alias is shown in the auto-generated help.
+   *
+   * @returns `this` command for chaining
+   */
+  alias(alias: string): this;
+  /**
+   * Get alias for the command.
+   */
+  alias(): string;
+
+  /**
+   * Set aliases for the command.
+   *
+   * Only the first alias is shown in the auto-generated help.
+   *
+   * @returns `this` command for chaining
+   */
+  aliases(aliases: readonly string[]): this;
+  /**
+   * Get aliases for the command.
+   */
+  aliases(): string[];
+
+  /**
+   * Set the command usage.
+   *
+   * @returns `this` command for chaining
+   */
+  usage(str: string): this;
+  /**
+   * Get the command usage.
+   */
+  usage(): string;
+
+  /**
+   * Set the name of the command.
+   *
+   * @returns `this` command for chaining
+   */
+  name(str: string): this;
+  /**
+   * Get the name of the command.
+   */
+  name(): string;
+
+  /**
+   * Set the name of the command from script filename, such as process.argv[1],
+   * or require.main.filename, or __filename.
+   *
+   * (Used internally and public although not documented in README.)
+   *
+   * @example
+   * ```ts
+   * program.nameFromFilename(require.main.filename);
+   * ```
+   *
+   * @returns `this` command for chaining
+   */
+  nameFromFilename(filename: string): this;
+
+  /**
+   * Set the directory for searching for executable subcommands of this command.
+   *
+   * @example
+   * ```ts
+   * program.executableDir(__dirname);
+   * // or
+   * program.executableDir('subcommands');
+   * ```
+   *
+   * @returns `this` command for chaining
+   */
+  executableDir(path: string): this;
+  /**
+   * Get the executable search directory.
+   */
+  executableDir(): string;
+
+  /**
+   * Output help information for this command.
+   *
+   * Outputs built-in help, and custom text added using `.addHelpText()`.
+   *
+   */
+  outputHelp(context?: HelpContext): void;
+  /** @deprecated since v7 */
+  outputHelp(cb?: (str: string) => string): void;
+
+  /**
+   * Return command help documentation.
+   */
+  helpInformation(context?: HelpContext): string;
+
+  /**
+   * You can pass in flags and a description to override the help
+   * flags and help description for your command. Pass in false
+   * to disable the built-in help option.
+   */
+  helpOption(flags?: string | boolean, description?: string): this;
+
+  /**
+   * Output help information and exit.
+   *
+   * Outputs built-in help, and custom text added using `.addHelpText()`.
+   */
+  help(context?: HelpContext): never;
+  /** @deprecated since v7 */
+  help(cb?: (str: string) => string): never;
+
+  /**
+   * Add additional text to be displayed with the built-in help.
+   *
+   * Position is 'before' or 'after' to affect just this command,
+   * and 'beforeAll' or 'afterAll' to affect this command and all its subcommands.
+   */
+  addHelpText(position: AddHelpTextPosition, text: string): this;
+  addHelpText(position: AddHelpTextPosition, text: (context: AddHelpTextContext) => string): this;
+
+  /**
+   * Add a listener (callback) for when events occur. (Implemented using EventEmitter.)
+   */
+  on(event: string | symbol, listener: (...args: any[]) => void): this;
+}
+
+export interface CommandOptions {
+  hidden?: boolean;
+  isDefault?: boolean;
+  /** @deprecated since v7, replaced by hidden */
+  noHelp?: boolean;
+}
+export interface ExecutableCommandOptions extends CommandOptions {
+  executableFile?: string;
+}
+
+export interface ParseOptionsResult {
+  operands: string[];
+  unknown: string[];
+}
+
+export function createCommand(name?: string): Command;
+export function createOption(flags: string, description?: string): Option;
+export function createArgument(name: string, description?: string): Argument;
+
+export const program: Command;

SerpentRace_Backend/node_modules/z-schema/package.json

@@ -0,0 +1,91 @@
+{
+  "name": "z-schema",
+  "version": "5.0.5",
+  "engines": {
+    "node": ">=8.0.0"
+  },
+  "description": "JSON schema validator",
+  "homepage": "https://github.com/zaggino/z-schema",
+  "authors": [
+    "Martin Zagora <zaggino@gmail.com>"
+  ],
+  "license": "MIT",
+  "keywords": [
+    "JSON",
+    "Schema",
+    "Validator"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zaggino/z-schema.git"
+  },
+  "bugs": {
+    "url": "https://github.com/zaggino/z-schema/issues"
+  },
+  "main": "src/ZSchema.js",
+  "bin": {
+    "z-schema": "./bin/z-schema"
+  },
+  "files": [
+    "bin",
+    "src",
+    "dist",
+    "LICENSE",
+    "README.md",
+    "index.d.ts"
+  ],
+  "types": "index.d.ts",
+  "scripts": {
+    "prepare": "grunt",
+    "prepublishOnly": "npm test",
+    "test": "jasmine-node test/ && grunt lint",
+    "test-z": "jasmine-node test/spec/ZSchemaTestSuiteSpec.js",
+    "grunt": "grunt"
+  },
+  "testling": {
+    "scripts": [
+      "test/lib/jasmine-2.0.1/jasmine.js",
+      "test/lib/jasmine-2.0.1/jasmine-html.js",
+      "test/lib/jasmine-2.0.1/boot.js",
+      "test/lib/jasmine-2.0.1/tap_reporter.js",
+      "test/Runner.js",
+      "dist/ZSchema-browser-min.js",
+      "dist/ZSchema-browser-test.js"
+    ],
+    "browsers": [
+      "iexplore/9..latest",
+      "chrome/4",
+      "chrome/28..latest",
+      "firefox/3.5",
+      "firefox/23..latest",
+      "safari/5.1..latest",
+      "opera/12..latest",
+      "iphone/6..latest",
+      "ipad/6..latest",
+      "android-browser/4.2..latest"
+    ]
+  },
+  "dependencies": {
+    "lodash.get": "^4.4.2",
+    "lodash.isequal": "^4.5.0",
+    "validator": "^13.7.0"
+  },
+  "optionalDependencies": {
+    "commander": "^9.4.1"
+  },
+  "devDependencies": {
+    "coveralls": "^3.1.1",
+    "grunt": "^1.4.1",
+    "grunt-browserify": "^5.3.0",
+    "grunt-cli": "^1.4.3",
+    "grunt-contrib-copy": "^1.0.0",
+    "grunt-contrib-jasmine": "^1.2.0",
+    "grunt-contrib-jshint": "^2.1.0",
+    "grunt-contrib-uglify": "^3.4.0",
+    "grunt-jscs": "^3.0.1",
+    "grunt-lineending": "^1.0.0",
+    "jasmine-node": "^1.14.5",
+    "jasmine-reporters": "^2.5.0",
+    "remapify": "^2.2.0"
+  }
+}

SerpentRace_Backend/node_modules/z-schema/src/Errors.js

@@ -0,0 +1,60 @@
+"use strict";
+
+module.exports = {
+
+    INVALID_TYPE:                           "Expected type {0} but found type {1}",
+    INVALID_FORMAT:                         "Object didn't pass validation for format {0}: {1}",
+    ENUM_MISMATCH:                          "No enum match for: {0}",
+    ENUM_CASE_MISMATCH:                     "Enum does not match case for: {0}",
+    ANY_OF_MISSING:                         "Data does not match any schemas from 'anyOf'",
+    ONE_OF_MISSING:                         "Data does not match any schemas from 'oneOf'",
+    ONE_OF_MULTIPLE:                        "Data is valid against more than one schema from 'oneOf'",
+    NOT_PASSED:                             "Data matches schema from 'not'",
+
+    // Array errors
+    ARRAY_LENGTH_SHORT:                     "Array is too short ({0}), minimum {1}",
+    ARRAY_LENGTH_LONG:                      "Array is too long ({0}), maximum {1}",
+    ARRAY_UNIQUE:                           "Array items are not unique (indexes {0} and {1})",
+    ARRAY_ADDITIONAL_ITEMS:                 "Additional items not allowed",
+
+    // Numeric errors
+    MULTIPLE_OF:                            "Value {0} is not a multiple of {1}",
+    MINIMUM:                                "Value {0} is less than minimum {1}",
+    MINIMUM_EXCLUSIVE:                      "Value {0} is equal or less than exclusive minimum {1}",
+    MAXIMUM:                                "Value {0} is greater than maximum {1}",
+    MAXIMUM_EXCLUSIVE:                      "Value {0} is equal or greater than exclusive maximum {1}",
+
+    // Object errors
+    OBJECT_PROPERTIES_MINIMUM:              "Too few properties defined ({0}), minimum {1}",
+    OBJECT_PROPERTIES_MAXIMUM:              "Too many properties defined ({0}), maximum {1}",
+    OBJECT_MISSING_REQUIRED_PROPERTY:       "Missing required property: {0}",
+    OBJECT_ADDITIONAL_PROPERTIES:           "Additional properties not allowed: {0}",
+    OBJECT_DEPENDENCY_KEY:                  "Dependency failed - key must exist: {0} (due to key: {1})",
+
+    // String errors
+    MIN_LENGTH:                             "String is too short ({0} chars), minimum {1}",
+    MAX_LENGTH:                             "String is too long ({0} chars), maximum {1}",
+    PATTERN:                                "String does not match pattern {0}: {1}",
+
+    // Schema validation errors
+    KEYWORD_TYPE_EXPECTED:                  "Keyword '{0}' is expected to be of type '{1}'",
+    KEYWORD_UNDEFINED_STRICT:               "Keyword '{0}' must be defined in strict mode",
+    KEYWORD_UNEXPECTED:                     "Keyword '{0}' is not expected to appear in the schema",
+    KEYWORD_MUST_BE:                        "Keyword '{0}' must be {1}",
+    KEYWORD_DEPENDENCY:                     "Keyword '{0}' requires keyword '{1}'",
+    KEYWORD_PATTERN:                        "Keyword '{0}' is not a valid RegExp pattern: {1}",
+    KEYWORD_VALUE_TYPE:                     "Each element of keyword '{0}' array must be a '{1}'",
+    UNKNOWN_FORMAT:                         "There is no validation function for format '{0}'",
+    CUSTOM_MODE_FORCE_PROPERTIES:           "{0} must define at least one property if present",
+
+    // Remote errors
+    REF_UNRESOLVED:                         "Reference has not been resolved during compilation: {0}",
+    UNRESOLVABLE_REFERENCE:                 "Reference could not be resolved: {0}",
+    SCHEMA_NOT_REACHABLE:                   "Validator was not able to read schema with uri: {0}",
+    SCHEMA_TYPE_EXPECTED:                   "Schema is expected to be of type 'object'",
+    SCHEMA_NOT_AN_OBJECT:                   "Schema is not an object: {0}",
+    ASYNC_TIMEOUT:                          "{0} asynchronous task(s) have timed out after {1} ms",
+    PARENT_SCHEMA_VALIDATION_FAILED:        "Schema failed to validate against its parent schema, see inner errors for details.",
+    REMOTE_NOT_VALID:                       "Remote reference didn't compile successfully: {0}"
+
+};

SerpentRace_Backend/node_modules/z-schema/src/FormatValidators.js

@@ -0,0 +1,129 @@
+/*jshint maxlen: false*/
+
+var validator = require("validator");
+
+var FormatValidators = {
+    "date": function (date) {
+        if (typeof date !== "string") {
+            return true;
+        }
+        // full-date from http://tools.ietf.org/html/rfc3339#section-5.6
+        var matches = /^([0-9]{4})-([0-9]{2})-([0-9]{2})$/.exec(date);
+        if (matches === null) {
+            return false;
+        }
+        // var year = matches[1];
+        // var month = matches[2];
+        // var day = matches[3];
+        if (matches[2] < "01" || matches[2] > "12" || matches[3] < "01" || matches[3] > "31") {
+            return false;
+        }
+        return true;
+    },
+    "date-time": function (dateTime) {
+        if (typeof dateTime !== "string") {
+            return true;
+        }
+        // date-time from http://tools.ietf.org/html/rfc3339#section-5.6
+        var s = dateTime.toLowerCase().split("t");
+        if (!FormatValidators.date(s[0])) {
+            return false;
+        }
+        var matches = /^([0-9]{2}):([0-9]{2}):([0-9]{2})(.[0-9]+)?(z|([+-][0-9]{2}:[0-9]{2}))$/.exec(s[1]);
+        if (matches === null) {
+            return false;
+        }
+        // var hour = matches[1];
+        // var minute = matches[2];
+        // var second = matches[3];
+        // var fraction = matches[4];
+        // var timezone = matches[5];
+        if (matches[1] > "23" || matches[2] > "59" || matches[3] > "59") {
+            return false;
+        }
+        return true;
+    },
+    "email": function (email) {
+        if (typeof email !== "string") {
+            return true;
+        }
+        return validator.isEmail(email, { "require_tld": true });
+    },
+    "hostname": function (hostname) {
+        if (typeof hostname !== "string") {
+            return true;
+        }
+        /*
+            http://json-schema.org/latest/json-schema-validation.html#anchor114
+            A string instance is valid against this attribute if it is a valid
+            representation for an Internet host name, as defined by RFC 1034, section 3.1 [RFC1034].
+
+            http://tools.ietf.org/html/rfc1034#section-3.5
+
+            <digit> ::= any one of the ten digits 0 through 9
+            var digit = /[0-9]/;
+
+            <letter> ::= any one of the 52 alphabetic characters A through Z in upper case and a through z in lower case
+            var letter = /[a-zA-Z]/;
+
+            <let-dig> ::= <letter> | <digit>
+            var letDig = /[0-9a-zA-Z]/;
+
+            <let-dig-hyp> ::= <let-dig> | "-"
+            var letDigHyp = /[-0-9a-zA-Z]/;
+
+            <ldh-str> ::= <let-dig-hyp> | <let-dig-hyp> <ldh-str>
+            var ldhStr = /[-0-9a-zA-Z]+/;
+
+            <label> ::= <letter> [ [ <ldh-str> ] <let-dig> ]
+            var label = /[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?/;
+
+            <subdomain> ::= <label> | <subdomain> "." <label>
+            var subdomain = /^[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?(\.[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?)*$/;
+
+            <domain> ::= <subdomain> | " "
+            var domain = null;
+        */
+        var valid = /^[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?(\.[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?)*$/.test(hostname);
+        if (valid) {
+            // the sum of all label octets and label lengths is limited to 255.
+            if (hostname.length > 255) { return false; }
+            // Each node has a label, which is zero to 63 octets in length
+            var labels = hostname.split(".");
+            for (var i = 0; i < labels.length; i++) { if (labels[i].length > 63) { return false; } }
+        }
+        return valid;
+    },
+    "host-name": function (hostname) {
+        return FormatValidators.hostname.call(this, hostname);
+    },
+    "ipv4": function (ipv4) {
+        if (typeof ipv4 !== "string") { return true; }
+        return validator.isIP(ipv4, 4);
+    },
+    "ipv6": function (ipv6) {
+        if (typeof ipv6 !== "string") { return true; }
+        return validator.isIP(ipv6, 6);
+    },
+    "regex": function (str) {
+        try {
+            RegExp(str);
+            return true;
+        } catch (e) {
+            return false;
+        }
+    },
+    "uri": function (uri) {
+        if (this.options.strictUris) {
+            return FormatValidators["strict-uri"].apply(this, arguments);
+        }
+        // https://github.com/zaggino/z-schema/issues/18
+        // RegExp from http://tools.ietf.org/html/rfc3986#appendix-B
+        return typeof uri !== "string" || RegExp("^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?").test(uri);
+    },
+    "strict-uri": function (uri) {
+        return typeof uri !== "string" || validator.isURL(uri);
+    }
+};
+
+module.exports = FormatValidators;

SerpentRace_Backend/node_modules/z-schema/src/JsonValidation.js

@@ -0,0 +1,621 @@
+"use strict";
+
+var FormatValidators = require("./FormatValidators"),
+    Report           = require("./Report"),
+    Utils            = require("./Utils");
+
+var shouldSkipValidate = function (options, errors) {
+    return options &&
+        Array.isArray(options.includeErrors) &&
+        options.includeErrors.length > 0 &&
+        !errors.some(function (err) { return options.includeErrors.includes(err);});
+};
+
+var JsonValidators = {
+    multipleOf: function (report, schema, json) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.1.1.2
+        if (shouldSkipValidate(this.validateOptions, ["MULTIPLE_OF"])) {
+            return;
+        }
+        if (typeof json !== "number") {
+            return;
+        }
+
+        var stringMultipleOf = String(schema.multipleOf);
+        var scale = Math.pow(10, stringMultipleOf.length - stringMultipleOf.indexOf(".") - 1);
+        if (Utils.whatIs((json * scale) / (schema.multipleOf * scale)) !== "integer") {
+            report.addError("MULTIPLE_OF", [json, schema.multipleOf], null, schema);
+        }
+    },
+    maximum: function (report, schema, json) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.1.2.2
+        if (shouldSkipValidate(this.validateOptions, ["MAXIMUM", "MAXIMUM_EXCLUSIVE"])) {
+            return;
+        }
+        if (typeof json !== "number") {
+            return;
+        }
+        if (schema.exclusiveMaximum !== true) {
+            if (json > schema.maximum) {
+                report.addError("MAXIMUM", [json, schema.maximum], null, schema);
+            }
+        } else {
+            if (json >= schema.maximum) {
+                report.addError("MAXIMUM_EXCLUSIVE", [json, schema.maximum], null, schema);
+            }
+        }
+    },
+    exclusiveMaximum: function () {
+        // covered in maximum
+    },
+    minimum: function (report, schema, json) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.1.3.2
+        if (shouldSkipValidate(this.validateOptions, ["MINIMUM", "MINIMUM_EXCLUSIVE"])) {
+            return;
+        }
+        if (typeof json !== "number") {
+            return;
+        }
+        if (schema.exclusiveMinimum !== true) {
+            if (json < schema.minimum) {
+                report.addError("MINIMUM", [json, schema.minimum], null, schema);
+            }
+        } else {
+            if (json <= schema.minimum) {
+                report.addError("MINIMUM_EXCLUSIVE", [json, schema.minimum], null, schema);
+            }
+        }
+    },
+    exclusiveMinimum: function () {
+        // covered in minimum
+    },
+    maxLength: function (report, schema, json) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.2.1.2
+        if (shouldSkipValidate(this.validateOptions, ["MAX_LENGTH"])) {
+            return;
+        }
+        if (typeof json !== "string") {
+            return;
+        }
+        if (Utils.ucs2decode(json).length > schema.maxLength) {
+            report.addError("MAX_LENGTH", [json.length, schema.maxLength], null, schema);
+        }
+    },
+    minLength: function (report, schema, json) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.2.2.2
+        if (shouldSkipValidate(this.validateOptions, ["MIN_LENGTH"])) {
+            return;
+        }
+        if (typeof json !== "string") {
+            return;
+        }
+        if (Utils.ucs2decode(json).length < schema.minLength) {
+            report.addError("MIN_LENGTH", [json.length, schema.minLength], null, schema);
+        }
+    },
+    pattern: function (report, schema, json) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.2.3.2
+        if (shouldSkipValidate(this.validateOptions, ["PATTERN"])) {
+            return;
+        }
+        if (typeof json !== "string") {
+            return;
+        }
+        if (RegExp(schema.pattern).test(json) === false) {
+            report.addError("PATTERN", [schema.pattern, json], null, schema);
+        }
+    },
+    additionalItems: function (report, schema, json) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.3.1.2
+        if (shouldSkipValidate(this.validateOptions, ["ARRAY_ADDITIONAL_ITEMS"])) {
+            return;
+        }
+        if (!Array.isArray(json)) {
+            return;
+        }
+        // if the value of "additionalItems" is boolean value false and the value of "items" is an array,
+        // the json is valid if its size is less than, or equal to, the size of "items".
+        if (schema.additionalItems === false && Array.isArray(schema.items)) {
+            if (json.length > schema.items.length) {
+                report.addError("ARRAY_ADDITIONAL_ITEMS", null, null, schema);
+            }
+        }
+    },
+    items: function () { /*report, schema, json*/
+        // covered in additionalItems
+    },
+    maxItems: function (report, schema, json) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.3.2.2
+        if (shouldSkipValidate(this.validateOptions, ["ARRAY_LENGTH_LONG"])) {
+            return;
+        }
+        if (!Array.isArray(json)) {
+            return;
+        }
+        if (json.length > schema.maxItems) {
+            report.addError("ARRAY_LENGTH_LONG", [json.length, schema.maxItems], null, schema);
+        }
+    },
+    minItems: function (report, schema, json) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.3.3.2
+        if (shouldSkipValidate(this.validateOptions, ["ARRAY_LENGTH_SHORT"])) {
+            return;
+        }
+        if (!Array.isArray(json)) {
+            return;
+        }
+        if (json.length < schema.minItems) {
+            report.addError("ARRAY_LENGTH_SHORT", [json.length, schema.minItems], null, schema);
+        }
+    },
+    uniqueItems: function (report, schema, json) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.3.4.2
+        if (shouldSkipValidate(this.validateOptions, ["ARRAY_UNIQUE"])) {
+            return;
+        }
+        if (!Array.isArray(json)) {
+            return;
+        }
+        if (schema.uniqueItems === true) {
+            var matches = [];
+            if (Utils.isUniqueArray(json, matches) === false) {
+                report.addError("ARRAY_UNIQUE", matches, null, schema);
+            }
+        }
+    },
+    maxProperties: function (report, schema, json) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.1.2
+        if (shouldSkipValidate(this.validateOptions, ["OBJECT_PROPERTIES_MAXIMUM"])) {
+            return;
+        }
+        if (Utils.whatIs(json) !== "object") {
+            return;
+        }
+        var keysCount = Object.keys(json).length;
+        if (keysCount > schema.maxProperties) {
+            report.addError("OBJECT_PROPERTIES_MAXIMUM", [keysCount, schema.maxProperties], null, schema);
+        }
+    },
+    minProperties: function (report, schema, json) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.2.2
+        if (shouldSkipValidate(this.validateOptions, ["OBJECT_PROPERTIES_MINIMUM"])) {
+            return;
+        }
+        if (Utils.whatIs(json) !== "object") {
+            return;
+        }
+        var keysCount = Object.keys(json).length;
+        if (keysCount < schema.minProperties) {
+            report.addError("OBJECT_PROPERTIES_MINIMUM", [keysCount, schema.minProperties], null, schema);
+        }
+    },
+    required: function (report, schema, json) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.3.2
+        if (shouldSkipValidate(this.validateOptions, ["OBJECT_MISSING_REQUIRED_PROPERTY"])) {
+            return;
+        }
+        if (Utils.whatIs(json) !== "object") {
+            return;
+        }
+        var idx = schema.required.length;
+        while (idx--) {
+            var requiredPropertyName = schema.required[idx];
+            if (json[requiredPropertyName] === undefined) {
+                report.addError("OBJECT_MISSING_REQUIRED_PROPERTY", [requiredPropertyName], null, schema);
+            }
+        }
+    },
+    additionalProperties: function (report, schema, json) {
+        // covered in properties and patternProperties
+        if (schema.properties === undefined && schema.patternProperties === undefined) {
+            return JsonValidators.properties.call(this, report, schema, json);
+        }
+    },
+    patternProperties: function (report, schema, json) {
+        // covered in properties
+        if (schema.properties === undefined) {
+            return JsonValidators.properties.call(this, report, schema, json);
+        }
+    },
+    properties: function (report, schema, json) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.4.2
+        if (shouldSkipValidate(this.validateOptions, ["OBJECT_ADDITIONAL_PROPERTIES"])) {
+            return;
+        }
+        if (Utils.whatIs(json) !== "object") {
+            return;
+        }
+        var properties = schema.properties !== undefined ? schema.properties : {};
+        var patternProperties = schema.patternProperties !== undefined ? schema.patternProperties : {};
+        if (schema.additionalProperties === false) {
+            // The property set of the json to validate.
+            var s = Object.keys(json);
+            // The property set from "properties".
+            var p = Object.keys(properties);
+            // The property set from "patternProperties".
+            var pp = Object.keys(patternProperties);
+            // remove from "s" all elements of "p", if any;
+            s = Utils.difference(s, p);
+            // for each regex in "pp", remove all elements of "s" which this regex matches.
+            var idx = pp.length;
+            while (idx--) {
+                var regExp = RegExp(pp[idx]),
+                    idx2 = s.length;
+                while (idx2--) {
+                    if (regExp.test(s[idx2]) === true) {
+                        s.splice(idx2, 1);
+                    }
+                }
+            }
+            // Validation of the json succeeds if, after these two steps, set "s" is empty.
+            if (s.length > 0) {
+                // assumeAdditional can be an array of allowed properties
+                var idx3 = this.options.assumeAdditional.length;
+                if (idx3) {
+                    while (idx3--) {
+                        var io = s.indexOf(this.options.assumeAdditional[idx3]);
+                        if (io !== -1) {
+                            s.splice(io, 1);
+                        }
+                    }
+                }
+                var idx4 = s.length;
+                if (idx4) {
+                    while (idx4--) {
+                        report.addError("OBJECT_ADDITIONAL_PROPERTIES", [s[idx4]], null, schema);
+                    }
+                }
+            }
+        }
+    },
+    dependencies: function (report, schema, json) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.5.2
+        if (shouldSkipValidate(this.validateOptions, ["OBJECT_DEPENDENCY_KEY"])) {
+            return;
+        }
+        if (Utils.whatIs(json) !== "object") {
+            return;
+        }
+
+        var keys = Object.keys(schema.dependencies),
+            idx = keys.length;
+
+        while (idx--) {
+            // iterate all dependencies
+            var dependencyName = keys[idx];
+            if (json[dependencyName]) {
+                var dependencyDefinition = schema.dependencies[dependencyName];
+                if (Utils.whatIs(dependencyDefinition) === "object") {
+                    // if dependency is a schema, validate against this schema
+                    exports.validate.call(this, report, dependencyDefinition, json);
+                } else { // Array
+                    // if dependency is an array, object needs to have all properties in this array
+                    var idx2 = dependencyDefinition.length;
+                    while (idx2--) {
+                        var requiredPropertyName = dependencyDefinition[idx2];
+                        if (json[requiredPropertyName] === undefined) {
+                            report.addError("OBJECT_DEPENDENCY_KEY", [requiredPropertyName, dependencyName], null, schema);
+                        }
+                    }
+                }
+            }
+        }
+    },
+    enum: function (report, schema, json) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.1.2
+        if (shouldSkipValidate(this.validateOptions, ["ENUM_CASE_MISMATCH", "ENUM_MISMATCH"])) {
+            return;
+        }
+        var match = false,
+            caseInsensitiveMatch = false,
+            idx = schema.enum.length;
+        while (idx--) {
+            if (Utils.areEqual(json, schema.enum[idx])) {
+                match = true;
+                break;
+            } else if (Utils.areEqual(json, schema.enum[idx]), { caseInsensitiveComparison: true }) {
+                caseInsensitiveMatch = true;
+            }
+        }
+
+        if (match === false) {
+            var error = caseInsensitiveMatch && this.options.enumCaseInsensitiveComparison ? "ENUM_CASE_MISMATCH" : "ENUM_MISMATCH";
+            report.addError(error, [json], null, schema);
+        }
+    },
+    type: function (report, schema, json) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.2.2
+        if (shouldSkipValidate(this.validateOptions, ["INVALID_TYPE"])) {
+            return;
+        }
+        var jsonType = Utils.whatIs(json);
+        if (typeof schema.type === "string") {
+            if (jsonType !== schema.type && (jsonType !== "integer" || schema.type !== "number")) {
+                report.addError("INVALID_TYPE", [schema.type, jsonType], null, schema);
+            }
+        } else {
+            if (schema.type.indexOf(jsonType) === -1 && (jsonType !== "integer" || schema.type.indexOf("number") === -1)) {
+                report.addError("INVALID_TYPE", [schema.type, jsonType], null, schema);
+            }
+        }
+    },
+    allOf: function (report, schema, json) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.3.2
+        var idx = schema.allOf.length;
+        while (idx--) {
+            var validateResult = exports.validate.call(this, report, schema.allOf[idx], json);
+            if (this.options.breakOnFirstError && validateResult === false) {
+                break;
+            }
+        }
+    },
+    anyOf: function (report, schema, json) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.4.2
+        var subReports = [],
+            passed = false,
+            idx = schema.anyOf.length;
+
+        while (idx-- && passed === false) {
+            var subReport = new Report(report);
+            subReports.push(subReport);
+            passed = exports.validate.call(this, subReport, schema.anyOf[idx], json);
+        }
+
+        if (passed === false) {
+            report.addError("ANY_OF_MISSING", undefined, subReports, schema);
+        }
+    },
+    oneOf: function (report, schema, json) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.5.2
+        var passes = 0,
+            subReports = [],
+            idx = schema.oneOf.length;
+
+        while (idx--) {
+            var subReport = new Report(report, { maxErrors: 1 });
+            subReports.push(subReport);
+            if (exports.validate.call(this, subReport, schema.oneOf[idx], json) === true) {
+                passes++;
+            }
+        }
+
+        if (passes === 0) {
+            report.addError("ONE_OF_MISSING", undefined, subReports, schema);
+        } else if (passes > 1) {
+            report.addError("ONE_OF_MULTIPLE", null, null, schema);
+        }
+    },
+    not: function (report, schema, json) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.6.2
+        var subReport = new Report(report);
+        if (exports.validate.call(this, subReport, schema.not, json) === true) {
+            report.addError("NOT_PASSED", null, null, schema);
+        }
+    },
+    definitions: function () { /*report, schema, json*/
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.7.2
+        // nothing to do here
+    },
+    format: function (report, schema, json) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.7.2
+        var formatValidatorFn = FormatValidators[schema.format];
+        if (typeof formatValidatorFn === "function") {
+            if (shouldSkipValidate(this.validateOptions, ["INVALID_FORMAT"])) {
+                return;
+            }
+            if (formatValidatorFn.length === 2) {
+                // async - need to clone the path here, because it will change by the time async function reports back
+                var pathBeforeAsync = Utils.clone(report.path);
+                report.addAsyncTask(formatValidatorFn, [json], function (result) {
+                    if (result !== true) {
+                        var backup = report.path;
+                        report.path = pathBeforeAsync;
+                        report.addError("INVALID_FORMAT", [schema.format, json], null, schema);
+                        report.path = backup;
+                    }
+                });
+            } else {
+                // sync
+                if (formatValidatorFn.call(this, json) !== true) {
+                    report.addError("INVALID_FORMAT", [schema.format, json], null, schema);
+                }
+            }
+        } else if (this.options.ignoreUnknownFormats !== true) {
+            report.addError("UNKNOWN_FORMAT", [schema.format], null, schema);
+        }
+    }
+};
+
+var recurseArray = function (report, schema, json) {
+    // http://json-schema.org/latest/json-schema-validation.html#rfc.section.8.2
+
+    var idx = json.length;
+
+    // If "items" is an array, this situation, the schema depends on the index:
+    // if the index is less than, or equal to, the size of "items",
+    // the child instance must be valid against the corresponding schema in the "items" array;
+    // otherwise, it must be valid against the schema defined by "additionalItems".
+    if (Array.isArray(schema.items)) {
+
+        while (idx--) {
+            // equal to doesn't make sense here
+            if (idx < schema.items.length) {
+                report.path.push(idx);
+                exports.validate.call(this, report, schema.items[idx], json[idx]);
+                report.path.pop();
+            } else {
+                // might be boolean, so check that it's an object
+                if (typeof schema.additionalItems === "object") {
+                    report.path.push(idx);
+                    exports.validate.call(this, report, schema.additionalItems, json[idx]);
+                    report.path.pop();
+                }
+            }
+        }
+
+    } else if (typeof schema.items === "object") {
+
+        // If items is a schema, then the child instance must be valid against this schema,
+        // regardless of its index, and regardless of the value of "additionalItems".
+        while (idx--) {
+            report.path.push(idx);
+            exports.validate.call(this, report, schema.items, json[idx]);
+            report.path.pop();
+        }
+
+    }
+};
+
+var recurseObject = function (report, schema, json) {
+    // http://json-schema.org/latest/json-schema-validation.html#rfc.section.8.3
+
+    // If "additionalProperties" is absent, it is considered present with an empty schema as a value.
+    // In addition, boolean value true is considered equivalent to an empty schema.
+    var additionalProperties = schema.additionalProperties;
+    if (additionalProperties === true || additionalProperties === undefined) {
+        additionalProperties = {};
+    }
+
+    // p - The property set from "properties".
+    var p = schema.properties ? Object.keys(schema.properties) : [];
+
+    // pp - The property set from "patternProperties". Elements of this set will be called regexes for convenience.
+    var pp = schema.patternProperties ? Object.keys(schema.patternProperties) : [];
+
+    // m - The property name of the child.
+    var keys = Object.keys(json),
+        idx = keys.length;
+
+    while (idx--) {
+        var m = keys[idx],
+            propertyValue = json[m];
+
+        // s - The set of schemas for the child instance.
+        var s = [];
+
+        // 1. If set "p" contains value "m", then the corresponding schema in "properties" is added to "s".
+        if (p.indexOf(m) !== -1) {
+            s.push(schema.properties[m]);
+        }
+
+        // 2. For each regex in "pp", if it matches "m" successfully, the corresponding schema in "patternProperties" is added to "s".
+        var idx2 = pp.length;
+        while (idx2--) {
+            var regexString = pp[idx2];
+            if (RegExp(regexString).test(m) === true) {
+                s.push(schema.patternProperties[regexString]);
+            }
+        }
+
+        // 3. The schema defined by "additionalProperties" is added to "s" if and only if, at this stage, "s" is empty.
+        if (s.length === 0 && additionalProperties !== false) {
+            s.push(additionalProperties);
+        }
+
+        // we are passing tests even without this assert because this is covered by properties check
+        // if s is empty in this stage, no additionalProperties are allowed
+        // report.expect(s.length !== 0, 'E001', m);
+
+        // Instance property value must pass all schemas from s
+        idx2 = s.length;
+        while (idx2--) {
+            report.path.push(m);
+            exports.validate.call(this, report, s[idx2], propertyValue);
+            report.path.pop();
+        }
+    }
+};
+
+exports.JsonValidators = JsonValidators;
+
+/**
+ *
+ * @param {Report} report
+ * @param {*} schema
+ * @param {*} json
+ */
+exports.validate = function (report, schema, json) {
+
+    report.commonErrorMessage = "JSON_OBJECT_VALIDATION_FAILED";
+
+    // check if schema is an object
+    var to = Utils.whatIs(schema);
+    if (to !== "object") {
+        report.addError("SCHEMA_NOT_AN_OBJECT", [to], null, schema);
+        return false;
+    }
+
+    // check if schema is empty, everything is valid against empty schema
+    var keys = Object.keys(schema);
+    if (keys.length === 0) {
+        return true;
+    }
+
+    // this method can be called recursively, so we need to remember our root
+    var isRoot = false;
+    if (!report.rootSchema) {
+        report.rootSchema = schema;
+        isRoot = true;
+    }
+
+    // follow schema.$ref keys
+    if (schema.$ref !== undefined) {
+        // avoid infinite loop with maxRefs
+        var maxRefs = 99;
+        while (schema.$ref && maxRefs > 0) {
+            if (!schema.__$refResolved) {
+                report.addError("REF_UNRESOLVED", [schema.$ref], null, schema);
+                break;
+            } else if (schema.__$refResolved === schema) {
+                break;
+            } else {
+                schema = schema.__$refResolved;
+                keys = Object.keys(schema);
+            }
+            maxRefs--;
+        }
+        if (maxRefs === 0) {
+            throw new Error("Circular dependency by $ref references!");
+        }
+    }
+
+    // type checking first
+    var jsonType = Utils.whatIs(json);
+    if (schema.type) {
+        keys.splice(keys.indexOf("type"), 1);
+        JsonValidators.type.call(this, report, schema, json);
+        if (report.errors.length && this.options.breakOnFirstError) {
+            return false;
+        }
+    }
+
+    // now iterate all the keys in schema and execute validation methods
+    var idx = keys.length;
+    while (idx--) {
+        if (JsonValidators[keys[idx]]) {
+            JsonValidators[keys[idx]].call(this, report, schema, json);
+            if (report.errors.length && this.options.breakOnFirstError) { break; }
+        }
+    }
+
+    if (report.errors.length === 0 || this.options.breakOnFirstError === false) {
+        if (jsonType === "array") {
+            recurseArray.call(this, report, schema, json);
+        } else if (jsonType === "object") {
+            recurseObject.call(this, report, schema, json);
+        }
+    }
+
+    if (typeof this.options.customValidator === "function") {
+        this.options.customValidator.call(this, report, schema, json);
+    }
+
+    // we don't need the root pointer anymore
+    if (isRoot) {
+        report.rootSchema = undefined;
+    }
+
+    // return valid just to be able to break at some code points
+    return report.errors.length === 0;
+
+};

SerpentRace_Backend/node_modules/z-schema/src/Polyfills.js

@@ -0,0 +1,16 @@
+// Number.isFinite polyfill
+// http://people.mozilla.org/~jorendorff/es6-draft.html#sec-number.isfinite
+if (typeof Number.isFinite !== "function") {
+    Number.isFinite = function isFinite(value) {
+        // 1. If Type(number) is not Number, return false.
+        if (typeof value !== "number") {
+            return false;
+        }
+        // 2. If number is NaN, +∞, or −∞, return false.
+        if (value !== value || value === Infinity || value === -Infinity) {
+            return false;
+        }
+        // 3. Otherwise, return true.
+        return true;
+    };
+}

SerpentRace_Backend/node_modules/z-schema/src/Report.js

@@ -0,0 +1,299 @@
+"use strict";
+
+var get    = require("lodash.get");
+var Errors = require("./Errors");
+var Utils  = require("./Utils");
+
+/**
+ * @class
+ *
+ * @param {Report|object} parentOrOptions
+ * @param {object} [reportOptions]
+ */
+function Report(parentOrOptions, reportOptions) {
+    this.parentReport = parentOrOptions instanceof Report ?
+                            parentOrOptions :
+                            undefined;
+
+    this.options = parentOrOptions instanceof Report ?
+                       parentOrOptions.options :
+                       parentOrOptions || {};
+
+    this.reportOptions = reportOptions || {};
+
+    this.errors = [];
+    /**
+     * @type {string[]}
+     */
+    this.path = [];
+    this.asyncTasks = [];
+
+    this.rootSchema = undefined;
+    this.commonErrorMessage = undefined;
+    this.json = undefined;
+}
+
+/**
+ * @returns {boolean}
+ */
+Report.prototype.isValid = function () {
+    if (this.asyncTasks.length > 0) {
+        throw new Error("Async tasks pending, can't answer isValid");
+    }
+    return this.errors.length === 0;
+};
+
+/**
+ *
+ * @param {*} fn
+ * @param {*} args
+ * @param {*} asyncTaskResultProcessFn
+ */
+Report.prototype.addAsyncTask = function (fn, args, asyncTaskResultProcessFn) {
+    this.asyncTasks.push([fn, args, asyncTaskResultProcessFn]);
+};
+
+Report.prototype.getAncestor = function (id) {
+    if (!this.parentReport) {
+        return undefined;
+    }
+    if (this.parentReport.getSchemaId() === id) {
+        return this.parentReport;
+    }
+    return this.parentReport.getAncestor(id);
+};
+
+/**
+ *
+ * @param {*} timeout
+ * @param {function(*, *)} callback
+ *
+ * @returns {void}
+ */
+Report.prototype.processAsyncTasks = function (timeout, callback) {
+
+    var validationTimeout = timeout || 2000,
+        tasksCount        = this.asyncTasks.length,
+        idx               = tasksCount,
+        timedOut          = false,
+        self              = this;
+
+    function finish() {
+        process.nextTick(function () {
+            var valid = self.errors.length === 0,
+                err = valid ? null : self.errors;
+            callback(err, valid);
+        });
+    }
+
+    function respond(asyncTaskResultProcessFn) {
+        return function (asyncTaskResult) {
+            if (timedOut) { return; }
+            asyncTaskResultProcessFn(asyncTaskResult);
+            if (--tasksCount === 0) {
+                finish();
+            }
+        };
+    }
+
+    // finish if tasks are completed or there are any errors and breaking on first error was requested
+    if (tasksCount === 0 || (this.errors.length > 0 && this.options.breakOnFirstError)) {
+        finish();
+        return;
+    }
+
+    while (idx--) {
+        var task = this.asyncTasks[idx];
+        task[0].apply(null, task[1].concat(respond(task[2])));
+    }
+
+    setTimeout(function () {
+        if (tasksCount > 0) {
+            timedOut = true;
+            self.addError("ASYNC_TIMEOUT", [tasksCount, validationTimeout]);
+            callback(self.errors, false);
+        }
+    }, validationTimeout);
+
+};
+
+/**
+ *
+ * @param {*} returnPathAsString
+ *
+ * @return {string[]|string}
+ */
+Report.prototype.getPath = function (returnPathAsString) {
+    /**
+     * @type {string[]|string}
+     */
+    var path = [];
+    if (this.parentReport) {
+        path = path.concat(this.parentReport.path);
+    }
+    path = path.concat(this.path);
+
+    if (returnPathAsString !== true) {
+        // Sanitize the path segments (http://tools.ietf.org/html/rfc6901#section-4)
+        path = "#/" + path.map(function (segment) {
+            segment = segment.toString();
+
+            if (Utils.isAbsoluteUri(segment)) {
+                return "uri(" + segment + ")";
+            }
+
+            return segment.replace(/\~/g, "~0").replace(/\//g, "~1");
+        }).join("/");
+    }
+    return path;
+};
+
+Report.prototype.getSchemaId = function () {
+
+    if (!this.rootSchema) {
+        return null;
+    }
+
+    // get the error path as an array
+    var path = [];
+    if (this.parentReport) {
+        path = path.concat(this.parentReport.path);
+    }
+    path = path.concat(this.path);
+
+    // try to find id in the error path
+    while (path.length > 0) {
+        var obj = get(this.rootSchema, path);
+        if (obj && obj.id) { return obj.id; }
+        path.pop();
+    }
+
+    // return id of the root
+    return this.rootSchema.id;
+};
+
+/**
+ *
+ * @param {*} errorCode
+ * @param {*} params
+ *
+ * @return {boolean}
+ */
+Report.prototype.hasError = function (errorCode, params) {
+    var idx = this.errors.length;
+    while (idx--) {
+        if (this.errors[idx].code === errorCode) {
+            // assume match
+            var match = true;
+
+            // check the params too
+            var idx2 = this.errors[idx].params.length;
+            while (idx2--) {
+                if (this.errors[idx].params[idx2] !== params[idx2]) {
+                    match = false;
+                }
+            }
+
+            // if match, return true
+            if (match) { return match; }
+        }
+    }
+    return false;
+};
+
+/**
+ *
+ * @param {*} errorCode
+ * @param {*} params
+ * @param {Report[]|Report} [subReports]
+ * @param {*} [schema]
+ *
+ * @return {void}
+ */
+Report.prototype.addError = function (errorCode, params, subReports, schema) {
+    if (!errorCode) { throw new Error("No errorCode passed into addError()"); }
+
+    this.addCustomError(errorCode, Errors[errorCode], params, subReports, schema);
+};
+
+Report.prototype.getJson = function () {
+    var self = this;
+    while (self.json === undefined) {
+        self = self.parentReport;
+        if (self === undefined) {
+            return undefined;
+        }
+    }
+    return self.json;
+};
+
+/**
+ *
+ * @param {*} errorCode
+ * @param {*} errorMessage
+ * @param {*[]} params
+ * @param {Report[]|Report} subReports
+ * @param {*} schema
+ *
+ * @returns {void}
+ */
+Report.prototype.addCustomError = function (errorCode, errorMessage, params, subReports, schema) {
+    if (this.errors.length >= this.reportOptions.maxErrors) {
+        return;
+    }
+
+    if (!errorMessage) { throw new Error("No errorMessage known for code " + errorCode); }
+
+    params = params || [];
+
+    var idx = params.length;
+    while (idx--) {
+        var whatIs = Utils.whatIs(params[idx]);
+        var param = (whatIs === "object" || whatIs === "null") ? JSON.stringify(params[idx]) : params[idx];
+        errorMessage = errorMessage.replace("{" + idx + "}", param);
+    }
+
+    var err = {
+        code: errorCode,
+        params: params,
+        message: errorMessage,
+        path: this.getPath(this.options.reportPathAsArray),
+        schemaId: this.getSchemaId()
+    };
+
+    err[Utils.schemaSymbol] = schema;
+    err[Utils.jsonSymbol] = this.getJson();
+
+    if (schema && typeof schema === "string") {
+        err.description = schema;
+    } else if (schema && typeof schema === "object") {
+        if (schema.title) {
+            err.title = schema.title;
+        }
+        if (schema.description) {
+            err.description = schema.description;
+        }
+    }
+
+    if (subReports != null) {
+        if (!Array.isArray(subReports)) {
+            subReports = [subReports];
+        }
+        err.inner = [];
+        idx = subReports.length;
+        while (idx--) {
+            var subReport = subReports[idx],
+                idx2 = subReport.errors.length;
+            while (idx2--) {
+                err.inner.push(subReport.errors[idx2]);
+            }
+        }
+        if (err.inner.length === 0) {
+            err.inner = undefined;
+        }
+    }
+
+    this.errors.push(err);
+};
+
+module.exports = Report;

SerpentRace_Backend/node_modules/z-schema/src/SchemaCache.js

@@ -0,0 +1,188 @@
+"use strict";
+
+var isequal             = require("lodash.isequal");
+var Report              = require("./Report");
+var SchemaCompilation   = require("./SchemaCompilation");
+var SchemaValidation    = require("./SchemaValidation");
+var Utils               = require("./Utils");
+
+function decodeJSONPointer(str) {
+    // http://tools.ietf.org/html/draft-ietf-appsawg-json-pointer-07#section-3
+    return decodeURIComponent(str).replace(/~[0-1]/g, function (x) {
+        return x === "~1" ? "/" : "~";
+    });
+}
+
+function getRemotePath(uri) {
+    var io = uri.indexOf("#");
+    return io === -1 ? uri : uri.slice(0, io);
+}
+
+function getQueryPath(uri) {
+    var io = uri.indexOf("#");
+    var res = io === -1 ? undefined : uri.slice(io + 1);
+    // WARN: do not slice slash, #/ means take root and go down from it
+    // if (res && res[0] === "/") { res = res.slice(1); }
+    return res;
+}
+
+function findId(schema, id) {
+    // process only arrays and objects
+    if (typeof schema !== "object" || schema === null) {
+        return;
+    }
+
+    // no id means root so return itself
+    if (!id) {
+        return schema;
+    }
+
+    if (schema.id) {
+        if (schema.id === id || schema.id[0] === "#" && schema.id.substring(1) === id) {
+            return schema;
+        }
+    }
+
+    var idx, result;
+    if (Array.isArray(schema)) {
+        idx = schema.length;
+        while (idx--) {
+            result = findId(schema[idx], id);
+            if (result) { return result; }
+        }
+    } else {
+        var keys = Object.keys(schema);
+        idx = keys.length;
+        while (idx--) {
+            var k = keys[idx];
+            if (k.indexOf("__$") === 0) {
+                continue;
+            }
+            result = findId(schema[k], id);
+            if (result) { return result; }
+        }
+    }
+}
+
+/**
+ *
+ * @param {*} uri
+ * @param {*} schema
+ *
+ * @returns {void}
+ */
+exports.cacheSchemaByUri = function (uri, schema) {
+    var remotePath = getRemotePath(uri);
+    if (remotePath) {
+        this.cache[remotePath] = schema;
+    }
+};
+
+/**
+ *
+ * @param {*} uri
+ *
+ * @returns {void}
+ */
+exports.removeFromCacheByUri = function (uri) {
+    var remotePath = getRemotePath(uri);
+    if (remotePath) {
+        delete this.cache[remotePath];
+    }
+};
+
+/**
+ *
+ * @param {*} uri
+ *
+ * @returns {boolean}
+ */
+exports.checkCacheForUri = function (uri) {
+    var remotePath = getRemotePath(uri);
+    return remotePath ? this.cache[remotePath] != null : false;
+};
+
+exports.getSchema = function (report, schema) {
+    if (typeof schema === "object") {
+        schema = exports.getSchemaByReference.call(this, report, schema);
+    }
+    if (typeof schema === "string") {
+        schema = exports.getSchemaByUri.call(this, report, schema);
+    }
+    return schema;
+};
+
+exports.getSchemaByReference = function (report, key) {
+    var i = this.referenceCache.length;
+    while (i--) {
+        if (isequal(this.referenceCache[i][0], key)) {
+            return this.referenceCache[i][1];
+        }
+    }
+    // not found
+    var schema = Utils.cloneDeep(key);
+    this.referenceCache.push([key, schema]);
+    return schema;
+};
+
+exports.getSchemaByUri = function (report, uri, root) {
+    var remotePath = getRemotePath(uri),
+        queryPath = getQueryPath(uri),
+        result = remotePath ? this.cache[remotePath] : root;
+
+    if (result && remotePath) {
+        // we need to avoid compiling schemas in a recursive loop
+        var compileRemote = result !== root;
+        // now we need to compile and validate resolved schema (in case it's not already)
+        if (compileRemote) {
+
+            report.path.push(remotePath);
+
+            var remoteReport;
+
+            var anscestorReport = report.getAncestor(result.id);
+            if (anscestorReport) {
+                remoteReport = anscestorReport;
+            } else {
+                remoteReport = new Report(report);
+                if (SchemaCompilation.compileSchema.call(this, remoteReport, result)) {
+                    var savedOptions = this.options;
+                    try {
+                        // If custom validationOptions were provided to setRemoteReference(),
+                        // use them instead of the default options
+                        this.options = result.__$validationOptions || this.options;
+                        SchemaValidation.validateSchema.call(this, remoteReport, result);
+                    } finally {
+                        this.options = savedOptions;
+                    }
+                }
+            }
+            var remoteReportIsValid = remoteReport.isValid();
+            if (!remoteReportIsValid) {
+                report.addError("REMOTE_NOT_VALID", [uri], remoteReport);
+            }
+
+            report.path.pop();
+
+            if (!remoteReportIsValid) {
+                return undefined;
+            }
+        }
+    }
+
+    if (result && queryPath) {
+        var parts = queryPath.split("/");
+        for (var idx = 0, lim = parts.length; result && idx < lim; idx++) {
+            var key = decodeJSONPointer(parts[idx]);
+            if (idx === 0) { // it's an id
+                result = findId(result, key);
+            } else { // it's a path behind id
+                result = result[key];
+            }
+        }
+    }
+
+    return result;
+};
+
+exports.getRemotePath = getRemotePath;

SerpentRace_Backend/node_modules/z-schema/src/SchemaCompilation.js

@@ -0,0 +1,299 @@
+"use strict";
+
+var Report      = require("./Report");
+var SchemaCache = require("./SchemaCache");
+var Utils       = require("./Utils");
+
+function mergeReference(scope, ref) {
+    if (Utils.isAbsoluteUri(ref)) {
+        return ref;
+    }
+
+    var joinedScope = scope.join(""),
+        isScopeAbsolute = Utils.isAbsoluteUri(joinedScope),
+        isScopeRelative = Utils.isRelativeUri(joinedScope),
+        isRefRelative = Utils.isRelativeUri(ref),
+        toRemove;
+
+    if (isScopeAbsolute && isRefRelative) {
+        toRemove = joinedScope.match(/\/[^\/]*$/);
+        if (toRemove) {
+            joinedScope = joinedScope.slice(0, toRemove.index + 1);
+        }
+    } else if (isScopeRelative && isRefRelative) {
+        joinedScope = "";
+    } else {
+        toRemove = joinedScope.match(/[^#/]+$/);
+        if (toRemove) {
+            joinedScope = joinedScope.slice(0, toRemove.index);
+        }
+    }
+
+    var res = joinedScope + ref;
+    res = res.replace(/##/, "#");
+    return res;
+}
+
+function collectReferences(obj, results, scope, path) {
+    results = results || [];
+    scope = scope || [];
+    path = path || [];
+
+    if (typeof obj !== "object" || obj === null) {
+        return results;
+    }
+
+    if (typeof obj.id === "string") {
+        scope.push(obj.id);
+    }
+
+    if (typeof obj.$ref === "string" && typeof obj.__$refResolved === "undefined") {
+        results.push({
+            ref: mergeReference(scope, obj.$ref),
+            key: "$ref",
+            obj: obj,
+            path: path.slice(0)
+        });
+    }
+    if (typeof obj.$schema === "string" && typeof obj.__$schemaResolved === "undefined") {
+        results.push({
+            ref: mergeReference(scope, obj.$schema),
+            key: "$schema",
+            obj: obj,
+            path: path.slice(0)
+        });
+    }
+
+    var idx;
+    if (Array.isArray(obj)) {
+        idx = obj.length;
+        while (idx--) {
+            path.push(idx.toString());
+            collectReferences(obj[idx], results, scope, path);
+            path.pop();
+        }
+    } else {
+        var keys = Object.keys(obj);
+        idx = keys.length;
+        while (idx--) {
+            // do not recurse through resolved references and other z-schema props
+            if (keys[idx].indexOf("__$") === 0) { continue; }
+            path.push(keys[idx]);
+            collectReferences(obj[keys[idx]], results, scope, path);
+            path.pop();
+        }
+    }
+
+    if (typeof obj.id === "string") {
+        scope.pop();
+    }
+
+    return results;
+}
+
+var compileArrayOfSchemasLoop = function (mainReport, arr) {
+    var idx = arr.length,
+        compiledCount = 0;
+
+    while (idx--) {
+
+        // try to compile each schema separately
+        var report = new Report(mainReport);
+        var isValid = exports.compileSchema.call(this, report, arr[idx]);
+        if (isValid) { compiledCount++; }
+
+        // copy errors to report
+        mainReport.errors = mainReport.errors.concat(report.errors);
+
+    }
+
+    return compiledCount;
+};
+
+function findId(arr, id) {
+    var idx = arr.length;
+    while (idx--) {
+        if (arr[idx].id === id) {
+            return arr[idx];
+        }
+    }
+    return null;
+}
+
+var compileArrayOfSchemas = function (report, arr) {
+
+    var compiled = 0,
+        lastLoopCompiled;
+
+    do {
+
+        // remove all UNRESOLVABLE_REFERENCE errors before compiling array again
+        var idx = report.errors.length;
+        while (idx--) {
+            if (report.errors[idx].code === "UNRESOLVABLE_REFERENCE") {
+                report.errors.splice(idx, 1);
+            }
+        }
+
+        // remember how many were compiled in the last loop
+        lastLoopCompiled = compiled;
+
+        // count how many are compiled now
+        compiled = compileArrayOfSchemasLoop.call(this, report, arr);
+
+        // fix __$missingReferences if possible
+        idx = arr.length;
+        while (idx--) {
+            var sch = arr[idx];
+            if (sch.__$missingReferences) {
+                var idx2 = sch.__$missingReferences.length;
+                while (idx2--) {
+                    var refObj = sch.__$missingReferences[idx2];
+                    var response = findId(arr, refObj.ref);
+                    if (response) {
+                        // this might create circular references
+                        refObj.obj["__" + refObj.key + "Resolved"] = response;
+                        // it's resolved now so delete it
+                        sch.__$missingReferences.splice(idx2, 1);
+                    }
+                }
+                if (sch.__$missingReferences.length === 0) {
+                    delete sch.__$missingReferences;
+                }
+            }
+        }
+
+        // keep repeating if not all compiled and at least one more was compiled in the last loop
+    } while (compiled !== arr.length && compiled !== lastLoopCompiled);
+
+    return report.isValid();
+
+};
+
+exports.compileSchema = function (report, schema) {
+
+    report.commonErrorMessage = "SCHEMA_COMPILATION_FAILED";
+
+    // if schema is a string, assume it's a uri
+    if (typeof schema === "string") {
+        var loadedSchema = SchemaCache.getSchemaByUri.call(this, report, schema);
+        if (!loadedSchema) {
+            report.addError("SCHEMA_NOT_REACHABLE", [schema]);
+            return false;
+        }
+        schema = loadedSchema;
+    }
+
+    // if schema is an array, assume it's an array of schemas
+    if (Array.isArray(schema)) {
+        return compileArrayOfSchemas.call(this, report, schema);
+    }
+
+    // if we have an id than it should be cached already (if this instance has compiled it)
+    if (schema.__$compiled && schema.id && SchemaCache.checkCacheForUri.call(this, schema.id) === false) {
+        schema.__$compiled = undefined;
+    }
+
+    // do not re-compile schemas
+    if (schema.__$compiled) {
+        return true;
+    }
+
+    if (schema.id && typeof schema.id === "string") {
+        // add this to our schemaCache (before compilation in case we have references including id)
+        SchemaCache.cacheSchemaByUri.call(this, schema.id, schema);
+    }
+
+    // this method can be called recursively, so we need to remember our root
+    var isRoot = false;
+    if (!report.rootSchema) {
+        report.rootSchema = schema;
+        isRoot = true;
+    }
+
+    // delete all __$missingReferences from previous compilation attempts
+    var isValidExceptReferences = report.isValid();
+    delete schema.__$missingReferences;
+
+    // collect all references that need to be resolved - $ref and $schema
+    var refs = collectReferences.call(this, schema),
+        idx = refs.length;
+    while (idx--) {
+        // resolve all the collected references into __xxxResolved pointer
+        var refObj = refs[idx];
+        var response = SchemaCache.getSchemaByUri.call(this, report, refObj.ref, schema);
+
+        // we can try to use custom schemaReader if available
+        if (!response) {
+            var schemaReader = this.getSchemaReader();
+            if (schemaReader) {
+                // it's supposed to return a valid schema
+                var s = schemaReader(refObj.ref);
+                if (s) {
+                    // it needs to have the id
+                    s.id = refObj.ref;
+                    // try to compile the schema
+                    var subreport = new Report(report);
+                    if (!exports.compileSchema.call(this, subreport, s)) {
+                        // copy errors to report
+                        report.errors = report.errors.concat(subreport.errors);
+                    } else {
+                        response = SchemaCache.getSchemaByUri.call(this, report, refObj.ref, schema);
+                    }
+                }
+            }
+        }
+
+        if (!response) {
+
+            var hasNotValid = report.hasError("REMOTE_NOT_VALID", [refObj.ref]);
+            var isAbsolute = Utils.isAbsoluteUri(refObj.ref);
+            var isDownloaded = false;
+            var ignoreUnresolvableRemotes = this.options.ignoreUnresolvableReferences === true;
+
+            if (isAbsolute) {
+                // we shouldn't add UNRESOLVABLE_REFERENCE for schemas we already have downloaded
+                // and set through setRemoteReference method
+                isDownloaded = SchemaCache.checkCacheForUri.call(this, refObj.ref);
+            }
+
+            if (hasNotValid) {
+                // already has REMOTE_NOT_VALID error for this one
+            } else if (ignoreUnresolvableRemotes && isAbsolute) {
+                // ignoreUnresolvableRemotes is on and remote isAbsolute
+            } else if (isDownloaded) {
+                // remote is downloaded, so no UNRESOLVABLE_REFERENCE
+            } else {
+                Array.prototype.push.apply(report.path, refObj.path);
+                report.addError("UNRESOLVABLE_REFERENCE", [refObj.ref]);
+                report.path = report.path.slice(0, -refObj.path.length);
+
+                // pusblish unresolved references out
+                if (isValidExceptReferences) {
+                    schema.__$missingReferences = schema.__$missingReferences || [];
+                    schema.__$missingReferences.push(refObj);
+                }
+            }
+        }
+        // this might create circular references
+        refObj.obj["__" + refObj.key + "Resolved"] = response;
+    }
+
+    var isValid = report.isValid();
+    if (isValid) {
+        schema.__$compiled = true;
+    } else {
+        if (schema.id && typeof schema.id === "string") {
+            // remove this schema from schemaCache because it failed to compile
+            SchemaCache.removeFromCacheByUri.call(this, schema.id);
+        }
+    }
+
+    // we don't need the root pointer anymore
+    if (isRoot) {
+        report.rootSchema = undefined;
+    }
+
+    return isValid;
+
+};

SerpentRace_Backend/node_modules/z-schema/src/SchemaValidation.js

@@ -0,0 +1,619 @@
+"use strict";
+
+var FormatValidators = require("./FormatValidators"),
+    JsonValidation   = require("./JsonValidation"),
+    Report           = require("./Report"),
+    Utils            = require("./Utils");
+
+var SchemaValidators = {
+    $ref: function (report, schema) {
+        // http://tools.ietf.org/html/draft-ietf-appsawg-json-pointer-07
+        // http://tools.ietf.org/html/draft-pbryan-zyp-json-ref-03
+        if (typeof schema.$ref !== "string") {
+            report.addError("KEYWORD_TYPE_EXPECTED", ["$ref", "string"]);
+        }
+    },
+    $schema: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-core.html#rfc.section.6
+        if (typeof schema.$schema !== "string") {
+            report.addError("KEYWORD_TYPE_EXPECTED", ["$schema", "string"]);
+        }
+    },
+    multipleOf: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.1.1.1
+        if (typeof schema.multipleOf !== "number") {
+            report.addError("KEYWORD_TYPE_EXPECTED", ["multipleOf", "number"]);
+        } else if (schema.multipleOf <= 0) {
+            report.addError("KEYWORD_MUST_BE", ["multipleOf", "strictly greater than 0"]);
+        }
+    },
+    maximum: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.1.2.1
+        if (typeof schema.maximum !== "number") {
+            report.addError("KEYWORD_TYPE_EXPECTED", ["maximum", "number"]);
+        }
+    },
+    exclusiveMaximum: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.1.2.1
+        if (typeof schema.exclusiveMaximum !== "boolean") {
+            report.addError("KEYWORD_TYPE_EXPECTED", ["exclusiveMaximum", "boolean"]);
+        } else if (schema.maximum === undefined) {
+            report.addError("KEYWORD_DEPENDENCY", ["exclusiveMaximum", "maximum"]);
+        }
+    },
+    minimum: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.1.3.1
+        if (typeof schema.minimum !== "number") {
+            report.addError("KEYWORD_TYPE_EXPECTED", ["minimum", "number"]);
+        }
+    },
+    exclusiveMinimum: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.1.3.1
+        if (typeof schema.exclusiveMinimum !== "boolean") {
+            report.addError("KEYWORD_TYPE_EXPECTED", ["exclusiveMinimum", "boolean"]);
+        } else if (schema.minimum === undefined) {
+            report.addError("KEYWORD_DEPENDENCY", ["exclusiveMinimum", "minimum"]);
+        }
+    },
+    maxLength: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.2.1.1
+        if (Utils.whatIs(schema.maxLength) !== "integer") {
+            report.addError("KEYWORD_TYPE_EXPECTED", ["maxLength", "integer"]);
+        } else if (schema.maxLength < 0) {
+            report.addError("KEYWORD_MUST_BE", ["maxLength", "greater than, or equal to 0"]);
+        }
+    },
+    minLength: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.2.2.1
+        if (Utils.whatIs(schema.minLength) !== "integer") {
+            report.addError("KEYWORD_TYPE_EXPECTED", ["minLength", "integer"]);
+        } else if (schema.minLength < 0) {
+            report.addError("KEYWORD_MUST_BE", ["minLength", "greater than, or equal to 0"]);
+        }
+    },
+    pattern: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.2.3.1
+        if (typeof schema.pattern !== "string") {
+            report.addError("KEYWORD_TYPE_EXPECTED", ["pattern", "string"]);
+        } else {
+            try {
+                RegExp(schema.pattern);
+            } catch (e) {
+                report.addError("KEYWORD_PATTERN", ["pattern", schema.pattern]);
+            }
+        }
+    },
+    additionalItems: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.3.1.1
+        var type = Utils.whatIs(schema.additionalItems);
+        if (type !== "boolean" && type !== "object") {
+            report.addError("KEYWORD_TYPE_EXPECTED", ["additionalItems", ["boolean", "object"]]);
+        } else if (type === "object") {
+            report.path.push("additionalItems");
+            exports.validateSchema.call(this, report, schema.additionalItems);
+            report.path.pop();
+        }
+    },
+    items: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.3.1.1
+        var type = Utils.whatIs(schema.items);
+
+        if (type === "object") {
+            report.path.push("items");
+            exports.validateSchema.call(this, report, schema.items);
+            report.path.pop();
+        } else if (type === "array") {
+            var idx = schema.items.length;
+            while (idx--) {
+                report.path.push("items");
+                report.path.push(idx.toString());
+                exports.validateSchema.call(this, report, schema.items[idx]);
+                report.path.pop();
+                report.path.pop();
+            }
+        } else {
+            report.addError("KEYWORD_TYPE_EXPECTED", ["items", ["array", "object"]]);
+        }
+
+        // custom - strict mode
+        if (this.options.forceAdditional === true && schema.additionalItems === undefined && Array.isArray(schema.items)) {
+            report.addError("KEYWORD_UNDEFINED_STRICT", ["additionalItems"]);
+        }
+        // custome - assume defined false mode
+        if (this.options.assumeAdditional && schema.additionalItems === undefined && Array.isArray(schema.items)) {
+            schema.additionalItems = false;
+        }
+    },
+    maxItems: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.3.2.1
+        if (typeof schema.maxItems !== "number") {
+            report.addError("KEYWORD_TYPE_EXPECTED", ["maxItems", "integer"]);
+        } else if (schema.maxItems < 0) {
+            report.addError("KEYWORD_MUST_BE", ["maxItems", "greater than, or equal to 0"]);
+        }
+    },
+    minItems: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.3.3.1
+        if (Utils.whatIs(schema.minItems) !== "integer") {
+            report.addError("KEYWORD_TYPE_EXPECTED", ["minItems", "integer"]);
+        } else if (schema.minItems < 0) {
+            report.addError("KEYWORD_MUST_BE", ["minItems", "greater than, or equal to 0"]);
+        }
+    },
+    uniqueItems: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.3.4.1
+        if (typeof schema.uniqueItems !== "boolean") {
+            report.addError("KEYWORD_TYPE_EXPECTED", ["uniqueItems", "boolean"]);
+        }
+    },
+    maxProperties: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.1.1
+        if (Utils.whatIs(schema.maxProperties) !== "integer") {
+            report.addError("KEYWORD_TYPE_EXPECTED", ["maxProperties", "integer"]);
+        } else if (schema.maxProperties < 0) {
+            report.addError("KEYWORD_MUST_BE", ["maxProperties", "greater than, or equal to 0"]);
+        }
+    },
+    minProperties: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.2.1
+        if (Utils.whatIs(schema.minProperties) !== "integer") {
+            report.addError("KEYWORD_TYPE_EXPECTED", ["minProperties", "integer"]);
+        } else if (schema.minProperties < 0) {
+            report.addError("KEYWORD_MUST_BE", ["minProperties", "greater than, or equal to 0"]);
+        }
+    },
+    required: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.3.1
+        if (Utils.whatIs(schema.required) !== "array") {
+            report.addError("KEYWORD_TYPE_EXPECTED", ["required", "array"]);
+        } else if (schema.required.length === 0) {
+            report.addError("KEYWORD_MUST_BE", ["required", "an array with at least one element"]);
+        } else {
+            var idx = schema.required.length;
+            while (idx--) {
+                if (typeof schema.required[idx] !== "string") {
+                    report.addError("KEYWORD_VALUE_TYPE", ["required", "string"]);
+                }
+            }
+            if (Utils.isUniqueArray(schema.required) === false) {
+                report.addError("KEYWORD_MUST_BE", ["required", "an array with unique items"]);
+            }
+        }
+    },
+    additionalProperties: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.4.1
+        var type = Utils.whatIs(schema.additionalProperties);
+        if (type !== "boolean" && type !== "object") {
+            report.addError("KEYWORD_TYPE_EXPECTED", ["additionalProperties", ["boolean", "object"]]);
+        } else if (type === "object") {
+            report.path.push("additionalProperties");
+            exports.validateSchema.call(this, report, schema.additionalProperties);
+            report.path.pop();
+        }
+    },
+    properties: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.4.1
+        if (Utils.whatIs(schema.properties) !== "object") {
+            report.addError("KEYWORD_TYPE_EXPECTED", ["properties", "object"]);
+            return;
+        }
+
+        var keys = Object.keys(schema.properties),
+            idx = keys.length;
+        while (idx--) {
+            var key = keys[idx],
+                val = schema.properties[key];
+            report.path.push("properties");
+            report.path.push(key);
+            exports.validateSchema.call(this, report, val);
+            report.path.pop();
+            report.path.pop();
+        }
+
+        // custom - strict mode
+        if (this.options.forceAdditional === true && schema.additionalProperties === undefined) {
+            report.addError("KEYWORD_UNDEFINED_STRICT", ["additionalProperties"]);
+        }
+        // custome - assume defined false mode
+        if (this.options.assumeAdditional && schema.additionalProperties === undefined) {
+            schema.additionalProperties = false;
+        }
+        // custom - forceProperties
+        if (this.options.forceProperties === true && keys.length === 0) {
+            report.addError("CUSTOM_MODE_FORCE_PROPERTIES", ["properties"]);
+        }
+    },
+    patternProperties: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.4.1
+        if (Utils.whatIs(schema.patternProperties) !== "object") {
+            report.addError("KEYWORD_TYPE_EXPECTED", ["patternProperties", "object"]);
+            return;
+        }
+
+        var keys = Object.keys(schema.patternProperties),
+            idx = keys.length;
+        while (idx--) {
+            var key = keys[idx],
+                val = schema.patternProperties[key];
+            try {
+                RegExp(key);
+            } catch (e) {
+                report.addError("KEYWORD_PATTERN", ["patternProperties", key]);
+            }
+            report.path.push("patternProperties");
+            report.path.push(key.toString());
+            exports.validateSchema.call(this, report, val);
+            report.path.pop();
+            report.path.pop();
+        }
+
+        // custom - forceProperties
+        if (this.options.forceProperties === true && keys.length === 0) {
+            report.addError("CUSTOM_MODE_FORCE_PROPERTIES", ["patternProperties"]);
+        }
+    },
+    dependencies: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.5.1
+        if (Utils.whatIs(schema.dependencies) !== "object") {
+            report.addError("KEYWORD_TYPE_EXPECTED", ["dependencies", "object"]);
+        } else {
+            var keys = Object.keys(schema.dependencies),
+                idx = keys.length;
+            while (idx--) {
+                var schemaKey = keys[idx],
+                    schemaDependency = schema.dependencies[schemaKey],
+                    type = Utils.whatIs(schemaDependency);
+
+                if (type === "object") {
+                    report.path.push("dependencies");
+                    report.path.push(schemaKey);
+                    exports.validateSchema.call(this, report, schemaDependency);
+                    report.path.pop();
+                    report.path.pop();
+                } else if (type === "array") {
+                    var idx2 = schemaDependency.length;
+                    if (idx2 === 0) {
+                        report.addError("KEYWORD_MUST_BE", ["dependencies", "not empty array"]);
+                    }
+                    while (idx2--) {
+                        if (typeof schemaDependency[idx2] !== "string") {
+                            report.addError("KEYWORD_VALUE_TYPE", ["dependensices", "string"]);
+                        }
+                    }
+                    if (Utils.isUniqueArray(schemaDependency) === false) {
+                        report.addError("KEYWORD_MUST_BE", ["dependencies", "an array with unique items"]);
+                    }
+                } else {
+                    report.addError("KEYWORD_VALUE_TYPE", ["dependencies", "object or array"]);
+                }
+            }
+        }
+    },
+    enum: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.1.1
+        if (Array.isArray(schema.enum) === false) {
+            report.addError("KEYWORD_TYPE_EXPECTED", ["enum", "array"]);
+        } else if (schema.enum.length === 0) {
+            report.addError("KEYWORD_MUST_BE", ["enum", "an array with at least one element"]);
+        } else if (Utils.isUniqueArray(schema.enum) === false) {
+            report.addError("KEYWORD_MUST_BE", ["enum", "an array with unique elements"]);
+        }
+    },
+    type: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.2.1
+        var primitiveTypes = ["array", "boolean", "integer", "number", "null", "object", "string"],
+            primitiveTypeStr = primitiveTypes.join(","),
+            isArray = Array.isArray(schema.type);
+
+        if (isArray) {
+            var idx = schema.type.length;
+            while (idx--) {
+                if (primitiveTypes.indexOf(schema.type[idx]) === -1) {
+                    report.addError("KEYWORD_TYPE_EXPECTED", ["type", primitiveTypeStr]);
+                }
+            }
+            if (Utils.isUniqueArray(schema.type) === false) {
+                report.addError("KEYWORD_MUST_BE", ["type", "an object with unique properties"]);
+            }
+        } else if (typeof schema.type === "string") {
+            if (primitiveTypes.indexOf(schema.type) === -1) {
+                report.addError("KEYWORD_TYPE_EXPECTED", ["type", primitiveTypeStr]);
+            }
+        } else {
+            report.addError("KEYWORD_TYPE_EXPECTED", ["type", ["string", "array"]]);
+        }
+
+        if (this.options.noEmptyStrings === true) {
+            if (schema.type === "string" || isArray && schema.type.indexOf("string") !== -1) {
+                if (schema.minLength === undefined &&
+                    schema.enum === undefined &&
+                    schema.format === undefined) {
+
+                    schema.minLength = 1;
+                }
+            }
+        }
+        if (this.options.noEmptyArrays === true) {
+            if (schema.type === "array" || isArray && schema.type.indexOf("array") !== -1) {
+                if (schema.minItems === undefined) {
+                    schema.minItems = 1;
+                }
+            }
+        }
+        if (this.options.forceProperties === true) {
+            if (schema.type === "object" || isArray && schema.type.indexOf("object") !== -1) {
+                if (schema.properties === undefined && schema.patternProperties === undefined) {
+                    report.addError("KEYWORD_UNDEFINED_STRICT", ["properties"]);
+                }
+            }
+        }
+        if (this.options.forceItems === true) {
+            if (schema.type === "array" || isArray && schema.type.indexOf("array") !== -1) {
+                if (schema.items === undefined) {
+                    report.addError("KEYWORD_UNDEFINED_STRICT", ["items"]);
+                }
+            }
+        }
+        if (this.options.forceMinItems === true) {
+            if (schema.type === "array" || isArray && schema.type.indexOf("array") !== -1) {
+                if (schema.minItems === undefined) {
+                    report.addError("KEYWORD_UNDEFINED_STRICT", ["minItems"]);
+                }
+            }
+        }
+        if (this.options.forceMaxItems === true) {
+            if (schema.type === "array" || isArray && schema.type.indexOf("array") !== -1) {
+                if (schema.maxItems === undefined) {
+                    report.addError("KEYWORD_UNDEFINED_STRICT", ["maxItems"]);
+                }
+            }
+        }
+        if (this.options.forceMinLength === true) {
+            if (schema.type === "string" || isArray && schema.type.indexOf("string") !== -1) {
+                if (schema.minLength === undefined &&
+                    schema.format === undefined &&
+                    schema.enum === undefined &&
+                    schema.pattern === undefined) {
+                    report.addError("KEYWORD_UNDEFINED_STRICT", ["minLength"]);
+                }
+            }
+        }
+        if (this.options.forceMaxLength === true) {
+            if (schema.type === "string" || isArray && schema.type.indexOf("string") !== -1) {
+                if (schema.maxLength === undefined &&
+                    schema.format === undefined &&
+                    schema.enum === undefined &&
+                    schema.pattern === undefined) {
+                    report.addError("KEYWORD_UNDEFINED_STRICT", ["maxLength"]);
+                }
+            }
+        }
+    },
+    allOf: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.3.1
+        if (Array.isArray(schema.allOf) === false) {
+            report.addError("KEYWORD_TYPE_EXPECTED", ["allOf", "array"]);
+        } else if (schema.allOf.length === 0) {
+            report.addError("KEYWORD_MUST_BE", ["allOf", "an array with at least one element"]);
+        } else {
+            var idx = schema.allOf.length;
+            while (idx--) {
+                report.path.push("allOf");
+                report.path.push(idx.toString());
+                exports.validateSchema.call(this, report, schema.allOf[idx]);
+                report.path.pop();
+                report.path.pop();
+            }
+        }
+    },
+    anyOf: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.4.1
+        if (Array.isArray(schema.anyOf) === false) {
+            report.addError("KEYWORD_TYPE_EXPECTED", ["anyOf", "array"]);
+        } else if (schema.anyOf.length === 0) {
+            report.addError("KEYWORD_MUST_BE", ["anyOf", "an array with at least one element"]);
+        } else {
+            var idx = schema.anyOf.length;
+            while (idx--) {
+                report.path.push("anyOf");
+                report.path.push(idx.toString());
+                exports.validateSchema.call(this, report, schema.anyOf[idx]);
+                report.path.pop();
+                report.path.pop();
+            }
+        }
+    },
+    oneOf: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.5.1
+        if (Array.isArray(schema.oneOf) === false) {
+            report.addError("KEYWORD_TYPE_EXPECTED", ["oneOf", "array"]);
+        } else if (schema.oneOf.length === 0) {
+            report.addError("KEYWORD_MUST_BE", ["oneOf", "an array with at least one element"]);
+        } else {
+            var idx = schema.oneOf.length;
+            while (idx--) {
+                report.path.push("oneOf");
+                report.path.push(idx.toString());
+                exports.validateSchema.call(this, report, schema.oneOf[idx]);
+                report.path.pop();
+                report.path.pop();
+            }
+        }
+    },
+    not: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.6.1
+        if (Utils.whatIs(schema.not) !== "object") {
+            report.addError("KEYWORD_TYPE_EXPECTED", ["not", "object"]);
+        } else {
+            report.path.push("not");
+            exports.validateSchema.call(this, report, schema.not);
+            report.path.pop();
+        }
+    },
+    definitions: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.7.1
+        if (Utils.whatIs(schema.definitions) !== "object") {
+            report.addError("KEYWORD_TYPE_EXPECTED", ["definitions", "object"]);
+        } else {
+            var keys = Object.keys(schema.definitions),
+                idx = keys.length;
+            while (idx--) {
+                var key = keys[idx],
+                    val = schema.definitions[key];
+                report.path.push("definitions");
+                report.path.push(key);
+                exports.validateSchema.call(this, report, val);
+                report.path.pop();
+                report.path.pop();
+            }
+        }
+    },
+    format: function (report, schema) {
+        if (typeof schema.format !== "string") {
+            report.addError("KEYWORD_TYPE_EXPECTED", ["format", "string"]);
+        } else {
+            if (FormatValidators[schema.format] === undefined && this.options.ignoreUnknownFormats !== true) {
+                report.addError("UNKNOWN_FORMAT", [schema.format]);
+            }
+        }
+    },
+    id: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-core.html#rfc.section.7.2
+        if (typeof schema.id !== "string") {
+            report.addError("KEYWORD_TYPE_EXPECTED", ["id", "string"]);
+        }
+    },
+    title: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.6.1
+        if (typeof schema.title !== "string") {
+            report.addError("KEYWORD_TYPE_EXPECTED", ["title", "string"]);
+        }
+    },
+    description: function (report, schema) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.6.1
+        if (typeof schema.description !== "string") {
+            report.addError("KEYWORD_TYPE_EXPECTED", ["description", "string"]);
+        }
+    },
+    "default": function (/* report, schema */) {
+        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.6.2
+        // There are no restrictions placed on the value of this keyword.
+    }
+};
+
+/**
+ *
+ * @param {Report} report
+ * @param {*[]} arr
+ *
+ * @returns {boolean}
+ */
+var validateArrayOfSchemas = function (report, arr) {
+    var idx = arr.length;
+    while (idx--) {
+        exports.validateSchema.call(this, report, arr[idx]);
+    }
+    return report.isValid();
+};
+
+/**
+ *
+ * @param {Report} report
+ * @param {*} schema
+ */
+exports.validateSchema = function (report, schema) {
+
+    report.commonErrorMessage = "SCHEMA_VALIDATION_FAILED";
+
+    // if schema is an array, assume it's an array of schemas
+    if (Array.isArray(schema)) {
+        return validateArrayOfSchemas.call(this, report, schema);
+    }
+
+    // do not revalidate schema that has already been validated once
+    if (schema.__$validated) {
+        return true;
+    }
+
+    // if $schema is present, this schema should validate against that $schema
+    var hasParentSchema = schema.$schema && schema.id !== schema.$schema;
+    if (hasParentSchema) {
+        if (schema.__$schemaResolved && schema.__$schemaResolved !== schema) {
+            var subReport = new Report(report);
+            var valid = JsonValidation.validate.call(this, subReport, schema.__$schemaResolved, schema);
+            if (valid === false) {
+                report.addError("PARENT_SCHEMA_VALIDATION_FAILED", null, subReport);
+            }
+        } else {
+            if (this.options.ignoreUnresolvableReferences !== true) {
+                report.addError("REF_UNRESOLVED", [schema.$schema]);
+            }
+        }
+    }
+
+    if (this.options.noTypeless === true) {
+        // issue #36 - inherit type to anyOf, oneOf, allOf if noTypeless is defined
+        if (schema.type !== undefined) {
+            var schemas = [];
+            if (Array.isArray(schema.anyOf)) { schemas = schemas.concat(schema.anyOf); }
+            if (Array.isArray(schema.oneOf)) { schemas = schemas.concat(schema.oneOf); }
+            if (Array.isArray(schema.allOf)) { schemas = schemas.concat(schema.allOf); }
+            schemas.forEach(function (sch) {
+                if (!sch.type) { sch.type = schema.type; }
+            });
+        }
+        // end issue #36
+        if (schema.enum === undefined &&
+            schema.type === undefined &&
+            schema.anyOf === undefined &&
+            schema.oneOf === undefined &&
+            schema.not === undefined &&
+            schema.$ref === undefined) {
+            report.addError("KEYWORD_UNDEFINED_STRICT", ["type"]);
+        }
+    }
+
+    var keys = Object.keys(schema),
+        idx = keys.length;
+    while (idx--) {
+        var key = keys[idx];
+        if (key.indexOf("__") === 0) { continue; }
+        if (SchemaValidators[key] !== undefined) {
+            SchemaValidators[key].call(this, report, schema);
+        } else if (!hasParentSchema) {
+            if (this.options.noExtraKeywords === true) {
+                report.addError("KEYWORD_UNEXPECTED", [key]);
+            }
+        }
+    }
+
+    if (this.options.pedanticCheck === true) {
+        if (schema.enum) {
+            // break recursion
+            var tmpSchema = Utils.clone(schema);
+            delete tmpSchema.enum;
+            delete tmpSchema.default;
+
+            report.path.push("enum");
+            idx = schema.enum.length;
+            while (idx--) {
+                report.path.push(idx.toString());
+                JsonValidation.validate.call(this, report, tmpSchema, schema.enum[idx]);
+                report.path.pop();
+            }
+            report.path.pop();
+        }
+
+        if (schema.default) {
+            report.path.push("default");
+            JsonValidation.validate.call(this, report, schema, schema.default);
+            report.path.pop();
+        }
+    }
+
+    var isValid = report.isValid();
+    if (isValid) {
+        schema.__$validated = true;
+    }
+    return isValid;
+};

SerpentRace_Backend/node_modules/z-schema/src/Utils.js

@@ -0,0 +1,274 @@
+"use strict";
+
+exports.jsonSymbol = Symbol.for("z-schema/json");
+
+exports.schemaSymbol = Symbol.for("z-schema/schema");
+
+/**
+ * @param {object} obj
+ *
+ * @returns {string[]}
+ */
+var sortedKeys = exports.sortedKeys = function (obj) {
+    return Object.keys(obj).sort();
+};
+
+/**
+ *
+ * @param {string} uri
+ *
+ * @returns {boolean}
+ */
+exports.isAbsoluteUri = function (uri) {
+    return /^https?:\/\//.test(uri);
+};
+
+/**
+ *
+ * @param {string} uri
+ *
+ * @returns {boolean}
+ */
+exports.isRelativeUri = function (uri) {
+    // relative URIs that end with a hash sign, issue #56
+    return /.+#/.test(uri);
+};
+
+exports.whatIs = function (what) {
+
+    var to = typeof what;
+
+    if (to === "object") {
+        if (what === null) {
+            return "null";
+        }
+        if (Array.isArray(what)) {
+            return "array";
+        }
+        return "object"; // typeof what === 'object' && what === Object(what) && !Array.isArray(what);
+    }
+
+    if (to === "number") {
+        if (Number.isFinite(what)) {
+            if (what % 1 === 0) {
+                return "integer";
+            } else {
+                return "number";
+            }
+        }
+        if (Number.isNaN(what)) {
+            return "not-a-number";
+        }
+        return "unknown-number";
+    }
+
+    return to; // undefined, boolean, string, function
+
+};
+
+/**
+ *
+ * @param {*} json1
+ * @param {*} json2
+ * @param {*} [options]
+ *
+ * @returns {boolean}
+ */
+exports.areEqual = function areEqual(json1, json2, options) {
+
+    options = options || {};
+    var caseInsensitiveComparison = options.caseInsensitiveComparison || false;
+
+    // http://json-schema.org/latest/json-schema-core.html#rfc.section.3.6
+
+    // Two JSON values are said to be equal if and only if:
+    // both are nulls; or
+    // both are booleans, and have the same value; or
+    // both are strings, and have the same value; or
+    // both are numbers, and have the same mathematical value; or
+    if (json1 === json2) {
+        return true;
+    }
+    if (
+      caseInsensitiveComparison === true &&
+      typeof json1 === "string" && typeof json2 === "string" &&
+      json1.toUpperCase() === json2.toUpperCase()) {
+        return true;
+    }
+
+    var i, len;
+
+    // both are arrays, and:
+    if (Array.isArray(json1) && Array.isArray(json2)) {
+        // have the same number of items; and
+        if (json1.length !== json2.length) {
+            return false;
+        }
+        // items at the same index are equal according to this definition; or
+        len = json1.length;
+        for (i = 0; i < len; i++) {
+            if (!areEqual(json1[i], json2[i], { caseInsensitiveComparison: caseInsensitiveComparison })) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    // both are objects, and:
+    if (exports.whatIs(json1) === "object" && exports.whatIs(json2) === "object") {
+        // have the same set of property names; and
+        var keys1 = sortedKeys(json1);
+        var keys2 = sortedKeys(json2);
+        if (!areEqual(keys1, keys2, { caseInsensitiveComparison: caseInsensitiveComparison })) {
+            return false;
+        }
+        // values for a same property name are equal according to this definition.
+        len = keys1.length;
+        for (i = 0; i < len; i++) {
+            if (!areEqual(json1[keys1[i]], json2[keys1[i]], { caseInsensitiveComparison: caseInsensitiveComparison })) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    return false;
+};
+
+/**
+ *
+ * @param {*[]} arr
+ * @param {number[]} [indexes]
+ *
+ * @returns {boolean}
+ */
+exports.isUniqueArray = function (arr, indexes) {
+    var i, j, l = arr.length;
+    for (i = 0; i < l; i++) {
+        for (j = i + 1; j < l; j++) {
+            if (exports.areEqual(arr[i], arr[j])) {
+                if (indexes) { indexes.push(i, j); }
+                return false;
+            }
+        }
+    }
+    return true;
+};
+
+/**
+ *
+ * @param {*} bigSet
+ * @param {*} subSet
+ *
+ * @returns {*[]}
+ */
+exports.difference = function (bigSet, subSet) {
+    var arr = [],
+        idx = bigSet.length;
+    while (idx--) {
+        if (subSet.indexOf(bigSet[idx]) === -1) {
+            arr.push(bigSet[idx]);
+        }
+    }
+    return arr;
+};
+
+// NOT a deep version of clone
+exports.clone = function (src) {
+    if (typeof src === "undefined") { return void 0; }
+    if (typeof src !== "object" || src === null) { return src; }
+    var res, idx;
+    if (Array.isArray(src)) {
+        res = [];
+        idx = src.length;
+        while (idx--) {
+            res[idx] = src[idx];
+        }
+    } else {
+        res = {};
+        var keys = Object.keys(src);
+        idx = keys.length;
+        while (idx--) {
+            var key = keys[idx];
+            res[key] = src[key];
+        }
+    }
+    return res;
+};
+
+exports.cloneDeep = function (src) {
+    var vidx = 0, visited = new Map(), cloned = [];
+    function cloneDeep(src) {
+        if (typeof src !== "object" || src === null) { return src; }
+        var res, idx, cidx;
+
+        cidx = visited.get(src);
+        if (cidx !== undefined) { return cloned[cidx]; }
+
+        visited.set(src, vidx++);
+        if (Array.isArray(src)) {
+            res = [];
+            cloned.push(res);
+            idx = src.length;
+            while (idx--) {
+                res[idx] = cloneDeep(src[idx]);
+            }
+        } else {
+            res = {};
+            cloned.push(res);
+            var keys = Object.keys(src);
+            idx = keys.length;
+            while (idx--) {
+                var key = keys[idx];
+                res[key] = cloneDeep(src[key]);
+            }
+        }
+        return res;
+    }
+    return cloneDeep(src);
+};
+
+/*
+  following function comes from punycode.js library
+  see: https://github.com/bestiejs/punycode.js
+*/
+/*jshint -W016*/
+/**
+ * Creates an array containing the numeric code points of each Unicode
+ * character in the string. While JavaScript uses UCS-2 internally,
+ * this function will convert a pair of surrogate halves (each of which
+ * UCS-2 exposes as separate characters) into a single code point,
+ * matching UTF-16.
+ * @see `punycode.ucs2.encode`
+ * @see <https://mathiasbynens.be/notes/javascript-encoding>
+ * @memberOf punycode.ucs2
+ * @name decode
+ * @param {String} string The Unicode input string (UCS-2).
+ * @returns {Array} The new array of code points.
+ */
+exports.ucs2decode = function (string) {
+    var output = [],
+        counter = 0,
+        length = string.length,
+        value,
+        extra;
+    while (counter < length) {
+        value = string.charCodeAt(counter++);
+        if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
+            // high surrogate, and there is a next character
+            extra = string.charCodeAt(counter++);
+            if ((extra & 0xFC00) == 0xDC00) { // low surrogate
+                output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
+            } else {
+                // unmatched surrogate; only append this code unit, in case the next
+                // code unit is the high surrogate of a surrogate pair
+                output.push(value);
+                counter--;
+            }
+        } else {
+            output.push(value);
+        }
+    }
+    return output;
+};
+/*jshint +W016*/

SerpentRace_Backend/node_modules/z-schema/src/ZSchema.js

@@ -0,0 +1,409 @@
+"use strict";
+
+require("./Polyfills");
+var get               = require("lodash.get");
+var Report            = require("./Report");
+var FormatValidators  = require("./FormatValidators");
+var JsonValidation    = require("./JsonValidation");
+var SchemaCache       = require("./SchemaCache");
+var SchemaCompilation = require("./SchemaCompilation");
+var SchemaValidation  = require("./SchemaValidation");
+var Utils             = require("./Utils");
+var Draft4Schema      = require("./schemas/schema.json");
+var Draft4HyperSchema = require("./schemas/hyper-schema.json");
+
+/**
+ * default options
+ */
+var defaultOptions = {
+    // default timeout for all async tasks
+    asyncTimeout: 2000,
+    // force additionalProperties and additionalItems to be defined on "object" and "array" types
+    forceAdditional: false,
+    // assume additionalProperties and additionalItems are defined as "false" where appropriate
+    assumeAdditional: false,
+    // do case insensitive comparison for enums
+    enumCaseInsensitiveComparison: false,
+    // force items to be defined on "array" types
+    forceItems: false,
+    // force minItems to be defined on "array" types
+    forceMinItems: false,
+    // force maxItems to be defined on "array" types
+    forceMaxItems: false,
+    // force minLength to be defined on "string" types
+    forceMinLength: false,
+    // force maxLength to be defined on "string" types
+    forceMaxLength: false,
+    // force properties or patternProperties to be defined on "object" types
+    forceProperties: false,
+    // ignore references that cannot be resolved (remote schemas) // TODO: make sure this is only for remote schemas, not local ones
+    ignoreUnresolvableReferences: false,
+    // disallow usage of keywords that this validator can't handle
+    noExtraKeywords: false,
+    // disallow usage of schema's without "type" defined
+    noTypeless: false,
+    // disallow zero length strings in validated objects
+    noEmptyStrings: false,
+    // disallow zero length arrays in validated objects
+    noEmptyArrays: false,
+    // forces "uri" format to be in fully rfc3986 compliant
+    strictUris: false,
+    // turn on some of the above
+    strictMode: false,
+    // report error paths as an array of path segments to get to the offending node
+    reportPathAsArray: false,
+    // stop validation as soon as an error is found
+    breakOnFirstError: false,
+    // check if schema follows best practices and common sense
+    pedanticCheck: false,
+    // ignore unknown formats (do not report them as an error)
+    ignoreUnknownFormats: false,
+    // function to be called on every schema
+    customValidator: null
+};
+
+function normalizeOptions(options) {
+    var normalized;
+
+    // options
+    if (typeof options === "object") {
+        var keys = Object.keys(options),
+            idx = keys.length,
+            key;
+
+        // check that the options are correctly configured
+        while (idx--) {
+            key = keys[idx];
+            if (defaultOptions[key] === undefined) {
+                throw new Error("Unexpected option passed to constructor: " + key);
+            }
+        }
+
+        // copy the default options into passed options
+        keys = Object.keys(defaultOptions);
+        idx = keys.length;
+        while (idx--) {
+            key = keys[idx];
+            if (options[key] === undefined) {
+                options[key] = Utils.clone(defaultOptions[key]);
+            }
+        }
+
+        normalized = options;
+    } else {
+        normalized = Utils.clone(defaultOptions);
+    }
+
+    if (normalized.strictMode === true) {
+        normalized.forceAdditional  = true;
+        normalized.forceItems       = true;
+        normalized.forceMaxLength   = true;
+        normalized.forceProperties  = true;
+        normalized.noExtraKeywords  = true;
+        normalized.noTypeless       = true;
+        normalized.noEmptyStrings   = true;
+        normalized.noEmptyArrays    = true;
+    }
+
+    return normalized;
+}
+
+/**
+ * @class
+ *
+ * @param {*} [options]
+ */
+function ZSchema(options) {
+    this.cache = {};
+    this.referenceCache = [];
+    this.validateOptions = {};
+
+    this.options = normalizeOptions(options);
+
+    // Disable strict validation for the built-in schemas
+    var metaschemaOptions = normalizeOptions({ });
+
+    this.setRemoteReference("http://json-schema.org/draft-04/schema", Draft4Schema, metaschemaOptions);
+    this.setRemoteReference("http://json-schema.org/draft-04/hyper-schema", Draft4HyperSchema, metaschemaOptions);
+}
+
+/**
+ * instance methods
+ *
+ * @param {*} schema
+ *
+ * @returns {boolean}
+ */
+ZSchema.prototype.compileSchema = function (schema) {
+    var report = new Report(this.options);
+
+    schema = SchemaCache.getSchema.call(this, report, schema);
+
+    SchemaCompilation.compileSchema.call(this, report, schema);
+
+    this.lastReport = report;
+    return report.isValid();
+};
+
+/**
+ *
+ * @param {*} schema
+ *
+ * @returns {boolean}
+ */
+ZSchema.prototype.validateSchema = function (schema) {
+    if (Array.isArray(schema) && schema.length === 0) {
+        throw new Error(".validateSchema was called with an empty array");
+    }
+
+    var report = new Report(this.options);
+
+    schema = SchemaCache.getSchema.call(this, report, schema);
+
+    var compiled = SchemaCompilation.compileSchema.call(this, report, schema);
+    if (compiled) { SchemaValidation.validateSchema.call(this, report, schema); }
+
+    this.lastReport = report;
+    return report.isValid();
+};
+
+/**
+ *
+ * @param {*} json
+ * @param {*} schema
+ * @param {*} [options]
+ * @param {function(*, *)} [callback]
+ *
+ * @returns {boolean}
+ */
+ZSchema.prototype.validate = function (json, schema, options, callback) {
+
+    if (Utils.whatIs(options) === "function") {
+        callback = options;
+        options = {};
+    }
+    if (!options) { options = {}; }
+
+    this.validateOptions = options;
+
+    var whatIs = Utils.whatIs(schema);
+    if (whatIs !== "string" && whatIs !== "object") {
+        var e = new Error("Invalid .validate call - schema must be a string or object but " + whatIs + " was passed!");
+        if (callback) {
+            process.nextTick(function () {
+                callback(e, false);
+            });
+            return;
+        }
+        throw e;
+    }
+
+    var foundError = false;
+    var report = new Report(this.options);
+    report.json = json;
+
+    if (typeof schema === "string") {
+        var schemaName = schema;
+        schema = SchemaCache.getSchema.call(this, report, schemaName);
+        if (!schema) {
+            throw new Error("Schema with id '" + schemaName + "' wasn't found in the validator cache!");
+        }
+    } else {
+        schema = SchemaCache.getSchema.call(this, report, schema);
+    }
+
+    var compiled = false;
+    if (!foundError) {
+        compiled = SchemaCompilation.compileSchema.call(this, report, schema);
+    }
+    if (!compiled) {
+        this.lastReport = report;
+        foundError = true;
+    }
+
+    var validated = false;
+    if (!foundError) {
+        validated = SchemaValidation.validateSchema.call(this, report, schema);
+    }
+    if (!validated) {
+        this.lastReport = report;
+        foundError = true;
+    }
+
+    if (options.schemaPath) {
+        report.rootSchema = schema;
+        schema = get(schema, options.schemaPath);
+        if (!schema) {
+            throw new Error("Schema path '" + options.schemaPath + "' wasn't found in the schema!");
+        }
+    }
+
+    if (!foundError) {
+        JsonValidation.validate.call(this, report, schema, json);
+    }
+
+    if (callback) {
+        report.processAsyncTasks(this.options.asyncTimeout, callback);
+        return;
+    } else if (report.asyncTasks.length > 0) {
+        throw new Error("This validation has async tasks and cannot be done in sync mode, please provide callback argument.");
+    }
+
+    // assign lastReport so errors are retrievable in sync mode
+    this.lastReport = report;
+    return report.isValid();
+};
+ZSchema.prototype.getLastError = function () {
+    if (this.lastReport.errors.length === 0) {
+        return null;
+    }
+    var e = new Error();
+    e.name = "z-schema validation error";
+    e.message = this.lastReport.commonErrorMessage;
+    e.details = this.lastReport.errors;
+    return e;
+};
+ZSchema.prototype.getLastErrors = function () {
+    return this.lastReport && this.lastReport.errors.length > 0 ? this.lastReport.errors : null;
+};
+ZSchema.prototype.getMissingReferences = function (arr) {
+    arr = arr || this.lastReport.errors;
+    var res = [],
+        idx = arr.length;
+    while (idx--) {
+        var error = arr[idx];
+        if (error.code === "UNRESOLVABLE_REFERENCE") {
+            var reference = error.params[0];
+            if (res.indexOf(reference) === -1) {
+                res.push(reference);
+            }
+        }
+        if (error.inner) {
+            res = res.concat(this.getMissingReferences(error.inner));
+        }
+    }
+    return res;
+};
+ZSchema.prototype.getMissingRemoteReferences = function () {
+    var missingReferences = this.getMissingReferences(),
+        missingRemoteReferences = [],
+        idx = missingReferences.length;
+    while (idx--) {
+        var remoteReference = SchemaCache.getRemotePath(missingReferences[idx]);
+        if (remoteReference && missingRemoteReferences.indexOf(remoteReference) === -1) {
+            missingRemoteReferences.push(remoteReference);
+        }
+    }
+    return missingRemoteReferences;
+};
+ZSchema.prototype.setRemoteReference = function (uri, schema, validationOptions) {
+    if (typeof schema === "string") {
+        schema = JSON.parse(schema);
+    } else {
+        schema = Utils.cloneDeep(schema);
+    }
+
+    if (validationOptions) {
+        schema.__$validationOptions = normalizeOptions(validationOptions);
+    }
+
+    SchemaCache.cacheSchemaByUri.call(this, uri, schema);
+};
+ZSchema.prototype.getResolvedSchema = function (schema) {
+    var report = new Report(this.options);
+    schema = SchemaCache.getSchema.call(this, report, schema);
+
+    // clone before making any modifications
+    schema = Utils.cloneDeep(schema);
+
+    var visited = [];
+
+    // clean-up the schema and resolve references
+    var cleanup = function (schema) {
+        var key,
+            typeOf = Utils.whatIs(schema);
+        if (typeOf !== "object" && typeOf !== "array") {
+            return;
+        }
+
+        if (schema.___$visited) {
+            return;
+        }
+
+        schema.___$visited = true;
+        visited.push(schema);
+
+        if (schema.$ref && schema.__$refResolved) {
+            var from = schema.__$refResolved;
+            var to = schema;
+            delete schema.$ref;
+            delete schema.__$refResolved;
+            for (key in from) {
+                if (from.hasOwnProperty(key)) {
+                    to[key] = from[key];
+                }
+            }
+        }
+        for (key in schema) {
+            if (schema.hasOwnProperty(key)) {
+                if (key.indexOf("__$") === 0) {
+                    delete schema[key];
+                } else {
+                    cleanup(schema[key]);
+                }
+            }
+        }
+    };
+
+    cleanup(schema);
+    visited.forEach(function (s) {
+        delete s.___$visited;
+    });
+
+    this.lastReport = report;
+    if (report.isValid()) {
+        return schema;
+    } else {
+        throw this.getLastError();
+    }
+};
+
+/**
+ *
+ * @param {*} schemaReader
+ *
+ * @returns {void}
+ */
+ZSchema.prototype.setSchemaReader = function (schemaReader) {
+    return ZSchema.setSchemaReader(schemaReader);
+};
+
+ZSchema.prototype.getSchemaReader = function () {
+    return ZSchema.schemaReader;
+};
+
+ZSchema.schemaReader = undefined;
+/*
+    static methods
+*/
+ZSchema.setSchemaReader = function (schemaReader) {
+    ZSchema.schemaReader = schemaReader;
+};
+ZSchema.registerFormat = function (formatName, validatorFunction) {
+    FormatValidators[formatName] = validatorFunction;
+};
+ZSchema.unregisterFormat = function (formatName) {
+    delete FormatValidators[formatName];
+};
+ZSchema.getRegisteredFormats = function () {
+    return Object.keys(FormatValidators);
+};
+ZSchema.getDefaultOptions = function () {
+    return Utils.cloneDeep(defaultOptions);
+};
+
+ZSchema.schemaSymbol = Utils.schemaSymbol;
+
+ZSchema.jsonSymbol = Utils.jsonSymbol;
+
+module.exports = ZSchema;

SerpentRace_Backend/node_modules/z-schema/src/schemas/hyper-schema.json

@@ -0,0 +1,158 @@
+{
+    "$schema": "http://json-schema.org/draft-04/hyper-schema#",
+    "id": "http://json-schema.org/draft-04/hyper-schema#",
+    "title": "JSON Hyper-Schema",
+    "allOf": [
+        {
+            "$ref": "http://json-schema.org/draft-04/schema#"
+        }
+    ],
+    "properties": {
+        "additionalItems": {
+            "anyOf": [
+                {
+                    "type": "boolean"
+                },
+                {
+                    "$ref": "#"
+                }
+            ]
+        },
+        "additionalProperties": {
+            "anyOf": [
+                {
+                    "type": "boolean"
+                },
+                {
+                    "$ref": "#"
+                }
+            ]
+        },
+        "dependencies": {
+            "additionalProperties": {
+                "anyOf": [
+                    {
+                        "$ref": "#"
+                    },
+                    {
+                        "type": "array"
+                    }
+                ]
+            }
+        },
+        "items": {
+            "anyOf": [
+                {
+                    "$ref": "#"
+                },
+                {
+                    "$ref": "#/definitions/schemaArray"
+                }
+            ]
+        },
+        "definitions": {
+            "additionalProperties": {
+                "$ref": "#"
+            }
+        },
+        "patternProperties": {
+            "additionalProperties": {
+                "$ref": "#"
+            }
+        },
+        "properties": {
+            "additionalProperties": {
+                "$ref": "#"
+            }
+        },
+        "allOf": {
+            "$ref": "#/definitions/schemaArray"
+        },
+        "anyOf": {
+            "$ref": "#/definitions/schemaArray"
+        },
+        "oneOf": {
+            "$ref": "#/definitions/schemaArray"
+        },
+        "not": {
+            "$ref": "#"
+        },
+
+        "links": {
+            "type": "array",
+            "items": {
+                "$ref": "#/definitions/linkDescription"
+            }
+        },
+        "fragmentResolution": {
+            "type": "string"
+        },
+        "media": {
+            "type": "object",
+            "properties": {
+                "type": {
+                    "description": "A media type, as described in RFC 2046",
+                    "type": "string"
+                },
+                "binaryEncoding": {
+                    "description": "A content encoding scheme, as described in RFC 2045",
+                    "type": "string"
+                }
+            }
+        },
+        "pathStart": {
+            "description": "Instances' URIs must start with this value for this schema to apply to them",
+            "type": "string",
+            "format": "uri"
+        }
+    },
+    "definitions": {
+        "schemaArray": {
+            "type": "array",
+            "items": {
+                "$ref": "#"
+            }
+        },
+        "linkDescription": {
+            "title": "Link Description Object",
+            "type": "object",
+            "required": [ "href", "rel" ],
+            "properties": {
+                "href": {
+                    "description": "a URI template, as defined by RFC 6570, with the addition of the $, ( and ) characters for pre-processing",
+                    "type": "string"
+                },
+                "rel": {
+                    "description": "relation to the target resource of the link",
+                    "type": "string"
+                },
+                "title": {
+                    "description": "a title for the link",
+                    "type": "string"
+                },
+                "targetSchema": {
+                    "description": "JSON Schema describing the link target",
+                    "$ref": "#"
+                },
+                "mediaType": {
+                    "description": "media type (as defined by RFC 2046) describing the link target",
+                    "type": "string"
+                },
+                "method": {
+                    "description": "method for requesting the target of the link (e.g. for HTTP this might be \"GET\" or \"DELETE\")",
+                    "type": "string"
+                },
+                "encType": {
+                    "description": "The media type in which to submit data along with the request",
+                    "type": "string",
+                    "default": "application/json"
+                },
+                "schema": {
+                    "description": "Schema describing the data to submit along with the request",
+                    "$ref": "#"
+                }
+            }
+        }
+    }
+}
+

SerpentRace_Backend/node_modules/z-schema/src/schemas/schema.json

@@ -0,0 +1,151 @@
+{
+    "id": "http://json-schema.org/draft-04/schema#",
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Core schema meta-schema",
+    "definitions": {
+        "schemaArray": {
+            "type": "array",
+            "minItems": 1,
+            "items": { "$ref": "#" }
+        },
+        "positiveInteger": {
+            "type": "integer",
+            "minimum": 0
+        },
+        "positiveIntegerDefault0": {
+            "allOf": [ { "$ref": "#/definitions/positiveInteger" }, { "default": 0 } ]
+        },
+        "simpleTypes": {
+            "enum": [ "array", "boolean", "integer", "null", "number", "object", "string" ]
+        },
+        "stringArray": {
+            "type": "array",
+            "items": { "type": "string" },
+            "minItems": 1,
+            "uniqueItems": true
+        }
+    },
+    "type": "object",
+    "properties": {
+        "id": {
+            "type": "string",
+            "format": "uri"
+        },
+        "$schema": {
+            "type": "string",
+            "format": "uri"
+        },
+        "title": {
+            "type": "string"
+        },
+        "description": {
+            "type": "string"
+        },
+        "default": {},
+        "multipleOf": {
+            "type": "number",
+            "minimum": 0,
+            "exclusiveMinimum": true
+        },
+        "maximum": {
+            "type": "number"
+        },
+        "exclusiveMaximum": {
+            "type": "boolean",
+            "default": false
+        },
+        "minimum": {
+            "type": "number"
+        },
+        "exclusiveMinimum": {
+            "type": "boolean",
+            "default": false
+        },
+        "maxLength": { "$ref": "#/definitions/positiveInteger" },
+        "minLength": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "pattern": {
+            "type": "string",
+            "format": "regex"
+        },
+        "additionalItems": {
+            "anyOf": [
+                { "type": "boolean" },
+                { "$ref": "#" }
+            ],
+            "default": {}
+        },
+        "items": {
+            "anyOf": [
+                { "$ref": "#" },
+                { "$ref": "#/definitions/schemaArray" }
+            ],
+            "default": {}
+        },
+        "maxItems": { "$ref": "#/definitions/positiveInteger" },
+        "minItems": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "uniqueItems": {
+            "type": "boolean",
+            "default": false
+        },
+        "maxProperties": { "$ref": "#/definitions/positiveInteger" },
+        "minProperties": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "required": { "$ref": "#/definitions/stringArray" },
+        "additionalProperties": {
+            "anyOf": [
+                { "type": "boolean" },
+                { "$ref": "#" }
+            ],
+            "default": {}
+        },
+        "definitions": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "properties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "patternProperties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "dependencies": {
+            "type": "object",
+            "additionalProperties": {
+                "anyOf": [
+                    { "$ref": "#" },
+                    { "$ref": "#/definitions/stringArray" }
+                ]
+            }
+        },
+        "enum": {
+            "type": "array",
+            "minItems": 1,
+            "uniqueItems": true
+        },
+        "type": {
+            "anyOf": [
+                { "$ref": "#/definitions/simpleTypes" },
+                {
+                    "type": "array",
+                    "items": { "$ref": "#/definitions/simpleTypes" },
+                    "minItems": 1,
+                    "uniqueItems": true
+                }
+            ]
+        },
+        "format": { "type": "string" },
+        "allOf": { "$ref": "#/definitions/schemaArray" },
+        "anyOf": { "$ref": "#/definitions/schemaArray" },
+        "oneOf": { "$ref": "#/definitions/schemaArray" },
+        "not": { "$ref": "#" }
+    },
+    "dependencies": {
+        "exclusiveMaximum": [ "maximum" ],
+        "exclusiveMinimum": [ "minimum" ]
+    },
+    "default": {}
+}