docspring 3.2.0 → 4.0.0

package/dist/RequestValidator.js

@@ -0,0 +1,494 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ValidationError = void 0;
+exports.errors = errors;
+exports.requestError = requestError;
+exports.validate = validate;
+var _RequestSchemas = _interopRequireDefault(require("./RequestSchemas"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, e) { if ("object" != _typeof(t) || !t) return t; var r; if ("undefined" != typeof Symbol && void 0 !== (r = t[Symbol.toPrimitive])) { var i = r.call(t, e || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === e ? String : Number)(t); }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _possibleConstructorReturn(t, e) { if (e && ("object" == _typeof(e) || "function" == typeof e)) return e; if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined"); return _assertThisInitialized(t); }
+function _assertThisInitialized(e) { if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); return e; }
+function _inherits(t, e) { if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function"); t.prototype = Object.create(e && e.prototype, { constructor: { value: t, writable: !0, configurable: !0 } }), Object.defineProperty(t, "prototype", { writable: !1 }), e && _setPrototypeOf(t, e); }
+function _wrapNativeSuper(t) { var r = "function" == typeof Map ? new Map() : void 0; return _wrapNativeSuper = function _wrapNativeSuper(t) { if (null === t || !_isNativeFunction(t)) return t; if ("function" != typeof t) throw new TypeError("Super expression must either be null or a function"); if (void 0 !== r) { if (r.has(t)) return r.get(t); r.set(t, Wrapper); } function Wrapper() { return _construct(t, arguments, _getPrototypeOf(this).constructor); } return Wrapper.prototype = Object.create(t.prototype, { constructor: { value: Wrapper, enumerable: !1, writable: !0, configurable: !0 } }), _setPrototypeOf(Wrapper, t); }, _wrapNativeSuper(t); }
+function _construct(t, e, r) { if (_isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments); var o = [null]; o.push.apply(o, e); var p = new (t.bind.apply(t, o))(); return r && _setPrototypeOf(p, r.prototype), p; }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _isNativeFunction(t) { try { return -1 !== Function.toString.call(t).indexOf("[native code]"); } catch (n) { return "function" == typeof t; } }
+function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
+function _getPrototypeOf(t) { return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { return t.__proto__ || Object.getPrototypeOf(t); }, _getPrototypeOf(t); } /**
+ * Checks a request against API v2's request schemas (RequestSchemas.js, the schemas the API validates requests with)
+ * before it's sent, and says what the API would say about it. api_clients/validator_conformance checks that it agrees
+ * with the API.
+ */
+/**
+ * Rejects a request before it's sent when the API would reject it with a 422. `details` are the API's error details:
+ * objects with `code`, `message` and a `pointer` into the body (or a `parameter` for a query parameter).
+ */
+var ValidationError = exports.ValidationError = /*#__PURE__*/function (_Error) {
+  function ValidationError(details) {
+    var _this;
+    _classCallCheck(this, ValidationError);
+    var shown = details.slice(0, 3).map(function (detail) {
+      var subject = detail.pointer === '' ? 'the request body' : detail.pointer || detail.parameter;
+      return "".concat(subject, " ").concat(detail.message);
+    });
+    var message = "Invalid request: ".concat(shown.join('; '));
+    if (details.length > 3) message += " (and ".concat(details.length - 3, " more)");
+    _this = _callSuper(this, ValidationError, [message]);
+    _this.name = 'ValidationError';
+    _this.details = details;
+    return _this;
+  }
+  _inherits(ValidationError, _Error);
+  return _createClass(ValidationError);
+}(/*#__PURE__*/_wrapNativeSuper(Error));
+var TYPE_NAMES = {
+  string: 'a string',
+  integer: 'an integer',
+  number: 'a number',
+  "boolean": 'true or false',
+  object: 'an object',
+  array: 'an array',
+  "null": 'null'
+};
+// What a multipart body's file field holds when the API checks it
+var FILE_PLACEHOLDER = '(file)';
+// A date and time as the API reads it (Ruby's DateTime.rfc3339, then json_schemer's checks)
+var DATE_TIME = /^[ \t\n\v\f\r]*(-?\d{4})-(\d{2})-(\d{2})[Tt \t\n\v\f\r](\d{2}):(\d{2}):(\d{2})(?:\.\d+)?(?:[Zz]|([+-])(\d{2}):(\d{2}))$/;
+// An absolute URI as the API reads it (RFC 3986, as Ruby's URI parser has it), a little looser for IP addresses
+// Lookaheads check the escapes, so only character classes repeat: Java and PHP recurse on each repetition of a group
+var SEGMENT = '[%!$&-.0-9:;=@A-Z_a-z~/]';
+var URI = new RegExp('^(?![^?#]*%(?![0-9A-Fa-f]{2}))[A-Za-z][+\\-.0-9A-Za-z]*:' + '(?://(?:[%!$&-.0-9:;=A-Z_a-z~]*@)?' + '(?:\\[(?:[0-9A-Fa-f:.]+|[vV][0-9A-Fa-f]+\\.[!$&-.0-9:;=A-Z_a-z~]+)\\]|[%!$&-.0-9;=A-Z_a-z~]*)' + "(?::[0-9]*)?(?:/".concat(SEGMENT, "*)?") + "|/(?:(?!/)".concat(SEGMENT, "+)?") + "|(?!/)".concat(SEGMENT, "+") + '|)' + '(?:\\?[^#]*)?' + '(?:#(?![^#]*%(?![0-9A-Fa-f]{2}))[%!$&-.0-9:;=@A-Z_a-z~/?]*)?$');
+var WHITESPACE = /[ \t\n\v\f\r]/;
+var patterns = {};
+
+/**
+ * The ValidationError for a request the API would reject, or null. `path` is the operation's path template
+ * (/templates/{template_id}); `body` is the JSON the SDK sends, or a multipart body's params (files as file objects).
+ */
+function requestError(method, path, query, body, isFile) {
+  var operationId = _RequestSchemas["default"].routes["".concat(method.toUpperCase(), " ").concat(path)];
+  if (!operationId) return null;
+  var entry = _RequestSchemas["default"].operations[operationId];
+  var requestBody = body;
+  if (entry.body && entry.body.mediaType === 'multipart/form-data' && body) {
+    requestBody = {};
+    Object.keys(body).forEach(function (key) {
+      if (body[key] !== undefined) requestBody[key] = isFile(body[key]) ? FILE_PLACEHOLDER : body[key];
+    });
+  } else if (body !== null && body !== undefined) {
+    // The JSON the request sends
+    requestBody = JSON.parse(JSON.stringify(body));
+  }
+  var details = errors(operationId, query || {}, requestBody);
+  return details.length ? new ValidationError(details) : null;
+}
+
+/** The details for a request to an operation (createSubmission) */
+function errors(operationId, query, body) {
+  var entry = _RequestSchemas["default"].operations[operationId];
+  var details = [];
+  var queryValues = {};
+  Object.keys(query || {}).forEach(function (key) {
+    if (query[key] !== undefined && query[key] !== null) queryValues[key] = query[key];
+  });
+  if (entry.query && Object.keys(queryValues).length) {
+    var params = entry.query;
+    var properties = {};
+    var required = [];
+    Object.keys(params).forEach(function (name) {
+      properties[name] = params[name].schema;
+      if (params[name].required) required.push(name);
+    });
+    var schema = {
+      type: 'object',
+      properties: properties,
+      required: required,
+      additionalProperties: false
+    };
+    details.push.apply(details, _toConsumableArray(validateParams(schema, queryValues, 'query')));
+  }
+  if (entry.body && body !== null && body !== undefined) {
+    if (entry.body.mediaType === 'multipart/form-data') {
+      details.push.apply(details, _toConsumableArray(validateParams(entry.body.schema, body, 'body')));
+    } else {
+      details.push.apply(details, _toConsumableArray(validate(entry.body.schema, typeof body === 'string' ? JSON.parse(body) : body, 'body')));
+    }
+  }
+  return details;
+}
+
+/** The details for `data` checked against `schema` at `location` (body or query) */
+function validate(schema, data, location) {
+  var details = [];
+  check(schema, data, '', location, details);
+  return details;
+}
+
+// Query and multipart params arrive as strings, which the API converts where the schema types them
+function validateParams(schema, data, location) {
+  var properties = schema.properties || {};
+  var converted = {};
+  Object.keys(data).forEach(function (key) {
+    converted[key] = convertParam(data[key], properties[key]);
+  });
+  return validate(schema, converted, location);
+}
+function convertParam(value, schema) {
+  if (!isObject(schema)) return value;
+  var types = typesOf(schema);
+  if (Array.isArray(value) && types.includes('array')) return value.map(function (item) {
+    return convertParam(item, schema.items);
+  });
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value !== 'string') return value;
+  if (types.includes('integer') && /^-?[0-9]+$/.test(value)) return parseInt(value, 10);
+  if (types.includes('number') && /^-?[0-9]+(?:\.[0-9]+)?$/.test(value)) return Number(value);
+  if (types.includes('boolean') && (value === 'true' || value === 'false')) return value === 'true';
+  return value;
+}
+function typesOf(schema) {
+  if (schema.type === undefined) return [];
+  return Array.isArray(schema.type) ? schema.type : [schema.type];
+}
+function isObject(value) {
+  return value !== null && _typeof(value) === 'object' && !Array.isArray(value);
+}
+function resolve(schema) {
+  var resolved = schema;
+  while (isObject(resolved) && resolved.$ref) {
+    resolved = _RequestSchemas["default"].components.schemas[resolved.$ref.replace('#/components/schemas/', '')];
+  }
+  return resolved;
+}
+function check(rawSchema, data, pointer, location, details) {
+  var schema = resolve(rawSchema);
+  if (!isObject(schema)) return;
+  if (schema.discriminator) {
+    checkUnion(schema, data, pointer, location, details);
+    return;
+  }
+  if (schema.type !== undefined && !typesOf(schema).some(function (type) {
+    return isType(data, type);
+  })) {
+    var message = pointer === '' && location === 'body' ? 'must be a JSON object' : typeMessage(typesOf(schema));
+    details.push(detail(location, pointer, 'type', message));
+  }
+  if (schema["enum"] && !schema["enum"].some(function (value) {
+    return jsonEqual(value, data);
+  })) {
+    details.push(detail(location, pointer, 'enum', "must be one of: ".concat(schema["enum"].map(toJson).join(', '))));
+  }
+  if ('const' in schema && !jsonEqual(schema["const"], data)) {
+    details.push(detail(location, pointer, 'const', "must be ".concat(toJson(schema["const"]))));
+  }
+  if (typeof data === 'string') checkString(schema, data, pointer, location, details);else if (typeof data === 'number') checkNumber(schema, data, pointer, location, details);else if (Array.isArray(data)) checkArray(schema, data, pointer, location, details);else if (isObject(data)) checkObject(schema, data, pointer, location, details);
+}
+
+// A union (oneOf with a discriminator): the discriminator property's value picks the variant, and only that one is
+// checked, as the API does
+function checkUnion(schema, data, pointer, location, details) {
+  if (!isObject(data)) {
+    details.push(detail(location, pointer, 'type', "must be ".concat(TYPE_NAMES.object)));
+    return;
+  }
+  var name = schema.discriminator.propertyName;
+  var child = "".concat(pointer, "/").concat(escape(name));
+  if (!Object.prototype.hasOwnProperty.call(data, name)) {
+    details.push(detail(location, child, 'required', 'is required'));
+    return;
+  }
+
+  // [value, $ref] pairs, in the order the API lists them
+  var mapping = schema.discriminator.mapping;
+  var value = data[name];
+  var variant = typeof value === 'string' ? mapping.find(function (_ref) {
+    var _ref2 = _slicedToArray(_ref, 1),
+      candidate = _ref2[0];
+    return candidate === value;
+  }) : undefined;
+  if (variant) {
+    check({
+      $ref: variant[1]
+    }, data, pointer, location, details);
+    return;
+  }
+  details.push(detail(location, child, 'enum', "must be one of: ".concat(mapping.map(function (_ref3) {
+    var _ref4 = _slicedToArray(_ref3, 1),
+      candidate = _ref4[0];
+    return toJson(candidate);
+  }).join(', '))));
+}
+function checkString(schema, data, pointer, location, details) {
+  var length = Array.from(data).length;
+  if (schema.minLength !== undefined && length < schema.minLength) {
+    var message = atLeast(schema.minLength, "must be at least ".concat(count(schema.minLength, 'character')));
+    details.push(detail(location, pointer, 'minLength', message));
+  }
+  if (schema.maxLength !== undefined && length > schema.maxLength) {
+    details.push(detail(location, pointer, 'maxLength', "must be at most ".concat(count(schema.maxLength, 'character'))));
+  }
+  if (schema.pattern !== undefined && !pattern(schema.pattern).test(data)) {
+    var _message = schema['x-pattern-message'] || "must match the pattern ".concat(schema.pattern);
+    details.push(detail(location, pointer, 'pattern', _message));
+  }
+  if (schema.format !== undefined && !format(schema.format, data)) {
+    var _message2 = _RequestSchemas["default"].formatMessages[schema.format] || "must be a valid ".concat(schema.format);
+    details.push(detail(location, pointer, 'format', _message2));
+  }
+}
+function checkNumber(schema, data, pointer, location, details) {
+  if (schema.minimum !== undefined && data < schema.minimum) {
+    details.push(detail(location, pointer, 'minimum', "must be at least ".concat(schema.minimum)));
+  }
+  if (schema.maximum !== undefined && data > schema.maximum) {
+    details.push(detail(location, pointer, 'maximum', "must be at most ".concat(schema.maximum)));
+  }
+  if (schema.exclusiveMinimum !== undefined && data <= schema.exclusiveMinimum) {
+    details.push(detail(location, pointer, 'exclusiveMinimum', "must be greater than ".concat(schema.exclusiveMinimum)));
+  }
+  if (schema.exclusiveMaximum !== undefined && data >= schema.exclusiveMaximum) {
+    details.push(detail(location, pointer, 'exclusiveMaximum', "must be less than ".concat(schema.exclusiveMaximum)));
+  }
+}
+function checkArray(schema, data, pointer, location, details) {
+  if (schema.minItems !== undefined && data.length < schema.minItems) {
+    var message = atLeast(schema.minItems, "must have at least ".concat(count(schema.minItems, 'item')));
+    details.push(detail(location, pointer, 'minItems', message));
+  }
+  if (schema.maxItems !== undefined && data.length > schema.maxItems) {
+    details.push(detail(location, pointer, 'maxItems', "must have at most ".concat(count(schema.maxItems, 'item'))));
+  }
+  if (schema.uniqueItems && !unique(data)) {
+    var duplicate = firstDuplicate(data);
+    var _message3 = duplicate ? "has ".concat(toJson(duplicate.value), " more than once") : "can't contain the same item twice";
+    details.push(detail(location, pointer, 'uniqueItems', _message3));
+  }
+  if (schema.items !== undefined) {
+    data.forEach(function (item, index) {
+      return check(schema.items, item, "".concat(pointer, "/").concat(index), location, details);
+    });
+  }
+}
+function checkObject(schema, data, pointer, location, details) {
+  (schema.required || []).forEach(function (name) {
+    if (!Object.prototype.hasOwnProperty.call(data, name)) {
+      details.push(detail(location, "".concat(pointer, "/").concat(escape(name)), 'required', 'is required'));
+    }
+  });
+  var properties = schema.properties || {};
+  Object.keys(data).forEach(function (name) {
+    var child = "".concat(pointer, "/").concat(escape(name));
+    if (Object.prototype.hasOwnProperty.call(properties, name)) {
+      check(properties[name], data[name], child, location, details);
+    } else if (schema.additionalProperties === false) {
+      details.push(unknownProperty(schema, name, child, location));
+    } else if (isObject(schema.additionalProperties)) {
+      check(schema.additionalProperties, data[name], child, location, details);
+    }
+  });
+}
+function unknownProperty(schema, name, pointer, location) {
+  var notAllowed = (schema['x-not-allowed-properties'] || {})[name];
+  if (notAllowed) return detail(location, pointer, 'not_allowed', notAllowed);
+  var noun = location === 'query' ? 'query parameter' : 'property';
+  var custom = schema['x-unknown-property-message'];
+  var message = custom || "isn't a documented ".concat(noun);
+  var snake = underscore(name);
+  if (snake !== name && Object.prototype.hasOwnProperty.call(schema.properties || {}, snake)) {
+    var plural = custom ? 'settings' : noun === 'property' ? 'properties' : 'query parameters';
+    message += ". API v2 names ".concat(plural, " in snake_case: '").concat(snake, "'");
+  }
+  return detail(location, pointer, 'unknown_property', message);
+}
+function detail(location, pointer, code, message) {
+  if (location !== 'query') return {
+    code: code,
+    message: message,
+    pointer: pointer
+  };
+  var parameter = pointer.slice(1).split('/')[0].replace(/~1/g, '/').replace(/~0/g, '~');
+  return {
+    code: code,
+    message: message,
+    parameter: parameter
+  };
+}
+function isType(data, type) {
+  switch (type) {
+    case 'string':
+      return typeof data === 'string';
+    case 'integer':
+      return typeof data === 'number' && Number.isInteger(data);
+    case 'number':
+      return typeof data === 'number' && Number.isFinite(data);
+    case 'boolean':
+      return typeof data === 'boolean';
+    case 'object':
+      return isObject(data);
+    case 'array':
+      return Array.isArray(data);
+    case 'null':
+      return data === null;
+    default:
+      return false;
+  }
+}
+
+// Patterns are ECMA-262 regexps, as OpenAPI says: ^ and $ are the start and end of the value, not of a line. The
+// API's patterns only use ^ as the first character and $ as the last (api_clients/scripts/extract_request_schemas).
+// JavaScript reads them that way. The u flag counts characters as the API does (an emoji is one), but rejects some
+// escapes that are fine without it (\-).
+function pattern(source) {
+  if (!patterns[source]) {
+    try {
+      patterns[source] = new RegExp(source, 'u');
+    } catch (error) {
+      patterns[source] = new RegExp(source);
+    }
+  }
+  return patterns[source];
+}
+function format(name, data) {
+  if (name === 'uri') return /^[\x00-\x7f]*$/.test(data) && !WHITESPACE.test(data) && URI.test(data);
+  if (name === 'date-time') return dateTime(data);
+  return true;
+}
+function dateTime(data) {
+  var match = DATE_TIME.exec(data);
+  if (!match) return false;
+  var _match$slice$map = match.slice(1, 7).map(function (value) {
+      return parseInt(value, 10);
+    }),
+    _match$slice$map2 = _slicedToArray(_match$slice$map, 6),
+    year = _match$slice$map2[0],
+    month = _match$slice$map2[1],
+    day = _match$slice$map2[2],
+    hour = _match$slice$map2[3],
+    minute = _match$slice$map2[4],
+    second = _match$slice$map2[5];
+  if (month < 1 || month > 12 || day < 1 || day > daysInMonth(year, month)) return false;
+  if (hour > 23 || minute > 59 || second > 60) return false;
+  var offset = 0;
+  if (match[7]) {
+    var offsetHours = parseInt(match[8], 10);
+    var offsetMinutes = parseInt(match[9], 10);
+    if (offsetHours > 23 || offsetMinutes > 59) return false;
+    offset = (match[7] === '-' ? -1 : 1) * (offsetHours * 60 + offsetMinutes);
+  }
+  // A leap second is only at the end of a UTC day
+  return second < 60 || ((hour * 60 + minute - offset) % 1440 + 1440) % 1440 === 1439;
+}
+
+// Before the Gregorian calendar (1582), the API's dates are Julian: every fourth year is a leap year
+function daysInMonth(year, month) {
+  var leap = year % 4 === 0 && (year < 1583 || year % 100 !== 0 || year % 400 === 0);
+  if (month === 2 && leap) return 29;
+  return [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][month - 1];
+}
+function unique(data) {
+  return !data.some(function (item, index) {
+    return data.slice(index + 1).some(function (other) {
+      return jsonEqual(item, other);
+    });
+  });
+}
+
+// The first value that's in the list twice, as the API names it
+function firstDuplicate(data) {
+  var counts = new Map();
+  var firsts = new Map();
+  data.forEach(function (item) {
+    var key = tallyKey(item);
+    counts.set(key, (counts.get(key) || 0) + 1);
+    if (!firsts.has(key)) firsts.set(key, item);
+  });
+  var _iterator = _createForOfIteratorHelper(counts),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _step$value = _slicedToArray(_step.value, 2),
+        key = _step$value[0],
+        times = _step$value[1];
+      if (times > 1) return {
+        value: firsts.get(key)
+      };
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return null;
+}
+function tallyKey(value) {
+  if (Array.isArray(value)) return "[".concat(value.map(tallyKey).join(','), "]");
+  if (isObject(value)) {
+    return "{".concat(Object.keys(value).sort().map(function (key) {
+      return "".concat(JSON.stringify(key), ":").concat(tallyKey(value[key]));
+    }).join(','), "}");
+  }
+  return JSON.stringify(value);
+}
+
+// JSON equality: numbers by value, objects regardless of key order
+function jsonEqual(left, right) {
+  if (Array.isArray(left) && Array.isArray(right)) {
+    return left.length === right.length && left.every(function (item, index) {
+      return jsonEqual(item, right[index]);
+    });
+  }
+  if (isObject(left) && isObject(right)) {
+    var keys = Object.keys(left);
+    return keys.length === Object.keys(right).length && keys.every(function (key) {
+      return Object.prototype.hasOwnProperty.call(right, key) && jsonEqual(left[key], right[key]);
+    });
+  }
+  return left === right;
+}
+function typeMessage(types) {
+  var names = types.map(function (type) {
+    return TYPE_NAMES[type] || type;
+  });
+  var connector = names.length > 1 && names.some(function (name) {
+    return name.includes(' or ');
+  }) ? ', or ' : ' or ';
+  if (names.length === 1) return "must be ".concat(names[0]);
+  if (names.length === 2) return "must be ".concat(names.join(connector));
+  return "must be ".concat(names.slice(0, -1).join(', ')).concat(connector).concat(names[names.length - 1]);
+}
+function atLeast(limit, message) {
+  return limit === 1 ? "can't be empty" : message;
+}
+function count(number, noun) {
+  return "".concat(number, " ").concat(number === 1 ? noun : "".concat(noun, "s"));
+}
+function toJson(value) {
+  return JSON.stringify(value);
+}
+function escape(token) {
+  return String(token).replace(/~/g, '~0').replace(/\//g, '~1');
+}
+function underscore(name) {
+  return name.replace(/([A-Z\d]+)([A-Z][a-z])/g, '$1_$2').replace(/([a-z\d])([A-Z])/g, '$1_$2').replace(/-/g, '_').toLowerCase();
+}