First Commit

node_modules/mongoose/lib/error/browserMissingSchema.js

@@ -0,0 +1,38 @@
+/*!
+ * Module dependencies.
+ */
+
+'use strict';
+
+const MongooseError = require('./');
+
+/*!
+ * MissingSchema Error constructor.
+ *
+ * @inherits MongooseError
+ */
+
+function MissingSchemaError() {
+  const msg = 'Schema hasn\'t been registered for document.\n'
+          + 'Use mongoose.Document(name, schema)';
+  MongooseError.call(this, msg);
+  this.name = 'MissingSchemaError';
+  if (Error.captureStackTrace) {
+    Error.captureStackTrace(this);
+  } else {
+    this.stack = new Error().stack;
+  }
+}
+
+/*!
+ * Inherits from MongooseError.
+ */
+
+MissingSchemaError.prototype = Object.create(MongooseError.prototype);
+MissingSchemaError.prototype.constructor = MongooseError;
+
+/*!
+ * exports
+ */
+
+module.exports = MissingSchemaError;

node_modules/mongoose/lib/error/cast.js

@@ -0,0 +1,62 @@
+'use strict';
+
+/*!
+ * Module dependencies.
+ */
+
+const MongooseError = require('./mongooseError');
+const util = require('util');
+
+/**
+ * Casting Error constructor.
+ *
+ * @param {String} type
+ * @param {String} value
+ * @inherits MongooseError
+ * @api private
+ */
+
+function CastError(type, value, path, reason) {
+  let stringValue = util.inspect(value);
+  stringValue = stringValue.replace(/^'/, '"').replace(/'$/, '"');
+  if (!stringValue.startsWith('"')) {
+    stringValue = '"' + stringValue + '"';
+  }
+  MongooseError.call(this, 'Cast to ' + type + ' failed for value ' +
+    stringValue + ' at path "' + path + '"');
+  this.name = 'CastError';
+  if (Error.captureStackTrace) {
+    Error.captureStackTrace(this);
+  } else {
+    this.stack = new Error().stack;
+  }
+  this.stringValue = stringValue;
+  this.kind = type;
+  this.value = value;
+  this.path = path;
+  this.reason = reason;
+}
+
+/*!
+ * Inherits from MongooseError.
+ */
+
+CastError.prototype = Object.create(MongooseError.prototype);
+CastError.prototype.constructor = MongooseError;
+
+/*!
+ * ignore
+ */
+
+CastError.prototype.setModel = function(model) {
+  this.model = model;
+  this.message = 'Cast to ' + this.kind + ' failed for value ' +
+    this.stringValue + ' at path "' + this.path + '"' + ' for model "' +
+    model.modelName + '"';
+};
+
+/*!
+ * exports
+ */
+
+module.exports = CastError;

node_modules/mongoose/lib/error/disconnected.js

@@ -0,0 +1,43 @@
+/*!
+ * Module dependencies.
+ */
+
+'use strict';
+
+const MongooseError = require('./');
+
+/**
+ * The connection failed to reconnect and will never successfully reconnect to
+ * MongoDB without manual intervention.
+ *
+ * @param {String} type
+ * @param {String} value
+ * @inherits MongooseError
+ * @api private
+ */
+
+function DisconnectedError(connectionString) {
+  MongooseError.call(this, 'Ran out of retries trying to reconnect to "' +
+    connectionString + '". Try setting `server.reconnectTries` and ' +
+    '`server.reconnectInterval` to something higher.');
+  this.name = 'DisconnectedError';
+  if (Error.captureStackTrace) {
+    Error.captureStackTrace(this);
+  } else {
+    this.stack = new Error().stack;
+  }
+}
+
+/*!
+ * Inherits from MongooseError.
+ */
+
+DisconnectedError.prototype = Object.create(MongooseError.prototype);
+DisconnectedError.prototype.constructor = MongooseError;
+
+
+/*!
+ * exports
+ */
+
+module.exports = DisconnectedError;

node_modules/mongoose/lib/error/divergentArray.js

@@ -0,0 +1,48 @@
+
+/*!
+ * Module dependencies.
+ */
+
+'use strict';
+
+const MongooseError = require('./');
+
+/*!
+ * DivergentArrayError constructor.
+ *
+ * @inherits MongooseError
+ */
+
+function DivergentArrayError(paths) {
+  const msg = 'For your own good, using `document.save()` to update an array '
+          + 'which was selected using an $elemMatch projection OR '
+          + 'populated using skip, limit, query conditions, or exclusion of '
+          + 'the _id field when the operation results in a $pop or $set of '
+          + 'the entire array is not supported. The following '
+          + 'path(s) would have been modified unsafely:\n'
+          + '  ' + paths.join('\n  ') + '\n'
+          + 'Use Model.update() to update these arrays instead.';
+  // TODO write up a docs page (FAQ) and link to it
+
+  MongooseError.call(this, msg);
+  this.name = 'DivergentArrayError';
+  if (Error.captureStackTrace) {
+    Error.captureStackTrace(this);
+  } else {
+    this.stack = new Error().stack;
+  }
+}
+
+/*!
+ * Inherits from MongooseError.
+ */
+
+DivergentArrayError.prototype = Object.create(MongooseError.prototype);
+DivergentArrayError.prototype.constructor = MongooseError;
+
+
+/*!
+ * exports
+ */
+
+module.exports = DivergentArrayError;

node_modules/mongoose/lib/error/index.js

@@ -0,0 +1,180 @@
+'use strict';
+
+/**
+ * MongooseError constructor. MongooseError is the base class for all
+ * Mongoose-specific errors.
+ *
+ * ####Example:
+ *     const Model = mongoose.model('Test', new Schema({ answer: Number }));
+ *     const doc = new Model({ answer: 'not a number' });
+ *     const err = doc.validateSync();
+ *
+ *     err instanceof mongoose.Error; // true
+ *
+ * @constructor Error
+ * @param {String} msg Error message
+ * @inherits Error https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error
+ */
+
+const MongooseError = require('./mongooseError');
+
+/**
+ * The name of the error. The name uniquely identifies this Mongoose error. The
+ * possible values are:
+ *
+ * - `MongooseError`: general Mongoose error
+ * - `CastError`: Mongoose could not convert a value to the type defined in the schema path. May be in a `ValidationError` class' `errors` property.
+ * - `DisconnectedError`: This [connection](connections.html) timed out in trying to reconnect to MongoDB and will not successfully reconnect to MongoDB unless you explicitly reconnect.
+ * - `DivergentArrayError`: You attempted to `save()` an array that was modified after you loaded it with a `$elemMatch` or similar projection
+ * - `MissingSchemaError`: You tried to access a model with [`mongoose.model()`](api.html#mongoose_Mongoose-model) that was not defined
+ * - `DocumentNotFoundError`: The document you tried to [`save()`](api.html#document_Document-save) was not found
+ * - `ValidatorError`: error from an individual schema path's validator
+ * - `ValidationError`: error returned from [`validate()`](api.html#document_Document-validate) or [`validateSync()`](api.html#document_Document-validateSync). Contains zero or more `ValidatorError` instances in `.errors` property.
+ * - `MissingSchemaError`: You called `mongoose.Document()` without a schema
+ * - `ObjectExpectedError`: Thrown when you set a nested path to a non-object value with [strict mode set](guide.html#strict).
+ * - `ObjectParameterError`: Thrown when you pass a non-object value to a function which expects an object as a paramter
+ * - `OverwriteModelError`: Thrown when you call [`mongoose.model()`](api.html#mongoose_Mongoose-model) to re-define a model that was already defined.
+ * - `ParallelSaveError`: Thrown when you call [`save()`](api.html#model_Model-save) on a document when the same document instance is already saving.
+ * - `StrictModeError`: Thrown when you set a path that isn't the schema and [strict mode](guide.html#strict) is set to `throw`.
+ * - `VersionError`: Thrown when the [document is out of sync](guide.html#versionKey)
+ *
+ * @api public
+ * @property {String} name
+ * @memberOf Error
+ * @instance
+ */
+
+/*!
+ * Module exports.
+ */
+
+module.exports = exports = MongooseError;
+
+/**
+ * The default built-in validator error messages.
+ *
+ * @see Error.messages #error_messages_MongooseError-messages
+ * @api public
+ * @memberOf Error
+ * @static messages
+ */
+
+MongooseError.messages = require('./messages');
+
+// backward compat
+MongooseError.Messages = MongooseError.messages;
+
+/**
+ * An instance of this error class will be returned when `save()` fails
+ * because the underlying
+ * document was not found. The constructor takes one parameter, the
+ * conditions that mongoose passed to `update()` when trying to update
+ * the document.
+ *
+ * @api public
+ * @memberOf Error
+ * @static DocumentNotFoundError
+ */
+
+MongooseError.DocumentNotFoundError = require('./notFound');
+
+/**
+ * An instance of this error class will be returned when mongoose failed to
+ * cast a value.
+ *
+ * @api public
+ * @memberOf Error
+ * @static CastError
+ */
+
+MongooseError.CastError = require('./cast');
+
+/**
+ * An instance of this error class will be returned when [validation](/docs/validation.html) failed.
+ * The `errors` property contains an object whose keys are the paths that failed and whose values are
+ * instances of CastError or ValidationError.
+ *
+ * @api public
+ * @memberOf Error
+ * @static ValidationError
+ */
+
+MongooseError.ValidationError = require('./validation');
+
+/**
+ * A `ValidationError` has a hash of `errors` that contain individual `ValidatorError` instances
+ *
+ * @api public
+ * @memberOf Error
+ * @static ValidatorError
+ */
+
+MongooseError.ValidatorError = require('./validator');
+
+/**
+ * An instance of this error class will be returned when you call `save()` after
+ * the document in the database was changed in a potentially unsafe way. See
+ * the [`versionKey` option](/docs/guide.html#versionKey) for more information.
+ *
+ * @api public
+ * @memberOf Error
+ * @static VersionError
+ */
+
+MongooseError.VersionError = require('./version');
+
+/**
+ * An instance of this error class will be returned when you call `save()` multiple
+ * times on the same document in parallel. See the [FAQ](/docs/faq.html) for more
+ * information.
+ *
+ * @api public
+ * @memberOf Error
+ * @static ParallelSaveError
+ */
+
+MongooseError.ParallelSaveError = require('./parallelSave');
+
+/**
+ * Thrown when a model with the given name was already registered on the connection.
+ * See [the FAQ about `OverwriteModelError`](/docs/faq.html#overwrite-model-error).
+ *
+ * @api public
+ * @memberOf Error
+ * @static OverwriteModelError
+ */
+
+MongooseError.OverwriteModelError = require('./overwriteModel');
+
+/**
+ * Thrown when you try to access a model that has not been registered yet
+ *
+ * @api public
+ * @memberOf Error
+ * @static MissingSchemaError
+ */
+
+MongooseError.MissingSchemaError = require('./missingSchema');
+
+/**
+ * An instance of this error will be returned if you used an array projection
+ * and then modified the array in an unsafe way.
+ *
+ * @api public
+ * @memberOf Error
+ * @static DivergentArrayError
+ */
+
+MongooseError.DivergentArrayError = require('./divergentArray');
+
+/**
+ * Thrown when your try to pass values to model contrtuctor that
+ * were not specified in schema or change immutable properties when
+ * `strict` mode is `"throw"`
+ *
+ * @api public
+ * @memberOf Error
+ * @static StrictModeError
+ */
+
+MongooseError.StrictModeError = require('./strict');

node_modules/mongoose/lib/error/messages.js

@@ -0,0 +1,46 @@
+
+/**
+ * The default built-in validator error messages. These may be customized.
+ *
+ *     // customize within each schema or globally like so
+ *     var mongoose = require('mongoose');
+ *     mongoose.Error.messages.String.enum  = "Your custom message for {PATH}.";
+ *
+ * As you might have noticed, error messages support basic templating
+ *
+ * - `{PATH}` is replaced with the invalid document path
+ * - `{VALUE}` is replaced with the invalid value
+ * - `{TYPE}` is replaced with the validator type such as "regexp", "min", or "user defined"
+ * - `{MIN}` is replaced with the declared min value for the Number.min validator
+ * - `{MAX}` is replaced with the declared max value for the Number.max validator
+ *
+ * Click the "show code" link below to see all defaults.
+ *
+ * @static messages
+ * @receiver MongooseError
+ * @api public
+ */
+
+'use strict';
+
+const msg = module.exports = exports = {};
+
+msg.DocumentNotFoundError = null;
+
+msg.general = {};
+msg.general.default = 'Validator failed for path `{PATH}` with value `{VALUE}`';
+msg.general.required = 'Path `{PATH}` is required.';
+
+msg.Number = {};
+msg.Number.min = 'Path `{PATH}` ({VALUE}) is less than minimum allowed value ({MIN}).';
+msg.Number.max = 'Path `{PATH}` ({VALUE}) is more than maximum allowed value ({MAX}).';
+
+msg.Date = {};
+msg.Date.min = 'Path `{PATH}` ({VALUE}) is before minimum allowed value ({MIN}).';
+msg.Date.max = 'Path `{PATH}` ({VALUE}) is after maximum allowed value ({MAX}).';
+
+msg.String = {};
+msg.String.enum = '`{VALUE}` is not a valid enum value for path `{PATH}`.';
+msg.String.match = 'Path `{PATH}` is invalid ({VALUE}).';
+msg.String.minlength = 'Path `{PATH}` (`{VALUE}`) is shorter than the minimum allowed length ({MINLENGTH}).';
+msg.String.maxlength = 'Path `{PATH}` (`{VALUE}`) is longer than the maximum allowed length ({MAXLENGTH}).';

node_modules/mongoose/lib/error/missingSchema.js

@@ -0,0 +1,39 @@
+
+/*!
+ * Module dependencies.
+ */
+
+'use strict';
+
+const MongooseError = require('./');
+
+/*!
+ * MissingSchema Error constructor.
+ *
+ * @inherits MongooseError
+ */
+
+function MissingSchemaError(name) {
+  const msg = 'Schema hasn\'t been registered for model "' + name + '".\n'
+          + 'Use mongoose.model(name, schema)';
+  MongooseError.call(this, msg);
+  this.name = 'MissingSchemaError';
+  if (Error.captureStackTrace) {
+    Error.captureStackTrace(this);
+  } else {
+    this.stack = new Error().stack;
+  }
+}
+
+/*!
+ * Inherits from MongooseError.
+ */
+
+MissingSchemaError.prototype = Object.create(MongooseError.prototype);
+MissingSchemaError.prototype.constructor = MongooseError;
+
+/*!
+ * exports
+ */
+
+module.exports = MissingSchemaError;

node_modules/mongoose/lib/error/mongooseError.js

@@ -0,0 +1,25 @@
+'use strict';
+
+/*!
+ * ignore
+ */
+
+function MongooseError(msg) {
+  Error.call(this);
+  if (Error.captureStackTrace) {
+    Error.captureStackTrace(this);
+  } else {
+    this.stack = new Error().stack;
+  }
+  this.message = msg;
+  this.name = 'MongooseError';
+}
+
+/*!
+ * Inherits from Error.
+ */
+
+MongooseError.prototype = Object.create(Error.prototype);
+MongooseError.prototype.constructor = Error;
+
+module.exports = MongooseError;

node_modules/mongoose/lib/error/notFound.js

@@ -0,0 +1,55 @@
+'use strict';
+
+/*!
+ * Module dependencies.
+ */
+
+const MongooseError = require('./');
+const util = require('util');
+
+/*!
+ * OverwriteModel Error constructor.
+ *
+ * @inherits MongooseError
+ */
+
+function DocumentNotFoundError(filter, model, numAffected, result) {
+  let msg;
+  const messages = MongooseError.messages;
+  if (messages.DocumentNotFoundError != null) {
+    msg = typeof messages.DocumentNotFoundError === 'function' ?
+      messages.DocumentNotFoundError(filter, model) :
+      messages.DocumentNotFoundError;
+  } else {
+    msg = 'No document found for query "' + util.inspect(filter) +
+      '" on model "' + model + '"';
+  }
+
+  MongooseError.call(this, msg);
+
+  this.name = 'DocumentNotFoundError';
+  this.result = result;
+  this.numAffected = numAffected;
+  if (Error.captureStackTrace) {
+    Error.captureStackTrace(this);
+  } else {
+    this.stack = new Error().stack;
+  }
+
+  this.filter = filter;
+  // Backwards compat
+  this.query = filter;
+}
+
+/*!
+ * Inherits from MongooseError.
+ */
+
+DocumentNotFoundError.prototype = Object.create(MongooseError.prototype);
+DocumentNotFoundError.prototype.constructor = MongooseError;
+
+/*!
+ * exports
+ */
+
+module.exports = DocumentNotFoundError;

node_modules/mongoose/lib/error/objectExpected.js

@@ -0,0 +1,38 @@
+/*!
+ * Module dependencies.
+ */
+
+'use strict';
+
+const MongooseError = require('./');
+
+/**
+ * Strict mode error constructor
+ *
+ * @param {String} type
+ * @param {String} value
+ * @inherits MongooseError
+ * @api private
+ */
+
+function ObjectExpectedError(path, val) {
+  const typeDescription = Array.isArray(val) ? 'array' : 'primitive value';
+  MongooseError.call(this, 'Tried to set nested object field `' + path +
+    `\` to ${typeDescription} \`` + val + '` and strict mode is set to throw.');
+  this.name = 'ObjectExpectedError';
+  if (Error.captureStackTrace) {
+    Error.captureStackTrace(this);
+  } else {
+    this.stack = new Error().stack;
+  }
+  this.path = path;
+}
+
+/*!
+ * Inherits from MongooseError.
+ */
+
+ObjectExpectedError.prototype = Object.create(MongooseError.prototype);
+ObjectExpectedError.prototype.constructor = MongooseError;
+
+module.exports = ObjectExpectedError;

node_modules/mongoose/lib/error/objectParameter.js

@@ -0,0 +1,38 @@
+/*!
+ * Module dependencies.
+ */
+
+'use strict';
+
+const MongooseError = require('./');
+
+/**
+ * Constructor for errors that happen when a parameter that's expected to be
+ * an object isn't an object
+ *
+ * @param {Any} value
+ * @param {String} paramName
+ * @param {String} fnName
+ * @inherits MongooseError
+ * @api private
+ */
+
+function ObjectParameterError(value, paramName, fnName) {
+  MongooseError.call(this, 'Parameter "' + paramName + '" to ' + fnName +
+    '() must be an object, got ' + value.toString());
+  this.name = 'ObjectParameterError';
+  if (Error.captureStackTrace) {
+    Error.captureStackTrace(this);
+  } else {
+    this.stack = new Error().stack;
+  }
+}
+
+/*!
+ * Inherits from MongooseError.
+ */
+
+ObjectParameterError.prototype = Object.create(MongooseError.prototype);
+ObjectParameterError.prototype.constructor = MongooseError;
+
+module.exports = ObjectParameterError;

node_modules/mongoose/lib/error/overwriteModel.js

@@ -0,0 +1,37 @@
+
+/*!
+ * Module dependencies.
+ */
+
+'use strict';
+
+const MongooseError = require('./');
+
+/*!
+ * OverwriteModel Error constructor.
+ *
+ * @inherits MongooseError
+ */
+
+function OverwriteModelError(name) {
+  MongooseError.call(this, 'Cannot overwrite `' + name + '` model once compiled.');
+  this.name = 'OverwriteModelError';
+  if (Error.captureStackTrace) {
+    Error.captureStackTrace(this);
+  } else {
+    this.stack = new Error().stack;
+  }
+}
+
+/*!
+ * Inherits from MongooseError.
+ */
+
+OverwriteModelError.prototype = Object.create(MongooseError.prototype);
+OverwriteModelError.prototype.constructor = MongooseError;
+
+/*!
+ * exports
+ */
+
+module.exports = OverwriteModelError;

node_modules/mongoose/lib/error/parallelSave.js

@@ -0,0 +1,33 @@
+'use strict';
+
+/*!
+ * Module dependencies.
+ */
+
+const MongooseError = require('./');
+
+/**
+ * ParallelSave Error constructor.
+ *
+ * @inherits MongooseError
+ * @api private
+ */
+
+function ParallelSaveError(doc) {
+  const msg = 'Can\'t save() the same doc multiple times in parallel. Document: ';
+  MongooseError.call(this, msg + doc.id);
+  this.name = 'ParallelSaveError';
+}
+
+/*!
+ * Inherits from MongooseError.
+ */
+
+ParallelSaveError.prototype = Object.create(MongooseError.prototype);
+ParallelSaveError.prototype.constructor = MongooseError;
+
+/*!
+ * exports
+ */
+
+module.exports = ParallelSaveError;

node_modules/mongoose/lib/error/strict.js

@@ -0,0 +1,39 @@
+/*!
+ * Module dependencies.
+ */
+
+'use strict';
+
+const MongooseError = require('./');
+
+/**
+ * Strict mode error constructor
+ *
+ * @param {String} type
+ * @param {String} value
+ * @inherits MongooseError
+ * @api private
+ */
+
+function StrictModeError(path, msg, immutable) {
+  msg = msg || 'Field `' + path + '` is not in schema and strict ' +
+    'mode is set to throw.';
+  MongooseError.call(this, msg);
+  this.name = 'StrictModeError';
+  this.isImmutableError = !!immutable;
+  if (Error.captureStackTrace) {
+    Error.captureStackTrace(this);
+  } else {
+    this.stack = new Error().stack;
+  }
+  this.path = path;
+}
+
+/*!
+ * Inherits from MongooseError.
+ */
+
+StrictModeError.prototype = Object.create(MongooseError.prototype);
+StrictModeError.prototype.constructor = MongooseError;
+
+module.exports = StrictModeError;

node_modules/mongoose/lib/error/validation.js

@@ -0,0 +1,114 @@
+/*!
+ * Module requirements
+ */
+
+'use strict';
+
+const MongooseError = require('./');
+const util = require('util');
+
+/**
+ * Document Validation Error
+ *
+ * @api private
+ * @param {Document} instance
+ * @inherits MongooseError
+ */
+
+function ValidationError(instance) {
+  this.errors = {};
+  this._message = '';
+
+  MongooseError.call(this, this._message);
+  if (instance && instance.constructor.name === 'model') {
+    this._message = instance.constructor.modelName + ' validation failed';
+  } else {
+    this._message = 'Validation failed';
+  }
+  this.name = 'ValidationError';
+
+  if (Error.captureStackTrace) {
+    Error.captureStackTrace(this);
+  } else {
+    this.stack = new Error().stack;
+  }
+
+  if (instance) {
+    instance.errors = this.errors;
+  }
+}
+
+/*!
+ * Inherits from MongooseError.
+ */
+
+ValidationError.prototype = Object.create(MongooseError.prototype);
+ValidationError.prototype.constructor = MongooseError;
+
+/**
+ * Console.log helper
+ */
+
+ValidationError.prototype.toString = function() {
+  return this.name + ': ' + _generateMessage(this);
+};
+
+/*!
+ * inspect helper
+ */
+
+ValidationError.prototype.inspect = function() {
+  return Object.assign(new Error(this.message), this);
+};
+
+if (util.inspect.custom) {
+  /*!
+  * Avoid Node deprecation warning DEP0079
+  */
+
+  ValidationError.prototype[util.inspect.custom] = ValidationError.prototype.inspect;
+}
+
+/*!
+ * Helper for JSON.stringify
+ */
+
+ValidationError.prototype.toJSON = function() {
+  return Object.assign({}, this, { message: this.message });
+};
+
+/*!
+ * add message
+ */
+
+ValidationError.prototype.addError = function(path, error) {
+  this.errors[path] = error;
+  this.message = this._message + ': ' + _generateMessage(this);
+};
+
+/*!
+ * ignore
+ */
+
+function _generateMessage(err) {
+  const keys = Object.keys(err.errors || {});
+  const len = keys.length;
+  const msgs = [];
+  let key;
+
+  for (let i = 0; i < len; ++i) {
+    key = keys[i];
+    if (err === err.errors[key]) {
+      continue;
+    }
+    msgs.push(key + ': ' + err.errors[key].message);
+  }
+
+  return msgs.join(', ');
+}
+
+/*!
+ * Module exports
+ */
+
+module.exports = exports = ValidationError;

node_modules/mongoose/lib/error/validator.js

@@ -0,0 +1,89 @@
+/*!
+ * Module dependencies.
+ */
+
+'use strict';
+
+const MongooseError = require('./');
+
+/**
+ * Schema validator error
+ *
+ * @param {Object} properties
+ * @inherits MongooseError
+ * @api private
+ */
+
+function ValidatorError(properties) {
+  let msg = properties.message;
+  if (!msg) {
+    msg = MongooseError.messages.general.default;
+  }
+
+  const message = this.formatMessage(msg, properties);
+  MongooseError.call(this, message);
+
+  properties = Object.assign({}, properties, { message: message });
+  this.name = 'ValidatorError';
+  if (Error.captureStackTrace) {
+    Error.captureStackTrace(this);
+  } else {
+    this.stack = new Error().stack;
+  }
+  this.properties = properties;
+  this.kind = properties.type;
+  this.path = properties.path;
+  this.value = properties.value;
+  this.reason = properties.reason;
+}
+
+/*!
+ * Inherits from MongooseError
+ */
+
+ValidatorError.prototype = Object.create(MongooseError.prototype);
+ValidatorError.prototype.constructor = MongooseError;
+
+/*!
+ * The object used to define this validator. Not enumerable to hide
+ * it from `require('util').inspect()` output re: gh-3925
+ */
+
+Object.defineProperty(ValidatorError.prototype, 'properties', {
+  enumerable: false,
+  writable: true,
+  value: null
+});
+
+/*!
+ * Formats error messages
+ */
+
+ValidatorError.prototype.formatMessage = function(msg, properties) {
+  if (typeof msg === 'function') {
+    return msg(properties);
+  }
+  const propertyNames = Object.keys(properties);
+  for (let i = 0; i < propertyNames.length; ++i) {
+    const propertyName = propertyNames[i];
+    if (propertyName === 'message') {
+      continue;
+    }
+    msg = msg.replace('{' + propertyName.toUpperCase() + '}', properties[propertyName]);
+  }
+  return msg;
+};
+
+/*!
+ * toString helper
+ */
+
+ValidatorError.prototype.toString = function() {
+  return this.message;
+};
+
+/*!
+ * exports
+ */
+
+module.exports = ValidatorError;

node_modules/mongoose/lib/error/version.js

@@ -0,0 +1,36 @@
+'use strict';
+
+/*!
+ * Module dependencies.
+ */
+
+const MongooseError = require('./');
+
+/**
+ * Version Error constructor.
+ *
+ * @inherits MongooseError
+ * @api private
+ */
+
+function VersionError(doc, currentVersion, modifiedPaths) {
+  const modifiedPathsStr = modifiedPaths.join(', ');
+  MongooseError.call(this, 'No matching document found for id "' + doc._id +
+    '" version ' + currentVersion + ' modifiedPaths "' + modifiedPathsStr + '"');
+  this.name = 'VersionError';
+  this.version = currentVersion;
+  this.modifiedPaths = modifiedPaths;
+}
+
+/*!
+ * Inherits from MongooseError.
+ */
+
+VersionError.prototype = Object.create(MongooseError.prototype);
+VersionError.prototype.constructor = MongooseError;
+
+/*!
+ * exports
+ */
+
+module.exports = VersionError;