//////////////////////////////////////////////////////////////////////////
//                                                                      //
// This is a generated file. You can view the original                  //
// source in your browser if your browser supports source maps.         //
// Source maps are supported by all recent versions of Chrome, Safari,  //
// and Firefox, and by Internet Explorer 11.                            //
//                                                                      //
//////////////////////////////////////////////////////////////////////////


(function () {

/* Imports */
var Meteor = Package.meteor.Meteor;
var global = Package.meteor.global;
var meteorEnv = Package.meteor.meteorEnv;
var EJSON = Package.ejson.EJSON;
var meteorInstall = Package.modules.meteorInstall;
var meteorBabelHelpers = Package['babel-runtime'].meteorBabelHelpers;
var Promise = Package.promise.Promise;
var Symbol = Package['ecmascript-runtime-client'].Symbol;
var Map = Package['ecmascript-runtime-client'].Map;
var Set = Package['ecmascript-runtime-client'].Set;

/* Package-scope variables */
var check, Match;

var require = meteorInstall({"node_modules":{"meteor":{"check":{"match.js":function(require,exports,module){

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                                                                                                                  //
// packages/check/match.js                                                                                          //
//                                                                                                                  //
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                                                                                                                    //
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));

var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));

module.export({
  check: function () {
    return check;
  },
  Match: function () {
    return Match;
  }
});
var isPlainObject;
module.watch(require("./isPlainObject"), {
  isPlainObject: function (v) {
    isPlainObject = v;
  }
}, 0);
// Things we explicitly do NOT support:
//    - heterogenous arrays
var currentArgumentChecker = new Meteor.EnvironmentVariable();
var hasOwn = Object.prototype.hasOwnProperty;
/**
 * @summary Check that a value matches a [pattern](#matchpatterns).
 * If the value does not match the pattern, throw a `Match.Error`.
 *
 * Particularly useful to assert that arguments to a function have the right
 * types and structure.
 * @locus Anywhere
 * @param {Any} value The value to check
 * @param {MatchPattern} pattern The pattern to match `value` against
 */

function check(value, pattern) {
  // Record that check got called, if somebody cared.
  //
  // We use getOrNullIfOutsideFiber so that it's OK to call check()
  // from non-Fiber server contexts; the downside is that if you forget to
  // bindEnvironment on some random callback in your method/publisher,
  // it might not find the argumentChecker and you'll get an error about
  // not checking an argument that it looks like you're checking (instead
  // of just getting a "Node code must run in a Fiber" error).
  var argChecker = currentArgumentChecker.getOrNullIfOutsideFiber();

  if (argChecker) {
    argChecker.checking(value);
  }

  var result = testSubtree(value, pattern);

  if (result) {
    var err = new Match.Error(result.message);

    if (result.path) {
      err.message += " in field " + result.path;
      err.path = result.path;
    }

    throw err;
  }
}

;
/**
 * @namespace Match
 * @summary The namespace for all Match types and methods.
 */

var Match = {
  Optional: function (pattern) {
    return new Optional(pattern);
  },
  Maybe: function (pattern) {
    return new Maybe(pattern);
  },
  OneOf: function () {
    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

    return new OneOf(args);
  },
  Any: ['__any__'],
  Where: function (condition) {
    return new Where(condition);
  },
  ObjectIncluding: function (pattern) {
    return new ObjectIncluding(pattern);
  },
  ObjectWithValues: function (pattern) {
    return new ObjectWithValues(pattern);
  },
  // Matches only signed 32-bit integers
  Integer: ['__integer__'],
  // XXX matchers should know how to describe themselves for errors
  Error: Meteor.makeErrorType('Match.Error', function (msg) {
    this.message = "Match error: " + msg; // The path of the value that failed to match. Initially empty, this gets
    // populated by catching and rethrowing the exception as it goes back up the
    // stack.
    // E.g.: "vals[3].entity.created"

    this.path = ''; // If this gets sent over DDP, don't give full internal details but at least
    // provide something better than 500 Internal server error.

    this.sanitizedError = new Meteor.Error(400, 'Match failed');
  }),
  // Tests to see if value matches pattern. Unlike check, it merely returns true
  // or false (unless an error other than Match.Error was thrown). It does not
  // interact with _failIfArgumentsAreNotAllChecked.
  // XXX maybe also implement a Match.match which returns more information about
  //     failures but without using exception handling or doing what check()
  //     does with _failIfArgumentsAreNotAllChecked and Meteor.Error conversion

  /**
   * @summary Returns true if the value matches the pattern.
   * @locus Anywhere
   * @param {Any} value The value to check
   * @param {MatchPattern} pattern The pattern to match `value` against
   */
  test: function (value, pattern) {
    return !testSubtree(value, pattern);
  },
  // Runs `f.apply(context, args)`. If check() is not called on every element of
  // `args` (either directly or in the first level of an array), throws an error
  // (using `description` in the message).
  _failIfArgumentsAreNotAllChecked: function (f, context, args, description) {
    var argChecker = new ArgumentChecker(args, description);
    var result = currentArgumentChecker.withValue(argChecker, function () {
      return f.apply(context, args);
    }); // If f didn't itself throw, make sure it checked all of its arguments.

    argChecker.throwUnlessAllArgumentsHaveBeenChecked();
    return result;
  }
};

var Optional = function () {
  function Optional(pattern) {
    this.pattern = pattern;
  }

  return Optional;
}();

var Maybe = function () {
  function Maybe(pattern) {
    this.pattern = pattern;
  }

  return Maybe;
}();

var OneOf = function () {
  function OneOf(choices) {
    if (!choices || choices.length === 0) {
      throw new Error('Must provide at least one choice to Match.OneOf');
    }

    this.choices = choices;
  }

  return OneOf;
}();

var Where = function () {
  function Where(condition) {
    this.condition = condition;
  }

  return Where;
}();

var ObjectIncluding = function () {
  function ObjectIncluding(pattern) {
    this.pattern = pattern;
  }

  return ObjectIncluding;
}();

var ObjectWithValues = function () {
  function ObjectWithValues(pattern) {
    this.pattern = pattern;
  }

  return ObjectWithValues;
}();

var stringForErrorMessage = function (value) {
  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

  if (value === null) {
    return 'null';
  }

  if (options.onlyShowType) {
    return (0, _typeof2.default)(value);
  } // Your average non-object things.  Saves from doing the try/catch below for.


  if ((0, _typeof2.default)(value) !== 'object') {
    return EJSON.stringify(value);
  }

  try {
    // Find objects with circular references since EJSON doesn't support them yet (Issue #4778 + Unaccepted PR)
    // If the native stringify is going to choke, EJSON.stringify is going to choke too.
    JSON.stringify(value);
  } catch (stringifyError) {
    if (stringifyError.name === 'TypeError') {
      return (0, _typeof2.default)(value);
    }
  }

  return EJSON.stringify(value);
};

var typeofChecks = [[String, 'string'], [Number, 'number'], [Boolean, 'boolean'], // While we don't allow undefined/function in EJSON, this is good for optional
// arguments with OneOf.
[Function, 'function'], [undefined, 'undefined']]; // Return `false` if it matches. Otherwise, return an object with a `message` and a `path` field.

var testSubtree = function (value, pattern) {
  // Match anything!
  if (pattern === Match.Any) {
    return false;
  } // Basic atomic types.
  // Do not match boxed objects (e.g. String, Boolean)


  for (var i = 0; i < typeofChecks.length; ++i) {
    if (pattern === typeofChecks[i][0]) {
      if ((0, _typeof2.default)(value) === typeofChecks[i][1]) {
        return false;
      }

      return {
        message: "Expected " + typeofChecks[i][1] + ", got " + stringForErrorMessage(value, {
          onlyShowType: true
        }),
        path: ''
      };
    }
  }

  if (pattern === null) {
    if (value === null) {
      return false;
    }

    return {
      message: "Expected null, got " + stringForErrorMessage(value),
      path: ''
    };
  } // Strings, numbers, and booleans match literally. Goes well with Match.OneOf.


  if (typeof pattern === 'string' || typeof pattern === 'number' || typeof pattern === 'boolean') {
    if (value === pattern) {
      return false;
    }

    return {
      message: "Expected " + pattern + ", got " + stringForErrorMessage(value),
      path: ''
    };
  } // Match.Integer is special type encoded with array


  if (pattern === Match.Integer) {
    // There is no consistent and reliable way to check if variable is a 64-bit
    // integer. One of the popular solutions is to get reminder of division by 1
    // but this method fails on really large floats with big precision.
    // E.g.: 1.348192308491824e+23 % 1 === 0 in V8
    // Bitwise operators work consistantly but always cast variable to 32-bit
    // signed integer according to JavaScript specs.
    if (typeof value === 'number' && (value | 0) === value) {
      return false;
    }

    return {
      message: "Expected Integer, got " + stringForErrorMessage(value),
      path: ''
    };
  } // 'Object' is shorthand for Match.ObjectIncluding({});


  if (pattern === Object) {
    pattern = Match.ObjectIncluding({});
  } // Array (checked AFTER Any, which is implemented as an Array).


  if (pattern instanceof Array) {
    if (pattern.length !== 1) {
      return {
        message: "Bad pattern: arrays must have one type element " + stringForErrorMessage(pattern),
        path: ''
      };
    }

    if (!Array.isArray(value) && !isArguments(value)) {
      return {
        message: "Expected array, got " + stringForErrorMessage(value),
        path: ''
      };
    }

    for (var _i = 0, length = value.length; _i < length; _i++) {
      var result = testSubtree(value[_i], pattern[0]);

      if (result) {
        result.path = _prependPath(_i, result.path);
        return result;
      }
    }

    return false;
  } // Arbitrary validation checks. The condition can return false or throw a
  // Match.Error (ie, it can internally use check()) to fail.


  if (pattern instanceof Where) {
    var _result;

    try {
      _result = pattern.condition(value);
    } catch (err) {
      if (!(err instanceof Match.Error)) {
        throw err;
      }

      return {
        message: err.message,
        path: err.path
      };
    }

    if (_result) {
      return false;
    } // XXX this error is terrible


    return {
      message: 'Failed Match.Where validation',
      path: ''
    };
  }

  if (pattern instanceof Maybe) {
    pattern = Match.OneOf(undefined, null, pattern.pattern);
  } else if (pattern instanceof Optional) {
    pattern = Match.OneOf(undefined, pattern.pattern);
  }

  if (pattern instanceof OneOf) {
    for (var _i2 = 0; _i2 < pattern.choices.length; ++_i2) {
      var _result2 = testSubtree(value, pattern.choices[_i2]);

      if (!_result2) {
        // No error? Yay, return.
        return false;
      } // Match errors just mean try another choice.

    } // XXX this error is terrible


    return {
      message: 'Failed Match.OneOf, Match.Maybe or Match.Optional validation',
      path: ''
    };
  } // A function that isn't something we special-case is assumed to be a
  // constructor.


  if (pattern instanceof Function) {
    if (value instanceof pattern) {
      return false;
    }

    return {
      message: "Expected " + (pattern.name || 'particular constructor'),
      path: ''
    };
  }

  var unknownKeysAllowed = false;
  var unknownKeyPattern;

  if (pattern instanceof ObjectIncluding) {
    unknownKeysAllowed = true;
    pattern = pattern.pattern;
  }

  if (pattern instanceof ObjectWithValues) {
    unknownKeysAllowed = true;
    unknownKeyPattern = [pattern.pattern];
    pattern = {}; // no required keys
  }

  if ((0, _typeof2.default)(pattern) !== 'object') {
    return {
      message: 'Bad pattern: unknown pattern type',
      path: ''
    };
  } // An object, with required and optional keys. Note that this does NOT do
  // structural matches against objects of special types that happen to match
  // the pattern: this really needs to be a plain old {Object}!


  if ((0, _typeof2.default)(value) !== 'object') {
    return {
      message: "Expected object, got " + (0, _typeof2.default)(value),
      path: ''
    };
  }

  if (value === null) {
    return {
      message: "Expected object, got null",
      path: ''
    };
  }

  if (!isPlainObject(value)) {
    return {
      message: "Expected plain object",
      path: ''
    };
  }

  var requiredPatterns = Object.create(null);
  var optionalPatterns = Object.create(null);
  Object.keys(pattern).forEach(function (key) {
    var subPattern = pattern[key];

    if (subPattern instanceof Optional || subPattern instanceof Maybe) {
      optionalPatterns[key] = subPattern.pattern;
    } else {
      requiredPatterns[key] = subPattern;
    }
  });

  for (var key in meteorBabelHelpers.sanitizeForInObject(Object(value))) {
    var subValue = value[key];

    if (hasOwn.call(requiredPatterns, key)) {
      var _result3 = testSubtree(subValue, requiredPatterns[key]);

      if (_result3) {
        _result3.path = _prependPath(key, _result3.path);
        return _result3;
      }

      delete requiredPatterns[key];
    } else if (hasOwn.call(optionalPatterns, key)) {
      var _result4 = testSubtree(subValue, optionalPatterns[key]);

      if (_result4) {
        _result4.path = _prependPath(key, _result4.path);
        return _result4;
      }
    } else {
      if (!unknownKeysAllowed) {
        return {
          message: 'Unknown key',
          path: key
        };
      }

      if (unknownKeyPattern) {
        var _result5 = testSubtree(subValue, unknownKeyPattern[0]);

        if (_result5) {
          _result5.path = _prependPath(key, _result5.path);
          return _result5;
        }
      }
    }
  }

  var keys = Object.keys(requiredPatterns);

  if (keys.length) {
    return {
      message: "Missing key '" + keys[0] + "'",
      path: ''
    };
  }
};

var ArgumentChecker =
/*#__PURE__*/
function () {
  function ArgumentChecker(args, description) {
    // Make a SHALLOW copy of the arguments. (We'll be doing identity checks
    // against its contents.)
    this.args = (0, _toConsumableArray2.default)(args); // Since the common case will be to check arguments in order, and we splice
    // out arguments when we check them, make it so we splice out from the end
    // rather than the beginning.

    this.args.reverse();
    this.description = description;
  }

  var _proto = ArgumentChecker.prototype;

  _proto.checking = function () {
    function checking(value) {
      if (this._checkingOneValue(value)) {
        return;
      } // Allow check(arguments, [String]) or check(arguments.slice(1), [String])
      // or check([foo, bar], [String]) to count... but only if value wasn't
      // itself an argument.


      if (Array.isArray(value) || isArguments(value)) {
        Array.prototype.forEach.call(value, this._checkingOneValue.bind(this));
      }
    }

    return checking;
  }();

  _proto._checkingOneValue = function () {
    function _checkingOneValue(value) {
      for (var i = 0; i < this.args.length; ++i) {
        // Is this value one of the arguments? (This can have a false positive if
        // the argument is an interned primitive, but it's still a good enough
        // check.)
        // (NaN is not === to itself, so we have to check specially.)
        if (value === this.args[i] || Number.isNaN(value) && Number.isNaN(this.args[i])) {
          this.args.splice(i, 1);
          return true;
        }
      }

      return false;
    }

    return _checkingOneValue;
  }();

  _proto.throwUnlessAllArgumentsHaveBeenChecked = function () {
    function throwUnlessAllArgumentsHaveBeenChecked() {
      if (this.args.length > 0) throw new Error("Did not check() all arguments during " + this.description);
    }

    return throwUnlessAllArgumentsHaveBeenChecked;
  }();

  return ArgumentChecker;
}();

var _jsKeywords = ['do', 'if', 'in', 'for', 'let', 'new', 'try', 'var', 'case', 'else', 'enum', 'eval', 'false', 'null', 'this', 'true', 'void', 'with', 'break', 'catch', 'class', 'const', 'super', 'throw', 'while', 'yield', 'delete', 'export', 'import', 'public', 'return', 'static', 'switch', 'typeof', 'default', 'extends', 'finally', 'package', 'private', 'continue', 'debugger', 'function', 'arguments', 'interface', 'protected', 'implements', 'instanceof']; // Assumes the base of path is already escaped properly
// returns key + base

var _prependPath = function (key, base) {
  if (typeof key === 'number' || key.match(/^[0-9]+$/)) {
    key = "[" + key + "]";
  } else if (!key.match(/^[a-z_$][0-9a-z_$]*$/i) || _jsKeywords.indexOf(key) >= 0) {
    key = JSON.stringify([key]);
  }

  if (base && base[0] !== '[') {
    return key + "." + base;
  }

  return key + base;
};

var isObject = function (value) {
  return (0, _typeof2.default)(value) === 'object' && value !== null;
};

var baseIsArguments = function (item) {
  return isObject(item) && Object.prototype.toString.call(item) === '[object Arguments]';
};

var isArguments = baseIsArguments(function () {
  return arguments;
}()) ? baseIsArguments : function (value) {
  return isObject(value) && typeof value.callee === 'function';
};
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

},"isPlainObject.js":function(require,exports,module){

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                                                                                                                  //
// packages/check/isPlainObject.js                                                                                  //
//                                                                                                                  //
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                                                                                                                    //
module.export({
  isPlainObject: function () {
    return isPlainObject;
  }
});
// Copy of jQuery.isPlainObject for the server side from jQuery v3.1.1.
var class2type = {};
var toString = class2type.toString;
var hasOwn = Object.prototype.hasOwnProperty;
var fnToString = hasOwn.toString;
var ObjectFunctionString = fnToString.call(Object);
var getProto = Object.getPrototypeOf;

var isPlainObject = function (obj) {
  var proto;
  var Ctor; // Detect obvious negatives
  // Use toString instead of jQuery.type to catch host objects

  if (!obj || toString.call(obj) !== '[object Object]') {
    return false;
  }

  proto = getProto(obj); // Objects with no prototype (e.g., `Object.create( null )`) are plain

  if (!proto) {
    return true;
  } // Objects with prototype are plain iff they were constructed by a global Object function


  Ctor = hasOwn.call(proto, 'constructor') && proto.constructor;
  return typeof Ctor === 'function' && fnToString.call(Ctor) === ObjectFunctionString;
};
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

}}}}},{
  "extensions": [
    ".js",
    ".json"
  ]
});
var exports = require("/node_modules/meteor/check/match.js");

/* Exports */
Package._define("check", exports, {
  check: check,
  Match: Match
});

})();