diff --git a/.babelrc b/.babelrc new file mode 100644 index 0000000..c13c5f6 --- /dev/null +++ b/.babelrc @@ -0,0 +1,3 @@ +{ + "presets": ["es2015"] +} diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..fd4f2b0 --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +node_modules +.DS_Store diff --git a/.jshintrc b/.jshintrc new file mode 100644 index 0000000..51209b8 --- /dev/null +++ b/.jshintrc @@ -0,0 +1,36 @@ +{ + "bitwise": true, + "camelcase": true, + "curly": true, + "esnext": true, + "immed": true, + "newcap": true, + "noarg": true, + "node": true, + "strict": false, + "undef": true, + "unused": "vars", + "boss": true, + "browser": true, + "debug": false, + "devel": true, + "eqeqeq": true, + "eqnull": true, + "evil": true, + "expr": true, + "forin": false, + "laxbreak": false, + "noempty": false, + "nomen": false, + "nonew": false, + "onevar": false, + "plusplus": false, + "predef": [ + "describe", + "it", + "define" + ], + "regexp": false, + "sub": true, + "white": false +} diff --git a/.travis.yml b/.travis.yml new file mode 100644 index 0000000..24a8ab9 --- /dev/null +++ b/.travis.yml @@ -0,0 +1,3 @@ +language: node_js +node_js: + - "5" diff --git a/README.md b/README.md index 7cf31ac..c9daae2 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,5 @@ # xAPI Validator +![Test Passing Travis CI](https://travis-ci.org/elenatorro/xAPI-Validator-JS.svg?branch=master) A stand-alone Javascript validator for Experience API (xAPI) statements. @@ -22,7 +23,7 @@ The input `statement` may either be JSON string of an xAPI statement or a Javasc "actor": { "mbox": "mailto:bob@example.com" }, - "verb": { + "verb": { "id": "http://adlnet.gov/expapi/verbs/created", "display" :{"en-US": "created"} }, @@ -59,7 +60,7 @@ The produced report object contains three key properties: a collection of any `e "actor": { "mbox": "mailto:charles@example.com" }, - "verb": { + "verb": { "id": "http://adlnet.gov/expapi/verbs/created", "display" :{"en-US": "created"} }, @@ -92,4 +93,4 @@ Community feedback, criticism, and collaboration are most welcome. On the less-technical side, if an error message appears cryptic or unhelpful, please report it as an Issue and it should be addressed. ## License -MIT License (C) 2013 Zachary Pierce, Measured Progress \ No newline at end of file +MIT License (C) 2013 Zachary Pierce, Measured Progress diff --git a/gulpfile.js b/gulpfile.js new file mode 100644 index 0000000..32ecea3 --- /dev/null +++ b/gulpfile.js @@ -0,0 +1,91 @@ +'use strict'; + +/* Libraries */ +let + browserify = require('browserify'), + buffer = require('vinyl-buffer'), + connect = require('gulp-connect'), + gulp = require('gulp'), + livereload = require('gulp-livereload'), + source = require('vinyl-source-stream'), + sourcemaps = require('gulp-sourcemaps'), + uglify = require('gulp-uglify') +; + +/* Config */ +const + BABEL_CONFIG = Object.freeze({ + presets: ['es2015'] + }), + BROWSERIFY_TRANSFORM = 'babelify', + BROWSERIFY_CONFIG = Object.freeze({ + debug: true, + json: true, + standalone: 'xapi-validator' + }), + DIST_FILENAME = 'xapiValidator.js', + DIST_FILENAME_MIN = 'xapiValidator.min.js', + DIST_TEST_FILENAME = 'xapiValidator.test.js', + DIST_PATH = 'lib', + DIST_MAIN_PATH = './', + DIST_TEST_PATH = 'spec', + MAPS_PATH = './maps', + SRC_FILE = 'src/xapiValidator.js', + SRC_TEST_FILE = 'test/xapiValidator.test.js', + WATCH_FILES = ['src/*.js', 'constants/*.js', 'spec/*.js', 'spec/lib/*.js'] +; + +/* Task Config */ + +const + BUILD_TASK = 'build', + BUILD_PROD_TASK = 'build-prod', + BUILD_TEST_TASK = 'build-test', + CONNECT_TASK = 'connect', + DEFAULT_TASK = 'default', + DEFAULT_TASKS = [BUILD_TASK, BUILD_TEST_TASK], + WATCH_TASK = 'watch', + WATCH_TASKS = [BUILD_TASK, BUILD_TEST_TASK, CONNECT_TASK] +; + +gulp.task(BUILD_TASK, () => { + return browserify(SRC_FILE, BROWSERIFY_CONFIG) + .transform(BROWSERIFY_TRANSFORM, BABEL_CONFIG) + .bundle() + .pipe(source(DIST_FILENAME)) + .pipe(gulp.dest(DIST_MAIN_PATH)) + .pipe(livereload()); +}); + +gulp.task(BUILD_TEST_TASK, () => { + return browserify(SRC_TEST_FILE, BROWSERIFY_CONFIG) + .transform(BROWSERIFY_TRANSFORM, BABEL_CONFIG) + .bundle() + .pipe(source(DIST_TEST_FILENAME)) + .pipe(gulp.dest(DIST_TEST_PATH)) + .pipe(livereload()); +}); + +gulp.task(BUILD_PROD_TASK, () => { + return browserify(SRC_FILE, BROWSERIFY_CONFIG) + .transform(BROWSERIFY_TRANSFORM, BABEL_CONFIG) + .bundle() + .pipe(source(DIST_FILENAME_MIN)) + .pipe(buffer()) + .pipe(sourcemaps.init()) + .pipe(uglify()) + .pipe(sourcemaps.write(MAPS_PATH)) + .pipe(gulp.dest(DIST_PATH)) + .pipe(livereload()); +}); + +gulp.task(WATCH_TASK, WATCH_TASKS, () => { + livereload.listen(); + gulp.watch(WATCH_FILES, WATCH_TASKS); +}); + +gulp.task(CONNECT_TASK, () => { + connect.server(); +}); + +gulp.task(DEFAULT_TASK, DEFAULT_TASKS); diff --git a/index.js b/index.js new file mode 100644 index 0000000..54ca5b9 --- /dev/null +++ b/index.js @@ -0,0 +1,2 @@ +var xapiValidator = require('./xapiValidator'); +module.exports = xapiValidator; diff --git a/package.json b/package.json index 0c3da03..b8b4cfb 100644 --- a/package.json +++ b/package.json @@ -4,14 +4,45 @@ "main": "./xapiValidator", "author": "Zachary Pierce", "description": "A validator for Experience API (xAPI) statements", - "keywords":["xAPI", "validator", "lrs", "json", "TinCan"], + "scripts": { + "lint": "eslint src/xAPI-validator.js", + "test": "mocha --compilers js:babel-core/register" + }, + "keywords": [ + "xAPI", + "validator", + "lrs", + "json", + "TinCan" + ], "license": "MIT", "engines": { "node": ">=0.6.6" }, - "devDependencies":{ - "chai": "*", - "mocha": "*", - "underscore": "*" + "devDependencies": { + "babel": "^6.5.2", + "babel-cli": "^6.18.0", + "babel-core": "^6.18.2", + "babel-eslint": "^7.1.0", + "babel-plugin-add-module-exports": "^0.2.1", + "babel-preset-es2015": "^6.18.0", + "babelify": "^7.3.0", + "browserify": "^13.1.1", + "chai": "^3.5.0", + "coveralls": "^2.11.14", + "eslint": "^3.9.1", + "gulp": "^3.9.1", + "gulp-babel": "^6.1.2", + "gulp-browserify": "^0.5.1", + "gulp-connect": "^5.0.0", + "gulp-livereload": "^3.8.1", + "gulp-rename": "^1.2.2", + "gulp-sourcemaps": "^2.2.0", + "gulp-uglify": "^2.0.0", + "mocha": "^3.1.2", + "sinon": "^1.17.6", + "underscore": "*", + "vinyl-buffer": "^1.0.0", + "vinyl-source-stream": "^1.1.0" } -} \ No newline at end of file +} diff --git a/spec/mocha_runner.html b/spec/mocha_runner.html index 66e16b4..4c40df2 100644 --- a/spec/mocha_runner.html +++ b/spec/mocha_runner.html @@ -1,6 +1,7 @@ - + + xAPI Validator @@ -9,14 +10,14 @@ - - + + - \ No newline at end of file + diff --git a/spec/xapiValidator.test.js b/spec/xapiValidator.test.js new file mode 100644 index 0000000..7976a39 --- /dev/null +++ b/spec/xapiValidator.test.js @@ -0,0 +1,11322 @@ +(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.xapiValidator = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o + * MIT Licensed + */ + +/*! + * Return a function that will copy properties from + * one object to another excluding any originally + * listed. Returned function will create a new `{}`. + * + * @param {String} excluded properties ... + * @return {Function} + */ + +function exclude () { + var excludes = [].slice.call(arguments); + + function excludeProps (res, obj) { + Object.keys(obj).forEach(function (key) { + if (!~excludes.indexOf(key)) res[key] = obj[key]; + }); + } + + return function extendExclude () { + var args = [].slice.call(arguments) + , i = 0 + , res = {}; + + for (; i < args.length; i++) { + excludeProps(res, args[i]); + } + + return res; + }; +}; + +/*! + * Primary Exports + */ + +module.exports = AssertionError; + +/** + * ### AssertionError + * + * An extension of the JavaScript `Error` constructor for + * assertion and validation scenarios. + * + * @param {String} message + * @param {Object} properties to include (optional) + * @param {callee} start stack function (optional) + */ + +function AssertionError (message, _props, ssf) { + var extend = exclude('name', 'message', 'stack', 'constructor', 'toJSON') + , props = extend(_props || {}); + + // default values + this.message = message || 'Unspecified AssertionError'; + this.showDiff = false; + + // copy from properties + for (var key in props) { + this[key] = props[key]; + } + + // capture stack trace + ssf = ssf || arguments.callee; + if (ssf && Error.captureStackTrace) { + Error.captureStackTrace(this, ssf); + } else { + try { + throw new Error(); + } catch(e) { + this.stack = e.stack; + } + } +} + +/*! + * Inherit from Error.prototype + */ + +AssertionError.prototype = Object.create(Error.prototype); + +/*! + * Statically set name + */ + +AssertionError.prototype.name = 'AssertionError'; + +/*! + * Ensure correct constructor + */ + +AssertionError.prototype.constructor = AssertionError; + +/** + * Allow errors to be converted to JSON for static transfer. + * + * @param {Boolean} include stack (default: `true`) + * @return {Object} object that can be `JSON.stringify` + */ + +AssertionError.prototype.toJSON = function (stack) { + var extend = exclude('constructor', 'toJSON', 'stack') + , props = extend({ name: this.name }, this); + + // include stack if exists and not turned off + if (false !== stack && this.stack) { + props.stack = this.stack; + } + + return props; +}; + +},{}],2:[function(require,module,exports){ +'use strict' + +exports.byteLength = byteLength +exports.toByteArray = toByteArray +exports.fromByteArray = fromByteArray + +var lookup = [] +var revLookup = [] +var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array + +var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/' +for (var i = 0, len = code.length; i < len; ++i) { + lookup[i] = code[i] + revLookup[code.charCodeAt(i)] = i +} + +revLookup['-'.charCodeAt(0)] = 62 +revLookup['_'.charCodeAt(0)] = 63 + +function placeHoldersCount (b64) { + var len = b64.length + if (len % 4 > 0) { + throw new Error('Invalid string. Length must be a multiple of 4') + } + + // the number of equal signs (place holders) + // if there are two placeholders, than the two characters before it + // represent one byte + // if there is only one, then the three characters before it represent 2 bytes + // this is just a cheap hack to not do indexOf twice + return b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0 +} + +function byteLength (b64) { + // base64 is 4/3 + up to two characters of the original data + return b64.length * 3 / 4 - placeHoldersCount(b64) +} + +function toByteArray (b64) { + var i, j, l, tmp, placeHolders, arr + var len = b64.length + placeHolders = placeHoldersCount(b64) + + arr = new Arr(len * 3 / 4 - placeHolders) + + // if there are placeholders, only get up to the last complete 4 chars + l = placeHolders > 0 ? len - 4 : len + + var L = 0 + + for (i = 0, j = 0; i < l; i += 4, j += 3) { + tmp = (revLookup[b64.charCodeAt(i)] << 18) | (revLookup[b64.charCodeAt(i + 1)] << 12) | (revLookup[b64.charCodeAt(i + 2)] << 6) | revLookup[b64.charCodeAt(i + 3)] + arr[L++] = (tmp >> 16) & 0xFF + arr[L++] = (tmp >> 8) & 0xFF + arr[L++] = tmp & 0xFF + } + + if (placeHolders === 2) { + tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4) + arr[L++] = tmp & 0xFF + } else if (placeHolders === 1) { + tmp = (revLookup[b64.charCodeAt(i)] << 10) | (revLookup[b64.charCodeAt(i + 1)] << 4) | (revLookup[b64.charCodeAt(i + 2)] >> 2) + arr[L++] = (tmp >> 8) & 0xFF + arr[L++] = tmp & 0xFF + } + + return arr +} + +function tripletToBase64 (num) { + return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F] +} + +function encodeChunk (uint8, start, end) { + var tmp + var output = [] + for (var i = start; i < end; i += 3) { + tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2]) + output.push(tripletToBase64(tmp)) + } + return output.join('') +} + +function fromByteArray (uint8) { + var tmp + var len = uint8.length + var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes + var output = '' + var parts = [] + var maxChunkLength = 16383 // must be multiple of 3 + + // go through the array every three bytes, we'll deal with trailing stuff later + for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) { + parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength))) + } + + // pad the end with zeros, but make sure to not forget the extra bytes + if (extraBytes === 1) { + tmp = uint8[len - 1] + output += lookup[tmp >> 2] + output += lookup[(tmp << 4) & 0x3F] + output += '==' + } else if (extraBytes === 2) { + tmp = (uint8[len - 2] << 8) + (uint8[len - 1]) + output += lookup[tmp >> 10] + output += lookup[(tmp >> 4) & 0x3F] + output += lookup[(tmp << 2) & 0x3F] + output += '=' + } + + parts.push(output) + + return parts.join('') +} + +},{}],3:[function(require,module,exports){ +(function (global){ +/*! + * The buffer module from node.js, for the browser. + * + * @author Feross Aboukhadijeh + * @license MIT + */ +/* eslint-disable no-proto */ + +'use strict' + +var base64 = require('base64-js') +var ieee754 = require('ieee754') +var isArray = require('isarray') + +exports.Buffer = Buffer +exports.SlowBuffer = SlowBuffer +exports.INSPECT_MAX_BYTES = 50 + +/** + * If `Buffer.TYPED_ARRAY_SUPPORT`: + * === true Use Uint8Array implementation (fastest) + * === false Use Object implementation (most compatible, even IE6) + * + * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+, + * Opera 11.6+, iOS 4.2+. + * + * Due to various browser bugs, sometimes the Object implementation will be used even + * when the browser supports typed arrays. + * + * Note: + * + * - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances, + * See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438. + * + * - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function. + * + * - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of + * incorrect length in some situations. + + * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they + * get the Object implementation, which is slower but behaves correctly. + */ +Buffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined + ? global.TYPED_ARRAY_SUPPORT + : typedArraySupport() + +/* + * Export kMaxLength after typed array support is determined. + */ +exports.kMaxLength = kMaxLength() + +function typedArraySupport () { + try { + var arr = new Uint8Array(1) + arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }} + return arr.foo() === 42 && // typed array instances can be augmented + typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray` + arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray` + } catch (e) { + return false + } +} + +function kMaxLength () { + return Buffer.TYPED_ARRAY_SUPPORT + ? 0x7fffffff + : 0x3fffffff +} + +function createBuffer (that, length) { + if (kMaxLength() < length) { + throw new RangeError('Invalid typed array length') + } + if (Buffer.TYPED_ARRAY_SUPPORT) { + // Return an augmented `Uint8Array` instance, for best performance + that = new Uint8Array(length) + that.__proto__ = Buffer.prototype + } else { + // Fallback: Return an object instance of the Buffer class + if (that === null) { + that = new Buffer(length) + } + that.length = length + } + + return that +} + +/** + * The Buffer constructor returns instances of `Uint8Array` that have their + * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of + * `Uint8Array`, so the returned instances will have all the node `Buffer` methods + * and the `Uint8Array` methods. Square bracket notation works as expected -- it + * returns a single octet. + * + * The `Uint8Array` prototype remains unmodified. + */ + +function Buffer (arg, encodingOrOffset, length) { + if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) { + return new Buffer(arg, encodingOrOffset, length) + } + + // Common case. + if (typeof arg === 'number') { + if (typeof encodingOrOffset === 'string') { + throw new Error( + 'If encoding is specified then the first argument must be a string' + ) + } + return allocUnsafe(this, arg) + } + return from(this, arg, encodingOrOffset, length) +} + +Buffer.poolSize = 8192 // not used by this implementation + +// TODO: Legacy, not needed anymore. Remove in next major version. +Buffer._augment = function (arr) { + arr.__proto__ = Buffer.prototype + return arr +} + +function from (that, value, encodingOrOffset, length) { + if (typeof value === 'number') { + throw new TypeError('"value" argument must not be a number') + } + + if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) { + return fromArrayBuffer(that, value, encodingOrOffset, length) + } + + if (typeof value === 'string') { + return fromString(that, value, encodingOrOffset) + } + + return fromObject(that, value) +} + +/** + * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError + * if value is a number. + * Buffer.from(str[, encoding]) + * Buffer.from(array) + * Buffer.from(buffer) + * Buffer.from(arrayBuffer[, byteOffset[, length]]) + **/ +Buffer.from = function (value, encodingOrOffset, length) { + return from(null, value, encodingOrOffset, length) +} + +if (Buffer.TYPED_ARRAY_SUPPORT) { + Buffer.prototype.__proto__ = Uint8Array.prototype + Buffer.__proto__ = Uint8Array + if (typeof Symbol !== 'undefined' && Symbol.species && + Buffer[Symbol.species] === Buffer) { + // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97 + Object.defineProperty(Buffer, Symbol.species, { + value: null, + configurable: true + }) + } +} + +function assertSize (size) { + if (typeof size !== 'number') { + throw new TypeError('"size" argument must be a number') + } else if (size < 0) { + throw new RangeError('"size" argument must not be negative') + } +} + +function alloc (that, size, fill, encoding) { + assertSize(size) + if (size <= 0) { + return createBuffer(that, size) + } + if (fill !== undefined) { + // Only pay attention to encoding if it's a string. This + // prevents accidentally sending in a number that would + // be interpretted as a start offset. + return typeof encoding === 'string' + ? createBuffer(that, size).fill(fill, encoding) + : createBuffer(that, size).fill(fill) + } + return createBuffer(that, size) +} + +/** + * Creates a new filled Buffer instance. + * alloc(size[, fill[, encoding]]) + **/ +Buffer.alloc = function (size, fill, encoding) { + return alloc(null, size, fill, encoding) +} + +function allocUnsafe (that, size) { + assertSize(size) + that = createBuffer(that, size < 0 ? 0 : checked(size) | 0) + if (!Buffer.TYPED_ARRAY_SUPPORT) { + for (var i = 0; i < size; ++i) { + that[i] = 0 + } + } + return that +} + +/** + * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance. + * */ +Buffer.allocUnsafe = function (size) { + return allocUnsafe(null, size) +} +/** + * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance. + */ +Buffer.allocUnsafeSlow = function (size) { + return allocUnsafe(null, size) +} + +function fromString (that, string, encoding) { + if (typeof encoding !== 'string' || encoding === '') { + encoding = 'utf8' + } + + if (!Buffer.isEncoding(encoding)) { + throw new TypeError('"encoding" must be a valid string encoding') + } + + var length = byteLength(string, encoding) | 0 + that = createBuffer(that, length) + + var actual = that.write(string, encoding) + + if (actual !== length) { + // Writing a hex string, for example, that contains invalid characters will + // cause everything after the first invalid character to be ignored. (e.g. + // 'abxxcd' will be treated as 'ab') + that = that.slice(0, actual) + } + + return that +} + +function fromArrayLike (that, array) { + var length = array.length < 0 ? 0 : checked(array.length) | 0 + that = createBuffer(that, length) + for (var i = 0; i < length; i += 1) { + that[i] = array[i] & 255 + } + return that +} + +function fromArrayBuffer (that, array, byteOffset, length) { + array.byteLength // this throws if `array` is not a valid ArrayBuffer + + if (byteOffset < 0 || array.byteLength < byteOffset) { + throw new RangeError('\'offset\' is out of bounds') + } + + if (array.byteLength < byteOffset + (length || 0)) { + throw new RangeError('\'length\' is out of bounds') + } + + if (byteOffset === undefined && length === undefined) { + array = new Uint8Array(array) + } else if (length === undefined) { + array = new Uint8Array(array, byteOffset) + } else { + array = new Uint8Array(array, byteOffset, length) + } + + if (Buffer.TYPED_ARRAY_SUPPORT) { + // Return an augmented `Uint8Array` instance, for best performance + that = array + that.__proto__ = Buffer.prototype + } else { + // Fallback: Return an object instance of the Buffer class + that = fromArrayLike(that, array) + } + return that +} + +function fromObject (that, obj) { + if (Buffer.isBuffer(obj)) { + var len = checked(obj.length) | 0 + that = createBuffer(that, len) + + if (that.length === 0) { + return that + } + + obj.copy(that, 0, 0, len) + return that + } + + if (obj) { + if ((typeof ArrayBuffer !== 'undefined' && + obj.buffer instanceof ArrayBuffer) || 'length' in obj) { + if (typeof obj.length !== 'number' || isnan(obj.length)) { + return createBuffer(that, 0) + } + return fromArrayLike(that, obj) + } + + if (obj.type === 'Buffer' && isArray(obj.data)) { + return fromArrayLike(that, obj.data) + } + } + + throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.') +} + +function checked (length) { + // Note: cannot use `length < kMaxLength()` here because that fails when + // length is NaN (which is otherwise coerced to zero.) + if (length >= kMaxLength()) { + throw new RangeError('Attempt to allocate Buffer larger than maximum ' + + 'size: 0x' + kMaxLength().toString(16) + ' bytes') + } + return length | 0 +} + +function SlowBuffer (length) { + if (+length != length) { // eslint-disable-line eqeqeq + length = 0 + } + return Buffer.alloc(+length) +} + +Buffer.isBuffer = function isBuffer (b) { + return !!(b != null && b._isBuffer) +} + +Buffer.compare = function compare (a, b) { + if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) { + throw new TypeError('Arguments must be Buffers') + } + + if (a === b) return 0 + + var x = a.length + var y = b.length + + for (var i = 0, len = Math.min(x, y); i < len; ++i) { + if (a[i] !== b[i]) { + x = a[i] + y = b[i] + break + } + } + + if (x < y) return -1 + if (y < x) return 1 + return 0 +} + +Buffer.isEncoding = function isEncoding (encoding) { + switch (String(encoding).toLowerCase()) { + case 'hex': + case 'utf8': + case 'utf-8': + case 'ascii': + case 'latin1': + case 'binary': + case 'base64': + case 'ucs2': + case 'ucs-2': + case 'utf16le': + case 'utf-16le': + return true + default: + return false + } +} + +Buffer.concat = function concat (list, length) { + if (!isArray(list)) { + throw new TypeError('"list" argument must be an Array of Buffers') + } + + if (list.length === 0) { + return Buffer.alloc(0) + } + + var i + if (length === undefined) { + length = 0 + for (i = 0; i < list.length; ++i) { + length += list[i].length + } + } + + var buffer = Buffer.allocUnsafe(length) + var pos = 0 + for (i = 0; i < list.length; ++i) { + var buf = list[i] + if (!Buffer.isBuffer(buf)) { + throw new TypeError('"list" argument must be an Array of Buffers') + } + buf.copy(buffer, pos) + pos += buf.length + } + return buffer +} + +function byteLength (string, encoding) { + if (Buffer.isBuffer(string)) { + return string.length + } + if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' && + (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) { + return string.byteLength + } + if (typeof string !== 'string') { + string = '' + string + } + + var len = string.length + if (len === 0) return 0 + + // Use a for loop to avoid recursion + var loweredCase = false + for (;;) { + switch (encoding) { + case 'ascii': + case 'latin1': + case 'binary': + return len + case 'utf8': + case 'utf-8': + case undefined: + return utf8ToBytes(string).length + case 'ucs2': + case 'ucs-2': + case 'utf16le': + case 'utf-16le': + return len * 2 + case 'hex': + return len >>> 1 + case 'base64': + return base64ToBytes(string).length + default: + if (loweredCase) return utf8ToBytes(string).length // assume utf8 + encoding = ('' + encoding).toLowerCase() + loweredCase = true + } + } +} +Buffer.byteLength = byteLength + +function slowToString (encoding, start, end) { + var loweredCase = false + + // No need to verify that "this.length <= MAX_UINT32" since it's a read-only + // property of a typed array. + + // This behaves neither like String nor Uint8Array in that we set start/end + // to their upper/lower bounds if the value passed is out of range. + // undefined is handled specially as per ECMA-262 6th Edition, + // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization. + if (start === undefined || start < 0) { + start = 0 + } + // Return early if start > this.length. Done here to prevent potential uint32 + // coercion fail below. + if (start > this.length) { + return '' + } + + if (end === undefined || end > this.length) { + end = this.length + } + + if (end <= 0) { + return '' + } + + // Force coersion to uint32. This will also coerce falsey/NaN values to 0. + end >>>= 0 + start >>>= 0 + + if (end <= start) { + return '' + } + + if (!encoding) encoding = 'utf8' + + while (true) { + switch (encoding) { + case 'hex': + return hexSlice(this, start, end) + + case 'utf8': + case 'utf-8': + return utf8Slice(this, start, end) + + case 'ascii': + return asciiSlice(this, start, end) + + case 'latin1': + case 'binary': + return latin1Slice(this, start, end) + + case 'base64': + return base64Slice(this, start, end) + + case 'ucs2': + case 'ucs-2': + case 'utf16le': + case 'utf-16le': + return utf16leSlice(this, start, end) + + default: + if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) + encoding = (encoding + '').toLowerCase() + loweredCase = true + } + } +} + +// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect +// Buffer instances. +Buffer.prototype._isBuffer = true + +function swap (b, n, m) { + var i = b[n] + b[n] = b[m] + b[m] = i +} + +Buffer.prototype.swap16 = function swap16 () { + var len = this.length + if (len % 2 !== 0) { + throw new RangeError('Buffer size must be a multiple of 16-bits') + } + for (var i = 0; i < len; i += 2) { + swap(this, i, i + 1) + } + return this +} + +Buffer.prototype.swap32 = function swap32 () { + var len = this.length + if (len % 4 !== 0) { + throw new RangeError('Buffer size must be a multiple of 32-bits') + } + for (var i = 0; i < len; i += 4) { + swap(this, i, i + 3) + swap(this, i + 1, i + 2) + } + return this +} + +Buffer.prototype.swap64 = function swap64 () { + var len = this.length + if (len % 8 !== 0) { + throw new RangeError('Buffer size must be a multiple of 64-bits') + } + for (var i = 0; i < len; i += 8) { + swap(this, i, i + 7) + swap(this, i + 1, i + 6) + swap(this, i + 2, i + 5) + swap(this, i + 3, i + 4) + } + return this +} + +Buffer.prototype.toString = function toString () { + var length = this.length | 0 + if (length === 0) return '' + if (arguments.length === 0) return utf8Slice(this, 0, length) + return slowToString.apply(this, arguments) +} + +Buffer.prototype.equals = function equals (b) { + if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer') + if (this === b) return true + return Buffer.compare(this, b) === 0 +} + +Buffer.prototype.inspect = function inspect () { + var str = '' + var max = exports.INSPECT_MAX_BYTES + if (this.length > 0) { + str = this.toString('hex', 0, max).match(/.{2}/g).join(' ') + if (this.length > max) str += ' ... ' + } + return '' +} + +Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) { + if (!Buffer.isBuffer(target)) { + throw new TypeError('Argument must be a Buffer') + } + + if (start === undefined) { + start = 0 + } + if (end === undefined) { + end = target ? target.length : 0 + } + if (thisStart === undefined) { + thisStart = 0 + } + if (thisEnd === undefined) { + thisEnd = this.length + } + + if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) { + throw new RangeError('out of range index') + } + + if (thisStart >= thisEnd && start >= end) { + return 0 + } + if (thisStart >= thisEnd) { + return -1 + } + if (start >= end) { + return 1 + } + + start >>>= 0 + end >>>= 0 + thisStart >>>= 0 + thisEnd >>>= 0 + + if (this === target) return 0 + + var x = thisEnd - thisStart + var y = end - start + var len = Math.min(x, y) + + var thisCopy = this.slice(thisStart, thisEnd) + var targetCopy = target.slice(start, end) + + for (var i = 0; i < len; ++i) { + if (thisCopy[i] !== targetCopy[i]) { + x = thisCopy[i] + y = targetCopy[i] + break + } + } + + if (x < y) return -1 + if (y < x) return 1 + return 0 +} + +// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`, +// OR the last index of `val` in `buffer` at offset <= `byteOffset`. +// +// Arguments: +// - buffer - a Buffer to search +// - val - a string, Buffer, or number +// - byteOffset - an index into `buffer`; will be clamped to an int32 +// - encoding - an optional encoding, relevant is val is a string +// - dir - true for indexOf, false for lastIndexOf +function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) { + // Empty buffer means no match + if (buffer.length === 0) return -1 + + // Normalize byteOffset + if (typeof byteOffset === 'string') { + encoding = byteOffset + byteOffset = 0 + } else if (byteOffset > 0x7fffffff) { + byteOffset = 0x7fffffff + } else if (byteOffset < -0x80000000) { + byteOffset = -0x80000000 + } + byteOffset = +byteOffset // Coerce to Number. + if (isNaN(byteOffset)) { + // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer + byteOffset = dir ? 0 : (buffer.length - 1) + } + + // Normalize byteOffset: negative offsets start from the end of the buffer + if (byteOffset < 0) byteOffset = buffer.length + byteOffset + if (byteOffset >= buffer.length) { + if (dir) return -1 + else byteOffset = buffer.length - 1 + } else if (byteOffset < 0) { + if (dir) byteOffset = 0 + else return -1 + } + + // Normalize val + if (typeof val === 'string') { + val = Buffer.from(val, encoding) + } + + // Finally, search either indexOf (if dir is true) or lastIndexOf + if (Buffer.isBuffer(val)) { + // Special case: looking for empty string/buffer always fails + if (val.length === 0) { + return -1 + } + return arrayIndexOf(buffer, val, byteOffset, encoding, dir) + } else if (typeof val === 'number') { + val = val & 0xFF // Search for a byte value [0-255] + if (Buffer.TYPED_ARRAY_SUPPORT && + typeof Uint8Array.prototype.indexOf === 'function') { + if (dir) { + return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset) + } else { + return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset) + } + } + return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir) + } + + throw new TypeError('val must be string, number or Buffer') +} + +function arrayIndexOf (arr, val, byteOffset, encoding, dir) { + var indexSize = 1 + var arrLength = arr.length + var valLength = val.length + + if (encoding !== undefined) { + encoding = String(encoding).toLowerCase() + if (encoding === 'ucs2' || encoding === 'ucs-2' || + encoding === 'utf16le' || encoding === 'utf-16le') { + if (arr.length < 2 || val.length < 2) { + return -1 + } + indexSize = 2 + arrLength /= 2 + valLength /= 2 + byteOffset /= 2 + } + } + + function read (buf, i) { + if (indexSize === 1) { + return buf[i] + } else { + return buf.readUInt16BE(i * indexSize) + } + } + + var i + if (dir) { + var foundIndex = -1 + for (i = byteOffset; i < arrLength; i++) { + if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) { + if (foundIndex === -1) foundIndex = i + if (i - foundIndex + 1 === valLength) return foundIndex * indexSize + } else { + if (foundIndex !== -1) i -= i - foundIndex + foundIndex = -1 + } + } + } else { + if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength + for (i = byteOffset; i >= 0; i--) { + var found = true + for (var j = 0; j < valLength; j++) { + if (read(arr, i + j) !== read(val, j)) { + found = false + break + } + } + if (found) return i + } + } + + return -1 +} + +Buffer.prototype.includes = function includes (val, byteOffset, encoding) { + return this.indexOf(val, byteOffset, encoding) !== -1 +} + +Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) { + return bidirectionalIndexOf(this, val, byteOffset, encoding, true) +} + +Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) { + return bidirectionalIndexOf(this, val, byteOffset, encoding, false) +} + +function hexWrite (buf, string, offset, length) { + offset = Number(offset) || 0 + var remaining = buf.length - offset + if (!length) { + length = remaining + } else { + length = Number(length) + if (length > remaining) { + length = remaining + } + } + + // must be an even number of digits + var strLen = string.length + if (strLen % 2 !== 0) throw new TypeError('Invalid hex string') + + if (length > strLen / 2) { + length = strLen / 2 + } + for (var i = 0; i < length; ++i) { + var parsed = parseInt(string.substr(i * 2, 2), 16) + if (isNaN(parsed)) return i + buf[offset + i] = parsed + } + return i +} + +function utf8Write (buf, string, offset, length) { + return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length) +} + +function asciiWrite (buf, string, offset, length) { + return blitBuffer(asciiToBytes(string), buf, offset, length) +} + +function latin1Write (buf, string, offset, length) { + return asciiWrite(buf, string, offset, length) +} + +function base64Write (buf, string, offset, length) { + return blitBuffer(base64ToBytes(string), buf, offset, length) +} + +function ucs2Write (buf, string, offset, length) { + return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length) +} + +Buffer.prototype.write = function write (string, offset, length, encoding) { + // Buffer#write(string) + if (offset === undefined) { + encoding = 'utf8' + length = this.length + offset = 0 + // Buffer#write(string, encoding) + } else if (length === undefined && typeof offset === 'string') { + encoding = offset + length = this.length + offset = 0 + // Buffer#write(string, offset[, length][, encoding]) + } else if (isFinite(offset)) { + offset = offset | 0 + if (isFinite(length)) { + length = length | 0 + if (encoding === undefined) encoding = 'utf8' + } else { + encoding = length + length = undefined + } + // legacy write(string, encoding, offset, length) - remove in v0.13 + } else { + throw new Error( + 'Buffer.write(string, encoding, offset[, length]) is no longer supported' + ) + } + + var remaining = this.length - offset + if (length === undefined || length > remaining) length = remaining + + if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) { + throw new RangeError('Attempt to write outside buffer bounds') + } + + if (!encoding) encoding = 'utf8' + + var loweredCase = false + for (;;) { + switch (encoding) { + case 'hex': + return hexWrite(this, string, offset, length) + + case 'utf8': + case 'utf-8': + return utf8Write(this, string, offset, length) + + case 'ascii': + return asciiWrite(this, string, offset, length) + + case 'latin1': + case 'binary': + return latin1Write(this, string, offset, length) + + case 'base64': + // Warning: maxLength not taken into account in base64Write + return base64Write(this, string, offset, length) + + case 'ucs2': + case 'ucs-2': + case 'utf16le': + case 'utf-16le': + return ucs2Write(this, string, offset, length) + + default: + if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) + encoding = ('' + encoding).toLowerCase() + loweredCase = true + } + } +} + +Buffer.prototype.toJSON = function toJSON () { + return { + type: 'Buffer', + data: Array.prototype.slice.call(this._arr || this, 0) + } +} + +function base64Slice (buf, start, end) { + if (start === 0 && end === buf.length) { + return base64.fromByteArray(buf) + } else { + return base64.fromByteArray(buf.slice(start, end)) + } +} + +function utf8Slice (buf, start, end) { + end = Math.min(buf.length, end) + var res = [] + + var i = start + while (i < end) { + var firstByte = buf[i] + var codePoint = null + var bytesPerSequence = (firstByte > 0xEF) ? 4 + : (firstByte > 0xDF) ? 3 + : (firstByte > 0xBF) ? 2 + : 1 + + if (i + bytesPerSequence <= end) { + var secondByte, thirdByte, fourthByte, tempCodePoint + + switch (bytesPerSequence) { + case 1: + if (firstByte < 0x80) { + codePoint = firstByte + } + break + case 2: + secondByte = buf[i + 1] + if ((secondByte & 0xC0) === 0x80) { + tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F) + if (tempCodePoint > 0x7F) { + codePoint = tempCodePoint + } + } + break + case 3: + secondByte = buf[i + 1] + thirdByte = buf[i + 2] + if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) { + tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F) + if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) { + codePoint = tempCodePoint + } + } + break + case 4: + secondByte = buf[i + 1] + thirdByte = buf[i + 2] + fourthByte = buf[i + 3] + if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) { + tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F) + if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) { + codePoint = tempCodePoint + } + } + } + } + + if (codePoint === null) { + // we did not generate a valid codePoint so insert a + // replacement char (U+FFFD) and advance only 1 byte + codePoint = 0xFFFD + bytesPerSequence = 1 + } else if (codePoint > 0xFFFF) { + // encode to utf16 (surrogate pair dance) + codePoint -= 0x10000 + res.push(codePoint >>> 10 & 0x3FF | 0xD800) + codePoint = 0xDC00 | codePoint & 0x3FF + } + + res.push(codePoint) + i += bytesPerSequence + } + + return decodeCodePointsArray(res) +} + +// Based on http://stackoverflow.com/a/22747272/680742, the browser with +// the lowest limit is Chrome, with 0x10000 args. +// We go 1 magnitude less, for safety +var MAX_ARGUMENTS_LENGTH = 0x1000 + +function decodeCodePointsArray (codePoints) { + var len = codePoints.length + if (len <= MAX_ARGUMENTS_LENGTH) { + return String.fromCharCode.apply(String, codePoints) // avoid extra slice() + } + + // Decode in chunks to avoid "call stack size exceeded". + var res = '' + var i = 0 + while (i < len) { + res += String.fromCharCode.apply( + String, + codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH) + ) + } + return res +} + +function asciiSlice (buf, start, end) { + var ret = '' + end = Math.min(buf.length, end) + + for (var i = start; i < end; ++i) { + ret += String.fromCharCode(buf[i] & 0x7F) + } + return ret +} + +function latin1Slice (buf, start, end) { + var ret = '' + end = Math.min(buf.length, end) + + for (var i = start; i < end; ++i) { + ret += String.fromCharCode(buf[i]) + } + return ret +} + +function hexSlice (buf, start, end) { + var len = buf.length + + if (!start || start < 0) start = 0 + if (!end || end < 0 || end > len) end = len + + var out = '' + for (var i = start; i < end; ++i) { + out += toHex(buf[i]) + } + return out +} + +function utf16leSlice (buf, start, end) { + var bytes = buf.slice(start, end) + var res = '' + for (var i = 0; i < bytes.length; i += 2) { + res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256) + } + return res +} + +Buffer.prototype.slice = function slice (start, end) { + var len = this.length + start = ~~start + end = end === undefined ? len : ~~end + + if (start < 0) { + start += len + if (start < 0) start = 0 + } else if (start > len) { + start = len + } + + if (end < 0) { + end += len + if (end < 0) end = 0 + } else if (end > len) { + end = len + } + + if (end < start) end = start + + var newBuf + if (Buffer.TYPED_ARRAY_SUPPORT) { + newBuf = this.subarray(start, end) + newBuf.__proto__ = Buffer.prototype + } else { + var sliceLen = end - start + newBuf = new Buffer(sliceLen, undefined) + for (var i = 0; i < sliceLen; ++i) { + newBuf[i] = this[i + start] + } + } + + return newBuf +} + +/* + * Need to make sure that buffer isn't trying to write out of bounds. + */ +function checkOffset (offset, ext, length) { + if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint') + if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length') +} + +Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) { + offset = offset | 0 + byteLength = byteLength | 0 + if (!noAssert) checkOffset(offset, byteLength, this.length) + + var val = this[offset] + var mul = 1 + var i = 0 + while (++i < byteLength && (mul *= 0x100)) { + val += this[offset + i] * mul + } + + return val +} + +Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) { + offset = offset | 0 + byteLength = byteLength | 0 + if (!noAssert) { + checkOffset(offset, byteLength, this.length) + } + + var val = this[offset + --byteLength] + var mul = 1 + while (byteLength > 0 && (mul *= 0x100)) { + val += this[offset + --byteLength] * mul + } + + return val +} + +Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) { + if (!noAssert) checkOffset(offset, 1, this.length) + return this[offset] +} + +Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 2, this.length) + return this[offset] | (this[offset + 1] << 8) +} + +Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 2, this.length) + return (this[offset] << 8) | this[offset + 1] +} + +Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 4, this.length) + + return ((this[offset]) | + (this[offset + 1] << 8) | + (this[offset + 2] << 16)) + + (this[offset + 3] * 0x1000000) +} + +Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 4, this.length) + + return (this[offset] * 0x1000000) + + ((this[offset + 1] << 16) | + (this[offset + 2] << 8) | + this[offset + 3]) +} + +Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) { + offset = offset | 0 + byteLength = byteLength | 0 + if (!noAssert) checkOffset(offset, byteLength, this.length) + + var val = this[offset] + var mul = 1 + var i = 0 + while (++i < byteLength && (mul *= 0x100)) { + val += this[offset + i] * mul + } + mul *= 0x80 + + if (val >= mul) val -= Math.pow(2, 8 * byteLength) + + return val +} + +Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) { + offset = offset | 0 + byteLength = byteLength | 0 + if (!noAssert) checkOffset(offset, byteLength, this.length) + + var i = byteLength + var mul = 1 + var val = this[offset + --i] + while (i > 0 && (mul *= 0x100)) { + val += this[offset + --i] * mul + } + mul *= 0x80 + + if (val >= mul) val -= Math.pow(2, 8 * byteLength) + + return val +} + +Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) { + if (!noAssert) checkOffset(offset, 1, this.length) + if (!(this[offset] & 0x80)) return (this[offset]) + return ((0xff - this[offset] + 1) * -1) +} + +Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 2, this.length) + var val = this[offset] | (this[offset + 1] << 8) + return (val & 0x8000) ? val | 0xFFFF0000 : val +} + +Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 2, this.length) + var val = this[offset + 1] | (this[offset] << 8) + return (val & 0x8000) ? val | 0xFFFF0000 : val +} + +Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 4, this.length) + + return (this[offset]) | + (this[offset + 1] << 8) | + (this[offset + 2] << 16) | + (this[offset + 3] << 24) +} + +Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 4, this.length) + + return (this[offset] << 24) | + (this[offset + 1] << 16) | + (this[offset + 2] << 8) | + (this[offset + 3]) +} + +Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 4, this.length) + return ieee754.read(this, offset, true, 23, 4) +} + +Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 4, this.length) + return ieee754.read(this, offset, false, 23, 4) +} + +Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 8, this.length) + return ieee754.read(this, offset, true, 52, 8) +} + +Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 8, this.length) + return ieee754.read(this, offset, false, 52, 8) +} + +function checkInt (buf, value, offset, ext, max, min) { + if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance') + if (value > max || value < min) throw new RangeError('"value" argument is out of bounds') + if (offset + ext > buf.length) throw new RangeError('Index out of range') +} + +Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) { + value = +value + offset = offset | 0 + byteLength = byteLength | 0 + if (!noAssert) { + var maxBytes = Math.pow(2, 8 * byteLength) - 1 + checkInt(this, value, offset, byteLength, maxBytes, 0) + } + + var mul = 1 + var i = 0 + this[offset] = value & 0xFF + while (++i < byteLength && (mul *= 0x100)) { + this[offset + i] = (value / mul) & 0xFF + } + + return offset + byteLength +} + +Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) { + value = +value + offset = offset | 0 + byteLength = byteLength | 0 + if (!noAssert) { + var maxBytes = Math.pow(2, 8 * byteLength) - 1 + checkInt(this, value, offset, byteLength, maxBytes, 0) + } + + var i = byteLength - 1 + var mul = 1 + this[offset + i] = value & 0xFF + while (--i >= 0 && (mul *= 0x100)) { + this[offset + i] = (value / mul) & 0xFF + } + + return offset + byteLength +} + +Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0) + if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value) + this[offset] = (value & 0xff) + return offset + 1 +} + +function objectWriteUInt16 (buf, value, offset, littleEndian) { + if (value < 0) value = 0xffff + value + 1 + for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) { + buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>> + (littleEndian ? i : 1 - i) * 8 + } +} + +Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = (value & 0xff) + this[offset + 1] = (value >>> 8) + } else { + objectWriteUInt16(this, value, offset, true) + } + return offset + 2 +} + +Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = (value >>> 8) + this[offset + 1] = (value & 0xff) + } else { + objectWriteUInt16(this, value, offset, false) + } + return offset + 2 +} + +function objectWriteUInt32 (buf, value, offset, littleEndian) { + if (value < 0) value = 0xffffffff + value + 1 + for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) { + buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff + } +} + +Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset + 3] = (value >>> 24) + this[offset + 2] = (value >>> 16) + this[offset + 1] = (value >>> 8) + this[offset] = (value & 0xff) + } else { + objectWriteUInt32(this, value, offset, true) + } + return offset + 4 +} + +Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = (value >>> 24) + this[offset + 1] = (value >>> 16) + this[offset + 2] = (value >>> 8) + this[offset + 3] = (value & 0xff) + } else { + objectWriteUInt32(this, value, offset, false) + } + return offset + 4 +} + +Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) { + var limit = Math.pow(2, 8 * byteLength - 1) + + checkInt(this, value, offset, byteLength, limit - 1, -limit) + } + + var i = 0 + var mul = 1 + var sub = 0 + this[offset] = value & 0xFF + while (++i < byteLength && (mul *= 0x100)) { + if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) { + sub = 1 + } + this[offset + i] = ((value / mul) >> 0) - sub & 0xFF + } + + return offset + byteLength +} + +Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) { + var limit = Math.pow(2, 8 * byteLength - 1) + + checkInt(this, value, offset, byteLength, limit - 1, -limit) + } + + var i = byteLength - 1 + var mul = 1 + var sub = 0 + this[offset + i] = value & 0xFF + while (--i >= 0 && (mul *= 0x100)) { + if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) { + sub = 1 + } + this[offset + i] = ((value / mul) >> 0) - sub & 0xFF + } + + return offset + byteLength +} + +Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80) + if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value) + if (value < 0) value = 0xff + value + 1 + this[offset] = (value & 0xff) + return offset + 1 +} + +Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = (value & 0xff) + this[offset + 1] = (value >>> 8) + } else { + objectWriteUInt16(this, value, offset, true) + } + return offset + 2 +} + +Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = (value >>> 8) + this[offset + 1] = (value & 0xff) + } else { + objectWriteUInt16(this, value, offset, false) + } + return offset + 2 +} + +Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = (value & 0xff) + this[offset + 1] = (value >>> 8) + this[offset + 2] = (value >>> 16) + this[offset + 3] = (value >>> 24) + } else { + objectWriteUInt32(this, value, offset, true) + } + return offset + 4 +} + +Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000) + if (value < 0) value = 0xffffffff + value + 1 + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = (value >>> 24) + this[offset + 1] = (value >>> 16) + this[offset + 2] = (value >>> 8) + this[offset + 3] = (value & 0xff) + } else { + objectWriteUInt32(this, value, offset, false) + } + return offset + 4 +} + +function checkIEEE754 (buf, value, offset, ext, max, min) { + if (offset + ext > buf.length) throw new RangeError('Index out of range') + if (offset < 0) throw new RangeError('Index out of range') +} + +function writeFloat (buf, value, offset, littleEndian, noAssert) { + if (!noAssert) { + checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38) + } + ieee754.write(buf, value, offset, littleEndian, 23, 4) + return offset + 4 +} + +Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) { + return writeFloat(this, value, offset, true, noAssert) +} + +Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) { + return writeFloat(this, value, offset, false, noAssert) +} + +function writeDouble (buf, value, offset, littleEndian, noAssert) { + if (!noAssert) { + checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308) + } + ieee754.write(buf, value, offset, littleEndian, 52, 8) + return offset + 8 +} + +Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) { + return writeDouble(this, value, offset, true, noAssert) +} + +Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) { + return writeDouble(this, value, offset, false, noAssert) +} + +// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length) +Buffer.prototype.copy = function copy (target, targetStart, start, end) { + if (!start) start = 0 + if (!end && end !== 0) end = this.length + if (targetStart >= target.length) targetStart = target.length + if (!targetStart) targetStart = 0 + if (end > 0 && end < start) end = start + + // Copy 0 bytes; we're done + if (end === start) return 0 + if (target.length === 0 || this.length === 0) return 0 + + // Fatal error conditions + if (targetStart < 0) { + throw new RangeError('targetStart out of bounds') + } + if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds') + if (end < 0) throw new RangeError('sourceEnd out of bounds') + + // Are we oob? + if (end > this.length) end = this.length + if (target.length - targetStart < end - start) { + end = target.length - targetStart + start + } + + var len = end - start + var i + + if (this === target && start < targetStart && targetStart < end) { + // descending copy from end + for (i = len - 1; i >= 0; --i) { + target[i + targetStart] = this[i + start] + } + } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) { + // ascending copy from start + for (i = 0; i < len; ++i) { + target[i + targetStart] = this[i + start] + } + } else { + Uint8Array.prototype.set.call( + target, + this.subarray(start, start + len), + targetStart + ) + } + + return len +} + +// Usage: +// buffer.fill(number[, offset[, end]]) +// buffer.fill(buffer[, offset[, end]]) +// buffer.fill(string[, offset[, end]][, encoding]) +Buffer.prototype.fill = function fill (val, start, end, encoding) { + // Handle string cases: + if (typeof val === 'string') { + if (typeof start === 'string') { + encoding = start + start = 0 + end = this.length + } else if (typeof end === 'string') { + encoding = end + end = this.length + } + if (val.length === 1) { + var code = val.charCodeAt(0) + if (code < 256) { + val = code + } + } + if (encoding !== undefined && typeof encoding !== 'string') { + throw new TypeError('encoding must be a string') + } + if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) { + throw new TypeError('Unknown encoding: ' + encoding) + } + } else if (typeof val === 'number') { + val = val & 255 + } + + // Invalid ranges are not set to a default, so can range check early. + if (start < 0 || this.length < start || this.length < end) { + throw new RangeError('Out of range index') + } + + if (end <= start) { + return this + } + + start = start >>> 0 + end = end === undefined ? this.length : end >>> 0 + + if (!val) val = 0 + + var i + if (typeof val === 'number') { + for (i = start; i < end; ++i) { + this[i] = val + } + } else { + var bytes = Buffer.isBuffer(val) + ? val + : utf8ToBytes(new Buffer(val, encoding).toString()) + var len = bytes.length + for (i = 0; i < end - start; ++i) { + this[i + start] = bytes[i % len] + } + } + + return this +} + +// HELPER FUNCTIONS +// ================ + +var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g + +function base64clean (str) { + // Node strips out invalid characters like \n and \t from the string, base64-js does not + str = stringtrim(str).replace(INVALID_BASE64_RE, '') + // Node converts strings with length < 2 to '' + if (str.length < 2) return '' + // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not + while (str.length % 4 !== 0) { + str = str + '=' + } + return str +} + +function stringtrim (str) { + if (str.trim) return str.trim() + return str.replace(/^\s+|\s+$/g, '') +} + +function toHex (n) { + if (n < 16) return '0' + n.toString(16) + return n.toString(16) +} + +function utf8ToBytes (string, units) { + units = units || Infinity + var codePoint + var length = string.length + var leadSurrogate = null + var bytes = [] + + for (var i = 0; i < length; ++i) { + codePoint = string.charCodeAt(i) + + // is surrogate component + if (codePoint > 0xD7FF && codePoint < 0xE000) { + // last char was a lead + if (!leadSurrogate) { + // no lead yet + if (codePoint > 0xDBFF) { + // unexpected trail + if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) + continue + } else if (i + 1 === length) { + // unpaired lead + if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) + continue + } + + // valid lead + leadSurrogate = codePoint + + continue + } + + // 2 leads in a row + if (codePoint < 0xDC00) { + if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) + leadSurrogate = codePoint + continue + } + + // valid surrogate pair + codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000 + } else if (leadSurrogate) { + // valid bmp char, but last char was a lead + if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) + } + + leadSurrogate = null + + // encode utf8 + if (codePoint < 0x80) { + if ((units -= 1) < 0) break + bytes.push(codePoint) + } else if (codePoint < 0x800) { + if ((units -= 2) < 0) break + bytes.push( + codePoint >> 0x6 | 0xC0, + codePoint & 0x3F | 0x80 + ) + } else if (codePoint < 0x10000) { + if ((units -= 3) < 0) break + bytes.push( + codePoint >> 0xC | 0xE0, + codePoint >> 0x6 & 0x3F | 0x80, + codePoint & 0x3F | 0x80 + ) + } else if (codePoint < 0x110000) { + if ((units -= 4) < 0) break + bytes.push( + codePoint >> 0x12 | 0xF0, + codePoint >> 0xC & 0x3F | 0x80, + codePoint >> 0x6 & 0x3F | 0x80, + codePoint & 0x3F | 0x80 + ) + } else { + throw new Error('Invalid code point') + } + } + + return bytes +} + +function asciiToBytes (str) { + var byteArray = [] + for (var i = 0; i < str.length; ++i) { + // Node's code seems to be doing this and not & 0x7F.. + byteArray.push(str.charCodeAt(i) & 0xFF) + } + return byteArray +} + +function utf16leToBytes (str, units) { + var c, hi, lo + var byteArray = [] + for (var i = 0; i < str.length; ++i) { + if ((units -= 2) < 0) break + + c = str.charCodeAt(i) + hi = c >> 8 + lo = c % 256 + byteArray.push(lo) + byteArray.push(hi) + } + + return byteArray +} + +function base64ToBytes (str) { + return base64.toByteArray(base64clean(str)) +} + +function blitBuffer (src, dst, offset, length) { + for (var i = 0; i < length; ++i) { + if ((i + offset >= dst.length) || (i >= src.length)) break + dst[i + offset] = src[i] + } + return i +} + +function isnan (val) { + return val !== val // eslint-disable-line no-self-compare +} + +}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) + +},{"base64-js":2,"ieee754":37,"isarray":38}],4:[function(require,module,exports){ +module.exports = require('./lib/chai'); + +},{"./lib/chai":5}],5:[function(require,module,exports){ +/*! + * chai + * Copyright(c) 2011-2014 Jake Luer + * MIT Licensed + */ + +var used = [] + , exports = module.exports = {}; + +/*! + * Chai version + */ + +exports.version = '3.5.0'; + +/*! + * Assertion Error + */ + +exports.AssertionError = require('assertion-error'); + +/*! + * Utils for plugins (not exported) + */ + +var util = require('./chai/utils'); + +/** + * # .use(function) + * + * Provides a way to extend the internals of Chai + * + * @param {Function} + * @returns {this} for chaining + * @api public + */ + +exports.use = function (fn) { + if (!~used.indexOf(fn)) { + fn(this, util); + used.push(fn); + } + + return this; +}; + +/*! + * Utility Functions + */ + +exports.util = util; + +/*! + * Configuration + */ + +var config = require('./chai/config'); +exports.config = config; + +/*! + * Primary `Assertion` prototype + */ + +var assertion = require('./chai/assertion'); +exports.use(assertion); + +/*! + * Core Assertions + */ + +var core = require('./chai/core/assertions'); +exports.use(core); + +/*! + * Expect interface + */ + +var expect = require('./chai/interface/expect'); +exports.use(expect); + +/*! + * Should interface + */ + +var should = require('./chai/interface/should'); +exports.use(should); + +/*! + * Assert interface + */ + +var assert = require('./chai/interface/assert'); +exports.use(assert); + +},{"./chai/assertion":6,"./chai/config":7,"./chai/core/assertions":8,"./chai/interface/assert":9,"./chai/interface/expect":10,"./chai/interface/should":11,"./chai/utils":25,"assertion-error":1}],6:[function(require,module,exports){ +/*! + * chai + * http://chaijs.com + * Copyright(c) 2011-2014 Jake Luer + * MIT Licensed + */ + +var config = require('./config'); + +module.exports = function (_chai, util) { + /*! + * Module dependencies. + */ + + var AssertionError = _chai.AssertionError + , flag = util.flag; + + /*! + * Module export. + */ + + _chai.Assertion = Assertion; + + /*! + * Assertion Constructor + * + * Creates object for chaining. + * + * @api private + */ + + function Assertion (obj, msg, stack) { + flag(this, 'ssfi', stack || arguments.callee); + flag(this, 'object', obj); + flag(this, 'message', msg); + } + + Object.defineProperty(Assertion, 'includeStack', { + get: function() { + console.warn('Assertion.includeStack is deprecated, use chai.config.includeStack instead.'); + return config.includeStack; + }, + set: function(value) { + console.warn('Assertion.includeStack is deprecated, use chai.config.includeStack instead.'); + config.includeStack = value; + } + }); + + Object.defineProperty(Assertion, 'showDiff', { + get: function() { + console.warn('Assertion.showDiff is deprecated, use chai.config.showDiff instead.'); + return config.showDiff; + }, + set: function(value) { + console.warn('Assertion.showDiff is deprecated, use chai.config.showDiff instead.'); + config.showDiff = value; + } + }); + + Assertion.addProperty = function (name, fn) { + util.addProperty(this.prototype, name, fn); + }; + + Assertion.addMethod = function (name, fn) { + util.addMethod(this.prototype, name, fn); + }; + + Assertion.addChainableMethod = function (name, fn, chainingBehavior) { + util.addChainableMethod(this.prototype, name, fn, chainingBehavior); + }; + + Assertion.overwriteProperty = function (name, fn) { + util.overwriteProperty(this.prototype, name, fn); + }; + + Assertion.overwriteMethod = function (name, fn) { + util.overwriteMethod(this.prototype, name, fn); + }; + + Assertion.overwriteChainableMethod = function (name, fn, chainingBehavior) { + util.overwriteChainableMethod(this.prototype, name, fn, chainingBehavior); + }; + + /** + * ### .assert(expression, message, negateMessage, expected, actual, showDiff) + * + * Executes an expression and check expectations. Throws AssertionError for reporting if test doesn't pass. + * + * @name assert + * @param {Philosophical} expression to be tested + * @param {String|Function} message or function that returns message to display if expression fails + * @param {String|Function} negatedMessage or function that returns negatedMessage to display if negated expression fails + * @param {Mixed} expected value (remember to check for negation) + * @param {Mixed} actual (optional) will default to `this.obj` + * @param {Boolean} showDiff (optional) when set to `true`, assert will display a diff in addition to the message if expression fails + * @api private + */ + + Assertion.prototype.assert = function (expr, msg, negateMsg, expected, _actual, showDiff) { + var ok = util.test(this, arguments); + if (true !== showDiff) showDiff = false; + if (true !== config.showDiff) showDiff = false; + + if (!ok) { + var msg = util.getMessage(this, arguments) + , actual = util.getActual(this, arguments); + throw new AssertionError(msg, { + actual: actual + , expected: expected + , showDiff: showDiff + }, (config.includeStack) ? this.assert : flag(this, 'ssfi')); + } + }; + + /*! + * ### ._obj + * + * Quick reference to stored `actual` value for plugin developers. + * + * @api private + */ + + Object.defineProperty(Assertion.prototype, '_obj', + { get: function () { + return flag(this, 'object'); + } + , set: function (val) { + flag(this, 'object', val); + } + }); +}; + +},{"./config":7}],7:[function(require,module,exports){ +module.exports = { + + /** + * ### config.includeStack + * + * User configurable property, influences whether stack trace + * is included in Assertion error message. Default of false + * suppresses stack trace in the error message. + * + * chai.config.includeStack = true; // enable stack on error + * + * @param {Boolean} + * @api public + */ + + includeStack: false, + + /** + * ### config.showDiff + * + * User configurable property, influences whether or not + * the `showDiff` flag should be included in the thrown + * AssertionErrors. `false` will always be `false`; `true` + * will be true when the assertion has requested a diff + * be shown. + * + * @param {Boolean} + * @api public + */ + + showDiff: true, + + /** + * ### config.truncateThreshold + * + * User configurable property, sets length threshold for actual and + * expected values in assertion errors. If this threshold is exceeded, for + * example for large data structures, the value is replaced with something + * like `[ Array(3) ]` or `{ Object (prop1, prop2) }`. + * + * Set it to zero if you want to disable truncating altogether. + * + * This is especially userful when doing assertions on arrays: having this + * set to a reasonable large value makes the failure messages readily + * inspectable. + * + * chai.config.truncateThreshold = 0; // disable truncating + * + * @param {Number} + * @api public + */ + + truncateThreshold: 40 + +}; + +},{}],8:[function(require,module,exports){ +/*! + * chai + * http://chaijs.com + * Copyright(c) 2011-2014 Jake Luer + * MIT Licensed + */ + +module.exports = function (chai, _) { + var Assertion = chai.Assertion + , toString = Object.prototype.toString + , flag = _.flag; + + /** + * ### Language Chains + * + * The following are provided as chainable getters to + * improve the readability of your assertions. They + * do not provide testing capabilities unless they + * have been overwritten by a plugin. + * + * **Chains** + * + * - to + * - be + * - been + * - is + * - that + * - which + * - and + * - has + * - have + * - with + * - at + * - of + * - same + * + * @name language chains + * @namespace BDD + * @api public + */ + + [ 'to', 'be', 'been' + , 'is', 'and', 'has', 'have' + , 'with', 'that', 'which', 'at' + , 'of', 'same' ].forEach(function (chain) { + Assertion.addProperty(chain, function () { + return this; + }); + }); + + /** + * ### .not + * + * Negates any of assertions following in the chain. + * + * expect(foo).to.not.equal('bar'); + * expect(goodFn).to.not.throw(Error); + * expect({ foo: 'baz' }).to.have.property('foo') + * .and.not.equal('bar'); + * + * @name not + * @namespace BDD + * @api public + */ + + Assertion.addProperty('not', function () { + flag(this, 'negate', true); + }); + + /** + * ### .deep + * + * Sets the `deep` flag, later used by the `equal` and + * `property` assertions. + * + * expect(foo).to.deep.equal({ bar: 'baz' }); + * expect({ foo: { bar: { baz: 'quux' } } }) + * .to.have.deep.property('foo.bar.baz', 'quux'); + * + * `.deep.property` special characters can be escaped + * by adding two slashes before the `.` or `[]`. + * + * var deepCss = { '.link': { '[target]': 42 }}; + * expect(deepCss).to.have.deep.property('\\.link.\\[target\\]', 42); + * + * @name deep + * @namespace BDD + * @api public + */ + + Assertion.addProperty('deep', function () { + flag(this, 'deep', true); + }); + + /** + * ### .any + * + * Sets the `any` flag, (opposite of the `all` flag) + * later used in the `keys` assertion. + * + * expect(foo).to.have.any.keys('bar', 'baz'); + * + * @name any + * @namespace BDD + * @api public + */ + + Assertion.addProperty('any', function () { + flag(this, 'any', true); + flag(this, 'all', false) + }); + + + /** + * ### .all + * + * Sets the `all` flag (opposite of the `any` flag) + * later used by the `keys` assertion. + * + * expect(foo).to.have.all.keys('bar', 'baz'); + * + * @name all + * @namespace BDD + * @api public + */ + + Assertion.addProperty('all', function () { + flag(this, 'all', true); + flag(this, 'any', false); + }); + + /** + * ### .a(type) + * + * The `a` and `an` assertions are aliases that can be + * used either as language chains or to assert a value's + * type. + * + * // typeof + * expect('test').to.be.a('string'); + * expect({ foo: 'bar' }).to.be.an('object'); + * expect(null).to.be.a('null'); + * expect(undefined).to.be.an('undefined'); + * expect(new Error).to.be.an('error'); + * expect(new Promise).to.be.a('promise'); + * expect(new Float32Array()).to.be.a('float32array'); + * expect(Symbol()).to.be.a('symbol'); + * + * // es6 overrides + * expect({[Symbol.toStringTag]:()=>'foo'}).to.be.a('foo'); + * + * // language chain + * expect(foo).to.be.an.instanceof(Foo); + * + * @name a + * @alias an + * @param {String} type + * @param {String} message _optional_ + * @namespace BDD + * @api public + */ + + function an (type, msg) { + if (msg) flag(this, 'message', msg); + type = type.toLowerCase(); + var obj = flag(this, 'object') + , article = ~[ 'a', 'e', 'i', 'o', 'u' ].indexOf(type.charAt(0)) ? 'an ' : 'a '; + + this.assert( + type === _.type(obj) + , 'expected #{this} to be ' + article + type + , 'expected #{this} not to be ' + article + type + ); + } + + Assertion.addChainableMethod('an', an); + Assertion.addChainableMethod('a', an); + + /** + * ### .include(value) + * + * The `include` and `contain` assertions can be used as either property + * based language chains or as methods to assert the inclusion of an object + * in an array or a substring in a string. When used as language chains, + * they toggle the `contains` flag for the `keys` assertion. + * + * expect([1,2,3]).to.include(2); + * expect('foobar').to.contain('foo'); + * expect({ foo: 'bar', hello: 'universe' }).to.include.keys('foo'); + * + * @name include + * @alias contain + * @alias includes + * @alias contains + * @param {Object|String|Number} obj + * @param {String} message _optional_ + * @namespace BDD + * @api public + */ + + function includeChainingBehavior () { + flag(this, 'contains', true); + } + + function include (val, msg) { + _.expectTypes(this, ['array', 'object', 'string']); + + if (msg) flag(this, 'message', msg); + var obj = flag(this, 'object'); + var expected = false; + + if (_.type(obj) === 'array' && _.type(val) === 'object') { + for (var i in obj) { + if (_.eql(obj[i], val)) { + expected = true; + break; + } + } + } else if (_.type(val) === 'object') { + if (!flag(this, 'negate')) { + for (var k in val) new Assertion(obj).property(k, val[k]); + return; + } + var subset = {}; + for (var k in val) subset[k] = obj[k]; + expected = _.eql(subset, val); + } else { + expected = (obj != undefined) && ~obj.indexOf(val); + } + this.assert( + expected + , 'expected #{this} to include ' + _.inspect(val) + , 'expected #{this} to not include ' + _.inspect(val)); + } + + Assertion.addChainableMethod('include', include, includeChainingBehavior); + Assertion.addChainableMethod('contain', include, includeChainingBehavior); + Assertion.addChainableMethod('contains', include, includeChainingBehavior); + Assertion.addChainableMethod('includes', include, includeChainingBehavior); + + /** + * ### .ok + * + * Asserts that the target is truthy. + * + * expect('everything').to.be.ok; + * expect(1).to.be.ok; + * expect(false).to.not.be.ok; + * expect(undefined).to.not.be.ok; + * expect(null).to.not.be.ok; + * + * @name ok + * @namespace BDD + * @api public + */ + + Assertion.addProperty('ok', function () { + this.assert( + flag(this, 'object') + , 'expected #{this} to be truthy' + , 'expected #{this} to be falsy'); + }); + + /** + * ### .true + * + * Asserts that the target is `true`. + * + * expect(true).to.be.true; + * expect(1).to.not.be.true; + * + * @name true + * @namespace BDD + * @api public + */ + + Assertion.addProperty('true', function () { + this.assert( + true === flag(this, 'object') + , 'expected #{this} to be true' + , 'expected #{this} to be false' + , this.negate ? false : true + ); + }); + + /** + * ### .false + * + * Asserts that the target is `false`. + * + * expect(false).to.be.false; + * expect(0).to.not.be.false; + * + * @name false + * @namespace BDD + * @api public + */ + + Assertion.addProperty('false', function () { + this.assert( + false === flag(this, 'object') + , 'expected #{this} to be false' + , 'expected #{this} to be true' + , this.negate ? true : false + ); + }); + + /** + * ### .null + * + * Asserts that the target is `null`. + * + * expect(null).to.be.null; + * expect(undefined).to.not.be.null; + * + * @name null + * @namespace BDD + * @api public + */ + + Assertion.addProperty('null', function () { + this.assert( + null === flag(this, 'object') + , 'expected #{this} to be null' + , 'expected #{this} not to be null' + ); + }); + + /** + * ### .undefined + * + * Asserts that the target is `undefined`. + * + * expect(undefined).to.be.undefined; + * expect(null).to.not.be.undefined; + * + * @name undefined + * @namespace BDD + * @api public + */ + + Assertion.addProperty('undefined', function () { + this.assert( + undefined === flag(this, 'object') + , 'expected #{this} to be undefined' + , 'expected #{this} not to be undefined' + ); + }); + + /** + * ### .NaN + * Asserts that the target is `NaN`. + * + * expect('foo').to.be.NaN; + * expect(4).not.to.be.NaN; + * + * @name NaN + * @namespace BDD + * @api public + */ + + Assertion.addProperty('NaN', function () { + this.assert( + isNaN(flag(this, 'object')) + , 'expected #{this} to be NaN' + , 'expected #{this} not to be NaN' + ); + }); + + /** + * ### .exist + * + * Asserts that the target is neither `null` nor `undefined`. + * + * var foo = 'hi' + * , bar = null + * , baz; + * + * expect(foo).to.exist; + * expect(bar).to.not.exist; + * expect(baz).to.not.exist; + * + * @name exist + * @namespace BDD + * @api public + */ + + Assertion.addProperty('exist', function () { + this.assert( + null != flag(this, 'object') + , 'expected #{this} to exist' + , 'expected #{this} to not exist' + ); + }); + + + /** + * ### .empty + * + * Asserts that the target's length is `0`. For arrays and strings, it checks + * the `length` property. For objects, it gets the count of + * enumerable keys. + * + * expect([]).to.be.empty; + * expect('').to.be.empty; + * expect({}).to.be.empty; + * + * @name empty + * @namespace BDD + * @api public + */ + + Assertion.addProperty('empty', function () { + var obj = flag(this, 'object') + , expected = obj; + + if (Array.isArray(obj) || 'string' === typeof object) { + expected = obj.length; + } else if (typeof obj === 'object') { + expected = Object.keys(obj).length; + } + + this.assert( + !expected + , 'expected #{this} to be empty' + , 'expected #{this} not to be empty' + ); + }); + + /** + * ### .arguments + * + * Asserts that the target is an arguments object. + * + * function test () { + * expect(arguments).to.be.arguments; + * } + * + * @name arguments + * @alias Arguments + * @namespace BDD + * @api public + */ + + function checkArguments () { + var obj = flag(this, 'object') + , type = Object.prototype.toString.call(obj); + this.assert( + '[object Arguments]' === type + , 'expected #{this} to be arguments but got ' + type + , 'expected #{this} to not be arguments' + ); + } + + Assertion.addProperty('arguments', checkArguments); + Assertion.addProperty('Arguments', checkArguments); + + /** + * ### .equal(value) + * + * Asserts that the target is strictly equal (`===`) to `value`. + * Alternately, if the `deep` flag is set, asserts that + * the target is deeply equal to `value`. + * + * expect('hello').to.equal('hello'); + * expect(42).to.equal(42); + * expect(1).to.not.equal(true); + * expect({ foo: 'bar' }).to.not.equal({ foo: 'bar' }); + * expect({ foo: 'bar' }).to.deep.equal({ foo: 'bar' }); + * + * @name equal + * @alias equals + * @alias eq + * @alias deep.equal + * @param {Mixed} value + * @param {String} message _optional_ + * @namespace BDD + * @api public + */ + + function assertEqual (val, msg) { + if (msg) flag(this, 'message', msg); + var obj = flag(this, 'object'); + if (flag(this, 'deep')) { + return this.eql(val); + } else { + this.assert( + val === obj + , 'expected #{this} to equal #{exp}' + , 'expected #{this} to not equal #{exp}' + , val + , this._obj + , true + ); + } + } + + Assertion.addMethod('equal', assertEqual); + Assertion.addMethod('equals', assertEqual); + Assertion.addMethod('eq', assertEqual); + + /** + * ### .eql(value) + * + * Asserts that the target is deeply equal to `value`. + * + * expect({ foo: 'bar' }).to.eql({ foo: 'bar' }); + * expect([ 1, 2, 3 ]).to.eql([ 1, 2, 3 ]); + * + * @name eql + * @alias eqls + * @param {Mixed} value + * @param {String} message _optional_ + * @namespace BDD + * @api public + */ + + function assertEql(obj, msg) { + if (msg) flag(this, 'message', msg); + this.assert( + _.eql(obj, flag(this, 'object')) + , 'expected #{this} to deeply equal #{exp}' + , 'expected #{this} to not deeply equal #{exp}' + , obj + , this._obj + , true + ); + } + + Assertion.addMethod('eql', assertEql); + Assertion.addMethod('eqls', assertEql); + + /** + * ### .above(value) + * + * Asserts that the target is greater than `value`. + * + * expect(10).to.be.above(5); + * + * Can also be used in conjunction with `length` to + * assert a minimum length. The benefit being a + * more informative error message than if the length + * was supplied directly. + * + * expect('foo').to.have.length.above(2); + * expect([ 1, 2, 3 ]).to.have.length.above(2); + * + * @name above + * @alias gt + * @alias greaterThan + * @param {Number} value + * @param {String} message _optional_ + * @namespace BDD + * @api public + */ + + function assertAbove (n, msg) { + if (msg) flag(this, 'message', msg); + var obj = flag(this, 'object'); + if (flag(this, 'doLength')) { + new Assertion(obj, msg).to.have.property('length'); + var len = obj.length; + this.assert( + len > n + , 'expected #{this} to have a length above #{exp} but got #{act}' + , 'expected #{this} to not have a length above #{exp}' + , n + , len + ); + } else { + this.assert( + obj > n + , 'expected #{this} to be above ' + n + , 'expected #{this} to be at most ' + n + ); + } + } + + Assertion.addMethod('above', assertAbove); + Assertion.addMethod('gt', assertAbove); + Assertion.addMethod('greaterThan', assertAbove); + + /** + * ### .least(value) + * + * Asserts that the target is greater than or equal to `value`. + * + * expect(10).to.be.at.least(10); + * + * Can also be used in conjunction with `length` to + * assert a minimum length. The benefit being a + * more informative error message than if the length + * was supplied directly. + * + * expect('foo').to.have.length.of.at.least(2); + * expect([ 1, 2, 3 ]).to.have.length.of.at.least(3); + * + * @name least + * @alias gte + * @param {Number} value + * @param {String} message _optional_ + * @namespace BDD + * @api public + */ + + function assertLeast (n, msg) { + if (msg) flag(this, 'message', msg); + var obj = flag(this, 'object'); + if (flag(this, 'doLength')) { + new Assertion(obj, msg).to.have.property('length'); + var len = obj.length; + this.assert( + len >= n + , 'expected #{this} to have a length at least #{exp} but got #{act}' + , 'expected #{this} to have a length below #{exp}' + , n + , len + ); + } else { + this.assert( + obj >= n + , 'expected #{this} to be at least ' + n + , 'expected #{this} to be below ' + n + ); + } + } + + Assertion.addMethod('least', assertLeast); + Assertion.addMethod('gte', assertLeast); + + /** + * ### .below(value) + * + * Asserts that the target is less than `value`. + * + * expect(5).to.be.below(10); + * + * Can also be used in conjunction with `length` to + * assert a maximum length. The benefit being a + * more informative error message than if the length + * was supplied directly. + * + * expect('foo').to.have.length.below(4); + * expect([ 1, 2, 3 ]).to.have.length.below(4); + * + * @name below + * @alias lt + * @alias lessThan + * @param {Number} value + * @param {String} message _optional_ + * @namespace BDD + * @api public + */ + + function assertBelow (n, msg) { + if (msg) flag(this, 'message', msg); + var obj = flag(this, 'object'); + if (flag(this, 'doLength')) { + new Assertion(obj, msg).to.have.property('length'); + var len = obj.length; + this.assert( + len < n + , 'expected #{this} to have a length below #{exp} but got #{act}' + , 'expected #{this} to not have a length below #{exp}' + , n + , len + ); + } else { + this.assert( + obj < n + , 'expected #{this} to be below ' + n + , 'expected #{this} to be at least ' + n + ); + } + } + + Assertion.addMethod('below', assertBelow); + Assertion.addMethod('lt', assertBelow); + Assertion.addMethod('lessThan', assertBelow); + + /** + * ### .most(value) + * + * Asserts that the target is less than or equal to `value`. + * + * expect(5).to.be.at.most(5); + * + * Can also be used in conjunction with `length` to + * assert a maximum length. The benefit being a + * more informative error message than if the length + * was supplied directly. + * + * expect('foo').to.have.length.of.at.most(4); + * expect([ 1, 2, 3 ]).to.have.length.of.at.most(3); + * + * @name most + * @alias lte + * @param {Number} value + * @param {String} message _optional_ + * @namespace BDD + * @api public + */ + + function assertMost (n, msg) { + if (msg) flag(this, 'message', msg); + var obj = flag(this, 'object'); + if (flag(this, 'doLength')) { + new Assertion(obj, msg).to.have.property('length'); + var len = obj.length; + this.assert( + len <= n + , 'expected #{this} to have a length at most #{exp} but got #{act}' + , 'expected #{this} to have a length above #{exp}' + , n + , len + ); + } else { + this.assert( + obj <= n + , 'expected #{this} to be at most ' + n + , 'expected #{this} to be above ' + n + ); + } + } + + Assertion.addMethod('most', assertMost); + Assertion.addMethod('lte', assertMost); + + /** + * ### .within(start, finish) + * + * Asserts that the target is within a range. + * + * expect(7).to.be.within(5,10); + * + * Can also be used in conjunction with `length` to + * assert a length range. The benefit being a + * more informative error message than if the length + * was supplied directly. + * + * expect('foo').to.have.length.within(2,4); + * expect([ 1, 2, 3 ]).to.have.length.within(2,4); + * + * @name within + * @param {Number} start lowerbound inclusive + * @param {Number} finish upperbound inclusive + * @param {String} message _optional_ + * @namespace BDD + * @api public + */ + + Assertion.addMethod('within', function (start, finish, msg) { + if (msg) flag(this, 'message', msg); + var obj = flag(this, 'object') + , range = start + '..' + finish; + if (flag(this, 'doLength')) { + new Assertion(obj, msg).to.have.property('length'); + var len = obj.length; + this.assert( + len >= start && len <= finish + , 'expected #{this} to have a length within ' + range + , 'expected #{this} to not have a length within ' + range + ); + } else { + this.assert( + obj >= start && obj <= finish + , 'expected #{this} to be within ' + range + , 'expected #{this} to not be within ' + range + ); + } + }); + + /** + * ### .instanceof(constructor) + * + * Asserts that the target is an instance of `constructor`. + * + * var Tea = function (name) { this.name = name; } + * , Chai = new Tea('chai'); + * + * expect(Chai).to.be.an.instanceof(Tea); + * expect([ 1, 2, 3 ]).to.be.instanceof(Array); + * + * @name instanceof + * @param {Constructor} constructor + * @param {String} message _optional_ + * @alias instanceOf + * @namespace BDD + * @api public + */ + + function assertInstanceOf (constructor, msg) { + if (msg) flag(this, 'message', msg); + var name = _.getName(constructor); + this.assert( + flag(this, 'object') instanceof constructor + , 'expected #{this} to be an instance of ' + name + , 'expected #{this} to not be an instance of ' + name + ); + }; + + Assertion.addMethod('instanceof', assertInstanceOf); + Assertion.addMethod('instanceOf', assertInstanceOf); + + /** + * ### .property(name, [value]) + * + * Asserts that the target has a property `name`, optionally asserting that + * the value of that property is strictly equal to `value`. + * If the `deep` flag is set, you can use dot- and bracket-notation for deep + * references into objects and arrays. + * + * // simple referencing + * var obj = { foo: 'bar' }; + * expect(obj).to.have.property('foo'); + * expect(obj).to.have.property('foo', 'bar'); + * + * // deep referencing + * var deepObj = { + * green: { tea: 'matcha' } + * , teas: [ 'chai', 'matcha', { tea: 'konacha' } ] + * }; + * + * expect(deepObj).to.have.deep.property('green.tea', 'matcha'); + * expect(deepObj).to.have.deep.property('teas[1]', 'matcha'); + * expect(deepObj).to.have.deep.property('teas[2].tea', 'konacha'); + * + * You can also use an array as the starting point of a `deep.property` + * assertion, or traverse nested arrays. + * + * var arr = [ + * [ 'chai', 'matcha', 'konacha' ] + * , [ { tea: 'chai' } + * , { tea: 'matcha' } + * , { tea: 'konacha' } ] + * ]; + * + * expect(arr).to.have.deep.property('[0][1]', 'matcha'); + * expect(arr).to.have.deep.property('[1][2].tea', 'konacha'); + * + * Furthermore, `property` changes the subject of the assertion + * to be the value of that property from the original object. This + * permits for further chainable assertions on that property. + * + * expect(obj).to.have.property('foo') + * .that.is.a('string'); + * expect(deepObj).to.have.property('green') + * .that.is.an('object') + * .that.deep.equals({ tea: 'matcha' }); + * expect(deepObj).to.have.property('teas') + * .that.is.an('array') + * .with.deep.property('[2]') + * .that.deep.equals({ tea: 'konacha' }); + * + * Note that dots and bracket in `name` must be backslash-escaped when + * the `deep` flag is set, while they must NOT be escaped when the `deep` + * flag is not set. + * + * // simple referencing + * var css = { '.link[target]': 42 }; + * expect(css).to.have.property('.link[target]', 42); + * + * // deep referencing + * var deepCss = { '.link': { '[target]': 42 }}; + * expect(deepCss).to.have.deep.property('\\.link.\\[target\\]', 42); + * + * @name property + * @alias deep.property + * @param {String} name + * @param {Mixed} value (optional) + * @param {String} message _optional_ + * @returns value of property for chaining + * @namespace BDD + * @api public + */ + + Assertion.addMethod('property', function (name, val, msg) { + if (msg) flag(this, 'message', msg); + + var isDeep = !!flag(this, 'deep') + , descriptor = isDeep ? 'deep property ' : 'property ' + , negate = flag(this, 'negate') + , obj = flag(this, 'object') + , pathInfo = isDeep ? _.getPathInfo(name, obj) : null + , hasProperty = isDeep + ? pathInfo.exists + : _.hasProperty(name, obj) + , value = isDeep + ? pathInfo.value + : obj[name]; + + if (negate && arguments.length > 1) { + if (undefined === value) { + msg = (msg != null) ? msg + ': ' : ''; + throw new Error(msg + _.inspect(obj) + ' has no ' + descriptor + _.inspect(name)); + } + } else { + this.assert( + hasProperty + , 'expected #{this} to have a ' + descriptor + _.inspect(name) + , 'expected #{this} to not have ' + descriptor + _.inspect(name)); + } + + if (arguments.length > 1) { + this.assert( + val === value + , 'expected #{this} to have a ' + descriptor + _.inspect(name) + ' of #{exp}, but got #{act}' + , 'expected #{this} to not have a ' + descriptor + _.inspect(name) + ' of #{act}' + , val + , value + ); + } + + flag(this, 'object', value); + }); + + + /** + * ### .ownProperty(name) + * + * Asserts that the target has an own property `name`. + * + * expect('test').to.have.ownProperty('length'); + * + * @name ownProperty + * @alias haveOwnProperty + * @param {String} name + * @param {String} message _optional_ + * @namespace BDD + * @api public + */ + + function assertOwnProperty (name, msg) { + if (msg) flag(this, 'message', msg); + var obj = flag(this, 'object'); + this.assert( + obj.hasOwnProperty(name) + , 'expected #{this} to have own property ' + _.inspect(name) + , 'expected #{this} to not have own property ' + _.inspect(name) + ); + } + + Assertion.addMethod('ownProperty', assertOwnProperty); + Assertion.addMethod('haveOwnProperty', assertOwnProperty); + + /** + * ### .ownPropertyDescriptor(name[, descriptor[, message]]) + * + * Asserts that the target has an own property descriptor `name`, that optionally matches `descriptor`. + * + * expect('test').to.have.ownPropertyDescriptor('length'); + * expect('test').to.have.ownPropertyDescriptor('length', { enumerable: false, configurable: false, writable: false, value: 4 }); + * expect('test').not.to.have.ownPropertyDescriptor('length', { enumerable: false, configurable: false, writable: false, value: 3 }); + * expect('test').ownPropertyDescriptor('length').to.have.property('enumerable', false); + * expect('test').ownPropertyDescriptor('length').to.have.keys('value'); + * + * @name ownPropertyDescriptor + * @alias haveOwnPropertyDescriptor + * @param {String} name + * @param {Object} descriptor _optional_ + * @param {String} message _optional_ + * @namespace BDD + * @api public + */ + + function assertOwnPropertyDescriptor (name, descriptor, msg) { + if (typeof descriptor === 'string') { + msg = descriptor; + descriptor = null; + } + if (msg) flag(this, 'message', msg); + var obj = flag(this, 'object'); + var actualDescriptor = Object.getOwnPropertyDescriptor(Object(obj), name); + if (actualDescriptor && descriptor) { + this.assert( + _.eql(descriptor, actualDescriptor) + , 'expected the own property descriptor for ' + _.inspect(name) + ' on #{this} to match ' + _.inspect(descriptor) + ', got ' + _.inspect(actualDescriptor) + , 'expected the own property descriptor for ' + _.inspect(name) + ' on #{this} to not match ' + _.inspect(descriptor) + , descriptor + , actualDescriptor + , true + ); + } else { + this.assert( + actualDescriptor + , 'expected #{this} to have an own property descriptor for ' + _.inspect(name) + , 'expected #{this} to not have an own property descriptor for ' + _.inspect(name) + ); + } + flag(this, 'object', actualDescriptor); + } + + Assertion.addMethod('ownPropertyDescriptor', assertOwnPropertyDescriptor); + Assertion.addMethod('haveOwnPropertyDescriptor', assertOwnPropertyDescriptor); + + /** + * ### .length + * + * Sets the `doLength` flag later used as a chain precursor to a value + * comparison for the `length` property. + * + * expect('foo').to.have.length.above(2); + * expect([ 1, 2, 3 ]).to.have.length.above(2); + * expect('foo').to.have.length.below(4); + * expect([ 1, 2, 3 ]).to.have.length.below(4); + * expect('foo').to.have.length.within(2,4); + * expect([ 1, 2, 3 ]).to.have.length.within(2,4); + * + * *Deprecation notice:* Using `length` as an assertion will be deprecated + * in version 2.4.0 and removed in 3.0.0. Code using the old style of + * asserting for `length` property value using `length(value)` should be + * switched to use `lengthOf(value)` instead. + * + * @name length + * @namespace BDD + * @api public + */ + + /** + * ### .lengthOf(value[, message]) + * + * Asserts that the target's `length` property has + * the expected value. + * + * expect([ 1, 2, 3]).to.have.lengthOf(3); + * expect('foobar').to.have.lengthOf(6); + * + * @name lengthOf + * @param {Number} length + * @param {String} message _optional_ + * @namespace BDD + * @api public + */ + + function assertLengthChain () { + flag(this, 'doLength', true); + } + + function assertLength (n, msg) { + if (msg) flag(this, 'message', msg); + var obj = flag(this, 'object'); + new Assertion(obj, msg).to.have.property('length'); + var len = obj.length; + + this.assert( + len == n + , 'expected #{this} to have a length of #{exp} but got #{act}' + , 'expected #{this} to not have a length of #{act}' + , n + , len + ); + } + + Assertion.addChainableMethod('length', assertLength, assertLengthChain); + Assertion.addMethod('lengthOf', assertLength); + + /** + * ### .match(regexp) + * + * Asserts that the target matches a regular expression. + * + * expect('foobar').to.match(/^foo/); + * + * @name match + * @alias matches + * @param {RegExp} RegularExpression + * @param {String} message _optional_ + * @namespace BDD + * @api public + */ + function assertMatch(re, msg) { + if (msg) flag(this, 'message', msg); + var obj = flag(this, 'object'); + this.assert( + re.exec(obj) + , 'expected #{this} to match ' + re + , 'expected #{this} not to match ' + re + ); + } + + Assertion.addMethod('match', assertMatch); + Assertion.addMethod('matches', assertMatch); + + /** + * ### .string(string) + * + * Asserts that the string target contains another string. + * + * expect('foobar').to.have.string('bar'); + * + * @name string + * @param {String} string + * @param {String} message _optional_ + * @namespace BDD + * @api public + */ + + Assertion.addMethod('string', function (str, msg) { + if (msg) flag(this, 'message', msg); + var obj = flag(this, 'object'); + new Assertion(obj, msg).is.a('string'); + + this.assert( + ~obj.indexOf(str) + , 'expected #{this} to contain ' + _.inspect(str) + , 'expected #{this} to not contain ' + _.inspect(str) + ); + }); + + + /** + * ### .keys(key1, [key2], [...]) + * + * Asserts that the target contains any or all of the passed-in keys. + * Use in combination with `any`, `all`, `contains`, or `have` will affect + * what will pass. + * + * When used in conjunction with `any`, at least one key that is passed + * in must exist in the target object. This is regardless whether or not + * the `have` or `contain` qualifiers are used. Note, either `any` or `all` + * should be used in the assertion. If neither are used, the assertion is + * defaulted to `all`. + * + * When both `all` and `contain` are used, the target object must have at + * least all of the passed-in keys but may have more keys not listed. + * + * When both `all` and `have` are used, the target object must both contain + * all of the passed-in keys AND the number of keys in the target object must + * match the number of keys passed in (in other words, a target object must + * have all and only all of the passed-in keys). + * + * expect({ foo: 1, bar: 2 }).to.have.any.keys('foo', 'baz'); + * expect({ foo: 1, bar: 2 }).to.have.any.keys('foo'); + * expect({ foo: 1, bar: 2 }).to.contain.any.keys('bar', 'baz'); + * expect({ foo: 1, bar: 2 }).to.contain.any.keys(['foo']); + * expect({ foo: 1, bar: 2 }).to.contain.any.keys({'foo': 6}); + * expect({ foo: 1, bar: 2 }).to.have.all.keys(['bar', 'foo']); + * expect({ foo: 1, bar: 2 }).to.have.all.keys({'bar': 6, 'foo': 7}); + * expect({ foo: 1, bar: 2, baz: 3 }).to.contain.all.keys(['bar', 'foo']); + * expect({ foo: 1, bar: 2, baz: 3 }).to.contain.all.keys({'bar': 6}); + * + * + * @name keys + * @alias key + * @param {...String|Array|Object} keys + * @namespace BDD + * @api public + */ + + function assertKeys (keys) { + var obj = flag(this, 'object') + , str + , ok = true + , mixedArgsMsg = 'keys must be given single argument of Array|Object|String, or multiple String arguments'; + + switch (_.type(keys)) { + case "array": + if (arguments.length > 1) throw (new Error(mixedArgsMsg)); + break; + case "object": + if (arguments.length > 1) throw (new Error(mixedArgsMsg)); + keys = Object.keys(keys); + break; + default: + keys = Array.prototype.slice.call(arguments); + } + + if (!keys.length) throw new Error('keys required'); + + var actual = Object.keys(obj) + , expected = keys + , len = keys.length + , any = flag(this, 'any') + , all = flag(this, 'all'); + + if (!any && !all) { + all = true; + } + + // Has any + if (any) { + var intersection = expected.filter(function(key) { + return ~actual.indexOf(key); + }); + ok = intersection.length > 0; + } + + // Has all + if (all) { + ok = keys.every(function(key){ + return ~actual.indexOf(key); + }); + if (!flag(this, 'negate') && !flag(this, 'contains')) { + ok = ok && keys.length == actual.length; + } + } + + // Key string + if (len > 1) { + keys = keys.map(function(key){ + return _.inspect(key); + }); + var last = keys.pop(); + if (all) { + str = keys.join(', ') + ', and ' + last; + } + if (any) { + str = keys.join(', ') + ', or ' + last; + } + } else { + str = _.inspect(keys[0]); + } + + // Form + str = (len > 1 ? 'keys ' : 'key ') + str; + + // Have / include + str = (flag(this, 'contains') ? 'contain ' : 'have ') + str; + + // Assertion + this.assert( + ok + , 'expected #{this} to ' + str + , 'expected #{this} to not ' + str + , expected.slice(0).sort() + , actual.sort() + , true + ); + } + + Assertion.addMethod('keys', assertKeys); + Assertion.addMethod('key', assertKeys); + + /** + * ### .throw(constructor) + * + * Asserts that the function target will throw a specific error, or specific type of error + * (as determined using `instanceof`), optionally with a RegExp or string inclusion test + * for the error's message. + * + * var err = new ReferenceError('This is a bad function.'); + * var fn = function () { throw err; } + * expect(fn).to.throw(ReferenceError); + * expect(fn).to.throw(Error); + * expect(fn).to.throw(/bad function/); + * expect(fn).to.not.throw('good function'); + * expect(fn).to.throw(ReferenceError, /bad function/); + * expect(fn).to.throw(err); + * + * Please note that when a throw expectation is negated, it will check each + * parameter independently, starting with error constructor type. The appropriate way + * to check for the existence of a type of error but for a message that does not match + * is to use `and`. + * + * expect(fn).to.throw(ReferenceError) + * .and.not.throw(/good function/); + * + * @name throw + * @alias throws + * @alias Throw + * @param {ErrorConstructor} constructor + * @param {String|RegExp} expected error message + * @param {String} message _optional_ + * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types + * @returns error for chaining (null if no error) + * @namespace BDD + * @api public + */ + + function assertThrows (constructor, errMsg, msg) { + if (msg) flag(this, 'message', msg); + var obj = flag(this, 'object'); + new Assertion(obj, msg).is.a('function'); + + var thrown = false + , desiredError = null + , name = null + , thrownError = null; + + if (arguments.length === 0) { + errMsg = null; + constructor = null; + } else if (constructor && (constructor instanceof RegExp || 'string' === typeof constructor)) { + errMsg = constructor; + constructor = null; + } else if (constructor && constructor instanceof Error) { + desiredError = constructor; + constructor = null; + errMsg = null; + } else if (typeof constructor === 'function') { + name = constructor.prototype.name; + if (!name || (name === 'Error' && constructor !== Error)) { + name = constructor.name || (new constructor()).name; + } + } else { + constructor = null; + } + + try { + obj(); + } catch (err) { + // first, check desired error + if (desiredError) { + this.assert( + err === desiredError + , 'expected #{this} to throw #{exp} but #{act} was thrown' + , 'expected #{this} to not throw #{exp}' + , (desiredError instanceof Error ? desiredError.toString() : desiredError) + , (err instanceof Error ? err.toString() : err) + ); + + flag(this, 'object', err); + return this; + } + + // next, check constructor + if (constructor) { + this.assert( + err instanceof constructor + , 'expected #{this} to throw #{exp} but #{act} was thrown' + , 'expected #{this} to not throw #{exp} but #{act} was thrown' + , name + , (err instanceof Error ? err.toString() : err) + ); + + if (!errMsg) { + flag(this, 'object', err); + return this; + } + } + + // next, check message + var message = 'error' === _.type(err) && "message" in err + ? err.message + : '' + err; + + if ((message != null) && errMsg && errMsg instanceof RegExp) { + this.assert( + errMsg.exec(message) + , 'expected #{this} to throw error matching #{exp} but got #{act}' + , 'expected #{this} to throw error not matching #{exp}' + , errMsg + , message + ); + + flag(this, 'object', err); + return this; + } else if ((message != null) && errMsg && 'string' === typeof errMsg) { + this.assert( + ~message.indexOf(errMsg) + , 'expected #{this} to throw error including #{exp} but got #{act}' + , 'expected #{this} to throw error not including #{act}' + , errMsg + , message + ); + + flag(this, 'object', err); + return this; + } else { + thrown = true; + thrownError = err; + } + } + + var actuallyGot = '' + , expectedThrown = name !== null + ? name + : desiredError + ? '#{exp}' //_.inspect(desiredError) + : 'an error'; + + if (thrown) { + actuallyGot = ' but #{act} was thrown' + } + + this.assert( + thrown === true + , 'expected #{this} to throw ' + expectedThrown + actuallyGot + , 'expected #{this} to not throw ' + expectedThrown + actuallyGot + , (desiredError instanceof Error ? desiredError.toString() : desiredError) + , (thrownError instanceof Error ? thrownError.toString() : thrownError) + ); + + flag(this, 'object', thrownError); + }; + + Assertion.addMethod('throw', assertThrows); + Assertion.addMethod('throws', assertThrows); + Assertion.addMethod('Throw', assertThrows); + + /** + * ### .respondTo(method) + * + * Asserts that the object or class target will respond to a method. + * + * Klass.prototype.bar = function(){}; + * expect(Klass).to.respondTo('bar'); + * expect(obj).to.respondTo('bar'); + * + * To check if a constructor will respond to a static function, + * set the `itself` flag. + * + * Klass.baz = function(){}; + * expect(Klass).itself.to.respondTo('baz'); + * + * @name respondTo + * @alias respondsTo + * @param {String} method + * @param {String} message _optional_ + * @namespace BDD + * @api public + */ + + function respondTo (method, msg) { + if (msg) flag(this, 'message', msg); + var obj = flag(this, 'object') + , itself = flag(this, 'itself') + , context = ('function' === _.type(obj) && !itself) + ? obj.prototype[method] + : obj[method]; + + this.assert( + 'function' === typeof context + , 'expected #{this} to respond to ' + _.inspect(method) + , 'expected #{this} to not respond to ' + _.inspect(method) + ); + } + + Assertion.addMethod('respondTo', respondTo); + Assertion.addMethod('respondsTo', respondTo); + + /** + * ### .itself + * + * Sets the `itself` flag, later used by the `respondTo` assertion. + * + * function Foo() {} + * Foo.bar = function() {} + * Foo.prototype.baz = function() {} + * + * expect(Foo).itself.to.respondTo('bar'); + * expect(Foo).itself.not.to.respondTo('baz'); + * + * @name itself + * @namespace BDD + * @api public + */ + + Assertion.addProperty('itself', function () { + flag(this, 'itself', true); + }); + + /** + * ### .satisfy(method) + * + * Asserts that the target passes a given truth test. + * + * expect(1).to.satisfy(function(num) { return num > 0; }); + * + * @name satisfy + * @alias satisfies + * @param {Function} matcher + * @param {String} message _optional_ + * @namespace BDD + * @api public + */ + + function satisfy (matcher, msg) { + if (msg) flag(this, 'message', msg); + var obj = flag(this, 'object'); + var result = matcher(obj); + this.assert( + result + , 'expected #{this} to satisfy ' + _.objDisplay(matcher) + , 'expected #{this} to not satisfy' + _.objDisplay(matcher) + , this.negate ? false : true + , result + ); + } + + Assertion.addMethod('satisfy', satisfy); + Assertion.addMethod('satisfies', satisfy); + + /** + * ### .closeTo(expected, delta) + * + * Asserts that the target is equal `expected`, to within a +/- `delta` range. + * + * expect(1.5).to.be.closeTo(1, 0.5); + * + * @name closeTo + * @alias approximately + * @param {Number} expected + * @param {Number} delta + * @param {String} message _optional_ + * @namespace BDD + * @api public + */ + + function closeTo(expected, delta, msg) { + if (msg) flag(this, 'message', msg); + var obj = flag(this, 'object'); + + new Assertion(obj, msg).is.a('number'); + if (_.type(expected) !== 'number' || _.type(delta) !== 'number') { + throw new Error('the arguments to closeTo or approximately must be numbers'); + } + + this.assert( + Math.abs(obj - expected) <= delta + , 'expected #{this} to be close to ' + expected + ' +/- ' + delta + , 'expected #{this} not to be close to ' + expected + ' +/- ' + delta + ); + } + + Assertion.addMethod('closeTo', closeTo); + Assertion.addMethod('approximately', closeTo); + + function isSubsetOf(subset, superset, cmp) { + return subset.every(function(elem) { + if (!cmp) return superset.indexOf(elem) !== -1; + + return superset.some(function(elem2) { + return cmp(elem, elem2); + }); + }) + } + + /** + * ### .members(set) + * + * Asserts that the target is a superset of `set`, + * or that the target and `set` have the same strictly-equal (===) members. + * Alternately, if the `deep` flag is set, set members are compared for deep + * equality. + * + * expect([1, 2, 3]).to.include.members([3, 2]); + * expect([1, 2, 3]).to.not.include.members([3, 2, 8]); + * + * expect([4, 2]).to.have.members([2, 4]); + * expect([5, 2]).to.not.have.members([5, 2, 1]); + * + * expect([{ id: 1 }]).to.deep.include.members([{ id: 1 }]); + * + * @name members + * @param {Array} set + * @param {String} message _optional_ + * @namespace BDD + * @api public + */ + + Assertion.addMethod('members', function (subset, msg) { + if (msg) flag(this, 'message', msg); + var obj = flag(this, 'object'); + + new Assertion(obj).to.be.an('array'); + new Assertion(subset).to.be.an('array'); + + var cmp = flag(this, 'deep') ? _.eql : undefined; + + if (flag(this, 'contains')) { + return this.assert( + isSubsetOf(subset, obj, cmp) + , 'expected #{this} to be a superset of #{act}' + , 'expected #{this} to not be a superset of #{act}' + , obj + , subset + ); + } + + this.assert( + isSubsetOf(obj, subset, cmp) && isSubsetOf(subset, obj, cmp) + , 'expected #{this} to have the same members as #{act}' + , 'expected #{this} to not have the same members as #{act}' + , obj + , subset + ); + }); + + /** + * ### .oneOf(list) + * + * Assert that a value appears somewhere in the top level of array `list`. + * + * expect('a').to.be.oneOf(['a', 'b', 'c']); + * expect(9).to.not.be.oneOf(['z']); + * expect([3]).to.not.be.oneOf([1, 2, [3]]); + * + * var three = [3]; + * // for object-types, contents are not compared + * expect(three).to.not.be.oneOf([1, 2, [3]]); + * // comparing references works + * expect(three).to.be.oneOf([1, 2, three]); + * + * @name oneOf + * @param {Array<*>} list + * @param {String} message _optional_ + * @namespace BDD + * @api public + */ + + function oneOf (list, msg) { + if (msg) flag(this, 'message', msg); + var expected = flag(this, 'object'); + new Assertion(list).to.be.an('array'); + + this.assert( + list.indexOf(expected) > -1 + , 'expected #{this} to be one of #{exp}' + , 'expected #{this} to not be one of #{exp}' + , list + , expected + ); + } + + Assertion.addMethod('oneOf', oneOf); + + + /** + * ### .change(function) + * + * Asserts that a function changes an object property + * + * var obj = { val: 10 }; + * var fn = function() { obj.val += 3 }; + * var noChangeFn = function() { return 'foo' + 'bar'; } + * expect(fn).to.change(obj, 'val'); + * expect(noChangeFn).to.not.change(obj, 'val') + * + * @name change + * @alias changes + * @alias Change + * @param {String} object + * @param {String} property name + * @param {String} message _optional_ + * @namespace BDD + * @api public + */ + + function assertChanges (object, prop, msg) { + if (msg) flag(this, 'message', msg); + var fn = flag(this, 'object'); + new Assertion(object, msg).to.have.property(prop); + new Assertion(fn).is.a('function'); + + var initial = object[prop]; + fn(); + + this.assert( + initial !== object[prop] + , 'expected .' + prop + ' to change' + , 'expected .' + prop + ' to not change' + ); + } + + Assertion.addChainableMethod('change', assertChanges); + Assertion.addChainableMethod('changes', assertChanges); + + /** + * ### .increase(function) + * + * Asserts that a function increases an object property + * + * var obj = { val: 10 }; + * var fn = function() { obj.val = 15 }; + * expect(fn).to.increase(obj, 'val'); + * + * @name increase + * @alias increases + * @alias Increase + * @param {String} object + * @param {String} property name + * @param {String} message _optional_ + * @namespace BDD + * @api public + */ + + function assertIncreases (object, prop, msg) { + if (msg) flag(this, 'message', msg); + var fn = flag(this, 'object'); + new Assertion(object, msg).to.have.property(prop); + new Assertion(fn).is.a('function'); + + var initial = object[prop]; + fn(); + + this.assert( + object[prop] - initial > 0 + , 'expected .' + prop + ' to increase' + , 'expected .' + prop + ' to not increase' + ); + } + + Assertion.addChainableMethod('increase', assertIncreases); + Assertion.addChainableMethod('increases', assertIncreases); + + /** + * ### .decrease(function) + * + * Asserts that a function decreases an object property + * + * var obj = { val: 10 }; + * var fn = function() { obj.val = 5 }; + * expect(fn).to.decrease(obj, 'val'); + * + * @name decrease + * @alias decreases + * @alias Decrease + * @param {String} object + * @param {String} property name + * @param {String} message _optional_ + * @namespace BDD + * @api public + */ + + function assertDecreases (object, prop, msg) { + if (msg) flag(this, 'message', msg); + var fn = flag(this, 'object'); + new Assertion(object, msg).to.have.property(prop); + new Assertion(fn).is.a('function'); + + var initial = object[prop]; + fn(); + + this.assert( + object[prop] - initial < 0 + , 'expected .' + prop + ' to decrease' + , 'expected .' + prop + ' to not decrease' + ); + } + + Assertion.addChainableMethod('decrease', assertDecreases); + Assertion.addChainableMethod('decreases', assertDecreases); + + /** + * ### .extensible + * + * Asserts that the target is extensible (can have new properties added to + * it). + * + * var nonExtensibleObject = Object.preventExtensions({}); + * var sealedObject = Object.seal({}); + * var frozenObject = Object.freeze({}); + * + * expect({}).to.be.extensible; + * expect(nonExtensibleObject).to.not.be.extensible; + * expect(sealedObject).to.not.be.extensible; + * expect(frozenObject).to.not.be.extensible; + * + * @name extensible + * @namespace BDD + * @api public + */ + + Assertion.addProperty('extensible', function() { + var obj = flag(this, 'object'); + + // In ES5, if the argument to this method is not an object (a primitive), then it will cause a TypeError. + // In ES6, a non-object argument will be treated as if it was a non-extensible ordinary object, simply return false. + // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isExtensible + // The following provides ES6 behavior when a TypeError is thrown under ES5. + + var isExtensible; + + try { + isExtensible = Object.isExtensible(obj); + } catch (err) { + if (err instanceof TypeError) isExtensible = false; + else throw err; + } + + this.assert( + isExtensible + , 'expected #{this} to be extensible' + , 'expected #{this} to not be extensible' + ); + }); + + /** + * ### .sealed + * + * Asserts that the target is sealed (cannot have new properties added to it + * and its existing properties cannot be removed). + * + * var sealedObject = Object.seal({}); + * var frozenObject = Object.freeze({}); + * + * expect(sealedObject).to.be.sealed; + * expect(frozenObject).to.be.sealed; + * expect({}).to.not.be.sealed; + * + * @name sealed + * @namespace BDD + * @api public + */ + + Assertion.addProperty('sealed', function() { + var obj = flag(this, 'object'); + + // In ES5, if the argument to this method is not an object (a primitive), then it will cause a TypeError. + // In ES6, a non-object argument will be treated as if it was a sealed ordinary object, simply return true. + // See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isSealed + // The following provides ES6 behavior when a TypeError is thrown under ES5. + + var isSealed; + + try { + isSealed = Object.isSealed(obj); + } catch (err) { + if (err instanceof TypeError) isSealed = true; + else throw err; + } + + this.assert( + isSealed + , 'expected #{this} to be sealed' + , 'expected #{this} to not be sealed' + ); + }); + + /** + * ### .frozen + * + * Asserts that the target is frozen (cannot have new properties added to it + * and its existing properties cannot be modified). + * + * var frozenObject = Object.freeze({}); + * + * expect(frozenObject).to.be.frozen; + * expect({}).to.not.be.frozen; + * + * @name frozen + * @namespace BDD + * @api public + */ + + Assertion.addProperty('frozen', function() { + var obj = flag(this, 'object'); + + // In ES5, if the argument to this method is not an object (a primitive), then it will cause a TypeError. + // In ES6, a non-object argument will be treated as if it was a frozen ordinary object, simply return true. + // See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isFrozen + // The following provides ES6 behavior when a TypeError is thrown under ES5. + + var isFrozen; + + try { + isFrozen = Object.isFrozen(obj); + } catch (err) { + if (err instanceof TypeError) isFrozen = true; + else throw err; + } + + this.assert( + isFrozen + , 'expected #{this} to be frozen' + , 'expected #{this} to not be frozen' + ); + }); +}; + +},{}],9:[function(require,module,exports){ +/*! + * chai + * Copyright(c) 2011-2014 Jake Luer + * MIT Licensed + */ + + +module.exports = function (chai, util) { + + /*! + * Chai dependencies. + */ + + var Assertion = chai.Assertion + , flag = util.flag; + + /*! + * Module export. + */ + + /** + * ### assert(expression, message) + * + * Write your own test expressions. + * + * assert('foo' !== 'bar', 'foo is not bar'); + * assert(Array.isArray([]), 'empty arrays are arrays'); + * + * @param {Mixed} expression to test for truthiness + * @param {String} message to display on error + * @name assert + * @namespace Assert + * @api public + */ + + var assert = chai.assert = function (express, errmsg) { + var test = new Assertion(null, null, chai.assert); + test.assert( + express + , errmsg + , '[ negation message unavailable ]' + ); + }; + + /** + * ### .fail(actual, expected, [message], [operator]) + * + * Throw a failure. Node.js `assert` module-compatible. + * + * @name fail + * @param {Mixed} actual + * @param {Mixed} expected + * @param {String} message + * @param {String} operator + * @namespace Assert + * @api public + */ + + assert.fail = function (actual, expected, message, operator) { + message = message || 'assert.fail()'; + throw new chai.AssertionError(message, { + actual: actual + , expected: expected + , operator: operator + }, assert.fail); + }; + + /** + * ### .isOk(object, [message]) + * + * Asserts that `object` is truthy. + * + * assert.isOk('everything', 'everything is ok'); + * assert.isOk(false, 'this will fail'); + * + * @name isOk + * @alias ok + * @param {Mixed} object to test + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.isOk = function (val, msg) { + new Assertion(val, msg).is.ok; + }; + + /** + * ### .isNotOk(object, [message]) + * + * Asserts that `object` is falsy. + * + * assert.isNotOk('everything', 'this will fail'); + * assert.isNotOk(false, 'this will pass'); + * + * @name isNotOk + * @alias notOk + * @param {Mixed} object to test + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.isNotOk = function (val, msg) { + new Assertion(val, msg).is.not.ok; + }; + + /** + * ### .equal(actual, expected, [message]) + * + * Asserts non-strict equality (`==`) of `actual` and `expected`. + * + * assert.equal(3, '3', '== coerces values to strings'); + * + * @name equal + * @param {Mixed} actual + * @param {Mixed} expected + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.equal = function (act, exp, msg) { + var test = new Assertion(act, msg, assert.equal); + + test.assert( + exp == flag(test, 'object') + , 'expected #{this} to equal #{exp}' + , 'expected #{this} to not equal #{act}' + , exp + , act + ); + }; + + /** + * ### .notEqual(actual, expected, [message]) + * + * Asserts non-strict inequality (`!=`) of `actual` and `expected`. + * + * assert.notEqual(3, 4, 'these numbers are not equal'); + * + * @name notEqual + * @param {Mixed} actual + * @param {Mixed} expected + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.notEqual = function (act, exp, msg) { + var test = new Assertion(act, msg, assert.notEqual); + + test.assert( + exp != flag(test, 'object') + , 'expected #{this} to not equal #{exp}' + , 'expected #{this} to equal #{act}' + , exp + , act + ); + }; + + /** + * ### .strictEqual(actual, expected, [message]) + * + * Asserts strict equality (`===`) of `actual` and `expected`. + * + * assert.strictEqual(true, true, 'these booleans are strictly equal'); + * + * @name strictEqual + * @param {Mixed} actual + * @param {Mixed} expected + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.strictEqual = function (act, exp, msg) { + new Assertion(act, msg).to.equal(exp); + }; + + /** + * ### .notStrictEqual(actual, expected, [message]) + * + * Asserts strict inequality (`!==`) of `actual` and `expected`. + * + * assert.notStrictEqual(3, '3', 'no coercion for strict equality'); + * + * @name notStrictEqual + * @param {Mixed} actual + * @param {Mixed} expected + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.notStrictEqual = function (act, exp, msg) { + new Assertion(act, msg).to.not.equal(exp); + }; + + /** + * ### .deepEqual(actual, expected, [message]) + * + * Asserts that `actual` is deeply equal to `expected`. + * + * assert.deepEqual({ tea: 'green' }, { tea: 'green' }); + * + * @name deepEqual + * @param {Mixed} actual + * @param {Mixed} expected + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.deepEqual = function (act, exp, msg) { + new Assertion(act, msg).to.eql(exp); + }; + + /** + * ### .notDeepEqual(actual, expected, [message]) + * + * Assert that `actual` is not deeply equal to `expected`. + * + * assert.notDeepEqual({ tea: 'green' }, { tea: 'jasmine' }); + * + * @name notDeepEqual + * @param {Mixed} actual + * @param {Mixed} expected + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.notDeepEqual = function (act, exp, msg) { + new Assertion(act, msg).to.not.eql(exp); + }; + + /** + * ### .isAbove(valueToCheck, valueToBeAbove, [message]) + * + * Asserts `valueToCheck` is strictly greater than (>) `valueToBeAbove` + * + * assert.isAbove(5, 2, '5 is strictly greater than 2'); + * + * @name isAbove + * @param {Mixed} valueToCheck + * @param {Mixed} valueToBeAbove + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.isAbove = function (val, abv, msg) { + new Assertion(val, msg).to.be.above(abv); + }; + + /** + * ### .isAtLeast(valueToCheck, valueToBeAtLeast, [message]) + * + * Asserts `valueToCheck` is greater than or equal to (>=) `valueToBeAtLeast` + * + * assert.isAtLeast(5, 2, '5 is greater or equal to 2'); + * assert.isAtLeast(3, 3, '3 is greater or equal to 3'); + * + * @name isAtLeast + * @param {Mixed} valueToCheck + * @param {Mixed} valueToBeAtLeast + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.isAtLeast = function (val, atlst, msg) { + new Assertion(val, msg).to.be.least(atlst); + }; + + /** + * ### .isBelow(valueToCheck, valueToBeBelow, [message]) + * + * Asserts `valueToCheck` is strictly less than (<) `valueToBeBelow` + * + * assert.isBelow(3, 6, '3 is strictly less than 6'); + * + * @name isBelow + * @param {Mixed} valueToCheck + * @param {Mixed} valueToBeBelow + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.isBelow = function (val, blw, msg) { + new Assertion(val, msg).to.be.below(blw); + }; + + /** + * ### .isAtMost(valueToCheck, valueToBeAtMost, [message]) + * + * Asserts `valueToCheck` is less than or equal to (<=) `valueToBeAtMost` + * + * assert.isAtMost(3, 6, '3 is less than or equal to 6'); + * assert.isAtMost(4, 4, '4 is less than or equal to 4'); + * + * @name isAtMost + * @param {Mixed} valueToCheck + * @param {Mixed} valueToBeAtMost + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.isAtMost = function (val, atmst, msg) { + new Assertion(val, msg).to.be.most(atmst); + }; + + /** + * ### .isTrue(value, [message]) + * + * Asserts that `value` is true. + * + * var teaServed = true; + * assert.isTrue(teaServed, 'the tea has been served'); + * + * @name isTrue + * @param {Mixed} value + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.isTrue = function (val, msg) { + new Assertion(val, msg).is['true']; + }; + + /** + * ### .isNotTrue(value, [message]) + * + * Asserts that `value` is not true. + * + * var tea = 'tasty chai'; + * assert.isNotTrue(tea, 'great, time for tea!'); + * + * @name isNotTrue + * @param {Mixed} value + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.isNotTrue = function (val, msg) { + new Assertion(val, msg).to.not.equal(true); + }; + + /** + * ### .isFalse(value, [message]) + * + * Asserts that `value` is false. + * + * var teaServed = false; + * assert.isFalse(teaServed, 'no tea yet? hmm...'); + * + * @name isFalse + * @param {Mixed} value + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.isFalse = function (val, msg) { + new Assertion(val, msg).is['false']; + }; + + /** + * ### .isNotFalse(value, [message]) + * + * Asserts that `value` is not false. + * + * var tea = 'tasty chai'; + * assert.isNotFalse(tea, 'great, time for tea!'); + * + * @name isNotFalse + * @param {Mixed} value + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.isNotFalse = function (val, msg) { + new Assertion(val, msg).to.not.equal(false); + }; + + /** + * ### .isNull(value, [message]) + * + * Asserts that `value` is null. + * + * assert.isNull(err, 'there was no error'); + * + * @name isNull + * @param {Mixed} value + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.isNull = function (val, msg) { + new Assertion(val, msg).to.equal(null); + }; + + /** + * ### .isNotNull(value, [message]) + * + * Asserts that `value` is not null. + * + * var tea = 'tasty chai'; + * assert.isNotNull(tea, 'great, time for tea!'); + * + * @name isNotNull + * @param {Mixed} value + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.isNotNull = function (val, msg) { + new Assertion(val, msg).to.not.equal(null); + }; + + /** + * ### .isNaN + * Asserts that value is NaN + * + * assert.isNaN('foo', 'foo is NaN'); + * + * @name isNaN + * @param {Mixed} value + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.isNaN = function (val, msg) { + new Assertion(val, msg).to.be.NaN; + }; + + /** + * ### .isNotNaN + * Asserts that value is not NaN + * + * assert.isNotNaN(4, '4 is not NaN'); + * + * @name isNotNaN + * @param {Mixed} value + * @param {String} message + * @namespace Assert + * @api public + */ + assert.isNotNaN = function (val, msg) { + new Assertion(val, msg).not.to.be.NaN; + }; + + /** + * ### .isUndefined(value, [message]) + * + * Asserts that `value` is `undefined`. + * + * var tea; + * assert.isUndefined(tea, 'no tea defined'); + * + * @name isUndefined + * @param {Mixed} value + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.isUndefined = function (val, msg) { + new Assertion(val, msg).to.equal(undefined); + }; + + /** + * ### .isDefined(value, [message]) + * + * Asserts that `value` is not `undefined`. + * + * var tea = 'cup of chai'; + * assert.isDefined(tea, 'tea has been defined'); + * + * @name isDefined + * @param {Mixed} value + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.isDefined = function (val, msg) { + new Assertion(val, msg).to.not.equal(undefined); + }; + + /** + * ### .isFunction(value, [message]) + * + * Asserts that `value` is a function. + * + * function serveTea() { return 'cup of tea'; }; + * assert.isFunction(serveTea, 'great, we can have tea now'); + * + * @name isFunction + * @param {Mixed} value + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.isFunction = function (val, msg) { + new Assertion(val, msg).to.be.a('function'); + }; + + /** + * ### .isNotFunction(value, [message]) + * + * Asserts that `value` is _not_ a function. + * + * var serveTea = [ 'heat', 'pour', 'sip' ]; + * assert.isNotFunction(serveTea, 'great, we have listed the steps'); + * + * @name isNotFunction + * @param {Mixed} value + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.isNotFunction = function (val, msg) { + new Assertion(val, msg).to.not.be.a('function'); + }; + + /** + * ### .isObject(value, [message]) + * + * Asserts that `value` is an object of type 'Object' (as revealed by `Object.prototype.toString`). + * _The assertion does not match subclassed objects._ + * + * var selection = { name: 'Chai', serve: 'with spices' }; + * assert.isObject(selection, 'tea selection is an object'); + * + * @name isObject + * @param {Mixed} value + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.isObject = function (val, msg) { + new Assertion(val, msg).to.be.a('object'); + }; + + /** + * ### .isNotObject(value, [message]) + * + * Asserts that `value` is _not_ an object of type 'Object' (as revealed by `Object.prototype.toString`). + * + * var selection = 'chai' + * assert.isNotObject(selection, 'tea selection is not an object'); + * assert.isNotObject(null, 'null is not an object'); + * + * @name isNotObject + * @param {Mixed} value + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.isNotObject = function (val, msg) { + new Assertion(val, msg).to.not.be.a('object'); + }; + + /** + * ### .isArray(value, [message]) + * + * Asserts that `value` is an array. + * + * var menu = [ 'green', 'chai', 'oolong' ]; + * assert.isArray(menu, 'what kind of tea do we want?'); + * + * @name isArray + * @param {Mixed} value + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.isArray = function (val, msg) { + new Assertion(val, msg).to.be.an('array'); + }; + + /** + * ### .isNotArray(value, [message]) + * + * Asserts that `value` is _not_ an array. + * + * var menu = 'green|chai|oolong'; + * assert.isNotArray(menu, 'what kind of tea do we want?'); + * + * @name isNotArray + * @param {Mixed} value + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.isNotArray = function (val, msg) { + new Assertion(val, msg).to.not.be.an('array'); + }; + + /** + * ### .isString(value, [message]) + * + * Asserts that `value` is a string. + * + * var teaOrder = 'chai'; + * assert.isString(teaOrder, 'order placed'); + * + * @name isString + * @param {Mixed} value + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.isString = function (val, msg) { + new Assertion(val, msg).to.be.a('string'); + }; + + /** + * ### .isNotString(value, [message]) + * + * Asserts that `value` is _not_ a string. + * + * var teaOrder = 4; + * assert.isNotString(teaOrder, 'order placed'); + * + * @name isNotString + * @param {Mixed} value + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.isNotString = function (val, msg) { + new Assertion(val, msg).to.not.be.a('string'); + }; + + /** + * ### .isNumber(value, [message]) + * + * Asserts that `value` is a number. + * + * var cups = 2; + * assert.isNumber(cups, 'how many cups'); + * + * @name isNumber + * @param {Number} value + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.isNumber = function (val, msg) { + new Assertion(val, msg).to.be.a('number'); + }; + + /** + * ### .isNotNumber(value, [message]) + * + * Asserts that `value` is _not_ a number. + * + * var cups = '2 cups please'; + * assert.isNotNumber(cups, 'how many cups'); + * + * @name isNotNumber + * @param {Mixed} value + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.isNotNumber = function (val, msg) { + new Assertion(val, msg).to.not.be.a('number'); + }; + + /** + * ### .isBoolean(value, [message]) + * + * Asserts that `value` is a boolean. + * + * var teaReady = true + * , teaServed = false; + * + * assert.isBoolean(teaReady, 'is the tea ready'); + * assert.isBoolean(teaServed, 'has tea been served'); + * + * @name isBoolean + * @param {Mixed} value + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.isBoolean = function (val, msg) { + new Assertion(val, msg).to.be.a('boolean'); + }; + + /** + * ### .isNotBoolean(value, [message]) + * + * Asserts that `value` is _not_ a boolean. + * + * var teaReady = 'yep' + * , teaServed = 'nope'; + * + * assert.isNotBoolean(teaReady, 'is the tea ready'); + * assert.isNotBoolean(teaServed, 'has tea been served'); + * + * @name isNotBoolean + * @param {Mixed} value + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.isNotBoolean = function (val, msg) { + new Assertion(val, msg).to.not.be.a('boolean'); + }; + + /** + * ### .typeOf(value, name, [message]) + * + * Asserts that `value`'s type is `name`, as determined by + * `Object.prototype.toString`. + * + * assert.typeOf({ tea: 'chai' }, 'object', 'we have an object'); + * assert.typeOf(['chai', 'jasmine'], 'array', 'we have an array'); + * assert.typeOf('tea', 'string', 'we have a string'); + * assert.typeOf(/tea/, 'regexp', 'we have a regular expression'); + * assert.typeOf(null, 'null', 'we have a null'); + * assert.typeOf(undefined, 'undefined', 'we have an undefined'); + * + * @name typeOf + * @param {Mixed} value + * @param {String} name + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.typeOf = function (val, type, msg) { + new Assertion(val, msg).to.be.a(type); + }; + + /** + * ### .notTypeOf(value, name, [message]) + * + * Asserts that `value`'s type is _not_ `name`, as determined by + * `Object.prototype.toString`. + * + * assert.notTypeOf('tea', 'number', 'strings are not numbers'); + * + * @name notTypeOf + * @param {Mixed} value + * @param {String} typeof name + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.notTypeOf = function (val, type, msg) { + new Assertion(val, msg).to.not.be.a(type); + }; + + /** + * ### .instanceOf(object, constructor, [message]) + * + * Asserts that `value` is an instance of `constructor`. + * + * var Tea = function (name) { this.name = name; } + * , chai = new Tea('chai'); + * + * assert.instanceOf(chai, Tea, 'chai is an instance of tea'); + * + * @name instanceOf + * @param {Object} object + * @param {Constructor} constructor + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.instanceOf = function (val, type, msg) { + new Assertion(val, msg).to.be.instanceOf(type); + }; + + /** + * ### .notInstanceOf(object, constructor, [message]) + * + * Asserts `value` is not an instance of `constructor`. + * + * var Tea = function (name) { this.name = name; } + * , chai = new String('chai'); + * + * assert.notInstanceOf(chai, Tea, 'chai is not an instance of tea'); + * + * @name notInstanceOf + * @param {Object} object + * @param {Constructor} constructor + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.notInstanceOf = function (val, type, msg) { + new Assertion(val, msg).to.not.be.instanceOf(type); + }; + + /** + * ### .include(haystack, needle, [message]) + * + * Asserts that `haystack` includes `needle`. Works + * for strings and arrays. + * + * assert.include('foobar', 'bar', 'foobar contains string "bar"'); + * assert.include([ 1, 2, 3 ], 3, 'array contains value'); + * + * @name include + * @param {Array|String} haystack + * @param {Mixed} needle + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.include = function (exp, inc, msg) { + new Assertion(exp, msg, assert.include).include(inc); + }; + + /** + * ### .notInclude(haystack, needle, [message]) + * + * Asserts that `haystack` does not include `needle`. Works + * for strings and arrays. + * + * assert.notInclude('foobar', 'baz', 'string not include substring'); + * assert.notInclude([ 1, 2, 3 ], 4, 'array not include contain value'); + * + * @name notInclude + * @param {Array|String} haystack + * @param {Mixed} needle + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.notInclude = function (exp, inc, msg) { + new Assertion(exp, msg, assert.notInclude).not.include(inc); + }; + + /** + * ### .match(value, regexp, [message]) + * + * Asserts that `value` matches the regular expression `regexp`. + * + * assert.match('foobar', /^foo/, 'regexp matches'); + * + * @name match + * @param {Mixed} value + * @param {RegExp} regexp + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.match = function (exp, re, msg) { + new Assertion(exp, msg).to.match(re); + }; + + /** + * ### .notMatch(value, regexp, [message]) + * + * Asserts that `value` does not match the regular expression `regexp`. + * + * assert.notMatch('foobar', /^foo/, 'regexp does not match'); + * + * @name notMatch + * @param {Mixed} value + * @param {RegExp} regexp + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.notMatch = function (exp, re, msg) { + new Assertion(exp, msg).to.not.match(re); + }; + + /** + * ### .property(object, property, [message]) + * + * Asserts that `object` has a property named by `property`. + * + * assert.property({ tea: { green: 'matcha' }}, 'tea'); + * + * @name property + * @param {Object} object + * @param {String} property + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.property = function (obj, prop, msg) { + new Assertion(obj, msg).to.have.property(prop); + }; + + /** + * ### .notProperty(object, property, [message]) + * + * Asserts that `object` does _not_ have a property named by `property`. + * + * assert.notProperty({ tea: { green: 'matcha' }}, 'coffee'); + * + * @name notProperty + * @param {Object} object + * @param {String} property + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.notProperty = function (obj, prop, msg) { + new Assertion(obj, msg).to.not.have.property(prop); + }; + + /** + * ### .deepProperty(object, property, [message]) + * + * Asserts that `object` has a property named by `property`, which can be a + * string using dot- and bracket-notation for deep reference. + * + * assert.deepProperty({ tea: { green: 'matcha' }}, 'tea.green'); + * + * @name deepProperty + * @param {Object} object + * @param {String} property + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.deepProperty = function (obj, prop, msg) { + new Assertion(obj, msg).to.have.deep.property(prop); + }; + + /** + * ### .notDeepProperty(object, property, [message]) + * + * Asserts that `object` does _not_ have a property named by `property`, which + * can be a string using dot- and bracket-notation for deep reference. + * + * assert.notDeepProperty({ tea: { green: 'matcha' }}, 'tea.oolong'); + * + * @name notDeepProperty + * @param {Object} object + * @param {String} property + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.notDeepProperty = function (obj, prop, msg) { + new Assertion(obj, msg).to.not.have.deep.property(prop); + }; + + /** + * ### .propertyVal(object, property, value, [message]) + * + * Asserts that `object` has a property named by `property` with value given + * by `value`. + * + * assert.propertyVal({ tea: 'is good' }, 'tea', 'is good'); + * + * @name propertyVal + * @param {Object} object + * @param {String} property + * @param {Mixed} value + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.propertyVal = function (obj, prop, val, msg) { + new Assertion(obj, msg).to.have.property(prop, val); + }; + + /** + * ### .propertyNotVal(object, property, value, [message]) + * + * Asserts that `object` has a property named by `property`, but with a value + * different from that given by `value`. + * + * assert.propertyNotVal({ tea: 'is good' }, 'tea', 'is bad'); + * + * @name propertyNotVal + * @param {Object} object + * @param {String} property + * @param {Mixed} value + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.propertyNotVal = function (obj, prop, val, msg) { + new Assertion(obj, msg).to.not.have.property(prop, val); + }; + + /** + * ### .deepPropertyVal(object, property, value, [message]) + * + * Asserts that `object` has a property named by `property` with value given + * by `value`. `property` can use dot- and bracket-notation for deep + * reference. + * + * assert.deepPropertyVal({ tea: { green: 'matcha' }}, 'tea.green', 'matcha'); + * + * @name deepPropertyVal + * @param {Object} object + * @param {String} property + * @param {Mixed} value + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.deepPropertyVal = function (obj, prop, val, msg) { + new Assertion(obj, msg).to.have.deep.property(prop, val); + }; + + /** + * ### .deepPropertyNotVal(object, property, value, [message]) + * + * Asserts that `object` has a property named by `property`, but with a value + * different from that given by `value`. `property` can use dot- and + * bracket-notation for deep reference. + * + * assert.deepPropertyNotVal({ tea: { green: 'matcha' }}, 'tea.green', 'konacha'); + * + * @name deepPropertyNotVal + * @param {Object} object + * @param {String} property + * @param {Mixed} value + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.deepPropertyNotVal = function (obj, prop, val, msg) { + new Assertion(obj, msg).to.not.have.deep.property(prop, val); + }; + + /** + * ### .lengthOf(object, length, [message]) + * + * Asserts that `object` has a `length` property with the expected value. + * + * assert.lengthOf([1,2,3], 3, 'array has length of 3'); + * assert.lengthOf('foobar', 6, 'string has length of 6'); + * + * @name lengthOf + * @param {Mixed} object + * @param {Number} length + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.lengthOf = function (exp, len, msg) { + new Assertion(exp, msg).to.have.length(len); + }; + + /** + * ### .throws(function, [constructor/string/regexp], [string/regexp], [message]) + * + * Asserts that `function` will throw an error that is an instance of + * `constructor`, or alternately that it will throw an error with message + * matching `regexp`. + * + * assert.throws(fn, 'function throws a reference error'); + * assert.throws(fn, /function throws a reference error/); + * assert.throws(fn, ReferenceError); + * assert.throws(fn, ReferenceError, 'function throws a reference error'); + * assert.throws(fn, ReferenceError, /function throws a reference error/); + * + * @name throws + * @alias throw + * @alias Throw + * @param {Function} function + * @param {ErrorConstructor} constructor + * @param {RegExp} regexp + * @param {String} message + * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types + * @namespace Assert + * @api public + */ + + assert.throws = function (fn, errt, errs, msg) { + if ('string' === typeof errt || errt instanceof RegExp) { + errs = errt; + errt = null; + } + + var assertErr = new Assertion(fn, msg).to.throw(errt, errs); + return flag(assertErr, 'object'); + }; + + /** + * ### .doesNotThrow(function, [constructor/regexp], [message]) + * + * Asserts that `function` will _not_ throw an error that is an instance of + * `constructor`, or alternately that it will not throw an error with message + * matching `regexp`. + * + * assert.doesNotThrow(fn, Error, 'function does not throw'); + * + * @name doesNotThrow + * @param {Function} function + * @param {ErrorConstructor} constructor + * @param {RegExp} regexp + * @param {String} message + * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types + * @namespace Assert + * @api public + */ + + assert.doesNotThrow = function (fn, type, msg) { + if ('string' === typeof type) { + msg = type; + type = null; + } + + new Assertion(fn, msg).to.not.Throw(type); + }; + + /** + * ### .operator(val1, operator, val2, [message]) + * + * Compares two values using `operator`. + * + * assert.operator(1, '<', 2, 'everything is ok'); + * assert.operator(1, '>', 2, 'this will fail'); + * + * @name operator + * @param {Mixed} val1 + * @param {String} operator + * @param {Mixed} val2 + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.operator = function (val, operator, val2, msg) { + var ok; + switch(operator) { + case '==': + ok = val == val2; + break; + case '===': + ok = val === val2; + break; + case '>': + ok = val > val2; + break; + case '>=': + ok = val >= val2; + break; + case '<': + ok = val < val2; + break; + case '<=': + ok = val <= val2; + break; + case '!=': + ok = val != val2; + break; + case '!==': + ok = val !== val2; + break; + default: + throw new Error('Invalid operator "' + operator + '"'); + } + var test = new Assertion(ok, msg); + test.assert( + true === flag(test, 'object') + , 'expected ' + util.inspect(val) + ' to be ' + operator + ' ' + util.inspect(val2) + , 'expected ' + util.inspect(val) + ' to not be ' + operator + ' ' + util.inspect(val2) ); + }; + + /** + * ### .closeTo(actual, expected, delta, [message]) + * + * Asserts that the target is equal `expected`, to within a +/- `delta` range. + * + * assert.closeTo(1.5, 1, 0.5, 'numbers are close'); + * + * @name closeTo + * @param {Number} actual + * @param {Number} expected + * @param {Number} delta + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.closeTo = function (act, exp, delta, msg) { + new Assertion(act, msg).to.be.closeTo(exp, delta); + }; + + /** + * ### .approximately(actual, expected, delta, [message]) + * + * Asserts that the target is equal `expected`, to within a +/- `delta` range. + * + * assert.approximately(1.5, 1, 0.5, 'numbers are close'); + * + * @name approximately + * @param {Number} actual + * @param {Number} expected + * @param {Number} delta + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.approximately = function (act, exp, delta, msg) { + new Assertion(act, msg).to.be.approximately(exp, delta); + }; + + /** + * ### .sameMembers(set1, set2, [message]) + * + * Asserts that `set1` and `set2` have the same members. + * Order is not taken into account. + * + * assert.sameMembers([ 1, 2, 3 ], [ 2, 1, 3 ], 'same members'); + * + * @name sameMembers + * @param {Array} set1 + * @param {Array} set2 + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.sameMembers = function (set1, set2, msg) { + new Assertion(set1, msg).to.have.same.members(set2); + } + + /** + * ### .sameDeepMembers(set1, set2, [message]) + * + * Asserts that `set1` and `set2` have the same members - using a deep equality checking. + * Order is not taken into account. + * + * assert.sameDeepMembers([ {b: 3}, {a: 2}, {c: 5} ], [ {c: 5}, {b: 3}, {a: 2} ], 'same deep members'); + * + * @name sameDeepMembers + * @param {Array} set1 + * @param {Array} set2 + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.sameDeepMembers = function (set1, set2, msg) { + new Assertion(set1, msg).to.have.same.deep.members(set2); + } + + /** + * ### .includeMembers(superset, subset, [message]) + * + * Asserts that `subset` is included in `superset`. + * Order is not taken into account. + * + * assert.includeMembers([ 1, 2, 3 ], [ 2, 1 ], 'include members'); + * + * @name includeMembers + * @param {Array} superset + * @param {Array} subset + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.includeMembers = function (superset, subset, msg) { + new Assertion(superset, msg).to.include.members(subset); + } + + /** + * ### .includeDeepMembers(superset, subset, [message]) + * + * Asserts that `subset` is included in `superset` - using deep equality checking. + * Order is not taken into account. + * Duplicates are ignored. + * + * assert.includeDeepMembers([ {a: 1}, {b: 2}, {c: 3} ], [ {b: 2}, {a: 1}, {b: 2} ], 'include deep members'); + * + * @name includeDeepMembers + * @param {Array} superset + * @param {Array} subset + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.includeDeepMembers = function (superset, subset, msg) { + new Assertion(superset, msg).to.include.deep.members(subset); + } + + /** + * ### .oneOf(inList, list, [message]) + * + * Asserts that non-object, non-array value `inList` appears in the flat array `list`. + * + * assert.oneOf(1, [ 2, 1 ], 'Not found in list'); + * + * @name oneOf + * @param {*} inList + * @param {Array<*>} list + * @param {String} message + * @namespace Assert + * @api public + */ + + assert.oneOf = function (inList, list, msg) { + new Assertion(inList, msg).to.be.oneOf(list); + } + + /** + * ### .changes(function, object, property) + * + * Asserts that a function changes the value of a property + * + * var obj = { val: 10 }; + * var fn = function() { obj.val = 22 }; + * assert.changes(fn, obj, 'val'); + * + * @name changes + * @param {Function} modifier function + * @param {Object} object + * @param {String} property name + * @param {String} message _optional_ + * @namespace Assert + * @api public + */ + + assert.changes = function (fn, obj, prop) { + new Assertion(fn).to.change(obj, prop); + } + + /** + * ### .doesNotChange(function, object, property) + * + * Asserts that a function does not changes the value of a property + * + * var obj = { val: 10 }; + * var fn = function() { console.log('foo'); }; + * assert.doesNotChange(fn, obj, 'val'); + * + * @name doesNotChange + * @param {Function} modifier function + * @param {Object} object + * @param {String} property name + * @param {String} message _optional_ + * @namespace Assert + * @api public + */ + + assert.doesNotChange = function (fn, obj, prop) { + new Assertion(fn).to.not.change(obj, prop); + } + + /** + * ### .increases(function, object, property) + * + * Asserts that a function increases an object property + * + * var obj = { val: 10 }; + * var fn = function() { obj.val = 13 }; + * assert.increases(fn, obj, 'val'); + * + * @name increases + * @param {Function} modifier function + * @param {Object} object + * @param {String} property name + * @param {String} message _optional_ + * @namespace Assert + * @api public + */ + + assert.increases = function (fn, obj, prop) { + new Assertion(fn).to.increase(obj, prop); + } + + /** + * ### .doesNotIncrease(function, object, property) + * + * Asserts that a function does not increase object property + * + * var obj = { val: 10 }; + * var fn = function() { obj.val = 8 }; + * assert.doesNotIncrease(fn, obj, 'val'); + * + * @name doesNotIncrease + * @param {Function} modifier function + * @param {Object} object + * @param {String} property name + * @param {String} message _optional_ + * @namespace Assert + * @api public + */ + + assert.doesNotIncrease = function (fn, obj, prop) { + new Assertion(fn).to.not.increase(obj, prop); + } + + /** + * ### .decreases(function, object, property) + * + * Asserts that a function decreases an object property + * + * var obj = { val: 10 }; + * var fn = function() { obj.val = 5 }; + * assert.decreases(fn, obj, 'val'); + * + * @name decreases + * @param {Function} modifier function + * @param {Object} object + * @param {String} property name + * @param {String} message _optional_ + * @namespace Assert + * @api public + */ + + assert.decreases = function (fn, obj, prop) { + new Assertion(fn).to.decrease(obj, prop); + } + + /** + * ### .doesNotDecrease(function, object, property) + * + * Asserts that a function does not decreases an object property + * + * var obj = { val: 10 }; + * var fn = function() { obj.val = 15 }; + * assert.doesNotDecrease(fn, obj, 'val'); + * + * @name doesNotDecrease + * @param {Function} modifier function + * @param {Object} object + * @param {String} property name + * @param {String} message _optional_ + * @namespace Assert + * @api public + */ + + assert.doesNotDecrease = function (fn, obj, prop) { + new Assertion(fn).to.not.decrease(obj, prop); + } + + /*! + * ### .ifError(object) + * + * Asserts if value is not a false value, and throws if it is a true value. + * This is added to allow for chai to be a drop-in replacement for Node's + * assert class. + * + * var err = new Error('I am a custom error'); + * assert.ifError(err); // Rethrows err! + * + * @name ifError + * @param {Object} object + * @namespace Assert + * @api public + */ + + assert.ifError = function (val) { + if (val) { + throw(val); + } + }; + + /** + * ### .isExtensible(object) + * + * Asserts that `object` is extensible (can have new properties added to it). + * + * assert.isExtensible({}); + * + * @name isExtensible + * @alias extensible + * @param {Object} object + * @param {String} message _optional_ + * @namespace Assert + * @api public + */ + + assert.isExtensible = function (obj, msg) { + new Assertion(obj, msg).to.be.extensible; + }; + + /** + * ### .isNotExtensible(object) + * + * Asserts that `object` is _not_ extensible. + * + * var nonExtensibleObject = Object.preventExtensions({}); + * var sealedObject = Object.seal({}); + * var frozenObject = Object.freese({}); + * + * assert.isNotExtensible(nonExtensibleObject); + * assert.isNotExtensible(sealedObject); + * assert.isNotExtensible(frozenObject); + * + * @name isNotExtensible + * @alias notExtensible + * @param {Object} object + * @param {String} message _optional_ + * @namespace Assert + * @api public + */ + + assert.isNotExtensible = function (obj, msg) { + new Assertion(obj, msg).to.not.be.extensible; + }; + + /** + * ### .isSealed(object) + * + * Asserts that `object` is sealed (cannot have new properties added to it + * and its existing properties cannot be removed). + * + * var sealedObject = Object.seal({}); + * var frozenObject = Object.seal({}); + * + * assert.isSealed(sealedObject); + * assert.isSealed(frozenObject); + * + * @name isSealed + * @alias sealed + * @param {Object} object + * @param {String} message _optional_ + * @namespace Assert + * @api public + */ + + assert.isSealed = function (obj, msg) { + new Assertion(obj, msg).to.be.sealed; + }; + + /** + * ### .isNotSealed(object) + * + * Asserts that `object` is _not_ sealed. + * + * assert.isNotSealed({}); + * + * @name isNotSealed + * @alias notSealed + * @param {Object} object + * @param {String} message _optional_ + * @namespace Assert + * @api public + */ + + assert.isNotSealed = function (obj, msg) { + new Assertion(obj, msg).to.not.be.sealed; + }; + + /** + * ### .isFrozen(object) + * + * Asserts that `object` is frozen (cannot have new properties added to it + * and its existing properties cannot be modified). + * + * var frozenObject = Object.freeze({}); + * assert.frozen(frozenObject); + * + * @name isFrozen + * @alias frozen + * @param {Object} object + * @param {String} message _optional_ + * @namespace Assert + * @api public + */ + + assert.isFrozen = function (obj, msg) { + new Assertion(obj, msg).to.be.frozen; + }; + + /** + * ### .isNotFrozen(object) + * + * Asserts that `object` is _not_ frozen. + * + * assert.isNotFrozen({}); + * + * @name isNotFrozen + * @alias notFrozen + * @param {Object} object + * @param {String} message _optional_ + * @namespace Assert + * @api public + */ + + assert.isNotFrozen = function (obj, msg) { + new Assertion(obj, msg).to.not.be.frozen; + }; + + /*! + * Aliases. + */ + + (function alias(name, as){ + assert[as] = assert[name]; + return alias; + }) + ('isOk', 'ok') + ('isNotOk', 'notOk') + ('throws', 'throw') + ('throws', 'Throw') + ('isExtensible', 'extensible') + ('isNotExtensible', 'notExtensible') + ('isSealed', 'sealed') + ('isNotSealed', 'notSealed') + ('isFrozen', 'frozen') + ('isNotFrozen', 'notFrozen'); +}; + +},{}],10:[function(require,module,exports){ +/*! + * chai + * Copyright(c) 2011-2014 Jake Luer + * MIT Licensed + */ + +module.exports = function (chai, util) { + chai.expect = function (val, message) { + return new chai.Assertion(val, message); + }; + + /** + * ### .fail(actual, expected, [message], [operator]) + * + * Throw a failure. + * + * @name fail + * @param {Mixed} actual + * @param {Mixed} expected + * @param {String} message + * @param {String} operator + * @namespace Expect + * @api public + */ + + chai.expect.fail = function (actual, expected, message, operator) { + message = message || 'expect.fail()'; + throw new chai.AssertionError(message, { + actual: actual + , expected: expected + , operator: operator + }, chai.expect.fail); + }; +}; + +},{}],11:[function(require,module,exports){ +/*! + * chai + * Copyright(c) 2011-2014 Jake Luer + * MIT Licensed + */ + +module.exports = function (chai, util) { + var Assertion = chai.Assertion; + + function loadShould () { + // explicitly define this method as function as to have it's name to include as `ssfi` + function shouldGetter() { + if (this instanceof String || this instanceof Number || this instanceof Boolean ) { + return new Assertion(this.valueOf(), null, shouldGetter); + } + return new Assertion(this, null, shouldGetter); + } + function shouldSetter(value) { + // See https://github.com/chaijs/chai/issues/86: this makes + // `whatever.should = someValue` actually set `someValue`, which is + // especially useful for `global.should = require('chai').should()`. + // + // Note that we have to use [[DefineProperty]] instead of [[Put]] + // since otherwise we would trigger this very setter! + Object.defineProperty(this, 'should', { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } + // modify Object.prototype to have `should` + Object.defineProperty(Object.prototype, 'should', { + set: shouldSetter + , get: shouldGetter + , configurable: true + }); + + var should = {}; + + /** + * ### .fail(actual, expected, [message], [operator]) + * + * Throw a failure. + * + * @name fail + * @param {Mixed} actual + * @param {Mixed} expected + * @param {String} message + * @param {String} operator + * @namespace Should + * @api public + */ + + should.fail = function (actual, expected, message, operator) { + message = message || 'should.fail()'; + throw new chai.AssertionError(message, { + actual: actual + , expected: expected + , operator: operator + }, should.fail); + }; + + /** + * ### .equal(actual, expected, [message]) + * + * Asserts non-strict equality (`==`) of `actual` and `expected`. + * + * should.equal(3, '3', '== coerces values to strings'); + * + * @name equal + * @param {Mixed} actual + * @param {Mixed} expected + * @param {String} message + * @namespace Should + * @api public + */ + + should.equal = function (val1, val2, msg) { + new Assertion(val1, msg).to.equal(val2); + }; + + /** + * ### .throw(function, [constructor/string/regexp], [string/regexp], [message]) + * + * Asserts that `function` will throw an error that is an instance of + * `constructor`, or alternately that it will throw an error with message + * matching `regexp`. + * + * should.throw(fn, 'function throws a reference error'); + * should.throw(fn, /function throws a reference error/); + * should.throw(fn, ReferenceError); + * should.throw(fn, ReferenceError, 'function throws a reference error'); + * should.throw(fn, ReferenceError, /function throws a reference error/); + * + * @name throw + * @alias Throw + * @param {Function} function + * @param {ErrorConstructor} constructor + * @param {RegExp} regexp + * @param {String} message + * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types + * @namespace Should + * @api public + */ + + should.Throw = function (fn, errt, errs, msg) { + new Assertion(fn, msg).to.Throw(errt, errs); + }; + + /** + * ### .exist + * + * Asserts that the target is neither `null` nor `undefined`. + * + * var foo = 'hi'; + * + * should.exist(foo, 'foo exists'); + * + * @name exist + * @namespace Should + * @api public + */ + + should.exist = function (val, msg) { + new Assertion(val, msg).to.exist; + } + + // negation + should.not = {} + + /** + * ### .not.equal(actual, expected, [message]) + * + * Asserts non-strict inequality (`!=`) of `actual` and `expected`. + * + * should.not.equal(3, 4, 'these numbers are not equal'); + * + * @name not.equal + * @param {Mixed} actual + * @param {Mixed} expected + * @param {String} message + * @namespace Should + * @api public + */ + + should.not.equal = function (val1, val2, msg) { + new Assertion(val1, msg).to.not.equal(val2); + }; + + /** + * ### .throw(function, [constructor/regexp], [message]) + * + * Asserts that `function` will _not_ throw an error that is an instance of + * `constructor`, or alternately that it will not throw an error with message + * matching `regexp`. + * + * should.not.throw(fn, Error, 'function does not throw'); + * + * @name not.throw + * @alias not.Throw + * @param {Function} function + * @param {ErrorConstructor} constructor + * @param {RegExp} regexp + * @param {String} message + * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types + * @namespace Should + * @api public + */ + + should.not.Throw = function (fn, errt, errs, msg) { + new Assertion(fn, msg).to.not.Throw(errt, errs); + }; + + /** + * ### .not.exist + * + * Asserts that the target is neither `null` nor `undefined`. + * + * var bar = null; + * + * should.not.exist(bar, 'bar does not exist'); + * + * @name not.exist + * @namespace Should + * @api public + */ + + should.not.exist = function (val, msg) { + new Assertion(val, msg).to.not.exist; + } + + should['throw'] = should['Throw']; + should.not['throw'] = should.not['Throw']; + + return should; + }; + + chai.should = loadShould; + chai.Should = loadShould; +}; + +},{}],12:[function(require,module,exports){ +/*! + * Chai - addChainingMethod utility + * Copyright(c) 2012-2014 Jake Luer + * MIT Licensed + */ + +/*! + * Module dependencies + */ + +var transferFlags = require('./transferFlags'); +var flag = require('./flag'); +var config = require('../config'); + +/*! + * Module variables + */ + +// Check whether `__proto__` is supported +var hasProtoSupport = '__proto__' in Object; + +// Without `__proto__` support, this module will need to add properties to a function. +// However, some Function.prototype methods cannot be overwritten, +// and there seems no easy cross-platform way to detect them (@see chaijs/chai/issues/69). +var excludeNames = /^(?:length|name|arguments|caller)$/; + +// Cache `Function` properties +var call = Function.prototype.call, + apply = Function.prototype.apply; + +/** + * ### addChainableMethod (ctx, name, method, chainingBehavior) + * + * Adds a method to an object, such that the method can also be chained. + * + * utils.addChainableMethod(chai.Assertion.prototype, 'foo', function (str) { + * var obj = utils.flag(this, 'object'); + * new chai.Assertion(obj).to.be.equal(str); + * }); + * + * Can also be accessed directly from `chai.Assertion`. + * + * chai.Assertion.addChainableMethod('foo', fn, chainingBehavior); + * + * The result can then be used as both a method assertion, executing both `method` and + * `chainingBehavior`, or as a language chain, which only executes `chainingBehavior`. + * + * expect(fooStr).to.be.foo('bar'); + * expect(fooStr).to.be.foo.equal('foo'); + * + * @param {Object} ctx object to which the method is added + * @param {String} name of method to add + * @param {Function} method function to be used for `name`, when called + * @param {Function} chainingBehavior function to be called every time the property is accessed + * @namespace Utils + * @name addChainableMethod + * @api public + */ + +module.exports = function (ctx, name, method, chainingBehavior) { + if (typeof chainingBehavior !== 'function') { + chainingBehavior = function () { }; + } + + var chainableBehavior = { + method: method + , chainingBehavior: chainingBehavior + }; + + // save the methods so we can overwrite them later, if we need to. + if (!ctx.__methods) { + ctx.__methods = {}; + } + ctx.__methods[name] = chainableBehavior; + + Object.defineProperty(ctx, name, + { get: function () { + chainableBehavior.chainingBehavior.call(this); + + var assert = function assert() { + var old_ssfi = flag(this, 'ssfi'); + if (old_ssfi && config.includeStack === false) + flag(this, 'ssfi', assert); + var result = chainableBehavior.method.apply(this, arguments); + return result === undefined ? this : result; + }; + + // Use `__proto__` if available + if (hasProtoSupport) { + // Inherit all properties from the object by replacing the `Function` prototype + var prototype = assert.__proto__ = Object.create(this); + // Restore the `call` and `apply` methods from `Function` + prototype.call = call; + prototype.apply = apply; + } + // Otherwise, redefine all properties (slow!) + else { + var asserterNames = Object.getOwnPropertyNames(ctx); + asserterNames.forEach(function (asserterName) { + if (!excludeNames.test(asserterName)) { + var pd = Object.getOwnPropertyDescriptor(ctx, asserterName); + Object.defineProperty(assert, asserterName, pd); + } + }); + } + + transferFlags(this, assert); + return assert; + } + , configurable: true + }); +}; + +},{"../config":7,"./flag":16,"./transferFlags":32}],13:[function(require,module,exports){ +/*! + * Chai - addMethod utility + * Copyright(c) 2012-2014 Jake Luer + * MIT Licensed + */ + +var config = require('../config'); + +/** + * ### .addMethod (ctx, name, method) + * + * Adds a method to the prototype of an object. + * + * utils.addMethod(chai.Assertion.prototype, 'foo', function (str) { + * var obj = utils.flag(this, 'object'); + * new chai.Assertion(obj).to.be.equal(str); + * }); + * + * Can also be accessed directly from `chai.Assertion`. + * + * chai.Assertion.addMethod('foo', fn); + * + * Then can be used as any other assertion. + * + * expect(fooStr).to.be.foo('bar'); + * + * @param {Object} ctx object to which the method is added + * @param {String} name of method to add + * @param {Function} method function to be used for name + * @namespace Utils + * @name addMethod + * @api public + */ +var flag = require('./flag'); + +module.exports = function (ctx, name, method) { + ctx[name] = function () { + var old_ssfi = flag(this, 'ssfi'); + if (old_ssfi && config.includeStack === false) + flag(this, 'ssfi', ctx[name]); + var result = method.apply(this, arguments); + return result === undefined ? this : result; + }; +}; + +},{"../config":7,"./flag":16}],14:[function(require,module,exports){ +/*! + * Chai - addProperty utility + * Copyright(c) 2012-2014 Jake Luer + * MIT Licensed + */ + +var config = require('../config'); +var flag = require('./flag'); + +/** + * ### addProperty (ctx, name, getter) + * + * Adds a property to the prototype of an object. + * + * utils.addProperty(chai.Assertion.prototype, 'foo', function () { + * var obj = utils.flag(this, 'object'); + * new chai.Assertion(obj).to.be.instanceof(Foo); + * }); + * + * Can also be accessed directly from `chai.Assertion`. + * + * chai.Assertion.addProperty('foo', fn); + * + * Then can be used as any other assertion. + * + * expect(myFoo).to.be.foo; + * + * @param {Object} ctx object to which the property is added + * @param {String} name of property to add + * @param {Function} getter function to be used for name + * @namespace Utils + * @name addProperty + * @api public + */ + +module.exports = function (ctx, name, getter) { + Object.defineProperty(ctx, name, + { get: function addProperty() { + var old_ssfi = flag(this, 'ssfi'); + if (old_ssfi && config.includeStack === false) + flag(this, 'ssfi', addProperty); + + var result = getter.call(this); + return result === undefined ? this : result; + } + , configurable: true + }); +}; + +},{"../config":7,"./flag":16}],15:[function(require,module,exports){ +/*! + * Chai - expectTypes utility + * Copyright(c) 2012-2014 Jake Luer + * MIT Licensed + */ + +/** + * ### expectTypes(obj, types) + * + * Ensures that the object being tested against is of a valid type. + * + * utils.expectTypes(this, ['array', 'object', 'string']); + * + * @param {Mixed} obj constructed Assertion + * @param {Array} type A list of allowed types for this assertion + * @namespace Utils + * @name expectTypes + * @api public + */ + +var AssertionError = require('assertion-error'); +var flag = require('./flag'); +var type = require('type-detect'); + +module.exports = function (obj, types) { + var obj = flag(obj, 'object'); + types = types.map(function (t) { return t.toLowerCase(); }); + types.sort(); + + // Transforms ['lorem', 'ipsum'] into 'a lirum, or an ipsum' + var str = types.map(function (t, index) { + var art = ~[ 'a', 'e', 'i', 'o', 'u' ].indexOf(t.charAt(0)) ? 'an' : 'a'; + var or = types.length > 1 && index === types.length - 1 ? 'or ' : ''; + return or + art + ' ' + t; + }).join(', '); + + if (!types.some(function (expected) { return type(obj) === expected; })) { + throw new AssertionError( + 'object tested must be ' + str + ', but ' + type(obj) + ' given' + ); + } +}; + +},{"./flag":16,"assertion-error":1,"type-detect":39}],16:[function(require,module,exports){ +/*! + * Chai - flag utility + * Copyright(c) 2012-2014 Jake Luer + * MIT Licensed + */ + +/** + * ### flag(object, key, [value]) + * + * Get or set a flag value on an object. If a + * value is provided it will be set, else it will + * return the currently set value or `undefined` if + * the value is not set. + * + * utils.flag(this, 'foo', 'bar'); // setter + * utils.flag(this, 'foo'); // getter, returns `bar` + * + * @param {Object} object constructed Assertion + * @param {String} key + * @param {Mixed} value (optional) + * @namespace Utils + * @name flag + * @api private + */ + +module.exports = function (obj, key, value) { + var flags = obj.__flags || (obj.__flags = Object.create(null)); + if (arguments.length === 3) { + flags[key] = value; + } else { + return flags[key]; + } +}; + +},{}],17:[function(require,module,exports){ +/*! + * Chai - getActual utility + * Copyright(c) 2012-2014 Jake Luer + * MIT Licensed + */ + +/** + * # getActual(object, [actual]) + * + * Returns the `actual` value for an Assertion + * + * @param {Object} object (constructed Assertion) + * @param {Arguments} chai.Assertion.prototype.assert arguments + * @namespace Utils + * @name getActual + */ + +module.exports = function (obj, args) { + return args.length > 4 ? args[4] : obj._obj; +}; + +},{}],18:[function(require,module,exports){ +/*! + * Chai - getEnumerableProperties utility + * Copyright(c) 2012-2014 Jake Luer + * MIT Licensed + */ + +/** + * ### .getEnumerableProperties(object) + * + * This allows the retrieval of enumerable property names of an object, + * inherited or not. + * + * @param {Object} object + * @returns {Array} + * @namespace Utils + * @name getEnumerableProperties + * @api public + */ + +module.exports = function getEnumerableProperties(object) { + var result = []; + for (var name in object) { + result.push(name); + } + return result; +}; + +},{}],19:[function(require,module,exports){ +/*! + * Chai - message composition utility + * Copyright(c) 2012-2014 Jake Luer + * MIT Licensed + */ + +/*! + * Module dependancies + */ + +var flag = require('./flag') + , getActual = require('./getActual') + , inspect = require('./inspect') + , objDisplay = require('./objDisplay'); + +/** + * ### .getMessage(object, message, negateMessage) + * + * Construct the error message based on flags + * and template tags. Template tags will return + * a stringified inspection of the object referenced. + * + * Message template tags: + * - `#{this}` current asserted object + * - `#{act}` actual value + * - `#{exp}` expected value + * + * @param {Object} object (constructed Assertion) + * @param {Arguments} chai.Assertion.prototype.assert arguments + * @namespace Utils + * @name getMessage + * @api public + */ + +module.exports = function (obj, args) { + var negate = flag(obj, 'negate') + , val = flag(obj, 'object') + , expected = args[3] + , actual = getActual(obj, args) + , msg = negate ? args[2] : args[1] + , flagMsg = flag(obj, 'message'); + + if(typeof msg === "function") msg = msg(); + msg = msg || ''; + msg = msg + .replace(/#\{this\}/g, function () { return objDisplay(val); }) + .replace(/#\{act\}/g, function () { return objDisplay(actual); }) + .replace(/#\{exp\}/g, function () { return objDisplay(expected); }); + + return flagMsg ? flagMsg + ': ' + msg : msg; +}; + +},{"./flag":16,"./getActual":17,"./inspect":26,"./objDisplay":27}],20:[function(require,module,exports){ +/*! + * Chai - getName utility + * Copyright(c) 2012-2014 Jake Luer + * MIT Licensed + */ + +/** + * # getName(func) + * + * Gets the name of a function, in a cross-browser way. + * + * @param {Function} a function (usually a constructor) + * @namespace Utils + * @name getName + */ + +module.exports = function (func) { + if (func.name) return func.name; + + var match = /^\s?function ([^(]*)\(/.exec(func); + return match && match[1] ? match[1] : ""; +}; + +},{}],21:[function(require,module,exports){ +/*! + * Chai - getPathInfo utility + * Copyright(c) 2012-2014 Jake Luer + * MIT Licensed + */ + +var hasProperty = require('./hasProperty'); + +/** + * ### .getPathInfo(path, object) + * + * This allows the retrieval of property info in an + * object given a string path. + * + * The path info consists of an object with the + * following properties: + * + * * parent - The parent object of the property referenced by `path` + * * name - The name of the final property, a number if it was an array indexer + * * value - The value of the property, if it exists, otherwise `undefined` + * * exists - Whether the property exists or not + * + * @param {String} path + * @param {Object} object + * @returns {Object} info + * @namespace Utils + * @name getPathInfo + * @api public + */ + +module.exports = function getPathInfo(path, obj) { + var parsed = parsePath(path), + last = parsed[parsed.length - 1]; + + var info = { + parent: parsed.length > 1 ? _getPathValue(parsed, obj, parsed.length - 1) : obj, + name: last.p || last.i, + value: _getPathValue(parsed, obj) + }; + info.exists = hasProperty(info.name, info.parent); + + return info; +}; + + +/*! + * ## parsePath(path) + * + * Helper function used to parse string object + * paths. Use in conjunction with `_getPathValue`. + * + * var parsed = parsePath('myobject.property.subprop'); + * + * ### Paths: + * + * * Can be as near infinitely deep and nested + * * Arrays are also valid using the formal `myobject.document[3].property`. + * * Literal dots and brackets (not delimiter) must be backslash-escaped. + * + * @param {String} path + * @returns {Object} parsed + * @api private + */ + +function parsePath (path) { + var str = path.replace(/([^\\])\[/g, '$1.[') + , parts = str.match(/(\\\.|[^.]+?)+/g); + return parts.map(function (value) { + var re = /^\[(\d+)\]$/ + , mArr = re.exec(value); + if (mArr) return { i: parseFloat(mArr[1]) }; + else return { p: value.replace(/\\([.\[\]])/g, '$1') }; + }); +} + + +/*! + * ## _getPathValue(parsed, obj) + * + * Helper companion function for `.parsePath` that returns + * the value located at the parsed address. + * + * var value = getPathValue(parsed, obj); + * + * @param {Object} parsed definition from `parsePath`. + * @param {Object} object to search against + * @param {Number} object to search against + * @returns {Object|Undefined} value + * @api private + */ + +function _getPathValue (parsed, obj, index) { + var tmp = obj + , res; + + index = (index === undefined ? parsed.length : index); + + for (var i = 0, l = index; i < l; i++) { + var part = parsed[i]; + if (tmp) { + if ('undefined' !== typeof part.p) + tmp = tmp[part.p]; + else if ('undefined' !== typeof part.i) + tmp = tmp[part.i]; + if (i == (l - 1)) res = tmp; + } else { + res = undefined; + } + } + return res; +} + +},{"./hasProperty":24}],22:[function(require,module,exports){ +/*! + * Chai - getPathValue utility + * Copyright(c) 2012-2014 Jake Luer + * @see https://github.com/logicalparadox/filtr + * MIT Licensed + */ + +var getPathInfo = require('./getPathInfo'); + +/** + * ### .getPathValue(path, object) + * + * This allows the retrieval of values in an + * object given a string path. + * + * var obj = { + * prop1: { + * arr: ['a', 'b', 'c'] + * , str: 'Hello' + * } + * , prop2: { + * arr: [ { nested: 'Universe' } ] + * , str: 'Hello again!' + * } + * } + * + * The following would be the results. + * + * getPathValue('prop1.str', obj); // Hello + * getPathValue('prop1.att[2]', obj); // b + * getPathValue('prop2.arr[0].nested', obj); // Universe + * + * @param {String} path + * @param {Object} object + * @returns {Object} value or `undefined` + * @namespace Utils + * @name getPathValue + * @api public + */ +module.exports = function(path, obj) { + var info = getPathInfo(path, obj); + return info.value; +}; + +},{"./getPathInfo":21}],23:[function(require,module,exports){ +/*! + * Chai - getProperties utility + * Copyright(c) 2012-2014 Jake Luer + * MIT Licensed + */ + +/** + * ### .getProperties(object) + * + * This allows the retrieval of property names of an object, enumerable or not, + * inherited or not. + * + * @param {Object} object + * @returns {Array} + * @namespace Utils + * @name getProperties + * @api public + */ + +module.exports = function getProperties(object) { + var result = Object.getOwnPropertyNames(object); + + function addProperty(property) { + if (result.indexOf(property) === -1) { + result.push(property); + } + } + + var proto = Object.getPrototypeOf(object); + while (proto !== null) { + Object.getOwnPropertyNames(proto).forEach(addProperty); + proto = Object.getPrototypeOf(proto); + } + + return result; +}; + +},{}],24:[function(require,module,exports){ +/*! + * Chai - hasProperty utility + * Copyright(c) 2012-2014 Jake Luer + * MIT Licensed + */ + +var type = require('type-detect'); + +/** + * ### .hasProperty(object, name) + * + * This allows checking whether an object has + * named property or numeric array index. + * + * Basically does the same thing as the `in` + * operator but works properly with natives + * and null/undefined values. + * + * var obj = { + * arr: ['a', 'b', 'c'] + * , str: 'Hello' + * } + * + * The following would be the results. + * + * hasProperty('str', obj); // true + * hasProperty('constructor', obj); // true + * hasProperty('bar', obj); // false + * + * hasProperty('length', obj.str); // true + * hasProperty(1, obj.str); // true + * hasProperty(5, obj.str); // false + * + * hasProperty('length', obj.arr); // true + * hasProperty(2, obj.arr); // true + * hasProperty(3, obj.arr); // false + * + * @param {Objuect} object + * @param {String|Number} name + * @returns {Boolean} whether it exists + * @namespace Utils + * @name getPathInfo + * @api public + */ + +var literals = { + 'number': Number + , 'string': String +}; + +module.exports = function hasProperty(name, obj) { + var ot = type(obj); + + // Bad Object, obviously no props at all + if(ot === 'null' || ot === 'undefined') + return false; + + // The `in` operator does not work with certain literals + // box these before the check + if(literals[ot] && typeof obj !== 'object') + obj = new literals[ot](obj); + + return name in obj; +}; + +},{"type-detect":39}],25:[function(require,module,exports){ +/*! + * chai + * Copyright(c) 2011 Jake Luer + * MIT Licensed + */ + +/*! + * Main exports + */ + +var exports = module.exports = {}; + +/*! + * test utility + */ + +exports.test = require('./test'); + +/*! + * type utility + */ + +exports.type = require('type-detect'); + +/*! + * expectTypes utility + */ +exports.expectTypes = require('./expectTypes'); + +/*! + * message utility + */ + +exports.getMessage = require('./getMessage'); + +/*! + * actual utility + */ + +exports.getActual = require('./getActual'); + +/*! + * Inspect util + */ + +exports.inspect = require('./inspect'); + +/*! + * Object Display util + */ + +exports.objDisplay = require('./objDisplay'); + +/*! + * Flag utility + */ + +exports.flag = require('./flag'); + +/*! + * Flag transferring utility + */ + +exports.transferFlags = require('./transferFlags'); + +/*! + * Deep equal utility + */ + +exports.eql = require('deep-eql'); + +/*! + * Deep path value + */ + +exports.getPathValue = require('./getPathValue'); + +/*! + * Deep path info + */ + +exports.getPathInfo = require('./getPathInfo'); + +/*! + * Check if a property exists + */ + +exports.hasProperty = require('./hasProperty'); + +/*! + * Function name + */ + +exports.getName = require('./getName'); + +/*! + * add Property + */ + +exports.addProperty = require('./addProperty'); + +/*! + * add Method + */ + +exports.addMethod = require('./addMethod'); + +/*! + * overwrite Property + */ + +exports.overwriteProperty = require('./overwriteProperty'); + +/*! + * overwrite Method + */ + +exports.overwriteMethod = require('./overwriteMethod'); + +/*! + * Add a chainable method + */ + +exports.addChainableMethod = require('./addChainableMethod'); + +/*! + * Overwrite chainable method + */ + +exports.overwriteChainableMethod = require('./overwriteChainableMethod'); + +},{"./addChainableMethod":12,"./addMethod":13,"./addProperty":14,"./expectTypes":15,"./flag":16,"./getActual":17,"./getMessage":19,"./getName":20,"./getPathInfo":21,"./getPathValue":22,"./hasProperty":24,"./inspect":26,"./objDisplay":27,"./overwriteChainableMethod":28,"./overwriteMethod":29,"./overwriteProperty":30,"./test":31,"./transferFlags":32,"deep-eql":33,"type-detect":39}],26:[function(require,module,exports){ +// This is (almost) directly from Node.js utils +// https://github.com/joyent/node/blob/f8c335d0caf47f16d31413f89aa28eda3878e3aa/lib/util.js + +var getName = require('./getName'); +var getProperties = require('./getProperties'); +var getEnumerableProperties = require('./getEnumerableProperties'); + +module.exports = inspect; + +/** + * Echos the value of a value. Trys to print the value out + * in the best way possible given the different types. + * + * @param {Object} obj The object to print out. + * @param {Boolean} showHidden Flag that shows hidden (not enumerable) + * properties of objects. + * @param {Number} depth Depth in which to descend in object. Default is 2. + * @param {Boolean} colors Flag to turn on ANSI escape codes to color the + * output. Default is false (no coloring). + * @namespace Utils + * @name inspect + */ +function inspect(obj, showHidden, depth, colors) { + var ctx = { + showHidden: showHidden, + seen: [], + stylize: function (str) { return str; } + }; + return formatValue(ctx, obj, (typeof depth === 'undefined' ? 2 : depth)); +} + +// Returns true if object is a DOM element. +var isDOMElement = function (object) { + if (typeof HTMLElement === 'object') { + return object instanceof HTMLElement; + } else { + return object && + typeof object === 'object' && + object.nodeType === 1 && + typeof object.nodeName === 'string'; + } +}; + +function formatValue(ctx, value, recurseTimes) { + // Provide a hook for user-specified inspect functions. + // Check that value is an object with an inspect function on it + if (value && typeof value.inspect === 'function' && + // Filter out the util module, it's inspect function is special + value.inspect !== exports.inspect && + // Also filter out any prototype objects using the circular check. + !(value.constructor && value.constructor.prototype === value)) { + var ret = value.inspect(recurseTimes); + if (typeof ret !== 'string') { + ret = formatValue(ctx, ret, recurseTimes); + } + return ret; + } + + // Primitive types cannot have properties + var primitive = formatPrimitive(ctx, value); + if (primitive) { + return primitive; + } + + // If this is a DOM element, try to get the outer HTML. + if (isDOMElement(value)) { + if ('outerHTML' in value) { + return value.outerHTML; + // This value does not have an outerHTML attribute, + // it could still be an XML element + } else { + // Attempt to serialize it + try { + if (document.xmlVersion) { + var xmlSerializer = new XMLSerializer(); + return xmlSerializer.serializeToString(value); + } else { + // Firefox 11- do not support outerHTML + // It does, however, support innerHTML + // Use the following to render the element + var ns = "http://www.w3.org/1999/xhtml"; + var container = document.createElementNS(ns, '_'); + + container.appendChild(value.cloneNode(false)); + html = container.innerHTML + .replace('><', '>' + value.innerHTML + '<'); + container.innerHTML = ''; + return html; + } + } catch (err) { + // This could be a non-native DOM implementation, + // continue with the normal flow: + // printing the element as if it is an object. + } + } + } + + // Look up the keys of the object. + var visibleKeys = getEnumerableProperties(value); + var keys = ctx.showHidden ? getProperties(value) : visibleKeys; + + // Some type of object without properties can be shortcutted. + // In IE, errors have a single `stack` property, or if they are vanilla `Error`, + // a `stack` plus `description` property; ignore those for consistency. + if (keys.length === 0 || (isError(value) && ( + (keys.length === 1 && keys[0] === 'stack') || + (keys.length === 2 && keys[0] === 'description' && keys[1] === 'stack') + ))) { + if (typeof value === 'function') { + var name = getName(value); + var nameSuffix = name ? ': ' + name : ''; + return ctx.stylize('[Function' + nameSuffix + ']', 'special'); + } + if (isRegExp(value)) { + return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); + } + if (isDate(value)) { + return ctx.stylize(Date.prototype.toUTCString.call(value), 'date'); + } + if (isError(value)) { + return formatError(value); + } + } + + var base = '', array = false, braces = ['{', '}']; + + // Make Array say that they are Array + if (isArray(value)) { + array = true; + braces = ['[', ']']; + } + + // Make functions say that they are functions + if (typeof value === 'function') { + var name = getName(value); + var nameSuffix = name ? ': ' + name : ''; + base = ' [Function' + nameSuffix + ']'; + } + + // Make RegExps say that they are RegExps + if (isRegExp(value)) { + base = ' ' + RegExp.prototype.toString.call(value); + } + + // Make dates with properties first say the date + if (isDate(value)) { + base = ' ' + Date.prototype.toUTCString.call(value); + } + + // Make error with message first say the error + if (isError(value)) { + return formatError(value); + } + + if (keys.length === 0 && (!array || value.length == 0)) { + return braces[0] + base + braces[1]; + } + + if (recurseTimes < 0) { + if (isRegExp(value)) { + return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); + } else { + return ctx.stylize('[Object]', 'special'); + } + } + + ctx.seen.push(value); + + var output; + if (array) { + output = formatArray(ctx, value, recurseTimes, visibleKeys, keys); + } else { + output = keys.map(function(key) { + return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array); + }); + } + + ctx.seen.pop(); + + return reduceToSingleString(output, base, braces); +} + + +function formatPrimitive(ctx, value) { + switch (typeof value) { + case 'undefined': + return ctx.stylize('undefined', 'undefined'); + + case 'string': + var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '') + .replace(/'/g, "\\'") + .replace(/\\"/g, '"') + '\''; + return ctx.stylize(simple, 'string'); + + case 'number': + if (value === 0 && (1/value) === -Infinity) { + return ctx.stylize('-0', 'number'); + } + return ctx.stylize('' + value, 'number'); + + case 'boolean': + return ctx.stylize('' + value, 'boolean'); + } + // For some reason typeof null is "object", so special case here. + if (value === null) { + return ctx.stylize('null', 'null'); + } +} + + +function formatError(value) { + return '[' + Error.prototype.toString.call(value) + ']'; +} + + +function formatArray(ctx, value, recurseTimes, visibleKeys, keys) { + var output = []; + for (var i = 0, l = value.length; i < l; ++i) { + if (Object.prototype.hasOwnProperty.call(value, String(i))) { + output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, + String(i), true)); + } else { + output.push(''); + } + } + keys.forEach(function(key) { + if (!key.match(/^\d+$/)) { + output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, + key, true)); + } + }); + return output; +} + + +function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) { + var name, str; + if (value.__lookupGetter__) { + if (value.__lookupGetter__(key)) { + if (value.__lookupSetter__(key)) { + str = ctx.stylize('[Getter/Setter]', 'special'); + } else { + str = ctx.stylize('[Getter]', 'special'); + } + } else { + if (value.__lookupSetter__(key)) { + str = ctx.stylize('[Setter]', 'special'); + } + } + } + if (visibleKeys.indexOf(key) < 0) { + name = '[' + key + ']'; + } + if (!str) { + if (ctx.seen.indexOf(value[key]) < 0) { + if (recurseTimes === null) { + str = formatValue(ctx, value[key], null); + } else { + str = formatValue(ctx, value[key], recurseTimes - 1); + } + if (str.indexOf('\n') > -1) { + if (array) { + str = str.split('\n').map(function(line) { + return ' ' + line; + }).join('\n').substr(2); + } else { + str = '\n' + str.split('\n').map(function(line) { + return ' ' + line; + }).join('\n'); + } + } + } else { + str = ctx.stylize('[Circular]', 'special'); + } + } + if (typeof name === 'undefined') { + if (array && key.match(/^\d+$/)) { + return str; + } + name = JSON.stringify('' + key); + if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) { + name = name.substr(1, name.length - 2); + name = ctx.stylize(name, 'name'); + } else { + name = name.replace(/'/g, "\\'") + .replace(/\\"/g, '"') + .replace(/(^"|"$)/g, "'"); + name = ctx.stylize(name, 'string'); + } + } + + return name + ': ' + str; +} + + +function reduceToSingleString(output, base, braces) { + var numLinesEst = 0; + var length = output.reduce(function(prev, cur) { + numLinesEst++; + if (cur.indexOf('\n') >= 0) numLinesEst++; + return prev + cur.length + 1; + }, 0); + + if (length > 60) { + return braces[0] + + (base === '' ? '' : base + '\n ') + + ' ' + + output.join(',\n ') + + ' ' + + braces[1]; + } + + return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1]; +} + +function isArray(ar) { + return Array.isArray(ar) || + (typeof ar === 'object' && objectToString(ar) === '[object Array]'); +} + +function isRegExp(re) { + return typeof re === 'object' && objectToString(re) === '[object RegExp]'; +} + +function isDate(d) { + return typeof d === 'object' && objectToString(d) === '[object Date]'; +} + +function isError(e) { + return typeof e === 'object' && objectToString(e) === '[object Error]'; +} + +function objectToString(o) { + return Object.prototype.toString.call(o); +} + +},{"./getEnumerableProperties":18,"./getName":20,"./getProperties":23}],27:[function(require,module,exports){ +/*! + * Chai - flag utility + * Copyright(c) 2012-2014 Jake Luer + * MIT Licensed + */ + +/*! + * Module dependancies + */ + +var inspect = require('./inspect'); +var config = require('../config'); + +/** + * ### .objDisplay (object) + * + * Determines if an object or an array matches + * criteria to be inspected in-line for error + * messages or should be truncated. + * + * @param {Mixed} javascript object to inspect + * @name objDisplay + * @namespace Utils + * @api public + */ + +module.exports = function (obj) { + var str = inspect(obj) + , type = Object.prototype.toString.call(obj); + + if (config.truncateThreshold && str.length >= config.truncateThreshold) { + if (type === '[object Function]') { + return !obj.name || obj.name === '' + ? '[Function]' + : '[Function: ' + obj.name + ']'; + } else if (type === '[object Array]') { + return '[ Array(' + obj.length + ') ]'; + } else if (type === '[object Object]') { + var keys = Object.keys(obj) + , kstr = keys.length > 2 + ? keys.splice(0, 2).join(', ') + ', ...' + : keys.join(', '); + return '{ Object (' + kstr + ') }'; + } else { + return str; + } + } else { + return str; + } +}; + +},{"../config":7,"./inspect":26}],28:[function(require,module,exports){ +/*! + * Chai - overwriteChainableMethod utility + * Copyright(c) 2012-2014 Jake Luer + * MIT Licensed + */ + +/** + * ### overwriteChainableMethod (ctx, name, method, chainingBehavior) + * + * Overwites an already existing chainable method + * and provides access to the previous function or + * property. Must return functions to be used for + * name. + * + * utils.overwriteChainableMethod(chai.Assertion.prototype, 'length', + * function (_super) { + * } + * , function (_super) { + * } + * ); + * + * Can also be accessed directly from `chai.Assertion`. + * + * chai.Assertion.overwriteChainableMethod('foo', fn, fn); + * + * Then can be used as any other assertion. + * + * expect(myFoo).to.have.length(3); + * expect(myFoo).to.have.length.above(3); + * + * @param {Object} ctx object whose method / property is to be overwritten + * @param {String} name of method / property to overwrite + * @param {Function} method function that returns a function to be used for name + * @param {Function} chainingBehavior function that returns a function to be used for property + * @namespace Utils + * @name overwriteChainableMethod + * @api public + */ + +module.exports = function (ctx, name, method, chainingBehavior) { + var chainableBehavior = ctx.__methods[name]; + + var _chainingBehavior = chainableBehavior.chainingBehavior; + chainableBehavior.chainingBehavior = function () { + var result = chainingBehavior(_chainingBehavior).call(this); + return result === undefined ? this : result; + }; + + var _method = chainableBehavior.method; + chainableBehavior.method = function () { + var result = method(_method).apply(this, arguments); + return result === undefined ? this : result; + }; +}; + +},{}],29:[function(require,module,exports){ +/*! + * Chai - overwriteMethod utility + * Copyright(c) 2012-2014 Jake Luer + * MIT Licensed + */ + +/** + * ### overwriteMethod (ctx, name, fn) + * + * Overwites an already existing method and provides + * access to previous function. Must return function + * to be used for name. + * + * utils.overwriteMethod(chai.Assertion.prototype, 'equal', function (_super) { + * return function (str) { + * var obj = utils.flag(this, 'object'); + * if (obj instanceof Foo) { + * new chai.Assertion(obj.value).to.equal(str); + * } else { + * _super.apply(this, arguments); + * } + * } + * }); + * + * Can also be accessed directly from `chai.Assertion`. + * + * chai.Assertion.overwriteMethod('foo', fn); + * + * Then can be used as any other assertion. + * + * expect(myFoo).to.equal('bar'); + * + * @param {Object} ctx object whose method is to be overwritten + * @param {String} name of method to overwrite + * @param {Function} method function that returns a function to be used for name + * @namespace Utils + * @name overwriteMethod + * @api public + */ + +module.exports = function (ctx, name, method) { + var _method = ctx[name] + , _super = function () { return this; }; + + if (_method && 'function' === typeof _method) + _super = _method; + + ctx[name] = function () { + var result = method(_super).apply(this, arguments); + return result === undefined ? this : result; + } +}; + +},{}],30:[function(require,module,exports){ +/*! + * Chai - overwriteProperty utility + * Copyright(c) 2012-2014 Jake Luer + * MIT Licensed + */ + +/** + * ### overwriteProperty (ctx, name, fn) + * + * Overwites an already existing property getter and provides + * access to previous value. Must return function to use as getter. + * + * utils.overwriteProperty(chai.Assertion.prototype, 'ok', function (_super) { + * return function () { + * var obj = utils.flag(this, 'object'); + * if (obj instanceof Foo) { + * new chai.Assertion(obj.name).to.equal('bar'); + * } else { + * _super.call(this); + * } + * } + * }); + * + * + * Can also be accessed directly from `chai.Assertion`. + * + * chai.Assertion.overwriteProperty('foo', fn); + * + * Then can be used as any other assertion. + * + * expect(myFoo).to.be.ok; + * + * @param {Object} ctx object whose property is to be overwritten + * @param {String} name of property to overwrite + * @param {Function} getter function that returns a getter function to be used for name + * @namespace Utils + * @name overwriteProperty + * @api public + */ + +module.exports = function (ctx, name, getter) { + var _get = Object.getOwnPropertyDescriptor(ctx, name) + , _super = function () {}; + + if (_get && 'function' === typeof _get.get) + _super = _get.get + + Object.defineProperty(ctx, name, + { get: function () { + var result = getter(_super).call(this); + return result === undefined ? this : result; + } + , configurable: true + }); +}; + +},{}],31:[function(require,module,exports){ +/*! + * Chai - test utility + * Copyright(c) 2012-2014 Jake Luer + * MIT Licensed + */ + +/*! + * Module dependancies + */ + +var flag = require('./flag'); + +/** + * # test(object, expression) + * + * Test and object for expression. + * + * @param {Object} object (constructed Assertion) + * @param {Arguments} chai.Assertion.prototype.assert arguments + * @namespace Utils + * @name test + */ + +module.exports = function (obj, args) { + var negate = flag(obj, 'negate') + , expr = args[0]; + return negate ? !expr : expr; +}; + +},{"./flag":16}],32:[function(require,module,exports){ +/*! + * Chai - transferFlags utility + * Copyright(c) 2012-2014 Jake Luer + * MIT Licensed + */ + +/** + * ### transferFlags(assertion, object, includeAll = true) + * + * Transfer all the flags for `assertion` to `object`. If + * `includeAll` is set to `false`, then the base Chai + * assertion flags (namely `object`, `ssfi`, and `message`) + * will not be transferred. + * + * + * var newAssertion = new Assertion(); + * utils.transferFlags(assertion, newAssertion); + * + * var anotherAsseriton = new Assertion(myObj); + * utils.transferFlags(assertion, anotherAssertion, false); + * + * @param {Assertion} assertion the assertion to transfer the flags from + * @param {Object} object the object to transfer the flags to; usually a new assertion + * @param {Boolean} includeAll + * @namespace Utils + * @name transferFlags + * @api private + */ + +module.exports = function (assertion, object, includeAll) { + var flags = assertion.__flags || (assertion.__flags = Object.create(null)); + + if (!object.__flags) { + object.__flags = Object.create(null); + } + + includeAll = arguments.length === 3 ? includeAll : true; + + for (var flag in flags) { + if (includeAll || + (flag !== 'object' && flag !== 'ssfi' && flag != 'message')) { + object.__flags[flag] = flags[flag]; + } + } +}; + +},{}],33:[function(require,module,exports){ +module.exports = require('./lib/eql'); + +},{"./lib/eql":34}],34:[function(require,module,exports){ +/*! + * deep-eql + * Copyright(c) 2013 Jake Luer + * MIT Licensed + */ + +/*! + * Module dependencies + */ + +var type = require('type-detect'); + +/*! + * Buffer.isBuffer browser shim + */ + +var Buffer; +try { Buffer = require('buffer').Buffer; } +catch(ex) { + Buffer = {}; + Buffer.isBuffer = function() { return false; } +} + +/*! + * Primary Export + */ + +module.exports = deepEqual; + +/** + * Assert super-strict (egal) equality between + * two objects of any type. + * + * @param {Mixed} a + * @param {Mixed} b + * @param {Array} memoised (optional) + * @return {Boolean} equal match + */ + +function deepEqual(a, b, m) { + if (sameValue(a, b)) { + return true; + } else if ('date' === type(a)) { + return dateEqual(a, b); + } else if ('regexp' === type(a)) { + return regexpEqual(a, b); + } else if (Buffer.isBuffer(a)) { + return bufferEqual(a, b); + } else if ('arguments' === type(a)) { + return argumentsEqual(a, b, m); + } else if (!typeEqual(a, b)) { + return false; + } else if (('object' !== type(a) && 'object' !== type(b)) + && ('array' !== type(a) && 'array' !== type(b))) { + return sameValue(a, b); + } else { + return objectEqual(a, b, m); + } +} + +/*! + * Strict (egal) equality test. Ensures that NaN always + * equals NaN and `-0` does not equal `+0`. + * + * @param {Mixed} a + * @param {Mixed} b + * @return {Boolean} equal match + */ + +function sameValue(a, b) { + if (a === b) return a !== 0 || 1 / a === 1 / b; + return a !== a && b !== b; +} + +/*! + * Compare the types of two given objects and + * return if they are equal. Note that an Array + * has a type of `array` (not `object`) and arguments + * have a type of `arguments` (not `array`/`object`). + * + * @param {Mixed} a + * @param {Mixed} b + * @return {Boolean} result + */ + +function typeEqual(a, b) { + return type(a) === type(b); +} + +/*! + * Compare two Date objects by asserting that + * the time values are equal using `saveValue`. + * + * @param {Date} a + * @param {Date} b + * @return {Boolean} result + */ + +function dateEqual(a, b) { + if ('date' !== type(b)) return false; + return sameValue(a.getTime(), b.getTime()); +} + +/*! + * Compare two regular expressions by converting them + * to string and checking for `sameValue`. + * + * @param {RegExp} a + * @param {RegExp} b + * @return {Boolean} result + */ + +function regexpEqual(a, b) { + if ('regexp' !== type(b)) return false; + return sameValue(a.toString(), b.toString()); +} + +/*! + * Assert deep equality of two `arguments` objects. + * Unfortunately, these must be sliced to arrays + * prior to test to ensure no bad behavior. + * + * @param {Arguments} a + * @param {Arguments} b + * @param {Array} memoize (optional) + * @return {Boolean} result + */ + +function argumentsEqual(a, b, m) { + if ('arguments' !== type(b)) return false; + a = [].slice.call(a); + b = [].slice.call(b); + return deepEqual(a, b, m); +} + +/*! + * Get enumerable properties of a given object. + * + * @param {Object} a + * @return {Array} property names + */ + +function enumerable(a) { + var res = []; + for (var key in a) res.push(key); + return res; +} + +/*! + * Simple equality for flat iterable objects + * such as Arrays or Node.js buffers. + * + * @param {Iterable} a + * @param {Iterable} b + * @return {Boolean} result + */ + +function iterableEqual(a, b) { + if (a.length !== b.length) return false; + + var i = 0; + var match = true; + + for (; i < a.length; i++) { + if (a[i] !== b[i]) { + match = false; + break; + } + } + + return match; +} + +/*! + * Extension to `iterableEqual` specifically + * for Node.js Buffers. + * + * @param {Buffer} a + * @param {Mixed} b + * @return {Boolean} result + */ + +function bufferEqual(a, b) { + if (!Buffer.isBuffer(b)) return false; + return iterableEqual(a, b); +} + +/*! + * Block for `objectEqual` ensuring non-existing + * values don't get in. + * + * @param {Mixed} object + * @return {Boolean} result + */ + +function isValue(a) { + return a !== null && a !== undefined; +} + +/*! + * Recursively check the equality of two objects. + * Once basic sameness has been established it will + * defer to `deepEqual` for each enumerable key + * in the object. + * + * @param {Mixed} a + * @param {Mixed} b + * @return {Boolean} result + */ + +function objectEqual(a, b, m) { + if (!isValue(a) || !isValue(b)) { + return false; + } + + if (a.prototype !== b.prototype) { + return false; + } + + var i; + if (m) { + for (i = 0; i < m.length; i++) { + if ((m[i][0] === a && m[i][1] === b) + || (m[i][0] === b && m[i][1] === a)) { + return true; + } + } + } else { + m = []; + } + + try { + var ka = enumerable(a); + var kb = enumerable(b); + } catch (ex) { + return false; + } + + ka.sort(); + kb.sort(); + + if (!iterableEqual(ka, kb)) { + return false; + } + + m.push([ a, b ]); + + var key; + for (i = ka.length - 1; i >= 0; i--) { + key = ka[i]; + if (!deepEqual(a[key], b[key], m)) { + return false; + } + } + + return true; +} + +},{"buffer":3,"type-detect":35}],35:[function(require,module,exports){ +module.exports = require('./lib/type'); + +},{"./lib/type":36}],36:[function(require,module,exports){ +/*! + * type-detect + * Copyright(c) 2013 jake luer + * MIT Licensed + */ + +/*! + * Primary Exports + */ + +var exports = module.exports = getType; + +/*! + * Detectable javascript natives + */ + +var natives = { + '[object Array]': 'array' + , '[object RegExp]': 'regexp' + , '[object Function]': 'function' + , '[object Arguments]': 'arguments' + , '[object Date]': 'date' +}; + +/** + * ### typeOf (obj) + * + * Use several different techniques to determine + * the type of object being tested. + * + * + * @param {Mixed} object + * @return {String} object type + * @api public + */ + +function getType (obj) { + var str = Object.prototype.toString.call(obj); + if (natives[str]) return natives[str]; + if (obj === null) return 'null'; + if (obj === undefined) return 'undefined'; + if (obj === Object(obj)) return 'object'; + return typeof obj; +} + +exports.Library = Library; + +/** + * ### Library + * + * Create a repository for custom type detection. + * + * ```js + * var lib = new type.Library; + * ``` + * + */ + +function Library () { + this.tests = {}; +} + +/** + * #### .of (obj) + * + * Expose replacement `typeof` detection to the library. + * + * ```js + * if ('string' === lib.of('hello world')) { + * // ... + * } + * ``` + * + * @param {Mixed} object to test + * @return {String} type + */ + +Library.prototype.of = getType; + +/** + * #### .define (type, test) + * + * Add a test to for the `.test()` assertion. + * + * Can be defined as a regular expression: + * + * ```js + * lib.define('int', /^[0-9]+$/); + * ``` + * + * ... or as a function: + * + * ```js + * lib.define('bln', function (obj) { + * if ('boolean' === lib.of(obj)) return true; + * var blns = [ 'yes', 'no', 'true', 'false', 1, 0 ]; + * if ('string' === lib.of(obj)) obj = obj.toLowerCase(); + * return !! ~blns.indexOf(obj); + * }); + * ``` + * + * @param {String} type + * @param {RegExp|Function} test + * @api public + */ + +Library.prototype.define = function (type, test) { + if (arguments.length === 1) return this.tests[type]; + this.tests[type] = test; + return this; +}; + +/** + * #### .test (obj, test) + * + * Assert that an object is of type. Will first + * check natives, and if that does not pass it will + * use the user defined custom tests. + * + * ```js + * assert(lib.test('1', 'int')); + * assert(lib.test('yes', 'bln')); + * ``` + * + * @param {Mixed} object + * @param {String} type + * @return {Boolean} result + * @api public + */ + +Library.prototype.test = function (obj, type) { + if (type === getType(obj)) return true; + var test = this.tests[type]; + + if (test && 'regexp' === getType(test)) { + return test.test(obj); + } else if (test && 'function' === getType(test)) { + return test(obj); + } else { + throw new ReferenceError('Type test "' + type + '" not defined or invalid.'); + } +}; + +},{}],37:[function(require,module,exports){ +exports.read = function (buffer, offset, isLE, mLen, nBytes) { + var e, m + var eLen = nBytes * 8 - mLen - 1 + var eMax = (1 << eLen) - 1 + var eBias = eMax >> 1 + var nBits = -7 + var i = isLE ? (nBytes - 1) : 0 + var d = isLE ? -1 : 1 + var s = buffer[offset + i] + + i += d + + e = s & ((1 << (-nBits)) - 1) + s >>= (-nBits) + nBits += eLen + for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {} + + m = e & ((1 << (-nBits)) - 1) + e >>= (-nBits) + nBits += mLen + for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {} + + if (e === 0) { + e = 1 - eBias + } else if (e === eMax) { + return m ? NaN : ((s ? -1 : 1) * Infinity) + } else { + m = m + Math.pow(2, mLen) + e = e - eBias + } + return (s ? -1 : 1) * m * Math.pow(2, e - mLen) +} + +exports.write = function (buffer, value, offset, isLE, mLen, nBytes) { + var e, m, c + var eLen = nBytes * 8 - mLen - 1 + var eMax = (1 << eLen) - 1 + var eBias = eMax >> 1 + var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0) + var i = isLE ? 0 : (nBytes - 1) + var d = isLE ? 1 : -1 + var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0 + + value = Math.abs(value) + + if (isNaN(value) || value === Infinity) { + m = isNaN(value) ? 1 : 0 + e = eMax + } else { + e = Math.floor(Math.log(value) / Math.LN2) + if (value * (c = Math.pow(2, -e)) < 1) { + e-- + c *= 2 + } + if (e + eBias >= 1) { + value += rt / c + } else { + value += rt * Math.pow(2, 1 - eBias) + } + if (value * c >= 2) { + e++ + c /= 2 + } + + if (e + eBias >= eMax) { + m = 0 + e = eMax + } else if (e + eBias >= 1) { + m = (value * c - 1) * Math.pow(2, mLen) + e = e + eBias + } else { + m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen) + e = 0 + } + } + + for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {} + + e = (e << mLen) | m + eLen += mLen + for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {} + + buffer[offset + i - d] |= s * 128 +} + +},{}],38:[function(require,module,exports){ +var toString = {}.toString; + +module.exports = Array.isArray || function (arr) { + return toString.call(arr) == '[object Array]'; +}; + +},{}],39:[function(require,module,exports){ +arguments[4][35][0].apply(exports,arguments) +},{"./lib/type":40,"dup":35}],40:[function(require,module,exports){ +/*! + * type-detect + * Copyright(c) 2013 jake luer + * MIT Licensed + */ + +/*! + * Primary Exports + */ + +var exports = module.exports = getType; + +/** + * ### typeOf (obj) + * + * Use several different techniques to determine + * the type of object being tested. + * + * + * @param {Mixed} object + * @return {String} object type + * @api public + */ +var objectTypeRegexp = /^\[object (.*)\]$/; + +function getType(obj) { + var type = Object.prototype.toString.call(obj).match(objectTypeRegexp)[1].toLowerCase(); + // Let "new String('')" return 'object' + if (typeof Promise === 'function' && obj instanceof Promise) return 'promise'; + // PhantomJS has type "DOMWindow" for null + if (obj === null) return 'null'; + // PhantomJS has type "DOMWindow" for undefined + if (obj === undefined) return 'undefined'; + return type; +} + +exports.Library = Library; + +/** + * ### Library + * + * Create a repository for custom type detection. + * + * ```js + * var lib = new type.Library; + * ``` + * + */ + +function Library() { + if (!(this instanceof Library)) return new Library(); + this.tests = {}; +} + +/** + * #### .of (obj) + * + * Expose replacement `typeof` detection to the library. + * + * ```js + * if ('string' === lib.of('hello world')) { + * // ... + * } + * ``` + * + * @param {Mixed} object to test + * @return {String} type + */ + +Library.prototype.of = getType; + +/** + * #### .define (type, test) + * + * Add a test to for the `.test()` assertion. + * + * Can be defined as a regular expression: + * + * ```js + * lib.define('int', /^[0-9]+$/); + * ``` + * + * ... or as a function: + * + * ```js + * lib.define('bln', function (obj) { + * if ('boolean' === lib.of(obj)) return true; + * var blns = [ 'yes', 'no', 'true', 'false', 1, 0 ]; + * if ('string' === lib.of(obj)) obj = obj.toLowerCase(); + * return !! ~blns.indexOf(obj); + * }); + * ``` + * + * @param {String} type + * @param {RegExp|Function} test + * @api public + */ + +Library.prototype.define = function(type, test) { + if (arguments.length === 1) return this.tests[type]; + this.tests[type] = test; + return this; +}; + +/** + * #### .test (obj, test) + * + * Assert that an object is of type. Will first + * check natives, and if that does not pass it will + * use the user defined custom tests. + * + * ```js + * assert(lib.test('1', 'int')); + * assert(lib.test('yes', 'bln')); + * ``` + * + * @param {Mixed} object + * @param {String} type + * @return {Boolean} result + * @api public + */ + +Library.prototype.test = function(obj, type) { + if (type === getType(obj)) return true; + var test = this.tests[type]; + + if (test && 'regexp' === getType(test)) { + return test.test(obj); + } else if (test && 'function' === getType(test)) { + return test(obj); + } else { + throw new ReferenceError('Type test "' + type + '" not defined or invalid.'); + } +}; + +},{}],41:[function(require,module,exports){ +// Underscore.js 1.8.3 +// http://underscorejs.org +// (c) 2009-2015 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors +// Underscore may be freely distributed under the MIT license. + +(function() { + + // Baseline setup + // -------------- + + // Establish the root object, `window` in the browser, or `exports` on the server. + var root = this; + + // Save the previous value of the `_` variable. + var previousUnderscore = root._; + + // Save bytes in the minified (but not gzipped) version: + var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype; + + // Create quick reference variables for speed access to core prototypes. + var + push = ArrayProto.push, + slice = ArrayProto.slice, + toString = ObjProto.toString, + hasOwnProperty = ObjProto.hasOwnProperty; + + // All **ECMAScript 5** native function implementations that we hope to use + // are declared here. + var + nativeIsArray = Array.isArray, + nativeKeys = Object.keys, + nativeBind = FuncProto.bind, + nativeCreate = Object.create; + + // Naked function reference for surrogate-prototype-swapping. + var Ctor = function(){}; + + // Create a safe reference to the Underscore object for use below. + var _ = function(obj) { + if (obj instanceof _) return obj; + if (!(this instanceof _)) return new _(obj); + this._wrapped = obj; + }; + + // Export the Underscore object for **Node.js**, with + // backwards-compatibility for the old `require()` API. If we're in + // the browser, add `_` as a global object. + if (typeof exports !== 'undefined') { + if (typeof module !== 'undefined' && module.exports) { + exports = module.exports = _; + } + exports._ = _; + } else { + root._ = _; + } + + // Current version. + _.VERSION = '1.8.3'; + + // Internal function that returns an efficient (for current engines) version + // of the passed-in callback, to be repeatedly applied in other Underscore + // functions. + var optimizeCb = function(func, context, argCount) { + if (context === void 0) return func; + switch (argCount == null ? 3 : argCount) { + case 1: return function(value) { + return func.call(context, value); + }; + case 2: return function(value, other) { + return func.call(context, value, other); + }; + case 3: return function(value, index, collection) { + return func.call(context, value, index, collection); + }; + case 4: return function(accumulator, value, index, collection) { + return func.call(context, accumulator, value, index, collection); + }; + } + return function() { + return func.apply(context, arguments); + }; + }; + + // A mostly-internal function to generate callbacks that can be applied + // to each element in a collection, returning the desired result — either + // identity, an arbitrary callback, a property matcher, or a property accessor. + var cb = function(value, context, argCount) { + if (value == null) return _.identity; + if (_.isFunction(value)) return optimizeCb(value, context, argCount); + if (_.isObject(value)) return _.matcher(value); + return _.property(value); + }; + _.iteratee = function(value, context) { + return cb(value, context, Infinity); + }; + + // An internal function for creating assigner functions. + var createAssigner = function(keysFunc, undefinedOnly) { + return function(obj) { + var length = arguments.length; + if (length < 2 || obj == null) return obj; + for (var index = 1; index < length; index++) { + var source = arguments[index], + keys = keysFunc(source), + l = keys.length; + for (var i = 0; i < l; i++) { + var key = keys[i]; + if (!undefinedOnly || obj[key] === void 0) obj[key] = source[key]; + } + } + return obj; + }; + }; + + // An internal function for creating a new object that inherits from another. + var baseCreate = function(prototype) { + if (!_.isObject(prototype)) return {}; + if (nativeCreate) return nativeCreate(prototype); + Ctor.prototype = prototype; + var result = new Ctor; + Ctor.prototype = null; + return result; + }; + + var property = function(key) { + return function(obj) { + return obj == null ? void 0 : obj[key]; + }; + }; + + // Helper for collection methods to determine whether a collection + // should be iterated as an array or as an object + // Related: http://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength + // Avoids a very nasty iOS 8 JIT bug on ARM-64. #2094 + var MAX_ARRAY_INDEX = Math.pow(2, 53) - 1; + var getLength = property('length'); + var isArrayLike = function(collection) { + var length = getLength(collection); + return typeof length == 'number' && length >= 0 && length <= MAX_ARRAY_INDEX; + }; + + // Collection Functions + // -------------------- + + // The cornerstone, an `each` implementation, aka `forEach`. + // Handles raw objects in addition to array-likes. Treats all + // sparse array-likes as if they were dense. + _.each = _.forEach = function(obj, iteratee, context) { + iteratee = optimizeCb(iteratee, context); + var i, length; + if (isArrayLike(obj)) { + for (i = 0, length = obj.length; i < length; i++) { + iteratee(obj[i], i, obj); + } + } else { + var keys = _.keys(obj); + for (i = 0, length = keys.length; i < length; i++) { + iteratee(obj[keys[i]], keys[i], obj); + } + } + return obj; + }; + + // Return the results of applying the iteratee to each element. + _.map = _.collect = function(obj, iteratee, context) { + iteratee = cb(iteratee, context); + var keys = !isArrayLike(obj) && _.keys(obj), + length = (keys || obj).length, + results = Array(length); + for (var index = 0; index < length; index++) { + var currentKey = keys ? keys[index] : index; + results[index] = iteratee(obj[currentKey], currentKey, obj); + } + return results; + }; + + // Create a reducing function iterating left or right. + function createReduce(dir) { + // Optimized iterator function as using arguments.length + // in the main function will deoptimize the, see #1991. + function iterator(obj, iteratee, memo, keys, index, length) { + for (; index >= 0 && index < length; index += dir) { + var currentKey = keys ? keys[index] : index; + memo = iteratee(memo, obj[currentKey], currentKey, obj); + } + return memo; + } + + return function(obj, iteratee, memo, context) { + iteratee = optimizeCb(iteratee, context, 4); + var keys = !isArrayLike(obj) && _.keys(obj), + length = (keys || obj).length, + index = dir > 0 ? 0 : length - 1; + // Determine the initial value if none is provided. + if (arguments.length < 3) { + memo = obj[keys ? keys[index] : index]; + index += dir; + } + return iterator(obj, iteratee, memo, keys, index, length); + }; + } + + // **Reduce** builds up a single result from a list of values, aka `inject`, + // or `foldl`. + _.reduce = _.foldl = _.inject = createReduce(1); + + // The right-associative version of reduce, also known as `foldr`. + _.reduceRight = _.foldr = createReduce(-1); + + // Return the first value which passes a truth test. Aliased as `detect`. + _.find = _.detect = function(obj, predicate, context) { + var key; + if (isArrayLike(obj)) { + key = _.findIndex(obj, predicate, context); + } else { + key = _.findKey(obj, predicate, context); + } + if (key !== void 0 && key !== -1) return obj[key]; + }; + + // Return all the elements that pass a truth test. + // Aliased as `select`. + _.filter = _.select = function(obj, predicate, context) { + var results = []; + predicate = cb(predicate, context); + _.each(obj, function(value, index, list) { + if (predicate(value, index, list)) results.push(value); + }); + return results; + }; + + // Return all the elements for which a truth test fails. + _.reject = function(obj, predicate, context) { + return _.filter(obj, _.negate(cb(predicate)), context); + }; + + // Determine whether all of the elements match a truth test. + // Aliased as `all`. + _.every = _.all = function(obj, predicate, context) { + predicate = cb(predicate, context); + var keys = !isArrayLike(obj) && _.keys(obj), + length = (keys || obj).length; + for (var index = 0; index < length; index++) { + var currentKey = keys ? keys[index] : index; + if (!predicate(obj[currentKey], currentKey, obj)) return false; + } + return true; + }; + + // Determine if at least one element in the object matches a truth test. + // Aliased as `any`. + _.some = _.any = function(obj, predicate, context) { + predicate = cb(predicate, context); + var keys = !isArrayLike(obj) && _.keys(obj), + length = (keys || obj).length; + for (var index = 0; index < length; index++) { + var currentKey = keys ? keys[index] : index; + if (predicate(obj[currentKey], currentKey, obj)) return true; + } + return false; + }; + + // Determine if the array or object contains a given item (using `===`). + // Aliased as `includes` and `include`. + _.contains = _.includes = _.include = function(obj, item, fromIndex, guard) { + if (!isArrayLike(obj)) obj = _.values(obj); + if (typeof fromIndex != 'number' || guard) fromIndex = 0; + return _.indexOf(obj, item, fromIndex) >= 0; + }; + + // Invoke a method (with arguments) on every item in a collection. + _.invoke = function(obj, method) { + var args = slice.call(arguments, 2); + var isFunc = _.isFunction(method); + return _.map(obj, function(value) { + var func = isFunc ? method : value[method]; + return func == null ? func : func.apply(value, args); + }); + }; + + // Convenience version of a common use case of `map`: fetching a property. + _.pluck = function(obj, key) { + return _.map(obj, _.property(key)); + }; + + // Convenience version of a common use case of `filter`: selecting only objects + // containing specific `key:value` pairs. + _.where = function(obj, attrs) { + return _.filter(obj, _.matcher(attrs)); + }; + + // Convenience version of a common use case of `find`: getting the first object + // containing specific `key:value` pairs. + _.findWhere = function(obj, attrs) { + return _.find(obj, _.matcher(attrs)); + }; + + // Return the maximum element (or element-based computation). + _.max = function(obj, iteratee, context) { + var result = -Infinity, lastComputed = -Infinity, + value, computed; + if (iteratee == null && obj != null) { + obj = isArrayLike(obj) ? obj : _.values(obj); + for (var i = 0, length = obj.length; i < length; i++) { + value = obj[i]; + if (value > result) { + result = value; + } + } + } else { + iteratee = cb(iteratee, context); + _.each(obj, function(value, index, list) { + computed = iteratee(value, index, list); + if (computed > lastComputed || computed === -Infinity && result === -Infinity) { + result = value; + lastComputed = computed; + } + }); + } + return result; + }; + + // Return the minimum element (or element-based computation). + _.min = function(obj, iteratee, context) { + var result = Infinity, lastComputed = Infinity, + value, computed; + if (iteratee == null && obj != null) { + obj = isArrayLike(obj) ? obj : _.values(obj); + for (var i = 0, length = obj.length; i < length; i++) { + value = obj[i]; + if (value < result) { + result = value; + } + } + } else { + iteratee = cb(iteratee, context); + _.each(obj, function(value, index, list) { + computed = iteratee(value, index, list); + if (computed < lastComputed || computed === Infinity && result === Infinity) { + result = value; + lastComputed = computed; + } + }); + } + return result; + }; + + // Shuffle a collection, using the modern version of the + // [Fisher-Yates shuffle](http://en.wikipedia.org/wiki/Fisher–Yates_shuffle). + _.shuffle = function(obj) { + var set = isArrayLike(obj) ? obj : _.values(obj); + var length = set.length; + var shuffled = Array(length); + for (var index = 0, rand; index < length; index++) { + rand = _.random(0, index); + if (rand !== index) shuffled[index] = shuffled[rand]; + shuffled[rand] = set[index]; + } + return shuffled; + }; + + // Sample **n** random values from a collection. + // If **n** is not specified, returns a single random element. + // The internal `guard` argument allows it to work with `map`. + _.sample = function(obj, n, guard) { + if (n == null || guard) { + if (!isArrayLike(obj)) obj = _.values(obj); + return obj[_.random(obj.length - 1)]; + } + return _.shuffle(obj).slice(0, Math.max(0, n)); + }; + + // Sort the object's values by a criterion produced by an iteratee. + _.sortBy = function(obj, iteratee, context) { + iteratee = cb(iteratee, context); + return _.pluck(_.map(obj, function(value, index, list) { + return { + value: value, + index: index, + criteria: iteratee(value, index, list) + }; + }).sort(function(left, right) { + var a = left.criteria; + var b = right.criteria; + if (a !== b) { + if (a > b || a === void 0) return 1; + if (a < b || b === void 0) return -1; + } + return left.index - right.index; + }), 'value'); + }; + + // An internal function used for aggregate "group by" operations. + var group = function(behavior) { + return function(obj, iteratee, context) { + var result = {}; + iteratee = cb(iteratee, context); + _.each(obj, function(value, index) { + var key = iteratee(value, index, obj); + behavior(result, value, key); + }); + return result; + }; + }; + + // Groups the object's values by a criterion. Pass either a string attribute + // to group by, or a function that returns the criterion. + _.groupBy = group(function(result, value, key) { + if (_.has(result, key)) result[key].push(value); else result[key] = [value]; + }); + + // Indexes the object's values by a criterion, similar to `groupBy`, but for + // when you know that your index values will be unique. + _.indexBy = group(function(result, value, key) { + result[key] = value; + }); + + // Counts instances of an object that group by a certain criterion. Pass + // either a string attribute to count by, or a function that returns the + // criterion. + _.countBy = group(function(result, value, key) { + if (_.has(result, key)) result[key]++; else result[key] = 1; + }); + + // Safely create a real, live array from anything iterable. + _.toArray = function(obj) { + if (!obj) return []; + if (_.isArray(obj)) return slice.call(obj); + if (isArrayLike(obj)) return _.map(obj, _.identity); + return _.values(obj); + }; + + // Return the number of elements in an object. + _.size = function(obj) { + if (obj == null) return 0; + return isArrayLike(obj) ? obj.length : _.keys(obj).length; + }; + + // Split a collection into two arrays: one whose elements all satisfy the given + // predicate, and one whose elements all do not satisfy the predicate. + _.partition = function(obj, predicate, context) { + predicate = cb(predicate, context); + var pass = [], fail = []; + _.each(obj, function(value, key, obj) { + (predicate(value, key, obj) ? pass : fail).push(value); + }); + return [pass, fail]; + }; + + // Array Functions + // --------------- + + // Get the first element of an array. Passing **n** will return the first N + // values in the array. Aliased as `head` and `take`. The **guard** check + // allows it to work with `_.map`. + _.first = _.head = _.take = function(array, n, guard) { + if (array == null) return void 0; + if (n == null || guard) return array[0]; + return _.initial(array, array.length - n); + }; + + // Returns everything but the last entry of the array. Especially useful on + // the arguments object. Passing **n** will return all the values in + // the array, excluding the last N. + _.initial = function(array, n, guard) { + return slice.call(array, 0, Math.max(0, array.length - (n == null || guard ? 1 : n))); + }; + + // Get the last element of an array. Passing **n** will return the last N + // values in the array. + _.last = function(array, n, guard) { + if (array == null) return void 0; + if (n == null || guard) return array[array.length - 1]; + return _.rest(array, Math.max(0, array.length - n)); + }; + + // Returns everything but the first entry of the array. Aliased as `tail` and `drop`. + // Especially useful on the arguments object. Passing an **n** will return + // the rest N values in the array. + _.rest = _.tail = _.drop = function(array, n, guard) { + return slice.call(array, n == null || guard ? 1 : n); + }; + + // Trim out all falsy values from an array. + _.compact = function(array) { + return _.filter(array, _.identity); + }; + + // Internal implementation of a recursive `flatten` function. + var flatten = function(input, shallow, strict, startIndex) { + var output = [], idx = 0; + for (var i = startIndex || 0, length = getLength(input); i < length; i++) { + var value = input[i]; + if (isArrayLike(value) && (_.isArray(value) || _.isArguments(value))) { + //flatten current level of array or arguments object + if (!shallow) value = flatten(value, shallow, strict); + var j = 0, len = value.length; + output.length += len; + while (j < len) { + output[idx++] = value[j++]; + } + } else if (!strict) { + output[idx++] = value; + } + } + return output; + }; + + // Flatten out an array, either recursively (by default), or just one level. + _.flatten = function(array, shallow) { + return flatten(array, shallow, false); + }; + + // Return a version of the array that does not contain the specified value(s). + _.without = function(array) { + return _.difference(array, slice.call(arguments, 1)); + }; + + // Produce a duplicate-free version of the array. If the array has already + // been sorted, you have the option of using a faster algorithm. + // Aliased as `unique`. + _.uniq = _.unique = function(array, isSorted, iteratee, context) { + if (!_.isBoolean(isSorted)) { + context = iteratee; + iteratee = isSorted; + isSorted = false; + } + if (iteratee != null) iteratee = cb(iteratee, context); + var result = []; + var seen = []; + for (var i = 0, length = getLength(array); i < length; i++) { + var value = array[i], + computed = iteratee ? iteratee(value, i, array) : value; + if (isSorted) { + if (!i || seen !== computed) result.push(value); + seen = computed; + } else if (iteratee) { + if (!_.contains(seen, computed)) { + seen.push(computed); + result.push(value); + } + } else if (!_.contains(result, value)) { + result.push(value); + } + } + return result; + }; + + // Produce an array that contains the union: each distinct element from all of + // the passed-in arrays. + _.union = function() { + return _.uniq(flatten(arguments, true, true)); + }; + + // Produce an array that contains every item shared between all the + // passed-in arrays. + _.intersection = function(array) { + var result = []; + var argsLength = arguments.length; + for (var i = 0, length = getLength(array); i < length; i++) { + var item = array[i]; + if (_.contains(result, item)) continue; + for (var j = 1; j < argsLength; j++) { + if (!_.contains(arguments[j], item)) break; + } + if (j === argsLength) result.push(item); + } + return result; + }; + + // Take the difference between one array and a number of other arrays. + // Only the elements present in just the first array will remain. + _.difference = function(array) { + var rest = flatten(arguments, true, true, 1); + return _.filter(array, function(value){ + return !_.contains(rest, value); + }); + }; + + // Zip together multiple lists into a single array -- elements that share + // an index go together. + _.zip = function() { + return _.unzip(arguments); + }; + + // Complement of _.zip. Unzip accepts an array of arrays and groups + // each array's elements on shared indices + _.unzip = function(array) { + var length = array && _.max(array, getLength).length || 0; + var result = Array(length); + + for (var index = 0; index < length; index++) { + result[index] = _.pluck(array, index); + } + return result; + }; + + // Converts lists into objects. Pass either a single array of `[key, value]` + // pairs, or two parallel arrays of the same length -- one of keys, and one of + // the corresponding values. + _.object = function(list, values) { + var result = {}; + for (var i = 0, length = getLength(list); i < length; i++) { + if (values) { + result[list[i]] = values[i]; + } else { + result[list[i][0]] = list[i][1]; + } + } + return result; + }; + + // Generator function to create the findIndex and findLastIndex functions + function createPredicateIndexFinder(dir) { + return function(array, predicate, context) { + predicate = cb(predicate, context); + var length = getLength(array); + var index = dir > 0 ? 0 : length - 1; + for (; index >= 0 && index < length; index += dir) { + if (predicate(array[index], index, array)) return index; + } + return -1; + }; + } + + // Returns the first index on an array-like that passes a predicate test + _.findIndex = createPredicateIndexFinder(1); + _.findLastIndex = createPredicateIndexFinder(-1); + + // Use a comparator function to figure out the smallest index at which + // an object should be inserted so as to maintain order. Uses binary search. + _.sortedIndex = function(array, obj, iteratee, context) { + iteratee = cb(iteratee, context, 1); + var value = iteratee(obj); + var low = 0, high = getLength(array); + while (low < high) { + var mid = Math.floor((low + high) / 2); + if (iteratee(array[mid]) < value) low = mid + 1; else high = mid; + } + return low; + }; + + // Generator function to create the indexOf and lastIndexOf functions + function createIndexFinder(dir, predicateFind, sortedIndex) { + return function(array, item, idx) { + var i = 0, length = getLength(array); + if (typeof idx == 'number') { + if (dir > 0) { + i = idx >= 0 ? idx : Math.max(idx + length, i); + } else { + length = idx >= 0 ? Math.min(idx + 1, length) : idx + length + 1; + } + } else if (sortedIndex && idx && length) { + idx = sortedIndex(array, item); + return array[idx] === item ? idx : -1; + } + if (item !== item) { + idx = predicateFind(slice.call(array, i, length), _.isNaN); + return idx >= 0 ? idx + i : -1; + } + for (idx = dir > 0 ? i : length - 1; idx >= 0 && idx < length; idx += dir) { + if (array[idx] === item) return idx; + } + return -1; + }; + } + + // Return the position of the first occurrence of an item in an array, + // or -1 if the item is not included in the array. + // If the array is large and already in sort order, pass `true` + // for **isSorted** to use binary search. + _.indexOf = createIndexFinder(1, _.findIndex, _.sortedIndex); + _.lastIndexOf = createIndexFinder(-1, _.findLastIndex); + + // Generate an integer Array containing an arithmetic progression. A port of + // the native Python `range()` function. See + // [the Python documentation](http://docs.python.org/library/functions.html#range). + _.range = function(start, stop, step) { + if (stop == null) { + stop = start || 0; + start = 0; + } + step = step || 1; + + var length = Math.max(Math.ceil((stop - start) / step), 0); + var range = Array(length); + + for (var idx = 0; idx < length; idx++, start += step) { + range[idx] = start; + } + + return range; + }; + + // Function (ahem) Functions + // ------------------ + + // Determines whether to execute a function as a constructor + // or a normal function with the provided arguments + var executeBound = function(sourceFunc, boundFunc, context, callingContext, args) { + if (!(callingContext instanceof boundFunc)) return sourceFunc.apply(context, args); + var self = baseCreate(sourceFunc.prototype); + var result = sourceFunc.apply(self, args); + if (_.isObject(result)) return result; + return self; + }; + + // Create a function bound to a given object (assigning `this`, and arguments, + // optionally). Delegates to **ECMAScript 5**'s native `Function.bind` if + // available. + _.bind = function(func, context) { + if (nativeBind && func.bind === nativeBind) return nativeBind.apply(func, slice.call(arguments, 1)); + if (!_.isFunction(func)) throw new TypeError('Bind must be called on a function'); + var args = slice.call(arguments, 2); + var bound = function() { + return executeBound(func, bound, context, this, args.concat(slice.call(arguments))); + }; + return bound; + }; + + // Partially apply a function by creating a version that has had some of its + // arguments pre-filled, without changing its dynamic `this` context. _ acts + // as a placeholder, allowing any combination of arguments to be pre-filled. + _.partial = function(func) { + var boundArgs = slice.call(arguments, 1); + var bound = function() { + var position = 0, length = boundArgs.length; + var args = Array(length); + for (var i = 0; i < length; i++) { + args[i] = boundArgs[i] === _ ? arguments[position++] : boundArgs[i]; + } + while (position < arguments.length) args.push(arguments[position++]); + return executeBound(func, bound, this, this, args); + }; + return bound; + }; + + // Bind a number of an object's methods to that object. Remaining arguments + // are the method names to be bound. Useful for ensuring that all callbacks + // defined on an object belong to it. + _.bindAll = function(obj) { + var i, length = arguments.length, key; + if (length <= 1) throw new Error('bindAll must be passed function names'); + for (i = 1; i < length; i++) { + key = arguments[i]; + obj[key] = _.bind(obj[key], obj); + } + return obj; + }; + + // Memoize an expensive function by storing its results. + _.memoize = function(func, hasher) { + var memoize = function(key) { + var cache = memoize.cache; + var address = '' + (hasher ? hasher.apply(this, arguments) : key); + if (!_.has(cache, address)) cache[address] = func.apply(this, arguments); + return cache[address]; + }; + memoize.cache = {}; + return memoize; + }; + + // Delays a function for the given number of milliseconds, and then calls + // it with the arguments supplied. + _.delay = function(func, wait) { + var args = slice.call(arguments, 2); + return setTimeout(function(){ + return func.apply(null, args); + }, wait); + }; + + // Defers a function, scheduling it to run after the current call stack has + // cleared. + _.defer = _.partial(_.delay, _, 1); + + // Returns a function, that, when invoked, will only be triggered at most once + // during a given window of time. Normally, the throttled function will run + // as much as it can, without ever going more than once per `wait` duration; + // but if you'd like to disable the execution on the leading edge, pass + // `{leading: false}`. To disable execution on the trailing edge, ditto. + _.throttle = function(func, wait, options) { + var context, args, result; + var timeout = null; + var previous = 0; + if (!options) options = {}; + var later = function() { + previous = options.leading === false ? 0 : _.now(); + timeout = null; + result = func.apply(context, args); + if (!timeout) context = args = null; + }; + return function() { + var now = _.now(); + if (!previous && options.leading === false) previous = now; + var remaining = wait - (now - previous); + context = this; + args = arguments; + if (remaining <= 0 || remaining > wait) { + if (timeout) { + clearTimeout(timeout); + timeout = null; + } + previous = now; + result = func.apply(context, args); + if (!timeout) context = args = null; + } else if (!timeout && options.trailing !== false) { + timeout = setTimeout(later, remaining); + } + return result; + }; + }; + + // Returns a function, that, as long as it continues to be invoked, will not + // be triggered. The function will be called after it stops being called for + // N milliseconds. If `immediate` is passed, trigger the function on the + // leading edge, instead of the trailing. + _.debounce = function(func, wait, immediate) { + var timeout, args, context, timestamp, result; + + var later = function() { + var last = _.now() - timestamp; + + if (last < wait && last >= 0) { + timeout = setTimeout(later, wait - last); + } else { + timeout = null; + if (!immediate) { + result = func.apply(context, args); + if (!timeout) context = args = null; + } + } + }; + + return function() { + context = this; + args = arguments; + timestamp = _.now(); + var callNow = immediate && !timeout; + if (!timeout) timeout = setTimeout(later, wait); + if (callNow) { + result = func.apply(context, args); + context = args = null; + } + + return result; + }; + }; + + // Returns the first function passed as an argument to the second, + // allowing you to adjust arguments, run code before and after, and + // conditionally execute the original function. + _.wrap = function(func, wrapper) { + return _.partial(wrapper, func); + }; + + // Returns a negated version of the passed-in predicate. + _.negate = function(predicate) { + return function() { + return !predicate.apply(this, arguments); + }; + }; + + // Returns a function that is the composition of a list of functions, each + // consuming the return value of the function that follows. + _.compose = function() { + var args = arguments; + var start = args.length - 1; + return function() { + var i = start; + var result = args[start].apply(this, arguments); + while (i--) result = args[i].call(this, result); + return result; + }; + }; + + // Returns a function that will only be executed on and after the Nth call. + _.after = function(times, func) { + return function() { + if (--times < 1) { + return func.apply(this, arguments); + } + }; + }; + + // Returns a function that will only be executed up to (but not including) the Nth call. + _.before = function(times, func) { + var memo; + return function() { + if (--times > 0) { + memo = func.apply(this, arguments); + } + if (times <= 1) func = null; + return memo; + }; + }; + + // Returns a function that will be executed at most one time, no matter how + // often you call it. Useful for lazy initialization. + _.once = _.partial(_.before, 2); + + // Object Functions + // ---------------- + + // Keys in IE < 9 that won't be iterated by `for key in ...` and thus missed. + var hasEnumBug = !{toString: null}.propertyIsEnumerable('toString'); + var nonEnumerableProps = ['valueOf', 'isPrototypeOf', 'toString', + 'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString']; + + function collectNonEnumProps(obj, keys) { + var nonEnumIdx = nonEnumerableProps.length; + var constructor = obj.constructor; + var proto = (_.isFunction(constructor) && constructor.prototype) || ObjProto; + + // Constructor is a special case. + var prop = 'constructor'; + if (_.has(obj, prop) && !_.contains(keys, prop)) keys.push(prop); + + while (nonEnumIdx--) { + prop = nonEnumerableProps[nonEnumIdx]; + if (prop in obj && obj[prop] !== proto[prop] && !_.contains(keys, prop)) { + keys.push(prop); + } + } + } + + // Retrieve the names of an object's own properties. + // Delegates to **ECMAScript 5**'s native `Object.keys` + _.keys = function(obj) { + if (!_.isObject(obj)) return []; + if (nativeKeys) return nativeKeys(obj); + var keys = []; + for (var key in obj) if (_.has(obj, key)) keys.push(key); + // Ahem, IE < 9. + if (hasEnumBug) collectNonEnumProps(obj, keys); + return keys; + }; + + // Retrieve all the property names of an object. + _.allKeys = function(obj) { + if (!_.isObject(obj)) return []; + var keys = []; + for (var key in obj) keys.push(key); + // Ahem, IE < 9. + if (hasEnumBug) collectNonEnumProps(obj, keys); + return keys; + }; + + // Retrieve the values of an object's properties. + _.values = function(obj) { + var keys = _.keys(obj); + var length = keys.length; + var values = Array(length); + for (var i = 0; i < length; i++) { + values[i] = obj[keys[i]]; + } + return values; + }; + + // Returns the results of applying the iteratee to each element of the object + // In contrast to _.map it returns an object + _.mapObject = function(obj, iteratee, context) { + iteratee = cb(iteratee, context); + var keys = _.keys(obj), + length = keys.length, + results = {}, + currentKey; + for (var index = 0; index < length; index++) { + currentKey = keys[index]; + results[currentKey] = iteratee(obj[currentKey], currentKey, obj); + } + return results; + }; + + // Convert an object into a list of `[key, value]` pairs. + _.pairs = function(obj) { + var keys = _.keys(obj); + var length = keys.length; + var pairs = Array(length); + for (var i = 0; i < length; i++) { + pairs[i] = [keys[i], obj[keys[i]]]; + } + return pairs; + }; + + // Invert the keys and values of an object. The values must be serializable. + _.invert = function(obj) { + var result = {}; + var keys = _.keys(obj); + for (var i = 0, length = keys.length; i < length; i++) { + result[obj[keys[i]]] = keys[i]; + } + return result; + }; + + // Return a sorted list of the function names available on the object. + // Aliased as `methods` + _.functions = _.methods = function(obj) { + var names = []; + for (var key in obj) { + if (_.isFunction(obj[key])) names.push(key); + } + return names.sort(); + }; + + // Extend a given object with all the properties in passed-in object(s). + _.extend = createAssigner(_.allKeys); + + // Assigns a given object with all the own properties in the passed-in object(s) + // (https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/assign) + _.extendOwn = _.assign = createAssigner(_.keys); + + // Returns the first key on an object that passes a predicate test + _.findKey = function(obj, predicate, context) { + predicate = cb(predicate, context); + var keys = _.keys(obj), key; + for (var i = 0, length = keys.length; i < length; i++) { + key = keys[i]; + if (predicate(obj[key], key, obj)) return key; + } + }; + + // Return a copy of the object only containing the whitelisted properties. + _.pick = function(object, oiteratee, context) { + var result = {}, obj = object, iteratee, keys; + if (obj == null) return result; + if (_.isFunction(oiteratee)) { + keys = _.allKeys(obj); + iteratee = optimizeCb(oiteratee, context); + } else { + keys = flatten(arguments, false, false, 1); + iteratee = function(value, key, obj) { return key in obj; }; + obj = Object(obj); + } + for (var i = 0, length = keys.length; i < length; i++) { + var key = keys[i]; + var value = obj[key]; + if (iteratee(value, key, obj)) result[key] = value; + } + return result; + }; + + // Return a copy of the object without the blacklisted properties. + _.omit = function(obj, iteratee, context) { + if (_.isFunction(iteratee)) { + iteratee = _.negate(iteratee); + } else { + var keys = _.map(flatten(arguments, false, false, 1), String); + iteratee = function(value, key) { + return !_.contains(keys, key); + }; + } + return _.pick(obj, iteratee, context); + }; + + // Fill in a given object with default properties. + _.defaults = createAssigner(_.allKeys, true); + + // Creates an object that inherits from the given prototype object. + // If additional properties are provided then they will be added to the + // created object. + _.create = function(prototype, props) { + var result = baseCreate(prototype); + if (props) _.extendOwn(result, props); + return result; + }; + + // Create a (shallow-cloned) duplicate of an object. + _.clone = function(obj) { + if (!_.isObject(obj)) return obj; + return _.isArray(obj) ? obj.slice() : _.extend({}, obj); + }; + + // Invokes interceptor with the obj, and then returns obj. + // The primary purpose of this method is to "tap into" a method chain, in + // order to perform operations on intermediate results within the chain. + _.tap = function(obj, interceptor) { + interceptor(obj); + return obj; + }; + + // Returns whether an object has a given set of `key:value` pairs. + _.isMatch = function(object, attrs) { + var keys = _.keys(attrs), length = keys.length; + if (object == null) return !length; + var obj = Object(object); + for (var i = 0; i < length; i++) { + var key = keys[i]; + if (attrs[key] !== obj[key] || !(key in obj)) return false; + } + return true; + }; + + + // Internal recursive comparison function for `isEqual`. + var eq = function(a, b, aStack, bStack) { + // Identical objects are equal. `0 === -0`, but they aren't identical. + // See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal). + if (a === b) return a !== 0 || 1 / a === 1 / b; + // A strict comparison is necessary because `null == undefined`. + if (a == null || b == null) return a === b; + // Unwrap any wrapped objects. + if (a instanceof _) a = a._wrapped; + if (b instanceof _) b = b._wrapped; + // Compare `[[Class]]` names. + var className = toString.call(a); + if (className !== toString.call(b)) return false; + switch (className) { + // Strings, numbers, regular expressions, dates, and booleans are compared by value. + case '[object RegExp]': + // RegExps are coerced to strings for comparison (Note: '' + /a/i === '/a/i') + case '[object String]': + // Primitives and their corresponding object wrappers are equivalent; thus, `"5"` is + // equivalent to `new String("5")`. + return '' + a === '' + b; + case '[object Number]': + // `NaN`s are equivalent, but non-reflexive. + // Object(NaN) is equivalent to NaN + if (+a !== +a) return +b !== +b; + // An `egal` comparison is performed for other numeric values. + return +a === 0 ? 1 / +a === 1 / b : +a === +b; + case '[object Date]': + case '[object Boolean]': + // Coerce dates and booleans to numeric primitive values. Dates are compared by their + // millisecond representations. Note that invalid dates with millisecond representations + // of `NaN` are not equivalent. + return +a === +b; + } + + var areArrays = className === '[object Array]'; + if (!areArrays) { + if (typeof a != 'object' || typeof b != 'object') return false; + + // Objects with different constructors are not equivalent, but `Object`s or `Array`s + // from different frames are. + var aCtor = a.constructor, bCtor = b.constructor; + if (aCtor !== bCtor && !(_.isFunction(aCtor) && aCtor instanceof aCtor && + _.isFunction(bCtor) && bCtor instanceof bCtor) + && ('constructor' in a && 'constructor' in b)) { + return false; + } + } + // Assume equality for cyclic structures. The algorithm for detecting cyclic + // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`. + + // Initializing stack of traversed objects. + // It's done here since we only need them for objects and arrays comparison. + aStack = aStack || []; + bStack = bStack || []; + var length = aStack.length; + while (length--) { + // Linear search. Performance is inversely proportional to the number of + // unique nested structures. + if (aStack[length] === a) return bStack[length] === b; + } + + // Add the first object to the stack of traversed objects. + aStack.push(a); + bStack.push(b); + + // Recursively compare objects and arrays. + if (areArrays) { + // Compare array lengths to determine if a deep comparison is necessary. + length = a.length; + if (length !== b.length) return false; + // Deep compare the contents, ignoring non-numeric properties. + while (length--) { + if (!eq(a[length], b[length], aStack, bStack)) return false; + } + } else { + // Deep compare objects. + var keys = _.keys(a), key; + length = keys.length; + // Ensure that both objects contain the same number of properties before comparing deep equality. + if (_.keys(b).length !== length) return false; + while (length--) { + // Deep compare each member + key = keys[length]; + if (!(_.has(b, key) && eq(a[key], b[key], aStack, bStack))) return false; + } + } + // Remove the first object from the stack of traversed objects. + aStack.pop(); + bStack.pop(); + return true; + }; + + // Perform a deep comparison to check if two objects are equal. + _.isEqual = function(a, b) { + return eq(a, b); + }; + + // Is a given array, string, or object empty? + // An "empty" object has no enumerable own-properties. + _.isEmpty = function(obj) { + if (obj == null) return true; + if (isArrayLike(obj) && (_.isArray(obj) || _.isString(obj) || _.isArguments(obj))) return obj.length === 0; + return _.keys(obj).length === 0; + }; + + // Is a given value a DOM element? + _.isElement = function(obj) { + return !!(obj && obj.nodeType === 1); + }; + + // Is a given value an array? + // Delegates to ECMA5's native Array.isArray + _.isArray = nativeIsArray || function(obj) { + return toString.call(obj) === '[object Array]'; + }; + + // Is a given variable an object? + _.isObject = function(obj) { + var type = typeof obj; + return type === 'function' || type === 'object' && !!obj; + }; + + // Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp, isError. + _.each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp', 'Error'], function(name) { + _['is' + name] = function(obj) { + return toString.call(obj) === '[object ' + name + ']'; + }; + }); + + // Define a fallback version of the method in browsers (ahem, IE < 9), where + // there isn't any inspectable "Arguments" type. + if (!_.isArguments(arguments)) { + _.isArguments = function(obj) { + return _.has(obj, 'callee'); + }; + } + + // Optimize `isFunction` if appropriate. Work around some typeof bugs in old v8, + // IE 11 (#1621), and in Safari 8 (#1929). + if (typeof /./ != 'function' && typeof Int8Array != 'object') { + _.isFunction = function(obj) { + return typeof obj == 'function' || false; + }; + } + + // Is a given object a finite number? + _.isFinite = function(obj) { + return isFinite(obj) && !isNaN(parseFloat(obj)); + }; + + // Is the given value `NaN`? (NaN is the only number which does not equal itself). + _.isNaN = function(obj) { + return _.isNumber(obj) && obj !== +obj; + }; + + // Is a given value a boolean? + _.isBoolean = function(obj) { + return obj === true || obj === false || toString.call(obj) === '[object Boolean]'; + }; + + // Is a given value equal to null? + _.isNull = function(obj) { + return obj === null; + }; + + // Is a given variable undefined? + _.isUndefined = function(obj) { + return obj === void 0; + }; + + // Shortcut function for checking if an object has a given property directly + // on itself (in other words, not on a prototype). + _.has = function(obj, key) { + return obj != null && hasOwnProperty.call(obj, key); + }; + + // Utility Functions + // ----------------- + + // Run Underscore.js in *noConflict* mode, returning the `_` variable to its + // previous owner. Returns a reference to the Underscore object. + _.noConflict = function() { + root._ = previousUnderscore; + return this; + }; + + // Keep the identity function around for default iteratees. + _.identity = function(value) { + return value; + }; + + // Predicate-generating functions. Often useful outside of Underscore. + _.constant = function(value) { + return function() { + return value; + }; + }; + + _.noop = function(){}; + + _.property = property; + + // Generates a function for a given object that returns a given property. + _.propertyOf = function(obj) { + return obj == null ? function(){} : function(key) { + return obj[key]; + }; + }; + + // Returns a predicate for checking whether an object has a given set of + // `key:value` pairs. + _.matcher = _.matches = function(attrs) { + attrs = _.extendOwn({}, attrs); + return function(obj) { + return _.isMatch(obj, attrs); + }; + }; + + // Run a function **n** times. + _.times = function(n, iteratee, context) { + var accum = Array(Math.max(0, n)); + iteratee = optimizeCb(iteratee, context, 1); + for (var i = 0; i < n; i++) accum[i] = iteratee(i); + return accum; + }; + + // Return a random integer between min and max (inclusive). + _.random = function(min, max) { + if (max == null) { + max = min; + min = 0; + } + return min + Math.floor(Math.random() * (max - min + 1)); + }; + + // A (possibly faster) way to get the current timestamp as an integer. + _.now = Date.now || function() { + return new Date().getTime(); + }; + + // List of HTML entities for escaping. + var escapeMap = { + '&': '&', + '<': '<', + '>': '>', + '"': '"', + "'": ''', + '`': '`' + }; + var unescapeMap = _.invert(escapeMap); + + // Functions for escaping and unescaping strings to/from HTML interpolation. + var createEscaper = function(map) { + var escaper = function(match) { + return map[match]; + }; + // Regexes for identifying a key that needs to be escaped + var source = '(?:' + _.keys(map).join('|') + ')'; + var testRegexp = RegExp(source); + var replaceRegexp = RegExp(source, 'g'); + return function(string) { + string = string == null ? '' : '' + string; + return testRegexp.test(string) ? string.replace(replaceRegexp, escaper) : string; + }; + }; + _.escape = createEscaper(escapeMap); + _.unescape = createEscaper(unescapeMap); + + // If the value of the named `property` is a function then invoke it with the + // `object` as context; otherwise, return it. + _.result = function(object, property, fallback) { + var value = object == null ? void 0 : object[property]; + if (value === void 0) { + value = fallback; + } + return _.isFunction(value) ? value.call(object) : value; + }; + + // Generate a unique integer id (unique within the entire client session). + // Useful for temporary DOM ids. + var idCounter = 0; + _.uniqueId = function(prefix) { + var id = ++idCounter + ''; + return prefix ? prefix + id : id; + }; + + // By default, Underscore uses ERB-style template delimiters, change the + // following template settings to use alternative delimiters. + _.templateSettings = { + evaluate : /<%([\s\S]+?)%>/g, + interpolate : /<%=([\s\S]+?)%>/g, + escape : /<%-([\s\S]+?)%>/g + }; + + // When customizing `templateSettings`, if you don't want to define an + // interpolation, evaluation or escaping regex, we need one that is + // guaranteed not to match. + var noMatch = /(.)^/; + + // Certain characters need to be escaped so that they can be put into a + // string literal. + var escapes = { + "'": "'", + '\\': '\\', + '\r': 'r', + '\n': 'n', + '\u2028': 'u2028', + '\u2029': 'u2029' + }; + + var escaper = /\\|'|\r|\n|\u2028|\u2029/g; + + var escapeChar = function(match) { + return '\\' + escapes[match]; + }; + + // JavaScript micro-templating, similar to John Resig's implementation. + // Underscore templating handles arbitrary delimiters, preserves whitespace, + // and correctly escapes quotes within interpolated code. + // NB: `oldSettings` only exists for backwards compatibility. + _.template = function(text, settings, oldSettings) { + if (!settings && oldSettings) settings = oldSettings; + settings = _.defaults({}, settings, _.templateSettings); + + // Combine delimiters into one regular expression via alternation. + var matcher = RegExp([ + (settings.escape || noMatch).source, + (settings.interpolate || noMatch).source, + (settings.evaluate || noMatch).source + ].join('|') + '|$', 'g'); + + // Compile the template source, escaping string literals appropriately. + var index = 0; + var source = "__p+='"; + text.replace(matcher, function(match, escape, interpolate, evaluate, offset) { + source += text.slice(index, offset).replace(escaper, escapeChar); + index = offset + match.length; + + if (escape) { + source += "'+\n((__t=(" + escape + "))==null?'':_.escape(__t))+\n'"; + } else if (interpolate) { + source += "'+\n((__t=(" + interpolate + "))==null?'':__t)+\n'"; + } else if (evaluate) { + source += "';\n" + evaluate + "\n__p+='"; + } + + // Adobe VMs need the match returned to produce the correct offest. + return match; + }); + source += "';\n"; + + // If a variable is not specified, place data values in local scope. + if (!settings.variable) source = 'with(obj||{}){\n' + source + '}\n'; + + source = "var __t,__p='',__j=Array.prototype.join," + + "print=function(){__p+=__j.call(arguments,'');};\n" + + source + 'return __p;\n'; + + try { + var render = new Function(settings.variable || 'obj', '_', source); + } catch (e) { + e.source = source; + throw e; + } + + var template = function(data) { + return render.call(this, data, _); + }; + + // Provide the compiled source as a convenience for precompilation. + var argument = settings.variable || 'obj'; + template.source = 'function(' + argument + '){\n' + source + '}'; + + return template; + }; + + // Add a "chain" function. Start chaining a wrapped Underscore object. + _.chain = function(obj) { + var instance = _(obj); + instance._chain = true; + return instance; + }; + + // OOP + // --------------- + // If Underscore is called as a function, it returns a wrapped object that + // can be used OO-style. This wrapper holds altered versions of all the + // underscore functions. Wrapped objects may be chained. + + // Helper function to continue chaining intermediate results. + var result = function(instance, obj) { + return instance._chain ? _(obj).chain() : obj; + }; + + // Add your own custom functions to the Underscore object. + _.mixin = function(obj) { + _.each(_.functions(obj), function(name) { + var func = _[name] = obj[name]; + _.prototype[name] = function() { + var args = [this._wrapped]; + push.apply(args, arguments); + return result(this, func.apply(_, args)); + }; + }); + }; + + // Add all of the Underscore functions to the wrapper object. + _.mixin(_); + + // Add all mutator Array functions to the wrapper. + _.each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) { + var method = ArrayProto[name]; + _.prototype[name] = function() { + var obj = this._wrapped; + method.apply(obj, arguments); + if ((name === 'shift' || name === 'splice') && obj.length === 0) delete obj[0]; + return result(this, obj); + }; + }); + + // Add all accessor Array functions to the wrapper. + _.each(['concat', 'join', 'slice'], function(name) { + var method = ArrayProto[name]; + _.prototype[name] = function() { + return result(this, method.apply(this._wrapped, arguments)); + }; + }); + + // Extracts the result from a wrapped and chained object. + _.prototype.value = function() { + return this._wrapped; + }; + + // Provide unwrapping proxy for some methods used in engine operations + // such as arithmetic and JSON stringification. + _.prototype.valueOf = _.prototype.toJSON = _.prototype.value; + + _.prototype.toString = function() { + return '' + this._wrapped; + }; + + // AMD registration happens at the end for compatibility with AMD loaders + // that may not enforce next-turn semantics on modules. Even though general + // practice for AMD registration is to be anonymous, underscore registers + // as a named module because, like jQuery, it is a base library that is + // popular enough to be bundled in a third party lib, but not be part of + // an AMD load request. Those cases could generate an error when an + // anonymous define() is called outside of a loader request. + if (typeof define === 'function' && define.amd) { + define('underscore', [], function() { + return _; + }); + } +}.call(this)); + +},{}],42:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +var xapiErrorLevels = Object.freeze({ + MAY_VIOLATION: 'MAY_VIOLATION', + MUST_VIOLATION: 'MUST_VIOLATION', + SHOULD_VIOLATION: 'SHOULD_VIOLATION' +}); + +var xapiValidationErrors = Object.freeze({ + ACTIVITIES_MUST_NOT_BE_NULL_MAP_OBJECTS: 'Activities must be non-null map objects', + ACTOR_MUST_BE_PROVIDED: 'Actor must be provided.', + AGENT_IFI_PROPERTIES_MUST_BE_SPECIFIED: 'Exactly one Inverse Functional Identifier property must be specified for an "agent".', + AGENT_MUST_BE_NON_NULL_MAP_OBJECT: '"agent" must be a non-null map object', + AGENT_MUST_NOT_HAVE_GROUP_CHARACTERISTICS: 'Invalid object with characteristics of a Group when an Agent was expected.', + ATTACHMENTS_MUST_BE_NOT_NULL_ARRAY: '"attachments" must be a non-null Array.', + ATTACHMENTS_MUST_NOT_BE_NULL_MAP_OBJECTS: '"attachment" instances must be non-null map objects.', + AUTHORITY_MUST_BE_NON_NULL_MAP_OBJECT: 'If present, the "authority" property must be a non-null map object.', + CONTEXT_ACTIVITIES_MUST_BE_ARRAY_OR_ACTIVITY_OBJ: 'Context Activities property values must be an array of Activity Objects or a single Activity Object.', + CONTEXT_ACTIVITIES_MUST_BE_NON_NULL_MAP_OBJECT: 'The Context Activities instances must be a non-null map object.', + CONTEXT_ACTIVITIES_MUST_NOT_BE_NULL: '"Context Activities" property values must not be null.', + CONTEXT_ACTIVITIES_SHOULD_BE_AN_ARRAY: 'Context Activities property values should prefer to be an array of Activities rather than a single Activity object.', + CONTEXT_MUST_BE_NON_NUL_MAP_OBJECT: 'If present, the "context" property must be a non-null map object.', + CORRECT_RESPONSES_PATTERN_MUST_BE_ARRAY: 'If present, the "correctResponsesPattern" value must be an Array of strings.', + CORRECT_RESPONSES_PATTERN_MUST_BE_STRINGS: '"correctResponsesPattern" items must be strings.', + DATE_MUST_BE_VALID: 'This propertys string value must be conformant to ISO 8601 for Date Times.', + DATE_SHOULD_INCLUDE_ZONE_INFORMATION: 'ISO 8601 date time strings used in the xAPI should include time zone information.', + DEFINITIONS_MUST_BE_OBJECTS: '"definitions", when present, must be map objects', + DISPLAY_SHOULD_BE_PROVIDED: '"display" property should be provided.', + DURATION_MUST_BE_VALID: 'If present, the "duration" property value must be an ISO 8601 duration', + EXTENSIONS_MUST_NOT_BE_NULL: 'If present, the extensions property must be a non-null map object.', + GROUP_AUTHORITY_AGENT_MEMBERS_MUST_BE_TWO: 'If used as a Group, the "authority" property must contain a "member" property that is an array containing exactly two Agent objects.', + GROUP_IFI_PROPERTIES_MUST_BE_SPECIFIED: 'Exactly one Inverse Functional Identifier property must be specified for a "group".', + GROUP_MEMBER_MUST_BE_ARRAY: 'If present, the member property of a Group must be an Array', + GROUP_MUST_BE_NON_NULL_MAP_OBJECT: '"group" must be a non-null map object', + ID_MUST_BE_UNIQUE: '"id" properties must be unique within each interaction component array', + ID_MUST_BE_VALID_UUID_REF: '"id" property value must be a valid UUID string for statement reference objects.', + ID_MUST_BE_VALID: 'Id was not a valid UUID', + ID_SHOULD_NOT_CONTAIN_WHITESPACES: '"id" properties on interaction components should not contain whitespace', + IDS_SHOULD_BE_GENERATED_BY_LRS: 'Ids should be generated by the Activity Provider, and must be generated by the LRS', + IFI_MUST_BE_MBOX_URI: '"mbox" property was required to be a mailto URI string but was not a string at all.', + IFI_MUST_BE_VALID_MBOX_FORMAT: '"mbox" property was required to be a mailto URI string but did not match the mailto format.', + INTERACTION_ACTIVITY_SHOULD_HAVE: 'Interaction Activity Definitions should have a type property of', + INTERACTION_COMPONENT_MUST_NOT_BE_NULL: 'This interaction component collection member must be a non-null map object', + INTERACTION_COMPONENT_SHOULD_BE_ARRAY: 'This interaction component collection property should be an array.', + INTERACTION_TYPE_MUST_BE_CMI: 'If present, the "interactionType" value must be a CMI interaction type option.', + INTERACTION_TYPE_MUST_BE_VALID: 'This interaction component collection property is not associated with the present interactionType of: ', + INVALID_JSON: 'Invalid JSON. The statement could not be parsed.', + LANGUAGE_MAP_KEY_INVALID: 'key, Language does not conform to RFC 5646', + LANGUAGE_MAP_KEY_MUST_BE_STRING: 'key: Language Map value should be a String, but was not', + LANGUAGE_MAPS_MUST_NOT_BE_NULL: 'Language Maps, when present, must be non-null map objects', + LANGUAGE_MUST_BE_STRING: 'The language property must be encoded as an RFC 5646 compliant string, but was not.', + LENGTH_MUST_BE_INTEGER: '"length" property must be provided with an integer value', + MAX_MUST_BE_GREATER_THAN_MIN: 'If both "max" and "min" are present, the max property value should be greater than min', + MEMBER_MUST_BE_PROVIDED_FOR_ANONYMOUS_GROUPS: '"member" property must be provided for Anonymous Groups.', + MUST_BE_BOOLEAN_PRESENT: 'property was required to be a Boolean but was absent.', + MUST_BE_BOOLEAN: 'property, if present, must be a Boolean.', + MUST_BE_IRI_STRING: 'property, if present, should be a IRI-like absolute URI per RFC 3987.', + MUST_BE_NUMBER_PRESENT: 'property was required to be a Number but was absent.', + MUST_BE_NUMBER: 'property, if present, must be a Number.', + MUST_BE_PRESENT: 'property was required to be a string but was absent.', + MUST_BE_STRING: 'property, if present, must be a string.', + MUST_BE_URI_PRESENT: 'property was required to be a URI string but was absent.', + MUST_BE_URI_STRING: 'property, if present, must be a URI string.', + OBJECT_MUST_BE_DEFINED: '"object" property must be provided.', + OBJECT_MUST_BE_NON_NULL_MAP_OBJECT: '"object" property must be a non-null map object.', + OBJECT_TYPE_MUST_BE_STATEMENT_REF: '"objectType" property value must be "StatementRef" for statement reference objects.', + OBJECT_TYPE_MUST_BE_VALID_OPTION: 'object\'s "objectType" did not match a valid option', + RAW_MUST_BE_GREATER_THAN_MIN: 'If both "raw" and "min" are present, the raw property value should be greater than min', + RAW_MUST_BE_LESS_THAN_MAX: 'If both "raw" and "max" are present, the raw property value should be less than max', + REGISTRATION_MUST_BE_UUID_STRING: 'If present, the registration property must be a UUID string.', + RESULT_MUST_BE_MAP_OBJECT: 'If present, the result must be a map object', + REVISION_MUST_BE_AGENT_OR_GROUP: 'The revision property must not be used if the Statement\'s Object is an Agent or Group.', + SCALED_MUST_BE_BETWEEN_0_1: 'If present, the scaled property value must be between 0 and 1', + SHA2_MUST_BE_PROVIDED_ON_ATTACHMENT_OBJECTS: '"sha2" property must be provided on attachment objects', + SHA2_MUST_CONTAIN_BASE_64_STRING: '"sha2" property must contain a string with base64 contents', + STATEMENT_ARGUMENT_IS_NOT_VALID: 'Statement argument provided was not a valid object or a valid JSON string.', + STATEMENT_ARGUMENT_MUST_BE_PROVIDED: 'No statement argument provided.', + STATEMENT_MUST_BE_PARSED_CORRECTLY: 'Null or non-object statement value parsed from provided statment JSON.', + STATEMENT_MUST_NOT_BE_NULL: 'Null statement argument provided.', + STATEMENT_REF_MUST_NOT_BE_NULL_MAP_OBJECTS: 'StatementRef instances must be non-null map objects', + SUB_STATEMENT_MUST_NOT_CONTAIN_SUB_STATEMENT: 'A SubStatement must not contain a SubStatement', + UNEXPECTED: 'Unexpected property not permitted', + VERB_MUST_BE_PROVIDED: 'Verb must be provided', + VERB_MUST_NOT_BE_NULL: 'Verb property value must a non-null map object.', + VERSION_MUST_COMPLY_SEMANTIC_VERSIONING: '"version" must be a non-null string that complies with Semantic Versioning 1.0.0' +}); + +exports.xapiErrorLevels = xapiErrorLevels; +exports.xapiValidationErrors = xapiValidationErrors; + +},{}],43:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +var xapiGeneral = Object.freeze({ + FIRST_REPORT_VERSTION: '1.0.0', + GROUP_AUTHORITY_AGENT_MEMBERS: 2, + INTERACTION_DEFINITION_TYPE: 'http://adlnet.gov/expapi/activities/cmi.interaction', + MAX_SCALED_VALUE: 1, + MIN_SCALED_VALUE: 0, + NO_INDEX_FOUND: -1, + NUMER_OF_SPECIFIED_IFI_PROPERTIES: 1 +}); + +exports.xapiGeneral = xapiGeneral; + +},{}],44:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +var interactionTypes = exports.interactionTypes = Object.freeze({ + CHOICE: 'choice', + FILL_IN: 'fill-in', + LIKERT: 'likert', + LONG_FILL_IN: 'long-fill-in', + MATCHING: 'matching', + NUMERIC: 'numeric', + OTHER: 'other', + PERFORMANCE: 'performance', + SEQUENCING: 'sequencing', + TRUE_FALSE: 'true-false' +}); + +var xapiValidationInteractionTypes = exports.xapiValidationInteractionTypes = Object.freeze([interactionTypes.CHOICE, interactionTypes.FILL_IN, interactionTypes.LIKERT, interactionTypes.LONG_FILL_IN, interactionTypes.MATCHING, interactionTypes.NUMERIC, interactionTypes.OTHER, interactionTypes.PERFORMANCE, interactionTypes.SEQUENCING, interactionTypes.TRUE_FALSE]); + +},{}],45:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +var properties = Object.freeze({ + ACCOUNT: 'account', + ACTIVITY: 'activity', + ACTOR: 'actor', + AGENT: 'agent', + ATTACHMENT: 'attachment', + ATTACHMENTS: 'attachments', + AUTHORITY: 'authority', + CATEGORY: 'category', + CHOICE: 'choice', + CHOICES: 'choices', + COMPLETION: 'completion', + CONTENT_TYPE: 'contentType', + CONTEXT_ACTIVITIES: 'contextActivities', + CONTEXT: 'context', + CORRECT_RESPONSES_PATTERN: 'correctResponsesPattern', + DATE_TIME: 'dateTime', + DEFINITION: 'definition', + DESCRIPTION: 'description', + DISPLAY: 'display', + DURATION: 'duration', + EXTENSIONS: 'extensions', + FILE_URL: 'fileUrl', + GROUP: 'group', + GROUPING: 'grouping', + HOME_PAGE: 'homePage', + ID: 'id', + INSTRUCTOR: 'instructor', + INTERACTION_COMPONENTS: 'interactionComponents', + INTERACTION_TYPE: 'interactionType', + LANGUAGE_MAP: 'languageMap', + LANGUAGE: 'language', + LENGTH: 'length', + LIKERT: 'likert', + MATCHING: 'matching', + MAX: 'max', + MBOX_SHA_1_SUM: 'mbox_sha1sum', + MBOX: 'mbox', + MEMBER: 'member', + MIN: 'min', + MORE_INFO: 'moreInfo', + NAME: 'name', + OBJECT_TYPE: 'objectType', + OBJECT: 'object', + OPEN_ID: 'openID', + OTHER: 'other', + PARENT: 'parent', + PERFORMANCE: 'performance', + PLATFORM: 'platform', + RAW: 'raw', + REGISTRATION: 'registration', + RESPONSE: 'response', + RESULT: 'result', + REVISION: 'revision', + SCALE: 'scale', + SCALED: 'scaled', + SCORE: 'score', + SEQUENCING: 'sequencing', + SHA2: 'sha2', + SOURCE: 'source', + STATEMENT_REF: 'statementRef', + STATEMENT: 'statement', + STEPS: 'steps', + STORED: 'stored', + SUB_CONTEXT: 'subContext', + SUCCESS: 'success', + TARGET: 'target', + TEAM: 'team', + TIMESTAMP: 'timestamp', + TYPE: 'type', + USAGE_TYPE: 'usageType', + VERB: 'verb', + VERSION: 'version' +}); + +var objectTypes = Object.freeze({ + GROUP: 'Group', + AGENT: 'Agent', + ACTIVITY: 'Activity', + STATEMENT_REF: 'StatementRef', + SUB_STATEMENT: 'SubStatement' +}); + +var xapiValidationIfiPropertyNames = Object.freeze([properties.ACCOUNT, properties.MBOX_SHA_1_SUM, properties.MBOX, properties.OPEN_ID]); + +var xApiValidObjectTypes = Object.freeze([objectTypes.GROUP, objectTypes.AGENT, objectTypes.ACTIVITY, objectTypes.STATEMENT_REF, objectTypes.SUB_STATEMENT]); + +var xapiWhiteListProperties = Object.freeze({ + IFI: [properties.HOME_PAGE, properties.NAME], + URI: [properties.ID, properties.DISPLAY], + COMPONENT_ARRAY: [properties.ID, properties.DESCRIPTION], + ACTIVITY_DEFINITION: [properties.NAME, properties.DESCRIPTION, properties.TYPE, properties.MORE_INFO, properties.EXTENSIONS, properties.INTERACTION_TYPE, properties.CORRECT_RESPONSES_PATTERN, properties.CHOICES, properties.SCALE, properties.SOURCE, properties.TARGET, properties.STEPS], + ACTIVITY: [properties.OBJECT_TYPE, properties.ID, properties.DEFINITION], + STATEMENT_REF: [properties.ID, properties.OBJECT_TYPE], + SCORE: [properties.SCALED, properties.RAW, properties.MIN, properties.MAX], + RESULT: [properties.SCORE, properties.SUCCESS, properties.COMPLETION, properties.RESPONSE, properties.DURATION, properties.EXTENSIONS], + ATTACHMENT: [properties.USAGE_TYPE, properties.DISPLAY, properties.DESCRIPTION, properties.CONTENT_TYPE, properties.LENGTH, properties.SHA2, properties.FILE_URL], + AGENT: [properties.OBJECT_TYPE, properties.NAME, properties.ACCOUNT, properties.MBOX_SHA_1_SUM, properties.MBOX, properties.OPEN_ID], + GROUP: [properties.OBJECT_TYPE, properties.NAME, properties.MEMBER, properties.ACCOUNT, properties.MBOX_SHA_1_SUM, properties.MBOX, properties.OPEN_ID], + CONTEXT_ACTIVITIES: [properties.PARENT, properties.GROUPING, properties.CATEGORY, properties.OTHER], + STATEMENT: [properties.ID, properties.ACTOR, properties.VERB, properties.OBJECT, properties.RESULT, properties.CONTEXT, properties.TIMESTAMP, properties.STORED, properties.AUTHORITY, properties.VERSION, properties.ATTACHMENTS], + SUB_STATEMENT: [properties.ACTOR, properties.VERB, properties.OBJECT, properties.RESULT, properties.CONTEXT, properties.TIMESTAMP, properties.ATTACHMENTS, properties.OBJECT_TYPE], + EXTENSIONS: [properties.REGISTRATION, properties.INSTRUCTOR, properties.TEAM, properties.CONTEXT_ACTIVITIES, properties.REVISION, properties.PLATFORM, properties.LANGUAGE, properties.STATEMENT, properties.EXTENSIONS] +}); + +exports.properties = properties; +exports.objectTypes = objectTypes; +exports.xapiValidationIfiPropertyNames = xapiValidationIfiPropertyNames; +exports.xApiValidObjectTypes = xApiValidObjectTypes; +exports.xapiWhiteListProperties = xapiWhiteListProperties; + +},{}],46:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +var xapiValidationRegex = Object.freeze({ + UUID: /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i, + ISO_8601_DURATION: /^P((\d+([\.,]\d+)?Y)?(\d+([\.,]\d+)?M)?(\d+([\.,]\d+)?W)?(\d+([\.,]\d+)?D)?)?(T(\d+([\.,]\d+)?H)?(\d+([\.,]\d+)?M)?(\d+([\.,]\d+)?S)?)?$/, + ISO_8601_DATE_TIME: /^(\d{4}|[+\-]\d{6})(?:-(\d{2})(?:-(\d{2}))?)?(?:T(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{3}))?)?(?:(Z)|([+\-])(\d{2})(?::(\d{2}))?)?)?$/, + MAILTO_URI: /^mailto:/, + CONTAINS_WHITESPACE: /\s/g, + SEMVER_1_P_0_P_0: /^((\d+)\.(\d+)\.(\d+))(?:-([\dA-Za-z\-]+))?$/, + BASE_64: /^(?:[A-Za-z0-9\+\/]{4})*(?:[A-Za-z0-9\+\/]{2}==|[A-Za-z0-9\+\/]{3}=|[A-Za-z0-9\+\/]{4})$/, + IRI: /^[a-z](?:[\-a-z0-9\+\.])*:(?:\/\/(?:(?:%[0-9a-f][0-9a-f]|[\-a-z0-9\._~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF\u10000-\u1FFFD\u20000-\u2FFFD\u30000-\u3FFFD\u40000-\u4FFFD\u50000-\u5FFFD\u60000-\u6FFFD\u70000-\u7FFFD\u80000-\u8FFFD\u90000-\u9FFFD\uA0000-\uAFFFD\uB0000-\uBFFFD\uC0000-\uCFFFD\uD0000-\uDFFFD\uE1000-\uEFFFD!\$&'\(\)\*\+,;=:])*@)?(?:\[(?:(?:(?:[0-9a-f]{1,4}:){6}(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3})|::(?:[0-9a-f]{1,4}:){5}(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3})|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3})|(?:[0-9a-f]{1,4}:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3})|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3})|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3})|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3})|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|v[0-9a-f]+[\-a-z0-9\._~!\$&'\(\)\*\+,;=:]+)\]|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3}|(?:%[0-9a-f][0-9a-f]|[\-a-z0-9\._~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF\u10000-\u1FFFD\u20000-\u2FFFD\u30000-\u3FFFD\u40000-\u4FFFD\u50000-\u5FFFD\u60000-\u6FFFD\u70000-\u7FFFD\u80000-\u8FFFD\u90000-\u9FFFD\uA0000-\uAFFFD\uB0000-\uBFFFD\uC0000-\uCFFFD\uD0000-\uDFFFD\uE1000-\uEFFFD!\$&'\(\)\*\+,;=@])*)(?::[0-9]*)?(?:\/(?:(?:%[0-9a-f][0-9a-f]|[\-a-z0-9\._~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF\u10000-\u1FFFD\u20000-\u2FFFD\u30000-\u3FFFD\u40000-\u4FFFD\u50000-\u5FFFD\u60000-\u6FFFD\u70000-\u7FFFD\u80000-\u8FFFD\u90000-\u9FFFD\uA0000-\uAFFFD\uB0000-\uBFFFD\uC0000-\uCFFFD\uD0000-\uDFFFD\uE1000-\uEFFFD!\$&'\(\)\*\+,;=:@]))*)*|\/(?:(?:(?:(?:%[0-9a-f][0-9a-f]|[\-a-z0-9\._~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF\u10000-\u1FFFD\u20000-\u2FFFD\u30000-\u3FFFD\u40000-\u4FFFD\u50000-\u5FFFD\u60000-\u6FFFD\u70000-\u7FFFD\u80000-\u8FFFD\u90000-\u9FFFD\uA0000-\uAFFFD\uB0000-\uBFFFD\uC0000-\uCFFFD\uD0000-\uDFFFD\uE1000-\uEFFFD!\$&'\(\)\*\+,;=:@]))+)(?:\/(?:(?:%[0-9a-f][0-9a-f]|[\-a-z0-9\._~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF\u10000-\u1FFFD\u20000-\u2FFFD\u30000-\u3FFFD\u40000-\u4FFFD\u50000-\u5FFFD\u60000-\u6FFFD\u70000-\u7FFFD\u80000-\u8FFFD\u90000-\u9FFFD\uA0000-\uAFFFD\uB0000-\uBFFFD\uC0000-\uCFFFD\uD0000-\uDFFFD\uE1000-\uEFFFD!\$&'\(\)\*\+,;=:@]))*)*)?|(?:(?:(?:%[0-9a-f][0-9a-f]|[\-a-z0-9\._~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF\u10000-\u1FFFD\u20000-\u2FFFD\u30000-\u3FFFD\u40000-\u4FFFD\u50000-\u5FFFD\u60000-\u6FFFD\u70000-\u7FFFD\u80000-\u8FFFD\u90000-\u9FFFD\uA0000-\uAFFFD\uB0000-\uBFFFD\uC0000-\uCFFFD\uD0000-\uDFFFD\uE1000-\uEFFFD!\$&'\(\)\*\+,;=:@]))+)(?:\/(?:(?:%[0-9a-f][0-9a-f]|[\-a-z0-9\._~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF\u10000-\u1FFFD\u20000-\u2FFFD\u30000-\u3FFFD\u40000-\u4FFFD\u50000-\u5FFFD\u60000-\u6FFFD\u70000-\u7FFFD\u80000-\u8FFFD\u90000-\u9FFFD\uA0000-\uAFFFD\uB0000-\uBFFFD\uC0000-\uCFFFD\uD0000-\uDFFFD\uE1000-\uEFFFD!\$&'\(\)\*\+,;=:@]))*)*|(?!(?:%[0-9a-f][0-9a-f]|[\-a-z0-9\._~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF\u10000-\u1FFFD\u20000-\u2FFFD\u30000-\u3FFFD\u40000-\u4FFFD\u50000-\u5FFFD\u60000-\u6FFFD\u70000-\u7FFFD\u80000-\u8FFFD\u90000-\u9FFFD\uA0000-\uAFFFD\uB0000-\uBFFFD\uC0000-\uCFFFD\uD0000-\uDFFFD\uE1000-\uEFFFD!\$&'\(\)\*\+,;=:@])))(?:\?(?:(?:%[0-9a-f][0-9a-f]|[\-a-z0-9\._~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF\u10000-\u1FFFD\u20000-\u2FFFD\u30000-\u3FFFD\u40000-\u4FFFD\u50000-\u5FFFD\u60000-\u6FFFD\u70000-\u7FFFD\u80000-\u8FFFD\u90000-\u9FFFD\uA0000-\uAFFFD\uB0000-\uBFFFD\uC0000-\uCFFFD\uD0000-\uDFFFD\uE1000-\uEFFFD!\$&'\(\)\*\+,;=:@])|[\uE000-\uF8FF\uF0000-\uFFFFD|\u100000-\u10FFFD\/\?])*)?(?:\#(?:(?:%[0-9a-f][0-9a-f]|[\-a-z0-9\._~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF\u10000-\u1FFFD\u20000-\u2FFFD\u30000-\u3FFFD\u40000-\u4FFFD\u50000-\u5FFFD\u60000-\u6FFFD\u70000-\u7FFFD\u80000-\u8FFFD\u90000-\u9FFFD\uA0000-\uAFFFD\uB0000-\uBFFFD\uC0000-\uCFFFD\uD0000-\uDFFFD\uE1000-\uEFFFD!\$&'\(\)\*\+,;=:@])|[\/\?])*)?$/i, + BCP_47: /^(?:(en-GB-oed|i-(?:ami|bnn|default|enochian|hak|klingon|lux|mingo|navajo|pwn|tao|tay|tsu)|sgn-(?:BE-FR|BE-NL|CH-DE))|(art-lojban|cel-gaulish|no-(?:bok|nyn)|zh-(?:guoyu|hakka|min|min-nan|xiang)))$|^(x(?:-[0-9a-z]{1,8})+)$|^(?:((?:[a-z]{2,3}(?:(?:-[a-z]{3}){1,3})?)|[a-z]{4}|[a-z]{5,8})(?:-([a-z]{4}))?(?:-([a-z]{2}|[0-9]{3}))?((?:-(?:[a-z0-9]{5,8}|[0-9][a-z0-9]{3}))*)?((?:-[0-9a-wy-z](?:-[a-z0-9]{2,8}){1,})*)?(-x(?:-[0-9a-z]{1,8})+)?)$/i +}); + +var dateFormatRegexPositions = Object.freeze({ + YEAR: 1, + MONTH: 2, + DAY: 3, + HOUR: 4, + MINUTE: 5, + SECOND: 6, + MSECOND: 7, + ZONE: 8, + RELATIVE_TIME: 9, + TIME_ZONE_HOUR: 10, + TIME_ZONE_MINUTE: 11 +}); + +exports.xapiValidationRegex = xapiValidationRegex; +exports.dateFormatRegexPositions = dateFormatRegexPositions; + +},{}],47:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +var IS_STRING = '[object String]', + IS_ARRAY = '[object Array]', + IS_BOOLEAN = '[object Boolean]', + IS_NUMBER = '[object Number]'; + +var toString = Object.prototype.toString; +var xapiValidationUtils; + +exports.xapiValidationUtils = xapiValidationUtils = { + isString: function isString(obj) { + return toString.call(obj) === IS_STRING; + }, + isObject: function isObject(obj) { + return obj === Object(obj); + }, + + + isArray: Array.isArray || function (obj) { + return toString.call(obj) === IS_ARRAY; + }, + + isBoolean: function isBoolean(obj) { + return obj === true || obj === false || toString.call(obj) === IS_BOOLEAN; + }, + isNumber: function isNumber(obj) { + return toString.call(obj) === IS_NUMBER; + }, + isDefined: function isDefined(obj) { + return obj !== null || obj !== undefined; + }, + isNonNullMapObject: function isNonNullMapObject(target) { + return this.isDefined(target) && this.isObject(target) && !this.isArray(target); + }, + isValidLanguageTag: function isValidLanguageTag(target, validLanguageRegex) { + // TODO - use more precise 5646 handling, rather than this simplified BCP 47 regex, which combines RFC 5646 and RFC 4647. + // return this.isDefined(target) && this.isString(target) && xapiValidationRegex.BCP_47.test(target); + return this.isDefined(target) && this.isString(target) && validLanguageRegex.test(target); + }, + addPropToTrace: function addPropToTrace(trace, addendum) { + return this.isDefined(addendum) ? trace + '.' + addendum : trace; + }, + addLookupToTrace: function addLookupToTrace(trace, key) { + return !this.isDefined(key) ? trace : this.isNumber(key) ? trace + '[' + key + ']' : trace + '["' + key + '"]'; + }, + localTraceToString: function localTraceToString(trace, addendum) { + return this.addPropToTrace(trace, addendum); + }, + isGroup: function isGroup(actorOrGroup, groupType) { + // return (actorOrGroup.member !== null && actorOrGroup.member !== undefined) || actorOrGroup.objectType === objectTypes.GROUP; + return actorOrGroup.member !== null && actorOrGroup.member !== undefined || actorOrGroup.objectType === groupType; + } +}; + +exports.xapiValidationUtils = xapiValidationUtils; + +},{}],48:[function(require,module,exports){ +'use strict'; + +var _properties = require('./constants/properties'); + +var _errors = require('./constants/errors'); + +var _interactionTypes = require('./constants/interaction-types'); + +var _regex = require('./constants/regex'); + +var _general = require('./constants/general'); + +var _utils = require('./utils/utils'); + +var xapiValidation; + +function makeV1Report(instance, errors) { + var version; + + instance = instance || null; + errors = errors || null; + version = _general.xapiGeneral.FIRST_REPORT_VERSTION; + return { instance: instance, errors: errors, version: version }; +} + +function makeV1SingleErrorReport(instance, error) { + return makeV1Report(instance, error === null || error === undefined ? [] : [error]); +} + +function validateAbsenceOfNonWhitelistedProperties(target, allowedProperties, trace, errors) { + var localErrors, localTrace, propertyName; + + localErrors = errors || []; + localTrace = trace || ''; + + for (propertyName in target) { + if (target.hasOwnProperty(propertyName) && allowedProperties.indexOf(propertyName) === _general.xapiGeneral.NO_INDEX_FOUND) { + localErrors.push({ + trace: _utils.xapiValidationUtils.addPropToTrace(localTrace, propertyName), + message: _errors.xapiValidationErrors.UNEXPECTED, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + } + + return localErrors; +} + +function validatePropertyIsString(parent, propertyName, trace, errors, isRequired, violationType) { + var localErrors, localTrace, propValue, localViolationType; + + localErrors = errors || []; + localTrace = trace || ''; + propValue = parent[propertyName], localViolationType = violationType || _errors.xapiErrorLevels.MUST_VIOLATION; + + if (propValue !== undefined) { + if (propValue === null || !_utils.xapiValidationUtils.isString(propValue)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace, propertyName), + message: propertyName + ' ' + _errors.xapiValidationErrors.MUST_BE_STRING, + level: localViolationType + }); + } + } else if (isRequired) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace, propertyName), + message: propertyName + ' ' + _errors.xapiValidationErrors.MUST_BE_PRESENT, + level: localViolationType + }); + } + + return localErrors; +} + +function validatePropertyIsUri(target, propertyName, trace, errors, isRequired) { + var localErrors, localTrace, propValue; + + localErrors = errors || []; + localTrace = trace || ''; + propValue = target[propertyName]; + + if (propValue !== undefined) { + if (propValue === null || !_utils.xapiValidationUtils.isString(propValue)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace, propertyName), + message: propertyName + ' ' + _errors.xapiValidationErrors.MUST_BE_URI_STRING, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } else if (!_regex.xapiValidationRegex.IRI.test(propValue)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace, propertyName), + message: propertyName + ' ' + _errors.xapiValidationErrors.MUST_BE_IRI_STRING, + level: _errors.xapiErrorLevels.SHOULD_VIOLATION + }); + } + } else if (isRequired) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace, propertyName), + message: propertyName + ' ' + _errors.xapiValidationErrors.MUST_BE_URI_PRESENT, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + return localErrors; +} + +function validatePropertyIsUrl(target, propertyName, trace, errors, isRequired) { + // TODO - check whether a formal URL format definition is recommended/enforced for xAPI + return validatePropertyIsString(target, propertyName, trace, errors, isRequired); +} + +function validatePropertyIsBoolean(parent, propertyName, trace, errors, isRequired) { + var localErrors, localTrace, propValue; + + localErrors = errors || []; + localTrace = trace || ''; + propValue = parent[propertyName]; + + if (propValue !== undefined) { + if (propValue === null || !_utils.xapiValidationUtils.isBoolean(propValue)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace, propertyName), + message: propertyName + ' ' + _errors.xapiValidationErrors.MUST_BE_BOOLEAN, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + } else if (isRequired) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace, propertyName), + message: propertyName + ' ' + _errors.xapiValidationErrors.MUST_BE_BOOLEAN_PRESENT, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + return localErrors; +} + +function validatePropertyIsNumber(parent, propertyName, trace, errors, isRequired) { + var localErrors, localTrace, propValue; + + localErrors = errors || []; + localTrace = trace || ''; + propValue = parent[propertyName]; + + if (propValue !== undefined) { + if (propValue === null || !_utils.xapiValidationUtils.isNumber(propValue)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace, propertyName), + message: propertyName + ' ' + _errors.xapiValidationErrors.MUST_BE_NUMBER, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + } else if (isRequired) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace, propertyName), + message: propertyName + ' ' + _errors.xapiValidationErrors.MUST_BE_NUMBER_PRESENT, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + return localErrors; +} + +function validateIFIProperties(target, trace, errors) { + var localErrors, localTrace, accountTrace; + + localErrors = errors || []; + localTrace = trace || ''; + + if (target.mbox !== undefined && target.mbox !== null) { + if (!_utils.xapiValidationUtils.isString(target.mbox)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace, _properties.properties.MBOX), + message: _errors.xapiValidationErrors.IFI_MUST_BE_MBOX_URI, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } else if (!_regex.xapiValidationRegex.MAILTO_URI.test(target.mbox)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace, _properties.properties.MBOX), + message: _errors.xapiValidationErrors.IFI_MUST_BE_VALID_MBOX_FORMAT, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + } + + validatePropertyIsString(target, _properties.properties.MBOX_SHA_1_SUM, localTrace, localErrors, /*isRequired*/false); + validatePropertyIsUri(target, _properties.properties.OPEN_ID, localTrace, localErrors, /*isRequired*/false); + + if (target.account !== undefined && target.account !== null) { + accountTrace = _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.ACCOUNT); + validatePropertyIsUri(target.account, _properties.properties.HOME_PAGE, accountTrace, localErrors, /*isRequired*/true); + validatePropertyIsString(target.account, _properties.properties.NAME, accountTrace, localErrors, /*isRequired*/true); + validateAbsenceOfNonWhitelistedProperties(target.account, _properties.xapiWhiteListProperties.IFI, accountTrace, localErrors); + } + + return localErrors; +} + +function getIFIs(target) { + var ifis; + + if (target === null || target === undefined) { + return []; + } + + ifis = _properties.xapiValidationIfiPropertyNames.filter(function (name) { + if (target[name] !== undefined && target[name] !== null) { + return { key: name, value: target[name] }; + } + }); + + return ifis; +} + +function getIFICount(target) { + return getIFIs(target).length; +} + +function validateExtensions(extensions, trace, errors) { + var localErrors, localTrace; + + localErrors = errors || [], localTrace = trace || _properties.properties.EXTENSIONS; + + if (extensions === undefined) { + return localErrors; + } + + if (!_utils.xapiValidationUtils.isNonNullMapObject(extensions)) { + localErrors.push({ + trace: localTrace, + message: _errors.xapiValidationErrors.EXTENSIONS_MUST_NOT_BE_NULL, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + // TODO - double-check what further enforceable constraints exist on extension object properties + return localErrors; +} + +function validateLanguageMap(languageMap, trace, errors) { + var localErrors, localTrace, propName, mappedValue; + + localErrors = errors || []; + localTrace = trace || _properties.properties.LANGUAGE_MAP; + + if (languageMap === undefined) { + return localErrors; + } + + if (!_utils.xapiValidationUtils.isNonNullMapObject(languageMap)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.addPropToTrace(localTrace), + message: _errors.xapiValidationErrors.LANGUAGE_MAPS_MUST_NOT_BE_NULL, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + + return localErrors; + } + + for (propName in languageMap) { + + if (languageMap.hasOwnProperty(propName)) { + if (!_utils.xapiValidationUtils.isValidLanguageTag(propName, _regex.xapiValidationRegex.BCP_47)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.addPropToTrace(localTrace, propName), + message: propName + ' ' + _errors.xapiValidationErrors.LANGUAGE_MAP_KEY_INVALID, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + + mappedValue = languageMap[propName]; + + if (mappedValue === null || mappedValue === undefined || !_utils.xapiValidationUtils.isString(mappedValue)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.addLookupToTrace(localTrace, propName), + message: propName + ' ' + _errors.xapiValidationErrors.LANGUAGE_MAP_KEY_MUST_BE_STRING, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + } + } + + return localErrors; +} + +function validateVerb(verb, trace, errors) { + var localErrors, localTrace; + + localErrors = errors || []; + localTrace = trace || _properties.properties.VERB; + + if (verb === undefined) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace), + message: _errors.xapiValidationErrors.VERB_MUST_BE_PROVIDED, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + + return localErrors; + } + + if (!_utils.xapiValidationUtils.isNonNullMapObject(verb)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace), + message: _errors.xapiValidationErrors.VERB_MUST_NOT_BE_NULL, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + + return localErrors; + } + + validatePropertyIsUri(verb, _properties.properties.ID, localTrace, localErrors, /*isRequired*/true); + + if (verb.display === undefined) { + localErrors.push({ + trace: _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.DISPLAY), + message: _errors.xapiValidationErrors.DISPLAY_SHOULD_BE_PROVIDED, + level: _errors.xapiErrorLevels.SHOULD_VIOLATION + }); + } else { + validateLanguageMap(verb.display, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.DISPLAY), localErrors); + } + + validateAbsenceOfNonWhitelistedProperties(verb, _properties.xapiWhiteListProperties.URI, localTrace, localErrors); + + return localErrors; +} + +function validateInteractionComponentArray(components, interactionType, allowedInteractionTypes, trace, errors) { + var localErrors, localTrace, isAllowedComponentType, ids, perComponentTrace; + + localErrors = errors || []; + localTrace = trace || _properties.properties.INTERACTION_COMPONENTS; + isAllowedComponentType = allowedInteractionTypes.indexOf(interactionType) !== _general.xapiGeneral.NO_INDEX_FOUND; + ids = []; + + if (isAllowedComponentType && components !== undefined) { + if (components === null || !_utils.xapiValidationUtils.isArray(components)) { + localErrors.push({ + trace: localTrace, + message: _errors.xapiValidationErrors.INTERACTION_COMPONENT_SHOULD_BE_ARRAY, + level: _errors.xapiErrorLevels.SHOULD_VIOLATION + }); + } else { + components.forEach(function (interactionComponent, i) { + perComponentTrace = _utils.xapiValidationUtils.addLookupToTrace(localTrace, i); + + if (!_utils.xapiValidationUtils.isNonNullMapObject(interactionComponent)) { + localErrors.push({ + trace: perComponentTrace, + message: _errors.xapiValidationErrors.INTERACTION_COMPONENT_MUST_NOT_BE_NULL, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } else { + validatePropertyIsString(interactionComponent, _properties.properties.ID, perComponentTrace, localErrors, /*isRequired*/true, _errors.xapiErrorLevels.MUST_VIOLATION); + if (ids.indexOf(interactionComponent.id) !== _general.xapiGeneral.NO_INDEX_FOUND) { + localErrors.push({ + trace: _utils.xapiValidationUtils.addPropToTrace(perComponentTrace, _properties.properties.ID), + message: _errors.xapiValidationErrors.ID_MUST_BE_UNIQUE, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } else { + ids.push(interactionComponent.id); + } + + if (interactionComponent.id && _regex.xapiValidationRegex.CONTAINS_WHITESPACE.test(interactionComponent.id)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.addPropToTrace(perComponentTrace, _properties.properties.ID), + message: _errors.xapiValidationErrors.ID_SHOULD_NOT_CONTAIN_WHITESPACES, + level: _errors.xapiErrorLevels.SHOULD_VIOLATION + }); + } + + validateLanguageMap(interactionComponent.description, _utils.xapiValidationUtils.addPropToTrace(perComponentTrace, _properties.properties.DESCRIPTION), localErrors); + validateAbsenceOfNonWhitelistedProperties(interactionComponent, _properties.xapiWhiteListProperties.COMPONENT_ARRAY, perComponentTrace, localErrors); + } + }); + } + } else if (interactionType && components) { + localErrors.push({ + trace: localTrace, + message: _errors.xapiValidationErrors.INTERACTION_TYPE_MUST_BE_VALID + ' ' + interactionType, + level: _errors.xapiErrorLevels.SHOULD_VIOLATION + }); + } + + return localErrors; +} + +function validateActivityDefintion(definition, trace, errors) { + var localErrors, localTrace, correctResponsesPatternTrace; + + localErrors = errors || []; + localTrace = trace || _properties.properties.DEFINITION; + correctResponsesPatternTrace = _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.CORRECT_RESPONSES_PATTERN); + + if (!_utils.xapiValidationUtils.isNonNullMapObject(definition)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.addPropToTrace(localTrace), + message: _errors.xapiValidationErrors.DEFINITIONS_MUST_BE_OBJECTS, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + + return localErrors; + } + + validateLanguageMap(definition.name, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.NAME), localErrors); + validateLanguageMap(definition.description, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.DESCRIPTION), localErrors); + + validatePropertyIsUri(definition, _properties.properties.TYPE, localTrace, localErrors, /*isRequired*/false); + validatePropertyIsUrl(definition, _properties.properties.MORE_INFO, localTrace, localErrors, /*isRequired*/false); + validateExtensions(definition.extensions, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.EXTENSIONS), localErrors); + + if (definition.interactionType !== undefined) { + if (definition.type !== _general.xapiGeneral.INTERACTION_DEFINITION_TYPE) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace, _properties.properties.TYPE), + message: _errors.xapiValidationErrors.INTERACTION_ACTIVITY_SHOULD_HAVE + ' "' + _general.xapiGeneral.INTERACTION_DEFINITION_TYPE + '"', + level: _errors.xapiErrorLevels.SHOULD_VIOLATION + }); + } + + if (_interactionTypes.xapiValidationInteractionTypes.indexOf(definition.interactionType) === _general.xapiGeneral.NO_INDEX_FOUND) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace, _properties.properties.INTERACTION_TYPE), + message: _errors.xapiValidationErrors.INTERACTION_TYPE_MUST_BE_CMI, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + } + + if (definition.correctResponsesPattern !== undefined) { + if (!_utils.xapiValidationUtils.isArray(definition.correctResponsesPattern)) { + localErrors.push({ + trace: correctResponsesPatternTrace, + message: _errors.xapiValidationErrors.CORRECT_RESPONSES_PATTERN_MUST_BE_ARRAY, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } else { + definition.correctResponsesPattern.forEach(function (response, i) { + if (response === null || response === undefined || !_utils.xapiValidationUtils.isString(response)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.addLookupToTrace(correctResponsesPatternTrace, i), + message: _errors.xapiValidationErrors.CORRECT_RESPONSES_PATTERN_MUST_BE_STRINGS, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + }); + } + } + + validateInteractionComponentArray(definition.choices, definition.interactionType, [_properties.properties.CHOICE, _properties.properties.SEQUENCING], _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.CHOICES), localErrors); + + validateInteractionComponentArray(definition.scale, definition.interactionType, [_properties.properties.LIKERT], _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.SCALE), localErrors); + + validateInteractionComponentArray(definition.source, definition.interactionType, [_properties.properties.MATCHING], _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.SOURCE), localErrors); + + validateInteractionComponentArray(definition.target, definition.interactionType, [_properties.properties.MATCHING], _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.TARGET), localErrors); + + validateInteractionComponentArray(definition.steps, definition.interactionType, [_properties.properties.PERFORMANCE], _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.STEPS), localErrors); + + validateAbsenceOfNonWhitelistedProperties(definition, _properties.xapiWhiteListProperties.ACTIVITY_DEFINITION, localTrace, localErrors); + return localErrors; +} + +function validateActivity(activity, trace, errors) { + var localErrors, localTrace; + + localErrors = errors || []; + localTrace = trace || _properties.properties.ACTIVITY; + + if (!_utils.xapiValidationUtils.isNonNullMapObject(activity)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace), + message: _errors.xapiValidationErrors.ACTIVITIES_MUST_NOT_BE_NULL, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + + return localErrors; + } + + validatePropertyIsUri(activity, _properties.properties.ID, localTrace, localErrors, /*isRequired*/true); + + if (activity.definition !== undefined) { + validateActivityDefintion(activity.definition, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.DEFINITION), localErrors); + } + + validateAbsenceOfNonWhitelistedProperties(activity, _properties.xapiWhiteListProperties.ACTIVITY, localTrace, localErrors); + + return localErrors; +} + +function validateStatementRef(statementRef, trace, errors) { + var localErrors, localTrace; + + localErrors = errors || []; + localTrace = trace || _properties.properties.STATEMENT_REF; + + if (!_utils.xapiValidationUtils.isNonNullMapObject(statementRef)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace), + message: _errors.xapiValidationErrors.STATEMENT_REF_MUST_NOT_BE_NULL_MAP_OBJECTS, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + return localErrors; + } + + if (statementRef.objectType !== _properties.objectTypes.STATEMENT_REF) { + localErrors.push({ + trace: _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.OBJECT_TYPE), + message: _errors.xapiValidationErrors.OBJECT_TYPE_MUST_BE_STATEMENT_REF, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + + if (!statementRef.id || !_regex.xapiValidationRegex.UUID.test(statementRef.id)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.ID), + message: _errors.xapiValidationErrors.ID_MUST_BE_VALID_UUID_REF, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + + validateAbsenceOfNonWhitelistedProperties(statementRef, _properties.xapiWhiteListProperties.STATEMENT_REF, localTrace, localErrors); + + return localErrors; +} + +function validateScore(score, trace, errors) { + var localErrors, localTrace; + + localErrors = errors || []; + localTrace = trace || _properties.properties.SCORE; + + if (score === undefined) { + return localErrors; + } + + validatePropertyIsNumber(score, _properties.properties.SCALED, localTrace, localErrors, /*isRequired*/false); + + if (score.scaled !== undefined) { + if (score.scaled < _general.xapiGeneral.MIN_SCALED_VALUE || score.scaled > _general.xapiGeneral.MAX_SCALED_VALUE) { + localErrors.push({ + trace: _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.SCALED), + message: _errors.xapiValidationErrors.SCALED_MUST_BE_BETWEEN_0_1, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + } + + if (score.min !== undefined) { + validatePropertyIsNumber(score, _properties.properties.MIN, localTrace, localErrors, /*isRequired*/false); + + if (score.raw !== undefined && score.raw < score.min) { + localErrors.push({ + trace: _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.RAW), + message: _errors.xapiValidationErrors.RAW_MUST_BE_GREATER_THAN_MIN, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + + if (score.max !== undefined && score.max < score.min) { + localErrors.push({ + trace: _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.MAX), + message: _errors.xapiValidationErrors.MAX_MUST_BE_GREATER_THAN_MIN, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + } + + if (score.max !== undefined) { + validatePropertyIsNumber(score, _properties.properties.MAX, localTrace, localErrors, /*isRequired*/false); + + if (score.raw !== undefined && score.raw > score.max) { + localErrors.push({ + trace: _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.RAW), + message: _errors.xapiValidationErrors.RAW_MUST_BE_LESS_THAN_MAX, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + } + + validatePropertyIsNumber(score, _properties.properties.RAW, localTrace, localErrors, /*isRequired*/false); + validateAbsenceOfNonWhitelistedProperties(score, _properties.xapiWhiteListProperties.SCORE, localTrace, localErrors); + + return localErrors; +} + +function validateResult(result, trace, errors) { + var localErrors, localTrace; + + localErrors = errors || []; + localTrace = trace || _properties.properties.RESULT; + + if (result === undefined) { + return localErrors; + } + + if (!_utils.xapiValidationUtils.isNonNullMapObject(result)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.addPropToTrace(localTrace), + message: _errors.xapiValidationErrors.RESULT_MUST_BE_MAP_OBJECT, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + + return localErrors; + } + + validateScore(result.score, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.SCORE), localErrors); + validatePropertyIsBoolean(result, _properties.properties.SUCCESS, localTrace, localErrors, /*isRequired*/false); + validatePropertyIsBoolean(result, _properties.properties.COMPLETION, localTrace, localErrors, /*isRequired*/false); + validatePropertyIsString(result, _properties.properties.RESPONSE, localTrace, localErrors, /*isRequired*/false); + validateExtensions(result.extensions, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.EXTENSIONS), localErrors); + + if (result.duration !== undefined && (result.duration === null || !_utils.xapiValidationUtils.isString(result.duration) || !_regex.xapiValidationRegex.ISO_8601_DURATION.test(result.duration))) { + localErrors.push({ + trace: _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.DURATION), + message: _errors.xapiValidationErrors.DURATION_MUST_BE_VALID, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + + validateAbsenceOfNonWhitelistedProperties(result, _properties.xapiWhiteListProperties.RESULT, localTrace, localErrors); + + return localErrors; +} + +function validatePropertyIsISO8601String(parent, propertyName, trace, errors) { + var localErrors, localTrace, matched, datetime; + + localErrors = errors || []; + localTrace = trace || _properties.properties.DATE_TIME; + datetime = parent[propertyName]; + + if (datetime === undefined) { + return localErrors; + } + + if (datetime === null || !_utils.xapiValidationUtils.isString(datetime)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace, propertyName), + message: propertyName + ' ' + _errors.xapiValidationErrors.MUST_BE_STRING, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + + return localErrors; + } + + matched = _regex.xapiValidationRegex.ISO_8601_DATE_TIME.exec(datetime); + + if (matched) { + if (!dateIncludesZoneInformation(matched)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace, propertyName), + message: _errors.xapiValidationErrors.DATE_SHOULD_INCLUDE_ZONE_INFORMATION, + level: _errors.xapiErrorLevels.SHOULD_VIOLATION + }); + } + } else { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace, propertyName), + message: _errors.xapiValidationErrors.DATE_MUST_BE_VALID, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + + return localErrors; +} + +function validateVersion(version, trace, errors) { + var localErrors, localTrace; + + localErrors = errors || []; + localTrace = trace || _properties.properties.VERSION; + + if (version === undefined) { + return localErrors; + } + + if (version === null || !_utils.xapiValidationUtils.isString(version) || !_regex.xapiValidationRegex.SEMVER_1_P_0_P_0.test(version)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace), + message: _errors.xapiValidationErrors.VERSION_MUST_COMPLY_SEMANTIC_VERSIONING, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + + return localErrors; +} + +function validateAttachmentObject(attachment, trace, errors) { + var localErrors, localTrace; + + localErrors = errors || []; + localTrace = trace || _properties.properties.ATTACHMENT; + + if (!_utils.xapiValidationUtils.isNonNullMapObject(attachment)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace), + message: _errors.xapiValidationErrors.ATTACHMENTS_MUST_NOT_BE_NULL_MAP_OBJECTS, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + + return localErrors; + } + + if (attachment.display === undefined) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace, _properties.properties.DISPLAY), + message: _errors.xapiValidationErrors.DISPLAY_SHOULD_BE_PROVIDED, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } else { + validateLanguageMap(attachment.display, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.DISPLAY), localErrors); + } + + validateLanguageMap(attachment.description, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.DESCRIPTION), localErrors); + validatePropertyIsUri(attachment, _properties.properties.USAGE_TYPE, localTrace, localErrors, /*isRequired*/true, _errors.xapiErrorLevels.MUST_VIOLATION); + validatePropertyIsUri(attachment, _properties.properties.FILE_URL, localTrace, localErrors, /*isRequired*/false, _errors.xapiErrorLevels.MUST_VIOLATION); + + // TODO - more complete validation for Internet Media Type via RFC 2046 + validatePropertyIsString(attachment, _properties.properties.CONTENT_TYPE, localTrace, localErrors, /*isRequired*/true, _errors.xapiErrorLevels.MUST_VIOLATION); + + if (attachment.length === undefined || attachment.length === null || !_utils.xapiValidationUtils.isNumber(attachment.length) || attachment.length % 1 !== 0) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace, _properties.properties.LENGTH), + message: _errors.xapiValidationErrors.LENGTH_MUST_BE_INTEGER, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + + if (attachment.sha2 === undefined) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace, _properties.properties.SHA2), + message: _errors.xapiValidationErrors.SHA2_MUST_BE_PROVIDED_ON_ATTACHMENT_OBJECTS, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } else if (attachment.sha2 === null || !_utils.xapiValidationUtils.isString(attachment.sha2) || !_regex.xapiValidationRegex.BASE_64.test(attachment.sha2)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace, _properties.properties.SHA2), + message: _errors.xapiValidationErrors.SHA2_MUST_CONTAIN_BASE_64_STRING, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + + validateAbsenceOfNonWhitelistedProperties(attachment, _properties.xapiWhiteListProperties.ATTACHMENT, localTrace, localErrors); + return localErrors; +} + +function validateAttachments(attachments, trace, errors) { + var localErrors, localTrace; + + localErrors = errors || []; + localTrace = trace || _properties.properties.ATTACHMENTS; + + if (attachments === undefined) { + return localErrors; + } + + if (attachments === null || !_utils.xapiValidationUtils.isArray(attachments)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace), + message: _errors.xapiValidationErrors.ATTACHMENTS_MUST_BE_NOT_NULL_ARRAY, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + + return localErrors; + } + + attachments.forEach(function (attachment, i) { + validateAttachmentObject(attachment, _utils.xapiValidationUtils.addLookupToTrace(localTrace, i), localErrors); + }); + + return localErrors; +} + +function validateAgent(agent, trace, errors) { + var localErrors, localTrace, ifiCount; + + localErrors = errors || []; + localTrace = trace || _properties.properties.AGENT; + + if (!_utils.xapiValidationUtils.isNonNullMapObject(agent)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace), + message: _errors.xapiValidationErrors.AGENT_MUST_BE_NON_NULL_MAP_OBJECT, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + return localErrors; + } + + ifiCount = getIFICount(agent); + + if (ifiCount !== _general.xapiGeneral.NUMER_OF_SPECIFIED_IFI_PROPERTIES) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace), + message: _errors.xapiValidationErrors.AGENT_IFI_PROPERTIES_MUST_BE_SPECIFIED, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + + if (agent.objectType === _properties.objectTypes.GROUP) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace), + message: _errors.xapiValidationErrors.AGENT_MUST_NOT_HAVE_GROUP_CHARACTERISTICS, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + + validateIFIProperties(agent, localTrace, localErrors); + validatePropertyIsString(agent, _properties.properties.NAME, localTrace, localErrors, /*isRequired*/false); + + validateAbsenceOfNonWhitelistedProperties(agent, _properties.xapiWhiteListProperties.AGENT, localTrace, localErrors); + + return localErrors; +} + +function validateGroup(group, trace, errors) { + var localErrors, localTrace, memberTrace, ifiCount; + + localErrors = errors || []; + localTrace = trace || _properties.properties.GROUP; + memberTrace = _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.MEMBER); + + if (!_utils.xapiValidationUtils.isNonNullMapObject(group)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace), + message: _errors.xapiValidationErrors.GROUP_MUST_BE_NON_NULL_MAP_OBJECT, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + + return localErrors; + } + + ifiCount = getIFICount(group); + + if (ifiCount === 0) { + if (group.member === null || group.member === undefined) { + localErrors.push({ + trace: memberTrace, + message: _errors.xapiValidationErrors.MEMBER_MUST_BE_PROVIDED_FOR_ANONYMOUS_GROUPS, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + } else if (ifiCount > _general.xapiGeneral.NUMER_OF_SPECIFIED_IFI_PROPERTIES) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace), + message: _errors.xapiValidationErrors.GROUP_IFI_PROPERTIES_MUST_BE_SPECIFIED, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + + validateIFIProperties(group, localTrace, localErrors); + + validatePropertyIsString(group, _properties.properties.NAME, localTrace, localErrors, /*isRequired*/false); + + if (group.member !== undefined) { + if (group.member === null || !_utils.xapiValidationUtils.isArray(group.member)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace, _properties.properties.MEMBER), + message: _errors.xapiValidationErrors.GROUP_MEMBER_MUST_BE_ARRAY, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } else { + group.member.forEach(function (member, i) { + validateAgent(member, _utils.xapiValidationUtils.addLookupToTrace(memberTrace, i), localErrors); + }); + } + } + + validateAbsenceOfNonWhitelistedProperties(group, _properties.xapiWhiteListProperties.GROUP, localTrace, localErrors); + + return localErrors; +} + +function validateActor(actor, trace, errors) { + var localErrors, localTrace; + + localErrors = errors || []; + localTrace = trace || _properties.properties.ACTOR; + + if (actor === null || actor === undefined) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace), + message: _errors.xapiValidationErrors.ACTOR_MUST_BE_PROVIDED, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + + return localErrors; + } + + if (_utils.xapiValidationUtils.isGroup(actor, _properties.objectTypes.GROUP)) { + validateGroup(actor, localTrace, localErrors); + } else { + validateAgent(actor, localTrace, localErrors); + } + + return localErrors; +} + +function validateAuthority(authority, trace, errors) { + var localErrors, localTrace; + + localErrors = errors || []; + localTrace = trace || _properties.properties.AUTHORITY; + + if (authority === undefined) { + return localErrors; + } + + if (!_utils.xapiValidationUtils.isNonNullMapObject(authority)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace), + message: _errors.xapiValidationErrors.AUTHORITY_MUST_BE_NON_NULL_MAP_OBJECT, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + + return localErrors; + } + if (_utils.xapiValidationUtils.isGroup(authority, _properties.objectTypes.GROUP)) { + validateGroup(authority, localTrace, localErrors); + if (!authority.member || !authority.member.length || authority.member.length !== _general.xapiGeneral.GROUP_AUTHORITY_AGENT_MEMBERS) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace, _properties.properties.MEMBER), + message: _errors.xapiValidationErrors.GROUP_AUTHORITY_AGENT_MEMBERS_MUST_BE_TWO, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + } else { + validateAgent(authority, localTrace, localErrors); + } + + return localErrors; +} + +function validateContextActivitySubContext(subContext, trace, errors) { + var localErrors, localTrace; + + localErrors = errors || []; + localTrace = trace || _properties.properties.SUB_CONTEXT; + + if (subContext === undefined) { + return localErrors; + } + + if (subContext === null) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace), + message: _errors.xapiValidationErrors.CONTEXT_ACTIVITIES_MUST_NOT_BE_NULL, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } else if (_utils.xapiValidationUtils.isArray(subContext)) { + subContext.forEach(function (activity, i) { + validateActivity(activity, _utils.xapiValidationUtils.addLookupToTrace(localTrace, i), localErrors); + }); + } else if (_utils.xapiValidationUtils.isObject(subContext)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace), + message: _errors.xapiValidationErrors.CONTEXT_ACTIVITIES_SHOULD_BE_AN_ARRAY, + level: _errors.xapiErrorLevels.SHOULD_VIOLATION + }); + + validateActivity(subContext, localTrace, localErrors); + } else { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace), + message: _errors.xapiValidationErrors.CONTEXT_ACTIVITIES_MUST_BE_ARRAY_OR_ACTIVITY_OBJ, + level: _errors.xapiErrorLevels.MUST_VIOLATION }); + } + return localErrors; +} + +function validateContextActivities(contextActivities, trace, errors) { + var localErrors, localTrace; + + localErrors = errors || []; + localTrace = trace || _properties.properties.CONTEXT_ACTIVITIES; + + if (contextActivities === undefined) { + return localErrors; + } + + if (!_utils.xapiValidationUtils.isNonNullMapObject(contextActivities)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace), + message: _errors.xapiValidationErrors.CONTEXT_ACTIVITIES_MUST_BE_NON_NULL_MAP_OBJECT, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + return localErrors; + } + + validateContextActivitySubContext(contextActivities.parent, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.PARENT), localErrors); + validateContextActivitySubContext(contextActivities.grouping, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.GROUPING), localErrors); + validateContextActivitySubContext(contextActivities.category, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.CATEGORY), localErrors); + validateContextActivitySubContext(contextActivities.other, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.OTHER), localErrors); + + validateAbsenceOfNonWhitelistedProperties(contextActivities, _properties.xapiWhiteListProperties.CONTEXT_ACTIVITIES, localTrace, localErrors); + + return localErrors; +} + +function validateContext(context, trace, errors, statementObjectObjectType) { + var localErrors, localTrace; + + localErrors = errors || []; + localTrace = trace || _properties.properties.CONTEXT; + + if (context === undefined) { + return localErrors; + } + + if (!_utils.xapiValidationUtils.isNonNullMapObject(context)) { + localErrors.push({ + trace: localTrace, + message: _errors.xapiValidationErrors.CONTEXT_MUST_BE_NON_NUL_MAP_OBJECT, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + + return localErrors; + } + + if (context.registration !== undefined && (context.registration === null || !_utils.xapiValidationUtils.isString(context.registration) || !_regex.xapiValidationRegex.UUID.test(context.registration))) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace, _properties.properties.REGISTRATION), + message: _errors.xapiValidationErrors.REGISTRATION_MUST_BE_UUID_STRING, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + + if ([_properties.objectTypes.GROUP, _properties.objectTypes.AGENT].indexOf(statementObjectObjectType) !== _general.xapiGeneral.NO_INDEX_FOUND) { + if (context.revision !== undefined) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace, _properties.properties.REVISION), + message: _errors.xapiValidationErrors.REVISION_MUST_BE_AGENT_OR_GROUP, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + + if (context.platform !== undefined) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace, _properties.properties.PLATFORM), + message: _errors.xapiValidationErrors.PLATFORM_MUST_NOT_BE_USED_WITH_REVISION_AGENT_OR_GROUP, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + } + + validatePropertyIsString(context, _properties.properties.REVISION, localTrace, localErrors, /*isRequired*/false, _errors.xapiErrorLevels.MUST_VIOLATION); + validatePropertyIsString(context, _properties.properties.PLATFORM, localTrace, localErrors, /*isRequired*/false, _errors.xapiErrorLevels.MUST_VIOLATION); + + if (context.team !== undefined) { + validateGroup(context.team, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.TEAM), localErrors); + } + + if (context.contextActivities !== undefined) { + validateContextActivities(context.contextActivities, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.CONTEXT_ACTIVITIES), localErrors); + } + + if (context.language !== undefined && !_utils.xapiValidationUtils.isValidLanguageTag(context.language, _regex.xapiValidationRegex.BCP_47)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace, _properties.properties.LANGUAGE), + message: _errors.xapiValidationErrors.LANGUAGE_MUST_BE_STRING, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + + if (context.statement !== undefined) { + validateStatementRef(context.statement, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.STATEMENT), localErrors); + } + + if (context.instructor !== undefined) { + if (_utils.xapiValidationUtils.isGroup(context.instructor, _properties.objectTypes.GROUP)) { + validateGroup(context.instructor, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.INSTRUCTOR), localErrors); + } else { + validateAgent(context.instructor, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.INSTRUCTOR), localErrors); + } + } + + validateExtensions(context.extensions, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.EXTENSIONS), localErrors); + validateAbsenceOfNonWhitelistedProperties(context, _properties.xapiWhiteListProperties.EXTENSIONS, localTrace, localErrors); + + return localErrors; +} + +function validateObject(object, trace, errors, isWithinSubStatement) { + var localErrors, localTrace, objectType; + + localErrors = errors || []; + localTrace = trace || _properties.properties.OBJECT; + + if (object === undefined) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace), + message: _errors.xapiValidationErrors.OBJECT_MUST_BE_DEFINED, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + + return localErrors; + } + + if (!_utils.xapiValidationUtils.isNonNullMapObject(object)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace), + message: _errors.xapiValidationErrors.OBJECT_MUST_BE_NON_NULL_MAP_OBJECT, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + + return localErrors; + } + + validatePropertyIsString(object, _properties.properties.OBJECT_TYPE, localTrace, localErrors, /*isRequired*/true, _errors.xapiErrorLevels.SHOULD_VIOLATION); + + objectType = object.objectType || _properties.objectTypes.ACTIVITY; + + switch (objectType) { + case _properties.objectTypes.ACTIVITY: + validateActivity(object, localTrace, localErrors); + break; + case _properties.objectTypes.AGENT: + validateAgent(object, localTrace, localErrors); + break; + case _properties.objectTypes.GROUP: + validateGroup(object, localTrace, localErrors); + break; + case _properties.objectTypes.STATEMENT_REF: + validateStatementRef(object, localTrace, localErrors); + break; + case _properties.objectTypes.SUB_STATEMENT: + if (isWithinSubStatement) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace, _properties.properties.OBJECT_TYPE), + message: _errors.xapiValidationErrors.SUB_STATEMENT_MUST_NOT_CONTAIN_SUB_STATEMENT, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + validate(object, localTrace, localErrors, /*isSubStatement*/true); + break; + default: + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace, _properties.properties.OBJECT_TYPE), + message: _errors.xapiValidationErrors.OBJECT_TYPE_MUST_BE_VALID_OPTION + ' ' + _properties.xApiValidObjectTypes.toString(), + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + + return localErrors; +} + +function validate(statement, trace, errors, isSubStatement) { + var localErrors, localTrace, statementObjectObjectType, whitelistedProperties; + + localErrors = errors || []; + localTrace = trace || _properties.properties.STATEMENT; + + whitelistedProperties = _properties.xapiWhiteListProperties.STATEMENT; + + if (!_utils.xapiValidationUtils.isNonNullMapObject(statement)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace), + message: _errors.xapiValidationErrors.STATEMENT_REF_MUST_NOT_BE_NULL_MAP_OBJECTS, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + + return localErrors; + } + + if (!isSubStatement) { + if (statement.id === null || statement.id === undefined || !_utils.xapiValidationUtils.isString(statement.id)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace, _properties.properties.ID), + message: _errors.xapiValidationErrors.IDS_SHOULD_BE_GENERATED_BY_LRS, + level: _errors.xapiErrorLevels.SHOULD_VIOLATION + }); + } else if (!_regex.xapiValidationRegex.UUID.test(statement.id)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace, _properties.properties.ID), + message: _errors.xapiValidationErrors.ID_MUST_BE_VALID, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + } else { + whitelistedProperties = _properties.xapiWhiteListProperties.SUB_STATEMENT; + } + + validateActor(statement.actor, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.ACTOR), localErrors); + validateVerb(statement.verb, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.VERB), localErrors); + validateObject(statement.object, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.OBJECT), localErrors, isSubStatement); + validateResult(statement.result, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.RESULT), localErrors); + + statementObjectObjectType = statement.object && statement.object.objectType ? statement.object.objectType : _properties.objectTypes.ACTIVITY; + + validateContext(statement.context, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.CONTEXT), localErrors, statementObjectObjectType); + validatePropertyIsISO8601String(statement, _properties.properties.TIMESTAMP, localTrace, localErrors); + validatePropertyIsISO8601String(statement, _properties.properties.STORED, localTrace, localErrors); + + validateAuthority(statement.authority, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.AUTHORITY), localErrors); + validateVersion(statement.version, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.VERSION), localErrors); + validateAttachments(statement.attachments, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.ATTACHMENTS), localErrors); + + validateAbsenceOfNonWhitelistedProperties(statement, whitelistedProperties, localTrace, localErrors); + + return localErrors; +} + +function makeStatementReport(statement) { + var localErrors; + + localErrors = []; + validate(statement, _properties.properties.STATEMENT, localErrors, /*isRequired*/false); + + return makeV1Report(statement, localErrors); +} + +function validateAmbiguousTypeStatement(statement) { + var statementObject; + + if (statement === undefined) { + return makeV1SingleErrorReport( /*instance*/null, { + trace: _properties.properties.STATEMENT, + message: _errors.xapiValidationErrors.STATEMENT_ARGUMENT_MUST_BE_PROVIDED, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + + if (statement === null) { + return makeV1SingleErrorReport( /*instance*/null, { + trace: _properties.properties.STATEMENT, + message: _errors.xapiValidationErrors.STATEMENT_MUST_NOT_BE_NULL, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + + if (_utils.xapiValidationUtils.isString(statement)) { + try { + statementObject = JSON.parse(statement); + if (statementObject === null || !_utils.xapiValidationUtils.isObject(statementObject) || _utils.xapiValidationUtils.isArray(statementObject)) { + return makeV1SingleErrorReport(statementObject, { + trace: _properties.properties.STATEMENT, + message: _errors.xapiValidationErrors.STATEMENT_MUST_BE_PARSED_CORRECTLY, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + } catch (e) { + return makeV1SingleErrorReport(statementObject, { + trace: _properties.properties.STATEMENT, + message: _errors.xapiValidationErrors.INVALID_JSON + ': ' + e.message, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + + return makeStatementReport(statementObject); + } + + if (_utils.xapiValidationUtils.isObject(statement) && !_utils.xapiValidationUtils.isArray(statement)) { + return makeStatementReport(statement); + } + + return makeV1SingleErrorReport( /*instance*/null, { + trace: _properties.properties.STATEMENT, + message: _errors.xapiValidationErrors.STATEMENT_ARGUMENT_IS_NOT_VALID, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); +} + +function dateIncludesZoneInformation(matched) { + return matched[_regex.dateFormatRegexPositions.ZONE] || matched[_regex.dateFormatRegexPositions.RELATIVE_TIME] && matched[_regex.dateFormatRegexPositions.TIME_ZONE_HOUR]; +} + +xapiValidation = { + validateStatement: validateAmbiguousTypeStatement +}; + +module.exports = xapiValidation; + +},{"./constants/errors":42,"./constants/general":43,"./constants/interaction-types":44,"./constants/properties":45,"./constants/regex":46,"./utils/utils":47}],49:[function(require,module,exports){ +'use strict';var _underscore=require('underscore');var _chai=require('chai');var _xapiValidator=require('../src/xapiValidator');// var xapiValidator = require('../xapiValidator'); +describe("xapiValidator",function(){describe("#validateStatement",function(){function reportHasErrorWithTracePrefix(report,prefix,targetLevel){if(report===null||report===undefined||report.errors===null||report.errors===undefined){return false;}var hasTargetLevel=targetLevel!==null&&targetLevel!==undefined;return _underscore._.any(report.errors,function(err){var foundPrefix=err.trace.indexOf(prefix)===0;return hasTargetLevel?targetLevel===err.level&&foundPrefix:foundPrefix;});}describe("when passed no arguments",function(){it("returns non-null report",function(){var result=_xapiValidator.xapiValidator.validateStatement();(0,_chai.expect)(result).to.be.not.null;(0,_chai.expect)(result).to.be.a("Object");});it("includes one error",function(){var result=_xapiValidator.xapiValidator.validateStatement();var errors=result.errors;(0,_chai.expect)(errors).to.be.instanceOf(Array);(0,_chai.expect)(errors).to.have.length(1);(0,_chai.expect)(errors[0]).to.have.property("message").that.is.a('string').that.equals('No statement argument provided.');(0,_chai.expect)(errors[0]).to.have.property("level").that.equals("MUST_VIOLATION");});it("has a null instance property in the report",function(){(0,_chai.expect)(_xapiValidator.xapiValidator.validateStatement()).to.have.property("instance").that.is.null;});});describe("when passed a null argument",function(){it("returns non-null report",function(){var result=_xapiValidator.xapiValidator.validateStatement(null);(0,_chai.expect)(result).to.be.not.null;(0,_chai.expect)(result).to.be.a("Object");(0,_chai.expect)(result).to.have.property("errors").that.is.a("Array");(0,_chai.expect)(result).to.have.property("instance");});it("includes one error",function(){var result=_xapiValidator.xapiValidator.validateStatement(null);var errors=result.errors;(0,_chai.expect)(errors).to.be.instanceOf(Array);(0,_chai.expect)(errors).to.have.length(1);(0,_chai.expect)(errors[0]).to.have.property("message").that.is.a('string').that.equals('Null statement argument provided.');(0,_chai.expect)(errors[0]).to.have.property("level").that.equals("MUST_VIOLATION");});it("has a null instance property in the report",function(){(0,_chai.expect)(_xapiValidator.xapiValidator.validateStatement(null)).to.have.property("instance").that.is.null;});});describe("when passed a json string argument",function(){var minimalJsonString="{\"id\":\"whatever\"}";it("returns non-null report",function(){var result=_xapiValidator.xapiValidator.validateStatement(minimalJsonString);(0,_chai.expect)(result).to.be.not.null;(0,_chai.expect)(result).to.be.a("Object");(0,_chai.expect)(result).to.have.property("errors").that.is.a("Array");(0,_chai.expect)(result).to.have.property("instance");});it("has an instance property with the deserialized JSON in the report",function(){var result=_xapiValidator.xapiValidator.validateStatement(minimalJsonString);(0,_chai.expect)(result).to.have.property("instance").that.is.an("Object").that.deep.equals({"id":"whatever"});});});describe("when passed a json string argument encoding null",function(){var minimalJsonString="null";it("returns non-null report",function(){var result=_xapiValidator.xapiValidator.validateStatement(minimalJsonString);(0,_chai.expect)(result).to.be.not.null;(0,_chai.expect)(result).to.be.a("Object");(0,_chai.expect)(result).to.have.property("errors").that.is.a("Array");(0,_chai.expect)(result).to.have.property("instance");});it("includes one error",function(){var result=_xapiValidator.xapiValidator.validateStatement(minimalJsonString);var errors=result.errors;(0,_chai.expect)(errors).to.be.instanceOf(Array);(0,_chai.expect)(errors).to.have.length(1);(0,_chai.expect)(errors[0]).to.have.property("message");(0,_chai.expect)(errors[0]).to.have.property("level").that.equals("MUST_VIOLATION");});it("has an instance property with null value",function(){var result=_xapiValidator.xapiValidator.validateStatement(minimalJsonString);(0,_chai.expect)(result).to.have.property("instance").that.is.null;});});describe("when passed an invalid json string argument",function(){var minimalJsonString="derp";it("returns non-null report",function(){var result=_xapiValidator.xapiValidator.validateStatement(minimalJsonString);(0,_chai.expect)(result).to.be.not.null;(0,_chai.expect)(result).to.be.a("Object");(0,_chai.expect)(result).to.have.property("errors").that.is.a("Array");(0,_chai.expect)(result).to.have.property("instance");});it("includes one error",function(){var result=_xapiValidator.xapiValidator.validateStatement(minimalJsonString);var errors=result.errors;(0,_chai.expect)(errors).to.be.instanceOf(Array);(0,_chai.expect)(errors).to.have.length(1);(0,_chai.expect)(errors[0]).to.have.property("message");(0,_chai.expect)(errors[0]).to.have.property("level").that.equals("MUST_VIOLATION");});it("has an instance property with null value",function(){var result=_xapiValidator.xapiValidator.validateStatement(minimalJsonString);(0,_chai.expect)(result).to.have.property("instance").that.is.null;});});describe("when passed a statement object",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"}};it("returns non-null report",function(){var result=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(result).to.be.not.null;(0,_chai.expect)(result).to.be.a("Object");(0,_chai.expect)(result).to.have.property("errors").that.is.a("Array");(0,_chai.expect)(result).to.have.property("instance");});it("has an instance property that matches the input object",function(){var result=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(result).to.have.property("instance").that.deep.equals(inputStatement);});});describe("when given a null id property",function(){var inputStatement={id:null,actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"}};it("has an error about the id property",function(){var result=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(reportHasErrorWithTracePrefix(result,"statement.id")).to.be.true;});});describe("when given an invalid UUID id property",function(){var inputStatement={id:"abc123",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"}};it("has an error about the id property",function(){var result=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(reportHasErrorWithTracePrefix(result,"statement.id")).to.be.true;});});describe("when given a valid UUID id property",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"}};it("has an error about the id property",function(){var result=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(reportHasErrorWithTracePrefix(result,"statement.id")).to.be.false;});});describe("when given a null actor property",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:null,verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"}};it("has an error about the actor property",function(){var result=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(reportHasErrorWithTracePrefix(result,"statement.actor")).to.be.true;});});describe("when given an empty non-null actor property",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"}};it("has an error about the actor property",function(){var result=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(reportHasErrorWithTracePrefix(result,"statement.actor")).to.be.true;});});describe("when given an otherwise valid actor",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:group@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"}};it("the name property is optional",function(){var result=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(result.errors).to.have.property("length",0);});it("the name property produces no errors when a simple string",function(){inputStatement.actor.name="hello";var result=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(result.errors).to.have.property("length",0);});it("the name property produces no errors when a simple string",function(){inputStatement.actor.name=1.23;var result=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(reportHasErrorWithTracePrefix(result,"statement.actor.name")).to.be.true;(0,_chai.expect)(result.errors).to.have.property("length",1);});});describe("when given an actor with an objectType of 'Group'",function(){var moreValidStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{objectType:"Group",member:[]},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"}};it("the member property has no errors about it when present",function(){var result=_xapiValidator.xapiValidator.validateStatement(moreValidStatement);(0,_chai.expect)(reportHasErrorWithTracePrefix(result,"statement.actor.member")).to.be.false;});it("the member property is required to be present if the actor is unidentified, and produces an error when absent",function(){var inputInvalidStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{objectType:"Group"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"}};var result=_xapiValidator.xapiValidator.validateStatement(inputInvalidStatement);(0,_chai.expect)(reportHasErrorWithTracePrefix(result,"statement.actor.member")).to.be.true;});it("the member property is not required to be present if the actor is identified",function(){var result=_xapiValidator.xapiValidator.validateStatement({id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{objectType:"Group",mbox:"mailto:group@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"}});(0,_chai.expect)(reportHasErrorWithTracePrefix(result,"statement.actor.member")).to.be.false;});it("the member property is allowed to be present if the actor is identified",function(){var result=_xapiValidator.xapiValidator.validateStatement({id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{objectType:"Group",mbox:"mailto:group@example.com",member:[]},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"}});(0,_chai.expect)(reportHasErrorWithTracePrefix(result,"statement.actor.member")).to.be.false;});});describe("when given an actor with a members property",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{member:[]},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"}};it("the member property has no errors about it when present but empty",function(){(0,_chai.expect)(_xapiValidator.xapiValidator.validateStatement(inputStatement).errors).to.be.empty;});it("the member property has no errors when populated with a simple agent",function(){inputStatement.actor.member=[{mbox:"mailto:group@example.com"}];(0,_chai.expect)(_xapiValidator.xapiValidator.validateStatement(inputStatement).errors).to.be.empty;});it("the member property reports an error when populated with a Group object via objectType",function(){inputStatement.actor.member=[{mbox:"mailto:group@example.com",objectType:"Group"}];(0,_chai.expect)(_xapiValidator.xapiValidator.validateStatement(inputStatement).errors).to.have.property("length",1);});it("the member property's agent reports an error when given an account missing its homePage",function(){inputStatement.actor.member=[{account:{name:"bob"}}];(0,_chai.expect)(reportHasErrorWithTracePrefix(_xapiValidator.xapiValidator.validateStatement(inputStatement),"statement.actor.member[0].account.homePage")).to.be.true;});it("the member property's agent reports an error when given an account missing its name",function(){inputStatement.actor.member=[{account:{homePage:"http://example.com"}}];(0,_chai.expect)(reportHasErrorWithTracePrefix(_xapiValidator.xapiValidator.validateStatement(inputStatement),"statement.actor.member[0].account.name")).to.be.true;});it("the member property's agent reports an error when given an account with an all-lowercase homepage",function(){inputStatement.actor.member=[{account:{homepage:"http://example.com",name:"bob"}}];var report=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(reportHasErrorWithTracePrefix(report,"statement.actor.member[0].account.homepage")).to.be.true;(0,_chai.expect)(report.errors).to.have.property("length",2);});it("the member property's agent reports no error when given a full account",function(){inputStatement.actor.member=[{account:{homePage:"http://example.com",name:"bob"}}];(0,_chai.expect)(_xapiValidator.xapiValidator.validateStatement(inputStatement).errors).to.have.property("length",0);});it("the member property's agent reports no error when given a valid mbox",function(){inputStatement.actor.member=[{mbox:"mailto:bob@example.com"}];(0,_chai.expect)(_xapiValidator.xapiValidator.validateStatement(inputStatement).errors).to.have.property("length",0);});it("the member property's agent reports an error when given an invalid mbox",function(){inputStatement.actor.member=[{mbox:"SOMETHINGWRONG:bob@example.com"}];var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.actor.member[0].mbox")).to.be.true;(0,_chai.expect)(results.errors).to.have.property("length",1);});it("the member property reports an error when populated with a Group object via member",function(){inputStatement.actor.member=[{mbox:"mailto:group@example.com",member:[]}];(0,_chai.expect)(_xapiValidator.xapiValidator.validateStatement(inputStatement).errors).to.have.property("length",1);});});describe("when given a statement without a verb property",function(){it("reports an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{member:[]},object:{id:"http://example.com/myUniqueId",objectType:"Activity"}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.verb")).to.be.true;});});describe("when given a verb without an id property",function(){it("reports an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{member:[]},verb:{"display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.verb.id","MUST_VIOLATION")).to.be.true;});});describe("when given a verb with a non-string id property",function(){it("reports an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{member:[]},verb:{"id":12.34,"display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.verb.id","MUST_VIOLATION")).to.be.true;});});describe("when given a verb with a relative URI id property",function(){it("reports an SHOULD_VIOLATION error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{member:[]},verb:{"id":"fragment","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.verb.id","SHOULD_VIOLATION")).to.be.true;});});describe("when given a verb without a display property",function(){it("reports an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{member:[]},verb:{"id":"http://adlnet.gov/expapi/verbs/created"},object:{id:"http://example.com/myUniqueId",objectType:"Activity"}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.verb.display","SHOULD_VIOLATION")).to.be.true;});});describe("when given a verb with an empty display property",function(){it("reports no errors",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{member:[]},verb:{"id":"http://adlnet.gov/expapi/verbs/created",display:{}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"}};(0,_chai.expect)(_xapiValidator.xapiValidator.validateStatement(inputStatement).errors).to.have.property("length",0);});});describe("when given a verb.display with RFC 5646 key and string value",function(){it("reports no errors",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{member:[]},verb:{"id":"http://adlnet.gov/expapi/verbs/created",display:{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"}};(0,_chai.expect)(_xapiValidator.xapiValidator.validateStatement(inputStatement).errors).to.have.property("length",0);});});describe("when given a verb.display with RFC 5646 key and non-string value",function(){it("reports an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{member:[]},verb:{"id":"http://adlnet.gov/expapi/verbs/created",display:{"en-US":1.23}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.verb.display[\"en-US\"]","MUST_VIOLATION")).to.be.true;});});describe("when given a verb.display with invalid key and string value",function(){it("reports an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{member:[]},verb:{"id":"http://adlnet.gov/expapi/verbs/created",display:{"123totallyWrong":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.verb.display.123totallyWrong","MUST_VIOLATION")).to.be.true;});});describe("when the object property is absent",function(){it("reports a MUST_VIOLATION error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{member:[]},verb:{"id":"http://adlnet.gov/expapi/verbs/created",display:{"en-US":"created"}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.object","MUST_VIOLATION")).to.be.true;});});describe("when the object property is null",function(){it("reports a MUST_VIOLATION error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{member:[]},verb:{"id":"http://adlnet.gov/expapi/verbs/created",display:{"en-US":"created"}},object:null};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.object","MUST_VIOLATION")).to.be.true;});});describe("when the object lacks an objectType property",function(){it("reports a SHOULD_VIOLATION error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{member:[]},verb:{"id":"http://adlnet.gov/expapi/verbs/created",display:{"en-US":"created"}},object:{id:"http://example.com/myUniqueId"}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.object.objectType","SHOULD_VIOLATION")).to.be.true;});});describe("when the object is an activity with a null definition property",function(){it("reports a MUST_VIOLATION error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{member:[]},verb:{"id":"http://adlnet.gov/expapi/verbs/created",display:{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity",definition:null}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.object.definition","MUST_VIOLATION")).to.be.true;});});describe("when the object is an activity with an array definition property",function(){it("reports a MUST_VIOLATION error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{member:[]},verb:{"id":"http://adlnet.gov/expapi/verbs/created",display:{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity",definition:[]}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.object.definition","MUST_VIOLATION")).to.be.true;});});describe("when the object is an Activity with a definition",function(){it("an array for the name property produces a must violation error.",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{member:[]},verb:{"id":"http://adlnet.gov/expapi/verbs/created",display:{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity",definition:{name:[]}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.object.definition.name","MUST_VIOLATION")).to.be.true;});it("a number for the name property produces a must violation error.",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{member:[]},verb:{"id":"http://adlnet.gov/expapi/verbs/created",display:{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity",definition:{name:1.23}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.object.definition.name","MUST_VIOLATION")).to.be.true;});it("an invalid language Map key for the name property produces a must violation error.",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{member:[]},verb:{"id":"http://adlnet.gov/expapi/verbs/created",display:{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity",definition:{name:{"123 totally not a language code":"created"}}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.object.definition.name","MUST_VIOLATION")).to.be.true;});it("a CMI interactionType value produces no errors",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{member:[]},verb:{"id":"http://adlnet.gov/expapi/verbs/created",display:{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity",definition:{type:"http://adlnet.gov/expapi/activities/cmi.interaction",interactionType:"true-false"}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",0);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.object.definition.name","MUST_VIOLATION")).to.be.false;});it("a non-CMI interactionType value produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{member:[]},verb:{"id":"http://adlnet.gov/expapi/verbs/created",display:{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity",definition:{type:"http://adlnet.gov/expapi/activities/cmi.interaction",interactionType:"graphicGapMatchInteraction"}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.object.definition.interactionType","MUST_VIOLATION")).to.be.true;});it("a numeric correctResponsesPattern value produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{member:[]},verb:{"id":"http://adlnet.gov/expapi/verbs/created",display:{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity",definition:{correctResponsesPattern:1.23}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.object.definition.correctResponsesPattern","MUST_VIOLATION")).to.be.true;});it("a flat string correctResponsesPattern value produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{member:[]},verb:{"id":"http://adlnet.gov/expapi/verbs/created",display:{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity",definition:{correctResponsesPattern:"1.23"}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.object.definition.correctResponsesPattern","MUST_VIOLATION")).to.be.true;});it("a nested number in a correctResponsesPattern Array value produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{member:[]},verb:{"id":"http://adlnet.gov/expapi/verbs/created",display:{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity",definition:{correctResponsesPattern:[1.23]}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.object.definition.correctResponsesPattern[0]","MUST_VIOLATION")).to.be.true;});it("a nested string in a correctResponsesPattern Array value produces no errors",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{member:[]},verb:{"id":"http://adlnet.gov/expapi/verbs/created",display:{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity",definition:{correctResponsesPattern:["1.23"]}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",0);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.object.definition.correctResponsesPattern","MUST_VIOLATION")).to.be.false;});it("an interaction activity without the standard \"http://adlnet.gov/expapi/activities/cmi.interaction\" value for the type property should produce a SHOULD error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{member:[]},verb:{"id":"http://adlnet.gov/expapi/verbs/created",display:{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity",definition:{type:"http://example.com/somethingElse",interactionType:"choice",choices:[]}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.object.definition.type","SHOULD_VIOLATION")).to.be.true;});it("an interaction component array property not associated with the current interactionType produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{member:[]},verb:{"id":"http://adlnet.gov/expapi/verbs/created",display:{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity",definition:{type:"http://adlnet.gov/expapi/activities/cmi.interaction",interactionType:"choice",steps:[]}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.object.definition.steps","SHOULD_VIOLATION")).to.be.true;});it("an interaction component with whitespace in the id property produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{member:[]},verb:{"id":"http://adlnet.gov/expapi/verbs/created",display:{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity",definition:{type:"http://adlnet.gov/expapi/activities/cmi.interaction",interactionType:"choice",choices:[{id:"hello invalid id",description:{}}]}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.object.definition.choices[0]","SHOULD_VIOLATION")).to.be.true;});it("an interaction component with repeated non-unique id produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{member:[]},verb:{"id":"http://adlnet.gov/expapi/verbs/created",display:{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity",definition:{type:"http://adlnet.gov/expapi/activities/cmi.interaction",interactionType:"choice",choices:[{id:"idA",description:{}},{id:"idA",description:{}}]}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.object.definition.choices[1]","MUST_VIOLATION")).to.be.true;});describe("given a statement reference type object",function(){it("reports a MUST error when the id property is missing",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{objectType:"StatementRef"}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.object.id","MUST_VIOLATION")).to.be.true;});it("reports a MUST error when the id property is not a UUID",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"not a UUID",objectType:"StatementRef"}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.object.id","MUST_VIOLATION")).to.be.true;});});describe("given a substatement type object",function(){it("should not report an error when valid",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{objectType:"SubStatement",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",0);});it("reports a MUST error when the id property is present",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa1",objectType:"SubStatement",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.object.id","MUST_VIOLATION")).to.be.true;});it("reports a MUST error when the version property is present",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{version:"1.0.0",objectType:"SubStatement",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.object.version","MUST_VIOLATION")).to.be.true;});it("reports a MUST error when the stored property is present",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{stored:"2013-05-28T07:12:57.245Z",objectType:"SubStatement",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.object.stored","MUST_VIOLATION")).to.be.true;});it("reports a MUST error when the authority property is present",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{authority:{mbox:"mailto:agent@example.com"},objectType:"SubStatement",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.object.authority","MUST_VIOLATION")).to.be.true;});});describe("given a non-Object results property",function(){it("if null, produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},result:null};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.result","MUST_VIOLATION")).to.be.true;});it("if an Array, produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},result:[]};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.result","MUST_VIOLATION")).to.be.true;});it("if an number, produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},result:1.23};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.result","MUST_VIOLATION")).to.be.true;});});describe("given a results property that is an object",function(){it("if empty, all is okay, no properties were required",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},result:{}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",0);});it("a non-Boolean success property produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},result:{success:123}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.result.success","MUST_VIOLATION")).to.be.true;});it("a Boolean success property produces no error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},result:{success:false}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",0);});it("a non-Boolean completion property produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},result:{completion:123}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.result.completion","MUST_VIOLATION")).to.be.true;});it("a Boolean completion property produces no error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},result:{completion:false}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",0);});it("a non-String response property produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},result:{response:123}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.result.response","MUST_VIOLATION")).to.be.true;});it("a String response property produces no error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},result:{response:"idA"}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",0);});it("a non-String duration property produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},result:{duration:123}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.result.duration","MUST_VIOLATION")).to.be.true;});it("a non-ISO 8601 duration String duration property produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},result:{duration:"not an ISO compliant duration"}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.result.duration","MUST_VIOLATION")).to.be.true;});it("an ISO 8601 duration String response property produces no error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},result:{duration:"P3Y6M4DT12H30M5S"}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",0);});it("an ISO 8601 duration String response property with fractional seconds produces no error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},result:{duration:"P3Y6M4DT12H30M5.01S"}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",0);});});describe("given a score property on the results",function(){it("a non-Number raw property produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},result:{score:{raw:"123"}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.result.score.raw","MUST_VIOLATION")).to.be.true;});it("a Number raw property produces no error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},result:{score:{raw:123}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",0);});it("a Number raw property below min produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},result:{score:{raw:123,min:200}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.result.score.raw","MUST_VIOLATION")).to.be.true;});it("a Number raw property above max produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},result:{score:{raw:123,max:100}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.result.score.raw","MUST_VIOLATION")).to.be.true;});it("a Number raw property between min and max produces no error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},result:{score:{raw:123,min:120,max:125}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",0);});it("a non-Number scaled property produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},result:{score:{scaled:"0.5"}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.result.score.scaled","MUST_VIOLATION")).to.be.true;});it("a Number scaled property produces no error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},result:{score:{scaled:0.5}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",0);});it("a Number scaled property below 0 produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},result:{score:{scaled:-0.5}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.result.score.scaled","MUST_VIOLATION")).to.be.true;});it("a Number scaled property above 1 produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},result:{score:{scaled:2}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.result.score.scaled","MUST_VIOLATION")).to.be.true;});it("a non-Number max property produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},result:{score:{max:"123"}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.result.score.max","MUST_VIOLATION")).to.be.true;});it("a Number max property produces no error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},result:{score:{max:123}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",0);});it("a Number max property below min produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},result:{score:{max:123,min:200}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.result.score.max","MUST_VIOLATION")).to.be.true;});it("a non-Number min property produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},result:{score:{min:"123"}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.result.score.min","MUST_VIOLATION")).to.be.true;});it("a Number min property produces no error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},result:{score:{min:123}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",0);});it("a Number min property above max produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},result:{score:{max:123,min:200}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.result.score.max","MUST_VIOLATION")).to.be.true;});});describe("for a given defined context property",function(){it("an empty object produces no errors",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},context:{}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",0);});it("an non-object context value produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},context:123};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.context","MUST_VIOLATION")).to.be.true;});it("an array context value produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},context:[]};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.context","MUST_VIOLATION")).to.be.true;});it("a non-UUID registration value produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},context:{registration:"not a UUID"}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.context.registration","MUST_VIOLATION")).to.be.true;});it("a UUID registration value produces no error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},context:{registration:"ed41c918-b88b-4b20-a0a5-a4c32391aaa0"}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",0);});it("an empty map for an instructor value produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},context:{instructor:{}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.context.instructor","MUST_VIOLATION")).to.be.true;});it("an unidentified Agent for an instructor value produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},context:{instructor:{objectType:"Agent"}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.context.instructor","MUST_VIOLATION")).to.be.true;});it("an unidentified Group with no member property for an instructor value produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},context:{instructor:{objectType:"Group"}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.context.instructor","MUST_VIOLATION")).to.be.true;});it("an Agent instructor value produces no error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},context:{instructor:{mbox:"mailto:bob@example.com"}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",0);});it("a Group instructor identified by member property produces no error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},context:{instructor:{mbox:"mailto:bob@example.com",member:[]}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",0);});it("a Group instructor identified by objectType property produces no error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},context:{instructor:{mbox:"mailto:bob@example.com",objectType:"Group"}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",0);});it("if the statement's object is an Agent, the presence of the revision property will result in an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{mbox:"mailto:bob@example.com",objectType:"Agent"},context:{revision:"1.0"}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.context.revision","MUST_VIOLATION")).to.be.true;});it("if the statement's object is an Group, the presence of the revision property will result in an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{mbox:"mailto:group@example.com",objectType:"Group"},context:{revision:"1.0"}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.context.revision","MUST_VIOLATION")).to.be.true;});it("a String revision property produces no error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},context:{revision:"1.0"}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",0);});it("a non-String numeric revision property will result in an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},context:{revision:1.0}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.context.revision","MUST_VIOLATION")).to.be.true;});it("a null revision property will result in an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},context:{revision:null}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.context.revision","MUST_VIOLATION")).to.be.true;});/// +it("if the statement's object is an Agent, the presence of the platform property will result in an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{mbox:"mailto:bob@example.com",objectType:"Agent"},context:{platform:"1.0"}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.context.platform","MUST_VIOLATION")).to.be.true;});it("if the statement's object is an Group, the presence of the platform property will result in an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{mbox:"mailto:group@example.com",objectType:"Group"},context:{platform:"1.0"}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.context.platform","MUST_VIOLATION")).to.be.true;});it("a String platform property produces no error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},context:{platform:"1.0"}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",0);});it("a non-String numeric platform property will result in an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},context:{platform:1.0}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.context.platform","MUST_VIOLATION")).to.be.true;});it("a null platform property will result in an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},context:{platform:null}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.context.platform","MUST_VIOLATION")).to.be.true;});it("a null team property will result in an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},context:{team:null}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.context.team","MUST_VIOLATION")).to.be.true;});it("a Group object team property will result in no error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},context:{team:{objectType:"Group",mbox:"mailto:group@example.com"}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",0);});it("a RFC 5646 string value for the language property will result in no error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},context:{language:"en-US"}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",0);});it("a non-RFC 5646 string value for the language property will result in an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},context:{language:"123 totally not RFC compliant"}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.context.language","MUST_VIOLATION")).to.be.true;});it("a null value for the language property will result in an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},context:{language:null}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.context.language","MUST_VIOLATION")).to.be.true;});it("a non-String value for the language property will result in an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},context:{language:1}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.context.language","MUST_VIOLATION")).to.be.true;});it("a null value for the context's statement property will result in an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},context:{statement:null}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.context.statement","MUST_VIOLATION")).to.be.true;});it("an Array value for the context's statement property will result in an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},context:{statement:[]}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.context.statement","MUST_VIOLATION")).to.be.true;});it("an empty object value for the context's statement property will result in errors",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},context:{statement:{}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",2);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.context.statement.objectType","MUST_VIOLATION")).to.be.true;(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.context.statement.id","MUST_VIOLATION")).to.be.true;});it("a valid statement reference for the context's statement property will result in no errors",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},context:{statement:{objectType:"StatementRef",id:"abcdc918-b88b-4b20-a0a5-a4c32391aaa0"}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",0);});});describe("for a context property with a contextActivities property",function(){it("a null contextActivities value produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},context:{contextActivities:null}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.context.contextActivities","MUST_VIOLATION")).to.be.true;});it("an Array contextActivities value produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},context:{contextActivities:[]}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.context.contextActivities","MUST_VIOLATION")).to.be.true;});it("an Numeric contextActivities value produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},context:{contextActivities:1.23}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.context.contextActivities","MUST_VIOLATION")).to.be.true;});it("an empty contextActivities object value produces no errors",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},context:{contextActivities:{}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",0);});it("a single Activity parent property value produces a SHOULD warning",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},context:{contextActivities:{parent:{id:"http://example.com/myOtherActivityUniqueId",objectType:"Activity"}}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.context.contextActivities","SHOULD_VIOLATION")).to.be.true;});it("an empty Array parent property value produces no errors",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},context:{contextActivities:{parent:[]}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",0);});it("an Array with a valid Activity in the parent property produces no errors",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},context:{contextActivities:{parent:[{id:"http://example.com/myOtherActivityUniqueId",objectType:"Activity"}]}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",0);});it("an Array with a invalid Activity in the parent property produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},context:{contextActivities:{parent:[{objectType:"Activity"}]}}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.context.contextActivities.parent[0].id","MUST_VIOLATION")).to.be.true;});});describe("given a timestamp property on the statement",function(){it("a null value produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},timestamp:null};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.timestamp","MUST_VIOLATION")).to.be.true;});it("a numeric value produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},timestamp:1.23};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.timestamp","MUST_VIOLATION")).to.be.true;});it("a Date value produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},timestamp:new Date()};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.timestamp","MUST_VIOLATION")).to.be.true;});it("a String value not in ISO 8601 produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},timestamp:"totally wrong"};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.timestamp","MUST_VIOLATION")).to.be.true;});it("a String value with ISO 8601 at UTC via Z produces no error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},timestamp:"2013-05-09T14:45:15Z"};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",0);});it("a String value with ISO 8601 at UTC via Z with millisecond precision produces no error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},timestamp:"2013-05-09T14:45:15.008Z"};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",0);});it("a String value with ISO 8601 with a positive timezone offset hour produces no error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},timestamp:"2013-05-09T14:45:15+01"};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",0);});it("a String value with ISO 8601 with a positive timezone offset hour and minutes produces no error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},timestamp:"2013-05-09T14:45:15+01:02"};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",0);});it("a String value with ISO 8601 with a negative timezone offset hour produces no error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},timestamp:"2013-05-09T14:45:15-01"};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",0);});it("a String value with ISO 8601 with a negative timezone offset hour and minutes produces no error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},timestamp:"2013-05-09T14:45:15-01:02"};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",0);});it("a String value with ISO8601 with no timezone offset or Z produces a SHOULD error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},timestamp:"2013-05-09T14:45:15"};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.timestamp","SHOULD_VIOLATION")).to.be.true;});});describe("given a stored property on the statement",function(){it("a null value produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},stored:null};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.stored","MUST_VIOLATION")).to.be.true;});it("a numeric value produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},stored:1.23};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.stored","MUST_VIOLATION")).to.be.true;});it("a Date value produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},stored:new Date()};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.stored","MUST_VIOLATION")).to.be.true;});it("a String value not in ISO 8601 produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},stored:"totally wrong"};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.stored","MUST_VIOLATION")).to.be.true;});it("a String value with ISO 8601 at UTC via Z produces no error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},stored:"2013-05-09T14:45:15Z"};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",0);});it("a String value with ISO 8601 at UTC via Z with millisecond precision produces no error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},stored:"2013-05-09T14:45:15.008Z"};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",0);});it("a String value with ISO 8601 with a positive timezone offset hour produces no error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},stored:"2013-05-09T14:45:15+01"};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",0);});it("a String value with ISO 8601 with a positive timezone offset hour and minutes produces no error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},stored:"2013-05-09T14:45:15+01:02"};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",0);});it("a String value with ISO 8601 with a negative timezone offset hour produces no error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},stored:"2013-05-09T14:45:15-01"};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",0);});it("a String value with ISO 8601 with a negative timezone offset hour and minutes produces no error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},stored:"2013-05-09T14:45:15-01:02"};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",0);});it("a String value with ISO8601 with no timezone offset or Z produces a SHOULD error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},stored:"2013-05-09T14:45:15"};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.stored","SHOULD_VIOLATION")).to.be.true;});});describe("for a non-object authority property on the statement",function(){it("a null authority value produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},authority:null};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.authority","MUST_VIOLATION")).to.be.true;});it("an Array authority value produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},authority:[]};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.authority","MUST_VIOLATION")).to.be.true;});it("an Numeric authority value produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},authority:[]};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.authority","MUST_VIOLATION")).to.be.true;});});describe("for an authority property with an object value on the statement",function(){it("an Agent authority value produces no errors",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},authority:{objectType:"Agent",mbox:"mailto:bob@example.com"}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",0);});it("an Agent authority value produces an error if an invalid Agent",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},authority:{objectType:"Agent"}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.authority","MUST_VIOLATION")).to.be.true;});it("an Group authority value with two members produces no errors",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},authority:{objectType:"Group",member:[{objectType:"Agent",mbox:"mailto:bob@example.com"},{objectType:"Agent",mbox:"mailto:tom@example.com"}]}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",0);});it("an Group authority value with less than two members produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},authority:{objectType:"Group",member:[{objectType:"Agent",mbox:"mailto:bob@example.com"}]}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.authority.member","MUST_VIOLATION")).to.be.true;});it("an Group authority value with more than two members produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},authority:{objectType:"Group",member:[{objectType:"Agent",mbox:"mailto:bob@example.com"},{objectType:"Agent",mbox:"mailto:tom@example.com"},{objectType:"Agent",mbox:"mailto:frank@example.com"}]}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.authority.member","MUST_VIOLATION")).to.be.true;});it("an Group authority value with an invalid member produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},authority:{objectType:"Group",member:[{objectType:"Agent",mbox:"mailto:bob@example.com"},{objectType:"Agent"}]}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.authority.member[1]","MUST_VIOLATION")).to.be.true;});});describe("for an version property on the statement with a non-string value",function(){it("a null value produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},version:null};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.version","MUST_VIOLATION")).to.be.true;});it("a numeric value produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},version:1.0};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.version","MUST_VIOLATION")).to.be.true;});});describe("for an version property with a string value",function(){it("a simple semantic version produces no error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},version:"1.0.0"};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",0);});it("a semantic version with intermixed non-numbers in the major/minor/patch produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},version:"1.0.a"};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.version","MUST_VIOLATION")).to.be.true;});it("a semantic version with valid pre-release info produces no error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},version:"1.0.0-rc1"};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",0);});it("a semantic version with invalid pre-release info produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},version:"1.0.0-rc.1"};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.version","MUST_VIOLATION")).to.be.true;});it("a semantic version with SemVer 2.0.0 build release info characters not in SemVer 1.0.0 produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},version:"1.0.0-alpha.1"};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.version","MUST_VIOLATION")).to.be.true;});it("a semantic version with SemVer 2.0.0 build release metadata not in SemVer 1.0.0 produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},version:"1.0.0-alpha+001"};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.version","MUST_VIOLATION")).to.be.true;});});describe("for an attachments property on the statement with a non-Array value",function(){it("a null value produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},attachments:null};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.attachments","MUST_VIOLATION")).to.be.true;});it("a numeric value produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},attachments:1.0};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.attachments","MUST_VIOLATION")).to.be.true;});it("an object map value produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},attachments:{}};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.attachments","MUST_VIOLATION")).to.be.true;});});describe("for an attachments property on the statement with an Array value",function(){it("an empty Array produces no error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},attachments:[]};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",0);});});describe("for an attachment object within the attachments property's Array on the statement",function(){it("a null object produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},attachments:[null]};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.attachments[0]","MUST_VIOLATION")).to.be.true;});it("minimal valid attachment object produces no error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},attachments:[{usageType:"http://example.com/usage/info/A",display:{},contentType:"text/plain",length:11,sha2:"uU0nuZNNPgilLlLX2n2r+sSE7+N6U4DukIj3rOLvzek="}]};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",0);});it("an absent usageType property object produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},attachments:[{display:{},contentType:"text/plain",length:11,sha2:"uU0nuZNNPgilLlLX2n2r+sSE7+N6U4DukIj3rOLvzek="}]};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.attachments[0].usageType","MUST_VIOLATION")).to.be.true;});it("a null usageType property object produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},attachments:[{usageType:null,display:{},contentType:"text/plain",length:11,sha2:"uU0nuZNNPgilLlLX2n2r+sSE7+N6U4DukIj3rOLvzek="}]};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.attachments[0].usageType","MUST_VIOLATION")).to.be.true;});it("a numeric usageType property object produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},attachments:[{usageType:123,display:{},contentType:"text/plain",length:11,sha2:"uU0nuZNNPgilLlLX2n2r+sSE7+N6U4DukIj3rOLvzek="}]};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.attachments[0].usageType","MUST_VIOLATION")).to.be.true;});it("an object usageType property object produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},attachments:[{usageType:{},display:{},contentType:"text/plain",length:11,sha2:"uU0nuZNNPgilLlLX2n2r+sSE7+N6U4DukIj3rOLvzek="}]};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.attachments[0].usageType","MUST_VIOLATION")).to.be.true;});it("an absent contentType property object produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},attachments:[{usageType:"http://example.com/usage/info/A",display:{},length:11,sha2:"uU0nuZNNPgilLlLX2n2r+sSE7+N6U4DukIj3rOLvzek="}]};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.attachments[0].contentType","MUST_VIOLATION")).to.be.true;});it("a null contentType property object produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},attachments:[{usageType:"http://example.com/usage/info/A",display:{},contentType:null,length:11,sha2:"uU0nuZNNPgilLlLX2n2r+sSE7+N6U4DukIj3rOLvzek="}]};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.attachments[0].contentType","MUST_VIOLATION")).to.be.true;});it("an absent length property object produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},attachments:[{usageType:"http://example.com/usage/info/A",display:{},contentType:"text/plain",sha2:"uU0nuZNNPgilLlLX2n2r+sSE7+N6U4DukIj3rOLvzek="}]};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.attachments[0].length","MUST_VIOLATION")).to.be.true;});it("a null length property object produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},attachments:[{usageType:"http://example.com/usage/info/A",display:{},contentType:"text/plain",length:null,sha2:"uU0nuZNNPgilLlLX2n2r+sSE7+N6U4DukIj3rOLvzek="}]};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.attachments[0].length","MUST_VIOLATION")).to.be.true;});it("a string length property object produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},attachments:[{usageType:"http://example.com/usage/info/A",display:{},contentType:"text/plain",length:"11",sha2:"uU0nuZNNPgilLlLX2n2r+sSE7+N6U4DukIj3rOLvzek="}]};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.attachments[0].length","MUST_VIOLATION")).to.be.true;});it("a non-integer length property object produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},attachments:[{usageType:"http://example.com/usage/info/A",display:{},contentType:"text/plain",length:11.5,sha2:"uU0nuZNNPgilLlLX2n2r+sSE7+N6U4DukIj3rOLvzek="}]};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.attachments[0].length","MUST_VIOLATION")).to.be.true;});it("a null sha2 property produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},attachments:[{usageType:"http://example.com/usage/info/A",display:{},contentType:"text/plain",length:11,sha2:null}]};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.attachments[0].sha2","MUST_VIOLATION")).to.be.true;});it("an absent sha2 property produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},attachments:[{usageType:"http://example.com/usage/info/A",display:{},contentType:"text/plain",length:11}]};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.attachments[0].sha2","MUST_VIOLATION")).to.be.true;});it("a numeric sha2 property produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},attachments:[{usageType:"http://example.com/usage/info/A",display:{},contentType:"text/plain",length:11,sha2:1.23}]};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.attachments[0].sha2","MUST_VIOLATION")).to.be.true;});it("a non-base64 sha2 property object produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},attachments:[{usageType:"http://example.com/usage/info/A",display:{},contentType:"text/plain",length:11,sha2:"uses ~ - characters &^% not in base64"}]};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.attachments[0].sha2","MUST_VIOLATION")).to.be.true;});it("a null fileUrl property produces an error",function(){var inputStatement={id:"fd41c918-b88b-4b20-a0a5-a4c32391aaa0",actor:{mbox:"mailto:agent@example.com"},verb:{"id":"http://adlnet.gov/expapi/verbs/created","display":{"en-US":"created"}},object:{id:"http://example.com/myUniqueId",objectType:"Activity"},attachments:[{usageType:"http://example.com/usage/info/A",display:{},fileUrl:null,contentType:"text/plain",length:11,sha2:"uU0nuZNNPgilLlLX2n2r+sSE7+N6U4DukIj3rOLvzek="}]};var results=_xapiValidator.xapiValidator.validateStatement(inputStatement);(0,_chai.expect)(results.errors).to.have.property("length",1);(0,_chai.expect)(reportHasErrorWithTracePrefix(results,"statement.attachments[0].fileUrl","MUST_VIOLATION")).to.be.true;});});});});}); + +},{"../src/xapiValidator":48,"chai":4,"underscore":41}]},{},[49])(49) +}); +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","node_modules/assertion-error/index.js","node_modules/base64-js/index.js","node_modules/buffer/index.js","node_modules/chai/index.js","node_modules/chai/lib/chai.js","node_modules/chai/lib/chai/assertion.js","node_modules/chai/lib/chai/config.js","node_modules/chai/lib/chai/core/assertions.js","node_modules/chai/lib/chai/interface/assert.js","node_modules/chai/lib/chai/interface/expect.js","node_modules/chai/lib/chai/interface/should.js","node_modules/chai/lib/chai/utils/addChainableMethod.js","node_modules/chai/lib/chai/utils/addMethod.js","node_modules/chai/lib/chai/utils/addProperty.js","node_modules/chai/lib/chai/utils/expectTypes.js","node_modules/chai/lib/chai/utils/flag.js","node_modules/chai/lib/chai/utils/getActual.js","node_modules/chai/lib/chai/utils/getEnumerableProperties.js","node_modules/chai/lib/chai/utils/getMessage.js","node_modules/chai/lib/chai/utils/getName.js","node_modules/chai/lib/chai/utils/getPathInfo.js","node_modules/chai/lib/chai/utils/getPathValue.js","node_modules/chai/lib/chai/utils/getProperties.js","node_modules/chai/lib/chai/utils/hasProperty.js","node_modules/chai/lib/chai/utils/index.js","node_modules/chai/lib/chai/utils/inspect.js","node_modules/chai/lib/chai/utils/objDisplay.js","node_modules/chai/lib/chai/utils/overwriteChainableMethod.js","node_modules/chai/lib/chai/utils/overwriteMethod.js","node_modules/chai/lib/chai/utils/overwriteProperty.js","node_modules/chai/lib/chai/utils/test.js","node_modules/chai/lib/chai/utils/transferFlags.js","node_modules/deep-eql/index.js","node_modules/deep-eql/lib/eql.js","node_modules/deep-eql/node_modules/type-detect/index.js","node_modules/deep-eql/node_modules/type-detect/lib/type.js","node_modules/ieee754/index.js","node_modules/isarray/index.js","node_modules/type-detect/lib/type.js","node_modules/underscore/underscore.js","src/constants/errors.js","src/constants/general.js","src/constants/interaction-types.js","src/constants/properties.js","src/constants/regex.js","src/utils/utils.js","src/xapiValidator.js","test/xapiValidator.test.js"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AClHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC7vDA;AACA;;ACDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7FA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACp0DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7mDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/GA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/UA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7CA;AACA;;ACDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjQA;AACA;;ACDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9IA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpFA;AACA;AACA;AACA;AACA;AACA;;;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAC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","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","/*!\n * assertion-error\n * Copyright(c) 2013 Jake Luer <jake@qualiancy.com>\n * MIT Licensed\n */\n\n/*!\n * Return a function that will copy properties from\n * one object to another excluding any originally\n * listed. Returned function will create a new `{}`.\n *\n * @param {String} excluded properties ...\n * @return {Function}\n */\n\nfunction exclude () {\n  var excludes = [].slice.call(arguments);\n\n  function excludeProps (res, obj) {\n    Object.keys(obj).forEach(function (key) {\n      if (!~excludes.indexOf(key)) res[key] = obj[key];\n    });\n  }\n\n  return function extendExclude () {\n    var args = [].slice.call(arguments)\n      , i = 0\n      , res = {};\n\n    for (; i < args.length; i++) {\n      excludeProps(res, args[i]);\n    }\n\n    return res;\n  };\n};\n\n/*!\n * Primary Exports\n */\n\nmodule.exports = AssertionError;\n\n/**\n * ### AssertionError\n *\n * An extension of the JavaScript `Error` constructor for\n * assertion and validation scenarios.\n *\n * @param {String} message\n * @param {Object} properties to include (optional)\n * @param {callee} start stack function (optional)\n */\n\nfunction AssertionError (message, _props, ssf) {\n  var extend = exclude('name', 'message', 'stack', 'constructor', 'toJSON')\n    , props = extend(_props || {});\n\n  // default values\n  this.message = message || 'Unspecified AssertionError';\n  this.showDiff = false;\n\n  // copy from properties\n  for (var key in props) {\n    this[key] = props[key];\n  }\n\n  // capture stack trace\n  ssf = ssf || arguments.callee;\n  if (ssf && Error.captureStackTrace) {\n    Error.captureStackTrace(this, ssf);\n  } else {\n    try {\n      throw new Error();\n    } catch(e) {\n      this.stack = e.stack;\n    }\n  }\n}\n\n/*!\n * Inherit from Error.prototype\n */\n\nAssertionError.prototype = Object.create(Error.prototype);\n\n/*!\n * Statically set name\n */\n\nAssertionError.prototype.name = 'AssertionError';\n\n/*!\n * Ensure correct constructor\n */\n\nAssertionError.prototype.constructor = AssertionError;\n\n/**\n * Allow errors to be converted to JSON for static transfer.\n *\n * @param {Boolean} include stack (default: `true`)\n * @return {Object} object that can be `JSON.stringify`\n */\n\nAssertionError.prototype.toJSON = function (stack) {\n  var extend = exclude('constructor', 'toJSON', 'stack')\n    , props = extend({ name: this.name }, this);\n\n  // include stack if exists and not turned off\n  if (false !== stack && this.stack) {\n    props.stack = this.stack;\n  }\n\n  return props;\n};\n","'use strict'\n\nexports.byteLength = byteLength\nexports.toByteArray = toByteArray\nexports.fromByteArray = fromByteArray\n\nvar lookup = []\nvar revLookup = []\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\n\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\nfor (var i = 0, len = code.length; i < len; ++i) {\n  lookup[i] = code[i]\n  revLookup[code.charCodeAt(i)] = i\n}\n\nrevLookup['-'.charCodeAt(0)] = 62\nrevLookup['_'.charCodeAt(0)] = 63\n\nfunction placeHoldersCount (b64) {\n  var len = b64.length\n  if (len % 4 > 0) {\n    throw new Error('Invalid string. Length must be a multiple of 4')\n  }\n\n  // the number of equal signs (place holders)\n  // if there are two placeholders, than the two characters before it\n  // represent one byte\n  // if there is only one, then the three characters before it represent 2 bytes\n  // this is just a cheap hack to not do indexOf twice\n  return b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0\n}\n\nfunction byteLength (b64) {\n  // base64 is 4/3 + up to two characters of the original data\n  return b64.length * 3 / 4 - placeHoldersCount(b64)\n}\n\nfunction toByteArray (b64) {\n  var i, j, l, tmp, placeHolders, arr\n  var len = b64.length\n  placeHolders = placeHoldersCount(b64)\n\n  arr = new Arr(len * 3 / 4 - placeHolders)\n\n  // if there are placeholders, only get up to the last complete 4 chars\n  l = placeHolders > 0 ? len - 4 : len\n\n  var L = 0\n\n  for (i = 0, j = 0; i < l; i += 4, j += 3) {\n    tmp = (revLookup[b64.charCodeAt(i)] << 18) | (revLookup[b64.charCodeAt(i + 1)] << 12) | (revLookup[b64.charCodeAt(i + 2)] << 6) | revLookup[b64.charCodeAt(i + 3)]\n    arr[L++] = (tmp >> 16) & 0xFF\n    arr[L++] = (tmp >> 8) & 0xFF\n    arr[L++] = tmp & 0xFF\n  }\n\n  if (placeHolders === 2) {\n    tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4)\n    arr[L++] = tmp & 0xFF\n  } else if (placeHolders === 1) {\n    tmp = (revLookup[b64.charCodeAt(i)] << 10) | (revLookup[b64.charCodeAt(i + 1)] << 4) | (revLookup[b64.charCodeAt(i + 2)] >> 2)\n    arr[L++] = (tmp >> 8) & 0xFF\n    arr[L++] = tmp & 0xFF\n  }\n\n  return arr\n}\n\nfunction tripletToBase64 (num) {\n  return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n  var tmp\n  var output = []\n  for (var i = start; i < end; i += 3) {\n    tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])\n    output.push(tripletToBase64(tmp))\n  }\n  return output.join('')\n}\n\nfunction fromByteArray (uint8) {\n  var tmp\n  var len = uint8.length\n  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n  var output = ''\n  var parts = []\n  var maxChunkLength = 16383 // must be multiple of 3\n\n  // go through the array every three bytes, we'll deal with trailing stuff later\n  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n    parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))\n  }\n\n  // pad the end with zeros, but make sure to not forget the extra bytes\n  if (extraBytes === 1) {\n    tmp = uint8[len - 1]\n    output += lookup[tmp >> 2]\n    output += lookup[(tmp << 4) & 0x3F]\n    output += '=='\n  } else if (extraBytes === 2) {\n    tmp = (uint8[len - 2] << 8) + (uint8[len - 1])\n    output += lookup[tmp >> 10]\n    output += lookup[(tmp >> 4) & 0x3F]\n    output += lookup[(tmp << 2) & 0x3F]\n    output += '='\n  }\n\n  parts.push(output)\n\n  return parts.join('')\n}\n","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n * @license  MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\nvar base64 = require('base64-js')\nvar ieee754 = require('ieee754')\nvar isArray = require('isarray')\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Use Object implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * Due to various browser bugs, sometimes the Object implementation will be used even\n * when the browser supports typed arrays.\n *\n * Note:\n *\n *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,\n *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\n *\n *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\n *\n *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\n *     incorrect length in some situations.\n\n * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they\n * get the Object implementation, which is slower but behaves correctly.\n */\nBuffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined\n  ? global.TYPED_ARRAY_SUPPORT\n  : typedArraySupport()\n\n/*\n * Export kMaxLength after typed array support is determined.\n */\nexports.kMaxLength = kMaxLength()\n\nfunction typedArraySupport () {\n  try {\n    var arr = new Uint8Array(1)\n    arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}\n    return arr.foo() === 42 && // typed array instances can be augmented\n        typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`\n        arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`\n  } catch (e) {\n    return false\n  }\n}\n\nfunction kMaxLength () {\n  return Buffer.TYPED_ARRAY_SUPPORT\n    ? 0x7fffffff\n    : 0x3fffffff\n}\n\nfunction createBuffer (that, length) {\n  if (kMaxLength() < length) {\n    throw new RangeError('Invalid typed array length')\n  }\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = new Uint8Array(length)\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    if (that === null) {\n      that = new Buffer(length)\n    }\n    that.length = length\n  }\n\n  return that\n}\n\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\nfunction Buffer (arg, encodingOrOffset, length) {\n  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {\n    return new Buffer(arg, encodingOrOffset, length)\n  }\n\n  // Common case.\n  if (typeof arg === 'number') {\n    if (typeof encodingOrOffset === 'string') {\n      throw new Error(\n        'If encoding is specified then the first argument must be a string'\n      )\n    }\n    return allocUnsafe(this, arg)\n  }\n  return from(this, arg, encodingOrOffset, length)\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\n// TODO: Legacy, not needed anymore. Remove in next major version.\nBuffer._augment = function (arr) {\n  arr.__proto__ = Buffer.prototype\n  return arr\n}\n\nfunction from (that, value, encodingOrOffset, length) {\n  if (typeof value === 'number') {\n    throw new TypeError('\"value\" argument must not be a number')\n  }\n\n  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {\n    return fromArrayBuffer(that, value, encodingOrOffset, length)\n  }\n\n  if (typeof value === 'string') {\n    return fromString(that, value, encodingOrOffset)\n  }\n\n  return fromObject(that, value)\n}\n\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\nBuffer.from = function (value, encodingOrOffset, length) {\n  return from(null, value, encodingOrOffset, length)\n}\n\nif (Buffer.TYPED_ARRAY_SUPPORT) {\n  Buffer.prototype.__proto__ = Uint8Array.prototype\n  Buffer.__proto__ = Uint8Array\n  if (typeof Symbol !== 'undefined' && Symbol.species &&\n      Buffer[Symbol.species] === Buffer) {\n    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97\n    Object.defineProperty(Buffer, Symbol.species, {\n      value: null,\n      configurable: true\n    })\n  }\n}\n\nfunction assertSize (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('\"size\" argument must be a number')\n  } else if (size < 0) {\n    throw new RangeError('\"size\" argument must not be negative')\n  }\n}\n\nfunction alloc (that, size, fill, encoding) {\n  assertSize(size)\n  if (size <= 0) {\n    return createBuffer(that, size)\n  }\n  if (fill !== undefined) {\n    // Only pay attention to encoding if it's a string. This\n    // prevents accidentally sending in a number that would\n    // be interpretted as a start offset.\n    return typeof encoding === 'string'\n      ? createBuffer(that, size).fill(fill, encoding)\n      : createBuffer(that, size).fill(fill)\n  }\n  return createBuffer(that, size)\n}\n\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\nBuffer.alloc = function (size, fill, encoding) {\n  return alloc(null, size, fill, encoding)\n}\n\nfunction allocUnsafe (that, size) {\n  assertSize(size)\n  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) {\n    for (var i = 0; i < size; ++i) {\n      that[i] = 0\n    }\n  }\n  return that\n}\n\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\nBuffer.allocUnsafe = function (size) {\n  return allocUnsafe(null, size)\n}\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\nBuffer.allocUnsafeSlow = function (size) {\n  return allocUnsafe(null, size)\n}\n\nfunction fromString (that, string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') {\n    encoding = 'utf8'\n  }\n\n  if (!Buffer.isEncoding(encoding)) {\n    throw new TypeError('\"encoding\" must be a valid string encoding')\n  }\n\n  var length = byteLength(string, encoding) | 0\n  that = createBuffer(that, length)\n\n  var actual = that.write(string, encoding)\n\n  if (actual !== length) {\n    // Writing a hex string, for example, that contains invalid characters will\n    // cause everything after the first invalid character to be ignored. (e.g.\n    // 'abxxcd' will be treated as 'ab')\n    that = that.slice(0, actual)\n  }\n\n  return that\n}\n\nfunction fromArrayLike (that, array) {\n  var length = array.length < 0 ? 0 : checked(array.length) | 0\n  that = createBuffer(that, length)\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255\n  }\n  return that\n}\n\nfunction fromArrayBuffer (that, array, byteOffset, length) {\n  array.byteLength // this throws if `array` is not a valid ArrayBuffer\n\n  if (byteOffset < 0 || array.byteLength < byteOffset) {\n    throw new RangeError('\\'offset\\' is out of bounds')\n  }\n\n  if (array.byteLength < byteOffset + (length || 0)) {\n    throw new RangeError('\\'length\\' is out of bounds')\n  }\n\n  if (byteOffset === undefined && length === undefined) {\n    array = new Uint8Array(array)\n  } else if (length === undefined) {\n    array = new Uint8Array(array, byteOffset)\n  } else {\n    array = new Uint8Array(array, byteOffset, length)\n  }\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = array\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    that = fromArrayLike(that, array)\n  }\n  return that\n}\n\nfunction fromObject (that, obj) {\n  if (Buffer.isBuffer(obj)) {\n    var len = checked(obj.length) | 0\n    that = createBuffer(that, len)\n\n    if (that.length === 0) {\n      return that\n    }\n\n    obj.copy(that, 0, 0, len)\n    return that\n  }\n\n  if (obj) {\n    if ((typeof ArrayBuffer !== 'undefined' &&\n        obj.buffer instanceof ArrayBuffer) || 'length' in obj) {\n      if (typeof obj.length !== 'number' || isnan(obj.length)) {\n        return createBuffer(that, 0)\n      }\n      return fromArrayLike(that, obj)\n    }\n\n    if (obj.type === 'Buffer' && isArray(obj.data)) {\n      return fromArrayLike(that, obj.data)\n    }\n  }\n\n  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')\n}\n\nfunction checked (length) {\n  // Note: cannot use `length < kMaxLength()` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= kMaxLength()) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n                         'size: 0x' + kMaxLength().toString(16) + ' bytes')\n  }\n  return length | 0\n}\n\nfunction SlowBuffer (length) {\n  if (+length != length) { // eslint-disable-line eqeqeq\n    length = 0\n  }\n  return Buffer.alloc(+length)\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n  return !!(b != null && b._isBuffer)\n}\n\nBuffer.compare = function compare (a, b) {\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n    throw new TypeError('Arguments must be Buffers')\n  }\n\n  if (a === b) return 0\n\n  var x = a.length\n  var y = b.length\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i]\n      y = b[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'latin1':\n    case 'binary':\n    case 'base64':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true\n    default:\n      return false\n  }\n}\n\nBuffer.concat = function concat (list, length) {\n  if (!isArray(list)) {\n    throw new TypeError('\"list\" argument must be an Array of Buffers')\n  }\n\n  if (list.length === 0) {\n    return Buffer.alloc(0)\n  }\n\n  var i\n  if (length === undefined) {\n    length = 0\n    for (i = 0; i < list.length; ++i) {\n      length += list[i].length\n    }\n  }\n\n  var buffer = Buffer.allocUnsafe(length)\n  var pos = 0\n  for (i = 0; i < list.length; ++i) {\n    var buf = list[i]\n    if (!Buffer.isBuffer(buf)) {\n      throw new TypeError('\"list\" argument must be an Array of Buffers')\n    }\n    buf.copy(buffer, pos)\n    pos += buf.length\n  }\n  return buffer\n}\n\nfunction byteLength (string, encoding) {\n  if (Buffer.isBuffer(string)) {\n    return string.length\n  }\n  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&\n      (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {\n    return string.byteLength\n  }\n  if (typeof string !== 'string') {\n    string = '' + string\n  }\n\n  var len = string.length\n  if (len === 0) return 0\n\n  // Use a for loop to avoid recursion\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n        return len\n      case 'utf8':\n      case 'utf-8':\n      case undefined:\n        return utf8ToBytes(string).length\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return len * 2\n      case 'hex':\n        return len >>> 1\n      case 'base64':\n        return base64ToBytes(string).length\n      default:\n        if (loweredCase) return utf8ToBytes(string).length // assume utf8\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n  var loweredCase = false\n\n  // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n  // property of a typed array.\n\n  // This behaves neither like String nor Uint8Array in that we set start/end\n  // to their upper/lower bounds if the value passed is out of range.\n  // undefined is handled specially as per ECMA-262 6th Edition,\n  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n  if (start === undefined || start < 0) {\n    start = 0\n  }\n  // Return early if start > this.length. Done here to prevent potential uint32\n  // coercion fail below.\n  if (start > this.length) {\n    return ''\n  }\n\n  if (end === undefined || end > this.length) {\n    end = this.length\n  }\n\n  if (end <= 0) {\n    return ''\n  }\n\n  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.\n  end >>>= 0\n  start >>>= 0\n\n  if (end <= start) {\n    return ''\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  while (true) {\n    switch (encoding) {\n      case 'hex':\n        return hexSlice(this, start, end)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Slice(this, start, end)\n\n      case 'ascii':\n        return asciiSlice(this, start, end)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Slice(this, start, end)\n\n      case 'base64':\n        return base64Slice(this, start, end)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return utf16leSlice(this, start, end)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = (encoding + '').toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\n// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect\n// Buffer instances.\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n  var i = b[n]\n  b[n] = b[m]\n  b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n  var len = this.length\n  if (len % 2 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 16-bits')\n  }\n  for (var i = 0; i < len; i += 2) {\n    swap(this, i, i + 1)\n  }\n  return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n  var len = this.length\n  if (len % 4 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 32-bits')\n  }\n  for (var i = 0; i < len; i += 4) {\n    swap(this, i, i + 3)\n    swap(this, i + 1, i + 2)\n  }\n  return this\n}\n\nBuffer.prototype.swap64 = function swap64 () {\n  var len = this.length\n  if (len % 8 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 64-bits')\n  }\n  for (var i = 0; i < len; i += 8) {\n    swap(this, i, i + 7)\n    swap(this, i + 1, i + 6)\n    swap(this, i + 2, i + 5)\n    swap(this, i + 3, i + 4)\n  }\n  return this\n}\n\nBuffer.prototype.toString = function toString () {\n  var length = this.length | 0\n  if (length === 0) return ''\n  if (arguments.length === 0) return utf8Slice(this, 0, length)\n  return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.equals = function equals (b) {\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n  if (this === b) return true\n  return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n  var str = ''\n  var max = exports.INSPECT_MAX_BYTES\n  if (this.length > 0) {\n    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')\n    if (this.length > max) str += ' ... '\n  }\n  return '<Buffer ' + str + '>'\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n  if (!Buffer.isBuffer(target)) {\n    throw new TypeError('Argument must be a Buffer')\n  }\n\n  if (start === undefined) {\n    start = 0\n  }\n  if (end === undefined) {\n    end = target ? target.length : 0\n  }\n  if (thisStart === undefined) {\n    thisStart = 0\n  }\n  if (thisEnd === undefined) {\n    thisEnd = this.length\n  }\n\n  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n    throw new RangeError('out of range index')\n  }\n\n  if (thisStart >= thisEnd && start >= end) {\n    return 0\n  }\n  if (thisStart >= thisEnd) {\n    return -1\n  }\n  if (start >= end) {\n    return 1\n  }\n\n  start >>>= 0\n  end >>>= 0\n  thisStart >>>= 0\n  thisEnd >>>= 0\n\n  if (this === target) return 0\n\n  var x = thisEnd - thisStart\n  var y = end - start\n  var len = Math.min(x, y)\n\n  var thisCopy = this.slice(thisStart, thisEnd)\n  var targetCopy = target.slice(start, end)\n\n  for (var i = 0; i < len; ++i) {\n    if (thisCopy[i] !== targetCopy[i]) {\n      x = thisCopy[i]\n      y = targetCopy[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n  // Empty buffer means no match\n  if (buffer.length === 0) return -1\n\n  // Normalize byteOffset\n  if (typeof byteOffset === 'string') {\n    encoding = byteOffset\n    byteOffset = 0\n  } else if (byteOffset > 0x7fffffff) {\n    byteOffset = 0x7fffffff\n  } else if (byteOffset < -0x80000000) {\n    byteOffset = -0x80000000\n  }\n  byteOffset = +byteOffset  // Coerce to Number.\n  if (isNaN(byteOffset)) {\n    // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n    byteOffset = dir ? 0 : (buffer.length - 1)\n  }\n\n  // Normalize byteOffset: negative offsets start from the end of the buffer\n  if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n  if (byteOffset >= buffer.length) {\n    if (dir) return -1\n    else byteOffset = buffer.length - 1\n  } else if (byteOffset < 0) {\n    if (dir) byteOffset = 0\n    else return -1\n  }\n\n  // Normalize val\n  if (typeof val === 'string') {\n    val = Buffer.from(val, encoding)\n  }\n\n  // Finally, search either indexOf (if dir is true) or lastIndexOf\n  if (Buffer.isBuffer(val)) {\n    // Special case: looking for empty string/buffer always fails\n    if (val.length === 0) {\n      return -1\n    }\n    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n  } else if (typeof val === 'number') {\n    val = val & 0xFF // Search for a byte value [0-255]\n    if (Buffer.TYPED_ARRAY_SUPPORT &&\n        typeof Uint8Array.prototype.indexOf === 'function') {\n      if (dir) {\n        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n      } else {\n        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n      }\n    }\n    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)\n  }\n\n  throw new TypeError('val must be string, number or Buffer')\n}\n\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n  var indexSize = 1\n  var arrLength = arr.length\n  var valLength = val.length\n\n  if (encoding !== undefined) {\n    encoding = String(encoding).toLowerCase()\n    if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n        encoding === 'utf16le' || encoding === 'utf-16le') {\n      if (arr.length < 2 || val.length < 2) {\n        return -1\n      }\n      indexSize = 2\n      arrLength /= 2\n      valLength /= 2\n      byteOffset /= 2\n    }\n  }\n\n  function read (buf, i) {\n    if (indexSize === 1) {\n      return buf[i]\n    } else {\n      return buf.readUInt16BE(i * indexSize)\n    }\n  }\n\n  var i\n  if (dir) {\n    var foundIndex = -1\n    for (i = byteOffset; i < arrLength; i++) {\n      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n        if (foundIndex === -1) foundIndex = i\n        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n      } else {\n        if (foundIndex !== -1) i -= i - foundIndex\n        foundIndex = -1\n      }\n    }\n  } else {\n    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n    for (i = byteOffset; i >= 0; i--) {\n      var found = true\n      for (var j = 0; j < valLength; j++) {\n        if (read(arr, i + j) !== read(val, j)) {\n          found = false\n          break\n        }\n      }\n      if (found) return i\n    }\n  }\n\n  return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n  return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n  offset = Number(offset) || 0\n  var remaining = buf.length - offset\n  if (!length) {\n    length = remaining\n  } else {\n    length = Number(length)\n    if (length > remaining) {\n      length = remaining\n    }\n  }\n\n  // must be an even number of digits\n  var strLen = string.length\n  if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')\n\n  if (length > strLen / 2) {\n    length = strLen / 2\n  }\n  for (var i = 0; i < length; ++i) {\n    var parsed = parseInt(string.substr(i * 2, 2), 16)\n    if (isNaN(parsed)) return i\n    buf[offset + i] = parsed\n  }\n  return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n  return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction latin1Write (buf, string, offset, length) {\n  return asciiWrite(buf, string, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n  return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n  // Buffer#write(string)\n  if (offset === undefined) {\n    encoding = 'utf8'\n    length = this.length\n    offset = 0\n  // Buffer#write(string, encoding)\n  } else if (length === undefined && typeof offset === 'string') {\n    encoding = offset\n    length = this.length\n    offset = 0\n  // Buffer#write(string, offset[, length][, encoding])\n  } else if (isFinite(offset)) {\n    offset = offset | 0\n    if (isFinite(length)) {\n      length = length | 0\n      if (encoding === undefined) encoding = 'utf8'\n    } else {\n      encoding = length\n      length = undefined\n    }\n  // legacy write(string, encoding, offset, length) - remove in v0.13\n  } else {\n    throw new Error(\n      'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n    )\n  }\n\n  var remaining = this.length - offset\n  if (length === undefined || length > remaining) length = remaining\n\n  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n    throw new RangeError('Attempt to write outside buffer bounds')\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'hex':\n        return hexWrite(this, string, offset, length)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Write(this, string, offset, length)\n\n      case 'ascii':\n        return asciiWrite(this, string, offset, length)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Write(this, string, offset, length)\n\n      case 'base64':\n        // Warning: maxLength not taken into account in base64Write\n        return base64Write(this, string, offset, length)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return ucs2Write(this, string, offset, length)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n  return {\n    type: 'Buffer',\n    data: Array.prototype.slice.call(this._arr || this, 0)\n  }\n}\n\nfunction base64Slice (buf, start, end) {\n  if (start === 0 && end === buf.length) {\n    return base64.fromByteArray(buf)\n  } else {\n    return base64.fromByteArray(buf.slice(start, end))\n  }\n}\n\nfunction utf8Slice (buf, start, end) {\n  end = Math.min(buf.length, end)\n  var res = []\n\n  var i = start\n  while (i < end) {\n    var firstByte = buf[i]\n    var codePoint = null\n    var bytesPerSequence = (firstByte > 0xEF) ? 4\n      : (firstByte > 0xDF) ? 3\n      : (firstByte > 0xBF) ? 2\n      : 1\n\n    if (i + bytesPerSequence <= end) {\n      var secondByte, thirdByte, fourthByte, tempCodePoint\n\n      switch (bytesPerSequence) {\n        case 1:\n          if (firstByte < 0x80) {\n            codePoint = firstByte\n          }\n          break\n        case 2:\n          secondByte = buf[i + 1]\n          if ((secondByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n            if (tempCodePoint > 0x7F) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 3:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 4:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          fourthByte = buf[i + 3]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n              codePoint = tempCodePoint\n            }\n          }\n      }\n    }\n\n    if (codePoint === null) {\n      // we did not generate a valid codePoint so insert a\n      // replacement char (U+FFFD) and advance only 1 byte\n      codePoint = 0xFFFD\n      bytesPerSequence = 1\n    } else if (codePoint > 0xFFFF) {\n      // encode to utf16 (surrogate pair dance)\n      codePoint -= 0x10000\n      res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n      codePoint = 0xDC00 | codePoint & 0x3FF\n    }\n\n    res.push(codePoint)\n    i += bytesPerSequence\n  }\n\n  return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nvar MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n  var len = codePoints.length\n  if (len <= MAX_ARGUMENTS_LENGTH) {\n    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n  }\n\n  // Decode in chunks to avoid \"call stack size exceeded\".\n  var res = ''\n  var i = 0\n  while (i < len) {\n    res += String.fromCharCode.apply(\n      String,\n      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n    )\n  }\n  return res\n}\n\nfunction asciiSlice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i] & 0x7F)\n  }\n  return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i])\n  }\n  return ret\n}\n\nfunction hexSlice (buf, start, end) {\n  var len = buf.length\n\n  if (!start || start < 0) start = 0\n  if (!end || end < 0 || end > len) end = len\n\n  var out = ''\n  for (var i = start; i < end; ++i) {\n    out += toHex(buf[i])\n  }\n  return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n  var bytes = buf.slice(start, end)\n  var res = ''\n  for (var i = 0; i < bytes.length; i += 2) {\n    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)\n  }\n  return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n  var len = this.length\n  start = ~~start\n  end = end === undefined ? len : ~~end\n\n  if (start < 0) {\n    start += len\n    if (start < 0) start = 0\n  } else if (start > len) {\n    start = len\n  }\n\n  if (end < 0) {\n    end += len\n    if (end < 0) end = 0\n  } else if (end > len) {\n    end = len\n  }\n\n  if (end < start) end = start\n\n  var newBuf\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    newBuf = this.subarray(start, end)\n    newBuf.__proto__ = Buffer.prototype\n  } else {\n    var sliceLen = end - start\n    newBuf = new Buffer(sliceLen, undefined)\n    for (var i = 0; i < sliceLen; ++i) {\n      newBuf[i] = this[i + start]\n    }\n  }\n\n  return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    checkOffset(offset, byteLength, this.length)\n  }\n\n  var val = this[offset + --byteLength]\n  var mul = 1\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  return this[offset]\n}\n\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return ((this[offset]) |\n      (this[offset + 1] << 8) |\n      (this[offset + 2] << 16)) +\n      (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] * 0x1000000) +\n    ((this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    this[offset + 3])\n}\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var i = byteLength\n  var mul = 1\n  var val = this[offset + --i]\n  while (i > 0 && (mul *= 0x100)) {\n    val += this[offset + --i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  if (!(this[offset] & 0x80)) return (this[offset])\n  return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset] | (this[offset + 1] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset + 1] | (this[offset] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset]) |\n    (this[offset + 1] << 8) |\n    (this[offset + 2] << 16) |\n    (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] << 24) |\n    (this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    (this[offset + 3])\n}\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n  if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n  if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var mul = 1\n  var i = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nfunction objectWriteUInt16 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {\n    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>\n      (littleEndian ? i : 1 - i) * 8\n  }\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nfunction objectWriteUInt32 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffffffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {\n    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff\n  }\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset + 3] = (value >>> 24)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 1] = (value >>> 8)\n    this[offset] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = 0\n  var mul = 1\n  var sub = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  var sub = 0\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  if (value < 0) value = 0xff + value + 1\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 3] = (value >>> 24)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (value < 0) value = 0xffffffff + value + 1\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n  if (offset < 0) throw new RangeError('Index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 23, 4)\n  return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 52, 8)\n  return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n  if (!start) start = 0\n  if (!end && end !== 0) end = this.length\n  if (targetStart >= target.length) targetStart = target.length\n  if (!targetStart) targetStart = 0\n  if (end > 0 && end < start) end = start\n\n  // Copy 0 bytes; we're done\n  if (end === start) return 0\n  if (target.length === 0 || this.length === 0) return 0\n\n  // Fatal error conditions\n  if (targetStart < 0) {\n    throw new RangeError('targetStart out of bounds')\n  }\n  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')\n  if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n  // Are we oob?\n  if (end > this.length) end = this.length\n  if (target.length - targetStart < end - start) {\n    end = target.length - targetStart + start\n  }\n\n  var len = end - start\n  var i\n\n  if (this === target && start < targetStart && targetStart < end) {\n    // descending copy from end\n    for (i = len - 1; i >= 0; --i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n    // ascending copy from start\n    for (i = 0; i < len; ++i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else {\n    Uint8Array.prototype.set.call(\n      target,\n      this.subarray(start, start + len),\n      targetStart\n    )\n  }\n\n  return len\n}\n\n// Usage:\n//    buffer.fill(number[, offset[, end]])\n//    buffer.fill(buffer[, offset[, end]])\n//    buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\n  // Handle string cases:\n  if (typeof val === 'string') {\n    if (typeof start === 'string') {\n      encoding = start\n      start = 0\n      end = this.length\n    } else if (typeof end === 'string') {\n      encoding = end\n      end = this.length\n    }\n    if (val.length === 1) {\n      var code = val.charCodeAt(0)\n      if (code < 256) {\n        val = code\n      }\n    }\n    if (encoding !== undefined && typeof encoding !== 'string') {\n      throw new TypeError('encoding must be a string')\n    }\n    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n      throw new TypeError('Unknown encoding: ' + encoding)\n    }\n  } else if (typeof val === 'number') {\n    val = val & 255\n  }\n\n  // Invalid ranges are not set to a default, so can range check early.\n  if (start < 0 || this.length < start || this.length < end) {\n    throw new RangeError('Out of range index')\n  }\n\n  if (end <= start) {\n    return this\n  }\n\n  start = start >>> 0\n  end = end === undefined ? this.length : end >>> 0\n\n  if (!val) val = 0\n\n  var i\n  if (typeof val === 'number') {\n    for (i = start; i < end; ++i) {\n      this[i] = val\n    }\n  } else {\n    var bytes = Buffer.isBuffer(val)\n      ? val\n      : utf8ToBytes(new Buffer(val, encoding).toString())\n    var len = bytes.length\n    for (i = 0; i < end - start; ++i) {\n      this[i + start] = bytes[i % len]\n    }\n  }\n\n  return this\n}\n\n// HELPER FUNCTIONS\n// ================\n\nvar INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = stringtrim(str).replace(INVALID_BASE64_RE, '')\n  // Node converts strings with length < 2 to ''\n  if (str.length < 2) return ''\n  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n  while (str.length % 4 !== 0) {\n    str = str + '='\n  }\n  return str\n}\n\nfunction stringtrim (str) {\n  if (str.trim) return str.trim()\n  return str.replace(/^\\s+|\\s+$/g, '')\n}\n\nfunction toHex (n) {\n  if (n < 16) return '0' + n.toString(16)\n  return n.toString(16)\n}\n\nfunction utf8ToBytes (string, units) {\n  units = units || Infinity\n  var codePoint\n  var length = string.length\n  var leadSurrogate = null\n  var bytes = []\n\n  for (var i = 0; i < length; ++i) {\n    codePoint = string.charCodeAt(i)\n\n    // is surrogate component\n    if (codePoint > 0xD7FF && codePoint < 0xE000) {\n      // last char was a lead\n      if (!leadSurrogate) {\n        // no lead yet\n        if (codePoint > 0xDBFF) {\n          // unexpected trail\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        } else if (i + 1 === length) {\n          // unpaired lead\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        }\n\n        // valid lead\n        leadSurrogate = codePoint\n\n        continue\n      }\n\n      // 2 leads in a row\n      if (codePoint < 0xDC00) {\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n        leadSurrogate = codePoint\n        continue\n      }\n\n      // valid surrogate pair\n      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n    } else if (leadSurrogate) {\n      // valid bmp char, but last char was a lead\n      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n    }\n\n    leadSurrogate = null\n\n    // encode utf8\n    if (codePoint < 0x80) {\n      if ((units -= 1) < 0) break\n      bytes.push(codePoint)\n    } else if (codePoint < 0x800) {\n      if ((units -= 2) < 0) break\n      bytes.push(\n        codePoint >> 0x6 | 0xC0,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x10000) {\n      if ((units -= 3) < 0) break\n      bytes.push(\n        codePoint >> 0xC | 0xE0,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x110000) {\n      if ((units -= 4) < 0) break\n      bytes.push(\n        codePoint >> 0x12 | 0xF0,\n        codePoint >> 0xC & 0x3F | 0x80,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else {\n      throw new Error('Invalid code point')\n    }\n  }\n\n  return bytes\n}\n\nfunction asciiToBytes (str) {\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF)\n  }\n  return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n  var c, hi, lo\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    if ((units -= 2) < 0) break\n\n    c = str.charCodeAt(i)\n    hi = c >> 8\n    lo = c % 256\n    byteArray.push(lo)\n    byteArray.push(hi)\n  }\n\n  return byteArray\n}\n\nfunction base64ToBytes (str) {\n  return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n  for (var i = 0; i < length; ++i) {\n    if ((i + offset >= dst.length) || (i >= src.length)) break\n    dst[i + offset] = src[i]\n  }\n  return i\n}\n\nfunction isnan (val) {\n  return val !== val // eslint-disable-line no-self-compare\n}\n","module.exports = require('./lib/chai');\n","/*!\n * chai\n * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\nvar used = []\n  , exports = module.exports = {};\n\n/*!\n * Chai version\n */\n\nexports.version = '3.5.0';\n\n/*!\n * Assertion Error\n */\n\nexports.AssertionError = require('assertion-error');\n\n/*!\n * Utils for plugins (not exported)\n */\n\nvar util = require('./chai/utils');\n\n/**\n * # .use(function)\n *\n * Provides a way to extend the internals of Chai\n *\n * @param {Function}\n * @returns {this} for chaining\n * @api public\n */\n\nexports.use = function (fn) {\n  if (!~used.indexOf(fn)) {\n    fn(this, util);\n    used.push(fn);\n  }\n\n  return this;\n};\n\n/*!\n * Utility Functions\n */\n\nexports.util = util;\n\n/*!\n * Configuration\n */\n\nvar config = require('./chai/config');\nexports.config = config;\n\n/*!\n * Primary `Assertion` prototype\n */\n\nvar assertion = require('./chai/assertion');\nexports.use(assertion);\n\n/*!\n * Core Assertions\n */\n\nvar core = require('./chai/core/assertions');\nexports.use(core);\n\n/*!\n * Expect interface\n */\n\nvar expect = require('./chai/interface/expect');\nexports.use(expect);\n\n/*!\n * Should interface\n */\n\nvar should = require('./chai/interface/should');\nexports.use(should);\n\n/*!\n * Assert interface\n */\n\nvar assert = require('./chai/interface/assert');\nexports.use(assert);\n","/*!\n * chai\n * http://chaijs.com\n * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\nvar config = require('./config');\n\nmodule.exports = function (_chai, util) {\n  /*!\n   * Module dependencies.\n   */\n\n  var AssertionError = _chai.AssertionError\n    , flag = util.flag;\n\n  /*!\n   * Module export.\n   */\n\n  _chai.Assertion = Assertion;\n\n  /*!\n   * Assertion Constructor\n   *\n   * Creates object for chaining.\n   *\n   * @api private\n   */\n\n  function Assertion (obj, msg, stack) {\n    flag(this, 'ssfi', stack || arguments.callee);\n    flag(this, 'object', obj);\n    flag(this, 'message', msg);\n  }\n\n  Object.defineProperty(Assertion, 'includeStack', {\n    get: function() {\n      console.warn('Assertion.includeStack is deprecated, use chai.config.includeStack instead.');\n      return config.includeStack;\n    },\n    set: function(value) {\n      console.warn('Assertion.includeStack is deprecated, use chai.config.includeStack instead.');\n      config.includeStack = value;\n    }\n  });\n\n  Object.defineProperty(Assertion, 'showDiff', {\n    get: function() {\n      console.warn('Assertion.showDiff is deprecated, use chai.config.showDiff instead.');\n      return config.showDiff;\n    },\n    set: function(value) {\n      console.warn('Assertion.showDiff is deprecated, use chai.config.showDiff instead.');\n      config.showDiff = value;\n    }\n  });\n\n  Assertion.addProperty = function (name, fn) {\n    util.addProperty(this.prototype, name, fn);\n  };\n\n  Assertion.addMethod = function (name, fn) {\n    util.addMethod(this.prototype, name, fn);\n  };\n\n  Assertion.addChainableMethod = function (name, fn, chainingBehavior) {\n    util.addChainableMethod(this.prototype, name, fn, chainingBehavior);\n  };\n\n  Assertion.overwriteProperty = function (name, fn) {\n    util.overwriteProperty(this.prototype, name, fn);\n  };\n\n  Assertion.overwriteMethod = function (name, fn) {\n    util.overwriteMethod(this.prototype, name, fn);\n  };\n\n  Assertion.overwriteChainableMethod = function (name, fn, chainingBehavior) {\n    util.overwriteChainableMethod(this.prototype, name, fn, chainingBehavior);\n  };\n\n  /**\n   * ### .assert(expression, message, negateMessage, expected, actual, showDiff)\n   *\n   * Executes an expression and check expectations. Throws AssertionError for reporting if test doesn't pass.\n   *\n   * @name assert\n   * @param {Philosophical} expression to be tested\n   * @param {String|Function} message or function that returns message to display if expression fails\n   * @param {String|Function} negatedMessage or function that returns negatedMessage to display if negated expression fails\n   * @param {Mixed} expected value (remember to check for negation)\n   * @param {Mixed} actual (optional) will default to `this.obj`\n   * @param {Boolean} showDiff (optional) when set to `true`, assert will display a diff in addition to the message if expression fails\n   * @api private\n   */\n\n  Assertion.prototype.assert = function (expr, msg, negateMsg, expected, _actual, showDiff) {\n    var ok = util.test(this, arguments);\n    if (true !== showDiff) showDiff = false;\n    if (true !== config.showDiff) showDiff = false;\n\n    if (!ok) {\n      var msg = util.getMessage(this, arguments)\n        , actual = util.getActual(this, arguments);\n      throw new AssertionError(msg, {\n          actual: actual\n        , expected: expected\n        , showDiff: showDiff\n      }, (config.includeStack) ? this.assert : flag(this, 'ssfi'));\n    }\n  };\n\n  /*!\n   * ### ._obj\n   *\n   * Quick reference to stored `actual` value for plugin developers.\n   *\n   * @api private\n   */\n\n  Object.defineProperty(Assertion.prototype, '_obj',\n    { get: function () {\n        return flag(this, 'object');\n      }\n    , set: function (val) {\n        flag(this, 'object', val);\n      }\n  });\n};\n","module.exports = {\n\n  /**\n   * ### config.includeStack\n   *\n   * User configurable property, influences whether stack trace\n   * is included in Assertion error message. Default of false\n   * suppresses stack trace in the error message.\n   *\n   *     chai.config.includeStack = true;  // enable stack on error\n   *\n   * @param {Boolean}\n   * @api public\n   */\n\n   includeStack: false,\n\n  /**\n   * ### config.showDiff\n   *\n   * User configurable property, influences whether or not\n   * the `showDiff` flag should be included in the thrown\n   * AssertionErrors. `false` will always be `false`; `true`\n   * will be true when the assertion has requested a diff\n   * be shown.\n   *\n   * @param {Boolean}\n   * @api public\n   */\n\n  showDiff: true,\n\n  /**\n   * ### config.truncateThreshold\n   *\n   * User configurable property, sets length threshold for actual and\n   * expected values in assertion errors. If this threshold is exceeded, for\n   * example for large data structures, the value is replaced with something\n   * like `[ Array(3) ]` or `{ Object (prop1, prop2) }`.\n   *\n   * Set it to zero if you want to disable truncating altogether.\n   *\n   * This is especially userful when doing assertions on arrays: having this\n   * set to a reasonable large value makes the failure messages readily\n   * inspectable.\n   *\n   *     chai.config.truncateThreshold = 0;  // disable truncating\n   *\n   * @param {Number}\n   * @api public\n   */\n\n  truncateThreshold: 40\n\n};\n","/*!\n * chai\n * http://chaijs.com\n * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\nmodule.exports = function (chai, _) {\n  var Assertion = chai.Assertion\n    , toString = Object.prototype.toString\n    , flag = _.flag;\n\n  /**\n   * ### Language Chains\n   *\n   * The following are provided as chainable getters to\n   * improve the readability of your assertions. They\n   * do not provide testing capabilities unless they\n   * have been overwritten by a plugin.\n   *\n   * **Chains**\n   *\n   * - to\n   * - be\n   * - been\n   * - is\n   * - that\n   * - which\n   * - and\n   * - has\n   * - have\n   * - with\n   * - at\n   * - of\n   * - same\n   *\n   * @name language chains\n   * @namespace BDD\n   * @api public\n   */\n\n  [ 'to', 'be', 'been'\n  , 'is', 'and', 'has', 'have'\n  , 'with', 'that', 'which', 'at'\n  , 'of', 'same' ].forEach(function (chain) {\n    Assertion.addProperty(chain, function () {\n      return this;\n    });\n  });\n\n  /**\n   * ### .not\n   *\n   * Negates any of assertions following in the chain.\n   *\n   *     expect(foo).to.not.equal('bar');\n   *     expect(goodFn).to.not.throw(Error);\n   *     expect({ foo: 'baz' }).to.have.property('foo')\n   *       .and.not.equal('bar');\n   *\n   * @name not\n   * @namespace BDD\n   * @api public\n   */\n\n  Assertion.addProperty('not', function () {\n    flag(this, 'negate', true);\n  });\n\n  /**\n   * ### .deep\n   *\n   * Sets the `deep` flag, later used by the `equal` and\n   * `property` assertions.\n   *\n   *     expect(foo).to.deep.equal({ bar: 'baz' });\n   *     expect({ foo: { bar: { baz: 'quux' } } })\n   *       .to.have.deep.property('foo.bar.baz', 'quux');\n   *\n   * `.deep.property` special characters can be escaped\n   * by adding two slashes before the `.` or `[]`.\n   *\n   *     var deepCss = { '.link': { '[target]': 42 }};\n   *     expect(deepCss).to.have.deep.property('\\\\.link.\\\\[target\\\\]', 42);\n   *\n   * @name deep\n   * @namespace BDD\n   * @api public\n   */\n\n  Assertion.addProperty('deep', function () {\n    flag(this, 'deep', true);\n  });\n\n  /**\n   * ### .any\n   *\n   * Sets the `any` flag, (opposite of the `all` flag)\n   * later used in the `keys` assertion.\n   *\n   *     expect(foo).to.have.any.keys('bar', 'baz');\n   *\n   * @name any\n   * @namespace BDD\n   * @api public\n   */\n\n  Assertion.addProperty('any', function () {\n    flag(this, 'any', true);\n    flag(this, 'all', false)\n  });\n\n\n  /**\n   * ### .all\n   *\n   * Sets the `all` flag (opposite of the `any` flag)\n   * later used by the `keys` assertion.\n   *\n   *     expect(foo).to.have.all.keys('bar', 'baz');\n   *\n   * @name all\n   * @namespace BDD\n   * @api public\n   */\n\n  Assertion.addProperty('all', function () {\n    flag(this, 'all', true);\n    flag(this, 'any', false);\n  });\n\n  /**\n   * ### .a(type)\n   *\n   * The `a` and `an` assertions are aliases that can be\n   * used either as language chains or to assert a value's\n   * type.\n   *\n   *     // typeof\n   *     expect('test').to.be.a('string');\n   *     expect({ foo: 'bar' }).to.be.an('object');\n   *     expect(null).to.be.a('null');\n   *     expect(undefined).to.be.an('undefined');\n   *     expect(new Error).to.be.an('error');\n   *     expect(new Promise).to.be.a('promise');\n   *     expect(new Float32Array()).to.be.a('float32array');\n   *     expect(Symbol()).to.be.a('symbol');\n   *\n   *     // es6 overrides\n   *     expect({[Symbol.toStringTag]:()=>'foo'}).to.be.a('foo');\n   *\n   *     // language chain\n   *     expect(foo).to.be.an.instanceof(Foo);\n   *\n   * @name a\n   * @alias an\n   * @param {String} type\n   * @param {String} message _optional_\n   * @namespace BDD\n   * @api public\n   */\n\n  function an (type, msg) {\n    if (msg) flag(this, 'message', msg);\n    type = type.toLowerCase();\n    var obj = flag(this, 'object')\n      , article = ~[ 'a', 'e', 'i', 'o', 'u' ].indexOf(type.charAt(0)) ? 'an ' : 'a ';\n\n    this.assert(\n        type === _.type(obj)\n      , 'expected #{this} to be ' + article + type\n      , 'expected #{this} not to be ' + article + type\n    );\n  }\n\n  Assertion.addChainableMethod('an', an);\n  Assertion.addChainableMethod('a', an);\n\n  /**\n   * ### .include(value)\n   *\n   * The `include` and `contain` assertions can be used as either property\n   * based language chains or as methods to assert the inclusion of an object\n   * in an array or a substring in a string. When used as language chains,\n   * they toggle the `contains` flag for the `keys` assertion.\n   *\n   *     expect([1,2,3]).to.include(2);\n   *     expect('foobar').to.contain('foo');\n   *     expect({ foo: 'bar', hello: 'universe' }).to.include.keys('foo');\n   *\n   * @name include\n   * @alias contain\n   * @alias includes\n   * @alias contains\n   * @param {Object|String|Number} obj\n   * @param {String} message _optional_\n   * @namespace BDD\n   * @api public\n   */\n\n  function includeChainingBehavior () {\n    flag(this, 'contains', true);\n  }\n\n  function include (val, msg) {\n    _.expectTypes(this, ['array', 'object', 'string']);\n\n    if (msg) flag(this, 'message', msg);\n    var obj = flag(this, 'object');\n    var expected = false;\n\n    if (_.type(obj) === 'array' && _.type(val) === 'object') {\n      for (var i in obj) {\n        if (_.eql(obj[i], val)) {\n          expected = true;\n          break;\n        }\n      }\n    } else if (_.type(val) === 'object') {\n      if (!flag(this, 'negate')) {\n        for (var k in val) new Assertion(obj).property(k, val[k]);\n        return;\n      }\n      var subset = {};\n      for (var k in val) subset[k] = obj[k];\n      expected = _.eql(subset, val);\n    } else {\n      expected = (obj != undefined) && ~obj.indexOf(val);\n    }\n    this.assert(\n        expected\n      , 'expected #{this} to include ' + _.inspect(val)\n      , 'expected #{this} to not include ' + _.inspect(val));\n  }\n\n  Assertion.addChainableMethod('include', include, includeChainingBehavior);\n  Assertion.addChainableMethod('contain', include, includeChainingBehavior);\n  Assertion.addChainableMethod('contains', include, includeChainingBehavior);\n  Assertion.addChainableMethod('includes', include, includeChainingBehavior);\n\n  /**\n   * ### .ok\n   *\n   * Asserts that the target is truthy.\n   *\n   *     expect('everything').to.be.ok;\n   *     expect(1).to.be.ok;\n   *     expect(false).to.not.be.ok;\n   *     expect(undefined).to.not.be.ok;\n   *     expect(null).to.not.be.ok;\n   *\n   * @name ok\n   * @namespace BDD\n   * @api public\n   */\n\n  Assertion.addProperty('ok', function () {\n    this.assert(\n        flag(this, 'object')\n      , 'expected #{this} to be truthy'\n      , 'expected #{this} to be falsy');\n  });\n\n  /**\n   * ### .true\n   *\n   * Asserts that the target is `true`.\n   *\n   *     expect(true).to.be.true;\n   *     expect(1).to.not.be.true;\n   *\n   * @name true\n   * @namespace BDD\n   * @api public\n   */\n\n  Assertion.addProperty('true', function () {\n    this.assert(\n        true === flag(this, 'object')\n      , 'expected #{this} to be true'\n      , 'expected #{this} to be false'\n      , this.negate ? false : true\n    );\n  });\n\n  /**\n   * ### .false\n   *\n   * Asserts that the target is `false`.\n   *\n   *     expect(false).to.be.false;\n   *     expect(0).to.not.be.false;\n   *\n   * @name false\n   * @namespace BDD\n   * @api public\n   */\n\n  Assertion.addProperty('false', function () {\n    this.assert(\n        false === flag(this, 'object')\n      , 'expected #{this} to be false'\n      , 'expected #{this} to be true'\n      , this.negate ? true : false\n    );\n  });\n\n  /**\n   * ### .null\n   *\n   * Asserts that the target is `null`.\n   *\n   *     expect(null).to.be.null;\n   *     expect(undefined).to.not.be.null;\n   *\n   * @name null\n   * @namespace BDD\n   * @api public\n   */\n\n  Assertion.addProperty('null', function () {\n    this.assert(\n        null === flag(this, 'object')\n      , 'expected #{this} to be null'\n      , 'expected #{this} not to be null'\n    );\n  });\n\n  /**\n   * ### .undefined\n   *\n   * Asserts that the target is `undefined`.\n   *\n   *     expect(undefined).to.be.undefined;\n   *     expect(null).to.not.be.undefined;\n   *\n   * @name undefined\n   * @namespace BDD\n   * @api public\n   */\n\n  Assertion.addProperty('undefined', function () {\n    this.assert(\n        undefined === flag(this, 'object')\n      , 'expected #{this} to be undefined'\n      , 'expected #{this} not to be undefined'\n    );\n  });\n\n  /**\n   * ### .NaN\n   * Asserts that the target is `NaN`.\n   *\n   *     expect('foo').to.be.NaN;\n   *     expect(4).not.to.be.NaN;\n   *\n   * @name NaN\n   * @namespace BDD\n   * @api public\n   */\n\n  Assertion.addProperty('NaN', function () {\n    this.assert(\n        isNaN(flag(this, 'object'))\n        , 'expected #{this} to be NaN'\n        , 'expected #{this} not to be NaN'\n    );\n  });\n\n  /**\n   * ### .exist\n   *\n   * Asserts that the target is neither `null` nor `undefined`.\n   *\n   *     var foo = 'hi'\n   *       , bar = null\n   *       , baz;\n   *\n   *     expect(foo).to.exist;\n   *     expect(bar).to.not.exist;\n   *     expect(baz).to.not.exist;\n   *\n   * @name exist\n   * @namespace BDD\n   * @api public\n   */\n\n  Assertion.addProperty('exist', function () {\n    this.assert(\n        null != flag(this, 'object')\n      , 'expected #{this} to exist'\n      , 'expected #{this} to not exist'\n    );\n  });\n\n\n  /**\n   * ### .empty\n   *\n   * Asserts that the target's length is `0`. For arrays and strings, it checks\n   * the `length` property. For objects, it gets the count of\n   * enumerable keys.\n   *\n   *     expect([]).to.be.empty;\n   *     expect('').to.be.empty;\n   *     expect({}).to.be.empty;\n   *\n   * @name empty\n   * @namespace BDD\n   * @api public\n   */\n\n  Assertion.addProperty('empty', function () {\n    var obj = flag(this, 'object')\n      , expected = obj;\n\n    if (Array.isArray(obj) || 'string' === typeof object) {\n      expected = obj.length;\n    } else if (typeof obj === 'object') {\n      expected = Object.keys(obj).length;\n    }\n\n    this.assert(\n        !expected\n      , 'expected #{this} to be empty'\n      , 'expected #{this} not to be empty'\n    );\n  });\n\n  /**\n   * ### .arguments\n   *\n   * Asserts that the target is an arguments object.\n   *\n   *     function test () {\n   *       expect(arguments).to.be.arguments;\n   *     }\n   *\n   * @name arguments\n   * @alias Arguments\n   * @namespace BDD\n   * @api public\n   */\n\n  function checkArguments () {\n    var obj = flag(this, 'object')\n      , type = Object.prototype.toString.call(obj);\n    this.assert(\n        '[object Arguments]' === type\n      , 'expected #{this} to be arguments but got ' + type\n      , 'expected #{this} to not be arguments'\n    );\n  }\n\n  Assertion.addProperty('arguments', checkArguments);\n  Assertion.addProperty('Arguments', checkArguments);\n\n  /**\n   * ### .equal(value)\n   *\n   * Asserts that the target is strictly equal (`===`) to `value`.\n   * Alternately, if the `deep` flag is set, asserts that\n   * the target is deeply equal to `value`.\n   *\n   *     expect('hello').to.equal('hello');\n   *     expect(42).to.equal(42);\n   *     expect(1).to.not.equal(true);\n   *     expect({ foo: 'bar' }).to.not.equal({ foo: 'bar' });\n   *     expect({ foo: 'bar' }).to.deep.equal({ foo: 'bar' });\n   *\n   * @name equal\n   * @alias equals\n   * @alias eq\n   * @alias deep.equal\n   * @param {Mixed} value\n   * @param {String} message _optional_\n   * @namespace BDD\n   * @api public\n   */\n\n  function assertEqual (val, msg) {\n    if (msg) flag(this, 'message', msg);\n    var obj = flag(this, 'object');\n    if (flag(this, 'deep')) {\n      return this.eql(val);\n    } else {\n      this.assert(\n          val === obj\n        , 'expected #{this} to equal #{exp}'\n        , 'expected #{this} to not equal #{exp}'\n        , val\n        , this._obj\n        , true\n      );\n    }\n  }\n\n  Assertion.addMethod('equal', assertEqual);\n  Assertion.addMethod('equals', assertEqual);\n  Assertion.addMethod('eq', assertEqual);\n\n  /**\n   * ### .eql(value)\n   *\n   * Asserts that the target is deeply equal to `value`.\n   *\n   *     expect({ foo: 'bar' }).to.eql({ foo: 'bar' });\n   *     expect([ 1, 2, 3 ]).to.eql([ 1, 2, 3 ]);\n   *\n   * @name eql\n   * @alias eqls\n   * @param {Mixed} value\n   * @param {String} message _optional_\n   * @namespace BDD\n   * @api public\n   */\n\n  function assertEql(obj, msg) {\n    if (msg) flag(this, 'message', msg);\n    this.assert(\n        _.eql(obj, flag(this, 'object'))\n      , 'expected #{this} to deeply equal #{exp}'\n      , 'expected #{this} to not deeply equal #{exp}'\n      , obj\n      , this._obj\n      , true\n    );\n  }\n\n  Assertion.addMethod('eql', assertEql);\n  Assertion.addMethod('eqls', assertEql);\n\n  /**\n   * ### .above(value)\n   *\n   * Asserts that the target is greater than `value`.\n   *\n   *     expect(10).to.be.above(5);\n   *\n   * Can also be used in conjunction with `length` to\n   * assert a minimum length. The benefit being a\n   * more informative error message than if the length\n   * was supplied directly.\n   *\n   *     expect('foo').to.have.length.above(2);\n   *     expect([ 1, 2, 3 ]).to.have.length.above(2);\n   *\n   * @name above\n   * @alias gt\n   * @alias greaterThan\n   * @param {Number} value\n   * @param {String} message _optional_\n   * @namespace BDD\n   * @api public\n   */\n\n  function assertAbove (n, msg) {\n    if (msg) flag(this, 'message', msg);\n    var obj = flag(this, 'object');\n    if (flag(this, 'doLength')) {\n      new Assertion(obj, msg).to.have.property('length');\n      var len = obj.length;\n      this.assert(\n          len > n\n        , 'expected #{this} to have a length above #{exp} but got #{act}'\n        , 'expected #{this} to not have a length above #{exp}'\n        , n\n        , len\n      );\n    } else {\n      this.assert(\n          obj > n\n        , 'expected #{this} to be above ' + n\n        , 'expected #{this} to be at most ' + n\n      );\n    }\n  }\n\n  Assertion.addMethod('above', assertAbove);\n  Assertion.addMethod('gt', assertAbove);\n  Assertion.addMethod('greaterThan', assertAbove);\n\n  /**\n   * ### .least(value)\n   *\n   * Asserts that the target is greater than or equal to `value`.\n   *\n   *     expect(10).to.be.at.least(10);\n   *\n   * Can also be used in conjunction with `length` to\n   * assert a minimum length. The benefit being a\n   * more informative error message than if the length\n   * was supplied directly.\n   *\n   *     expect('foo').to.have.length.of.at.least(2);\n   *     expect([ 1, 2, 3 ]).to.have.length.of.at.least(3);\n   *\n   * @name least\n   * @alias gte\n   * @param {Number} value\n   * @param {String} message _optional_\n   * @namespace BDD\n   * @api public\n   */\n\n  function assertLeast (n, msg) {\n    if (msg) flag(this, 'message', msg);\n    var obj = flag(this, 'object');\n    if (flag(this, 'doLength')) {\n      new Assertion(obj, msg).to.have.property('length');\n      var len = obj.length;\n      this.assert(\n          len >= n\n        , 'expected #{this} to have a length at least #{exp} but got #{act}'\n        , 'expected #{this} to have a length below #{exp}'\n        , n\n        , len\n      );\n    } else {\n      this.assert(\n          obj >= n\n        , 'expected #{this} to be at least ' + n\n        , 'expected #{this} to be below ' + n\n      );\n    }\n  }\n\n  Assertion.addMethod('least', assertLeast);\n  Assertion.addMethod('gte', assertLeast);\n\n  /**\n   * ### .below(value)\n   *\n   * Asserts that the target is less than `value`.\n   *\n   *     expect(5).to.be.below(10);\n   *\n   * Can also be used in conjunction with `length` to\n   * assert a maximum length. The benefit being a\n   * more informative error message than if the length\n   * was supplied directly.\n   *\n   *     expect('foo').to.have.length.below(4);\n   *     expect([ 1, 2, 3 ]).to.have.length.below(4);\n   *\n   * @name below\n   * @alias lt\n   * @alias lessThan\n   * @param {Number} value\n   * @param {String} message _optional_\n   * @namespace BDD\n   * @api public\n   */\n\n  function assertBelow (n, msg) {\n    if (msg) flag(this, 'message', msg);\n    var obj = flag(this, 'object');\n    if (flag(this, 'doLength')) {\n      new Assertion(obj, msg).to.have.property('length');\n      var len = obj.length;\n      this.assert(\n          len < n\n        , 'expected #{this} to have a length below #{exp} but got #{act}'\n        , 'expected #{this} to not have a length below #{exp}'\n        , n\n        , len\n      );\n    } else {\n      this.assert(\n          obj < n\n        , 'expected #{this} to be below ' + n\n        , 'expected #{this} to be at least ' + n\n      );\n    }\n  }\n\n  Assertion.addMethod('below', assertBelow);\n  Assertion.addMethod('lt', assertBelow);\n  Assertion.addMethod('lessThan', assertBelow);\n\n  /**\n   * ### .most(value)\n   *\n   * Asserts that the target is less than or equal to `value`.\n   *\n   *     expect(5).to.be.at.most(5);\n   *\n   * Can also be used in conjunction with `length` to\n   * assert a maximum length. The benefit being a\n   * more informative error message than if the length\n   * was supplied directly.\n   *\n   *     expect('foo').to.have.length.of.at.most(4);\n   *     expect([ 1, 2, 3 ]).to.have.length.of.at.most(3);\n   *\n   * @name most\n   * @alias lte\n   * @param {Number} value\n   * @param {String} message _optional_\n   * @namespace BDD\n   * @api public\n   */\n\n  function assertMost (n, msg) {\n    if (msg) flag(this, 'message', msg);\n    var obj = flag(this, 'object');\n    if (flag(this, 'doLength')) {\n      new Assertion(obj, msg).to.have.property('length');\n      var len = obj.length;\n      this.assert(\n          len <= n\n        , 'expected #{this} to have a length at most #{exp} but got #{act}'\n        , 'expected #{this} to have a length above #{exp}'\n        , n\n        , len\n      );\n    } else {\n      this.assert(\n          obj <= n\n        , 'expected #{this} to be at most ' + n\n        , 'expected #{this} to be above ' + n\n      );\n    }\n  }\n\n  Assertion.addMethod('most', assertMost);\n  Assertion.addMethod('lte', assertMost);\n\n  /**\n   * ### .within(start, finish)\n   *\n   * Asserts that the target is within a range.\n   *\n   *     expect(7).to.be.within(5,10);\n   *\n   * Can also be used in conjunction with `length` to\n   * assert a length range. The benefit being a\n   * more informative error message than if the length\n   * was supplied directly.\n   *\n   *     expect('foo').to.have.length.within(2,4);\n   *     expect([ 1, 2, 3 ]).to.have.length.within(2,4);\n   *\n   * @name within\n   * @param {Number} start lowerbound inclusive\n   * @param {Number} finish upperbound inclusive\n   * @param {String} message _optional_\n   * @namespace BDD\n   * @api public\n   */\n\n  Assertion.addMethod('within', function (start, finish, msg) {\n    if (msg) flag(this, 'message', msg);\n    var obj = flag(this, 'object')\n      , range = start + '..' + finish;\n    if (flag(this, 'doLength')) {\n      new Assertion(obj, msg).to.have.property('length');\n      var len = obj.length;\n      this.assert(\n          len >= start && len <= finish\n        , 'expected #{this} to have a length within ' + range\n        , 'expected #{this} to not have a length within ' + range\n      );\n    } else {\n      this.assert(\n          obj >= start && obj <= finish\n        , 'expected #{this} to be within ' + range\n        , 'expected #{this} to not be within ' + range\n      );\n    }\n  });\n\n  /**\n   * ### .instanceof(constructor)\n   *\n   * Asserts that the target is an instance of `constructor`.\n   *\n   *     var Tea = function (name) { this.name = name; }\n   *       , Chai = new Tea('chai');\n   *\n   *     expect(Chai).to.be.an.instanceof(Tea);\n   *     expect([ 1, 2, 3 ]).to.be.instanceof(Array);\n   *\n   * @name instanceof\n   * @param {Constructor} constructor\n   * @param {String} message _optional_\n   * @alias instanceOf\n   * @namespace BDD\n   * @api public\n   */\n\n  function assertInstanceOf (constructor, msg) {\n    if (msg) flag(this, 'message', msg);\n    var name = _.getName(constructor);\n    this.assert(\n        flag(this, 'object') instanceof constructor\n      , 'expected #{this} to be an instance of ' + name\n      , 'expected #{this} to not be an instance of ' + name\n    );\n  };\n\n  Assertion.addMethod('instanceof', assertInstanceOf);\n  Assertion.addMethod('instanceOf', assertInstanceOf);\n\n  /**\n   * ### .property(name, [value])\n   *\n   * Asserts that the target has a property `name`, optionally asserting that\n   * the value of that property is strictly equal to  `value`.\n   * If the `deep` flag is set, you can use dot- and bracket-notation for deep\n   * references into objects and arrays.\n   *\n   *     // simple referencing\n   *     var obj = { foo: 'bar' };\n   *     expect(obj).to.have.property('foo');\n   *     expect(obj).to.have.property('foo', 'bar');\n   *\n   *     // deep referencing\n   *     var deepObj = {\n   *         green: { tea: 'matcha' }\n   *       , teas: [ 'chai', 'matcha', { tea: 'konacha' } ]\n   *     };\n   *\n   *     expect(deepObj).to.have.deep.property('green.tea', 'matcha');\n   *     expect(deepObj).to.have.deep.property('teas[1]', 'matcha');\n   *     expect(deepObj).to.have.deep.property('teas[2].tea', 'konacha');\n   *\n   * You can also use an array as the starting point of a `deep.property`\n   * assertion, or traverse nested arrays.\n   *\n   *     var arr = [\n   *         [ 'chai', 'matcha', 'konacha' ]\n   *       , [ { tea: 'chai' }\n   *         , { tea: 'matcha' }\n   *         , { tea: 'konacha' } ]\n   *     ];\n   *\n   *     expect(arr).to.have.deep.property('[0][1]', 'matcha');\n   *     expect(arr).to.have.deep.property('[1][2].tea', 'konacha');\n   *\n   * Furthermore, `property` changes the subject of the assertion\n   * to be the value of that property from the original object. This\n   * permits for further chainable assertions on that property.\n   *\n   *     expect(obj).to.have.property('foo')\n   *       .that.is.a('string');\n   *     expect(deepObj).to.have.property('green')\n   *       .that.is.an('object')\n   *       .that.deep.equals({ tea: 'matcha' });\n   *     expect(deepObj).to.have.property('teas')\n   *       .that.is.an('array')\n   *       .with.deep.property('[2]')\n   *         .that.deep.equals({ tea: 'konacha' });\n   *\n   * Note that dots and bracket in `name` must be backslash-escaped when\n   * the `deep` flag is set, while they must NOT be escaped when the `deep`\n   * flag is not set.\n   *\n   *     // simple referencing\n   *     var css = { '.link[target]': 42 };\n   *     expect(css).to.have.property('.link[target]', 42);\n   *\n   *     // deep referencing\n   *     var deepCss = { '.link': { '[target]': 42 }};\n   *     expect(deepCss).to.have.deep.property('\\\\.link.\\\\[target\\\\]', 42);\n   *\n   * @name property\n   * @alias deep.property\n   * @param {String} name\n   * @param {Mixed} value (optional)\n   * @param {String} message _optional_\n   * @returns value of property for chaining\n   * @namespace BDD\n   * @api public\n   */\n\n  Assertion.addMethod('property', function (name, val, msg) {\n    if (msg) flag(this, 'message', msg);\n\n    var isDeep = !!flag(this, 'deep')\n      , descriptor = isDeep ? 'deep property ' : 'property '\n      , negate = flag(this, 'negate')\n      , obj = flag(this, 'object')\n      , pathInfo = isDeep ? _.getPathInfo(name, obj) : null\n      , hasProperty = isDeep\n        ? pathInfo.exists\n        : _.hasProperty(name, obj)\n      , value = isDeep\n        ? pathInfo.value\n        : obj[name];\n\n    if (negate && arguments.length > 1) {\n      if (undefined === value) {\n        msg = (msg != null) ? msg + ': ' : '';\n        throw new Error(msg + _.inspect(obj) + ' has no ' + descriptor + _.inspect(name));\n      }\n    } else {\n      this.assert(\n          hasProperty\n        , 'expected #{this} to have a ' + descriptor + _.inspect(name)\n        , 'expected #{this} to not have ' + descriptor + _.inspect(name));\n    }\n\n    if (arguments.length > 1) {\n      this.assert(\n          val === value\n        , 'expected #{this} to have a ' + descriptor + _.inspect(name) + ' of #{exp}, but got #{act}'\n        , 'expected #{this} to not have a ' + descriptor + _.inspect(name) + ' of #{act}'\n        , val\n        , value\n      );\n    }\n\n    flag(this, 'object', value);\n  });\n\n\n  /**\n   * ### .ownProperty(name)\n   *\n   * Asserts that the target has an own property `name`.\n   *\n   *     expect('test').to.have.ownProperty('length');\n   *\n   * @name ownProperty\n   * @alias haveOwnProperty\n   * @param {String} name\n   * @param {String} message _optional_\n   * @namespace BDD\n   * @api public\n   */\n\n  function assertOwnProperty (name, msg) {\n    if (msg) flag(this, 'message', msg);\n    var obj = flag(this, 'object');\n    this.assert(\n        obj.hasOwnProperty(name)\n      , 'expected #{this} to have own property ' + _.inspect(name)\n      , 'expected #{this} to not have own property ' + _.inspect(name)\n    );\n  }\n\n  Assertion.addMethod('ownProperty', assertOwnProperty);\n  Assertion.addMethod('haveOwnProperty', assertOwnProperty);\n\n  /**\n   * ### .ownPropertyDescriptor(name[, descriptor[, message]])\n   *\n   * Asserts that the target has an own property descriptor `name`, that optionally matches `descriptor`.\n   *\n   *     expect('test').to.have.ownPropertyDescriptor('length');\n   *     expect('test').to.have.ownPropertyDescriptor('length', { enumerable: false, configurable: false, writable: false, value: 4 });\n   *     expect('test').not.to.have.ownPropertyDescriptor('length', { enumerable: false, configurable: false, writable: false, value: 3 });\n   *     expect('test').ownPropertyDescriptor('length').to.have.property('enumerable', false);\n   *     expect('test').ownPropertyDescriptor('length').to.have.keys('value');\n   *\n   * @name ownPropertyDescriptor\n   * @alias haveOwnPropertyDescriptor\n   * @param {String} name\n   * @param {Object} descriptor _optional_\n   * @param {String} message _optional_\n   * @namespace BDD\n   * @api public\n   */\n\n  function assertOwnPropertyDescriptor (name, descriptor, msg) {\n    if (typeof descriptor === 'string') {\n      msg = descriptor;\n      descriptor = null;\n    }\n    if (msg) flag(this, 'message', msg);\n    var obj = flag(this, 'object');\n    var actualDescriptor = Object.getOwnPropertyDescriptor(Object(obj), name);\n    if (actualDescriptor && descriptor) {\n      this.assert(\n          _.eql(descriptor, actualDescriptor)\n        , 'expected the own property descriptor for ' + _.inspect(name) + ' on #{this} to match ' + _.inspect(descriptor) + ', got ' + _.inspect(actualDescriptor)\n        , 'expected the own property descriptor for ' + _.inspect(name) + ' on #{this} to not match ' + _.inspect(descriptor)\n        , descriptor\n        , actualDescriptor\n        , true\n      );\n    } else {\n      this.assert(\n          actualDescriptor\n        , 'expected #{this} to have an own property descriptor for ' + _.inspect(name)\n        , 'expected #{this} to not have an own property descriptor for ' + _.inspect(name)\n      );\n    }\n    flag(this, 'object', actualDescriptor);\n  }\n\n  Assertion.addMethod('ownPropertyDescriptor', assertOwnPropertyDescriptor);\n  Assertion.addMethod('haveOwnPropertyDescriptor', assertOwnPropertyDescriptor);\n\n  /**\n   * ### .length\n   *\n   * Sets the `doLength` flag later used as a chain precursor to a value\n   * comparison for the `length` property.\n   *\n   *     expect('foo').to.have.length.above(2);\n   *     expect([ 1, 2, 3 ]).to.have.length.above(2);\n   *     expect('foo').to.have.length.below(4);\n   *     expect([ 1, 2, 3 ]).to.have.length.below(4);\n   *     expect('foo').to.have.length.within(2,4);\n   *     expect([ 1, 2, 3 ]).to.have.length.within(2,4);\n   *\n   * *Deprecation notice:* Using `length` as an assertion will be deprecated\n   * in version 2.4.0 and removed in 3.0.0. Code using the old style of\n   * asserting for `length` property value using `length(value)` should be\n   * switched to use `lengthOf(value)` instead.\n   *\n   * @name length\n   * @namespace BDD\n   * @api public\n   */\n\n  /**\n   * ### .lengthOf(value[, message])\n   *\n   * Asserts that the target's `length` property has\n   * the expected value.\n   *\n   *     expect([ 1, 2, 3]).to.have.lengthOf(3);\n   *     expect('foobar').to.have.lengthOf(6);\n   *\n   * @name lengthOf\n   * @param {Number} length\n   * @param {String} message _optional_\n   * @namespace BDD\n   * @api public\n   */\n\n  function assertLengthChain () {\n    flag(this, 'doLength', true);\n  }\n\n  function assertLength (n, msg) {\n    if (msg) flag(this, 'message', msg);\n    var obj = flag(this, 'object');\n    new Assertion(obj, msg).to.have.property('length');\n    var len = obj.length;\n\n    this.assert(\n        len == n\n      , 'expected #{this} to have a length of #{exp} but got #{act}'\n      , 'expected #{this} to not have a length of #{act}'\n      , n\n      , len\n    );\n  }\n\n  Assertion.addChainableMethod('length', assertLength, assertLengthChain);\n  Assertion.addMethod('lengthOf', assertLength);\n\n  /**\n   * ### .match(regexp)\n   *\n   * Asserts that the target matches a regular expression.\n   *\n   *     expect('foobar').to.match(/^foo/);\n   *\n   * @name match\n   * @alias matches\n   * @param {RegExp} RegularExpression\n   * @param {String} message _optional_\n   * @namespace BDD\n   * @api public\n   */\n  function assertMatch(re, msg) {\n    if (msg) flag(this, 'message', msg);\n    var obj = flag(this, 'object');\n    this.assert(\n        re.exec(obj)\n      , 'expected #{this} to match ' + re\n      , 'expected #{this} not to match ' + re\n    );\n  }\n\n  Assertion.addMethod('match', assertMatch);\n  Assertion.addMethod('matches', assertMatch);\n\n  /**\n   * ### .string(string)\n   *\n   * Asserts that the string target contains another string.\n   *\n   *     expect('foobar').to.have.string('bar');\n   *\n   * @name string\n   * @param {String} string\n   * @param {String} message _optional_\n   * @namespace BDD\n   * @api public\n   */\n\n  Assertion.addMethod('string', function (str, msg) {\n    if (msg) flag(this, 'message', msg);\n    var obj = flag(this, 'object');\n    new Assertion(obj, msg).is.a('string');\n\n    this.assert(\n        ~obj.indexOf(str)\n      , 'expected #{this} to contain ' + _.inspect(str)\n      , 'expected #{this} to not contain ' + _.inspect(str)\n    );\n  });\n\n\n  /**\n   * ### .keys(key1, [key2], [...])\n   *\n   * Asserts that the target contains any or all of the passed-in keys.\n   * Use in combination with `any`, `all`, `contains`, or `have` will affect\n   * what will pass.\n   *\n   * When used in conjunction with `any`, at least one key that is passed\n   * in must exist in the target object. This is regardless whether or not\n   * the `have` or `contain` qualifiers are used. Note, either `any` or `all`\n   * should be used in the assertion. If neither are used, the assertion is\n   * defaulted to `all`.\n   *\n   * When both `all` and `contain` are used, the target object must have at\n   * least all of the passed-in keys but may have more keys not listed.\n   *\n   * When both `all` and `have` are used, the target object must both contain\n   * all of the passed-in keys AND the number of keys in the target object must\n   * match the number of keys passed in (in other words, a target object must\n   * have all and only all of the passed-in keys).\n   *\n   *     expect({ foo: 1, bar: 2 }).to.have.any.keys('foo', 'baz');\n   *     expect({ foo: 1, bar: 2 }).to.have.any.keys('foo');\n   *     expect({ foo: 1, bar: 2 }).to.contain.any.keys('bar', 'baz');\n   *     expect({ foo: 1, bar: 2 }).to.contain.any.keys(['foo']);\n   *     expect({ foo: 1, bar: 2 }).to.contain.any.keys({'foo': 6});\n   *     expect({ foo: 1, bar: 2 }).to.have.all.keys(['bar', 'foo']);\n   *     expect({ foo: 1, bar: 2 }).to.have.all.keys({'bar': 6, 'foo': 7});\n   *     expect({ foo: 1, bar: 2, baz: 3 }).to.contain.all.keys(['bar', 'foo']);\n   *     expect({ foo: 1, bar: 2, baz: 3 }).to.contain.all.keys({'bar': 6});\n   *\n   *\n   * @name keys\n   * @alias key\n   * @param {...String|Array|Object} keys\n   * @namespace BDD\n   * @api public\n   */\n\n  function assertKeys (keys) {\n    var obj = flag(this, 'object')\n      , str\n      , ok = true\n      , mixedArgsMsg = 'keys must be given single argument of Array|Object|String, or multiple String arguments';\n\n    switch (_.type(keys)) {\n      case \"array\":\n        if (arguments.length > 1) throw (new Error(mixedArgsMsg));\n        break;\n      case \"object\":\n        if (arguments.length > 1) throw (new Error(mixedArgsMsg));\n        keys = Object.keys(keys);\n        break;\n      default:\n        keys = Array.prototype.slice.call(arguments);\n    }\n\n    if (!keys.length) throw new Error('keys required');\n\n    var actual = Object.keys(obj)\n      , expected = keys\n      , len = keys.length\n      , any = flag(this, 'any')\n      , all = flag(this, 'all');\n\n    if (!any && !all) {\n      all = true;\n    }\n\n    // Has any\n    if (any) {\n      var intersection = expected.filter(function(key) {\n        return ~actual.indexOf(key);\n      });\n      ok = intersection.length > 0;\n    }\n\n    // Has all\n    if (all) {\n      ok = keys.every(function(key){\n        return ~actual.indexOf(key);\n      });\n      if (!flag(this, 'negate') && !flag(this, 'contains')) {\n        ok = ok && keys.length == actual.length;\n      }\n    }\n\n    // Key string\n    if (len > 1) {\n      keys = keys.map(function(key){\n        return _.inspect(key);\n      });\n      var last = keys.pop();\n      if (all) {\n        str = keys.join(', ') + ', and ' + last;\n      }\n      if (any) {\n        str = keys.join(', ') + ', or ' + last;\n      }\n    } else {\n      str = _.inspect(keys[0]);\n    }\n\n    // Form\n    str = (len > 1 ? 'keys ' : 'key ') + str;\n\n    // Have / include\n    str = (flag(this, 'contains') ? 'contain ' : 'have ') + str;\n\n    // Assertion\n    this.assert(\n        ok\n      , 'expected #{this} to ' + str\n      , 'expected #{this} to not ' + str\n      , expected.slice(0).sort()\n      , actual.sort()\n      , true\n    );\n  }\n\n  Assertion.addMethod('keys', assertKeys);\n  Assertion.addMethod('key', assertKeys);\n\n  /**\n   * ### .throw(constructor)\n   *\n   * Asserts that the function target will throw a specific error, or specific type of error\n   * (as determined using `instanceof`), optionally with a RegExp or string inclusion test\n   * for the error's message.\n   *\n   *     var err = new ReferenceError('This is a bad function.');\n   *     var fn = function () { throw err; }\n   *     expect(fn).to.throw(ReferenceError);\n   *     expect(fn).to.throw(Error);\n   *     expect(fn).to.throw(/bad function/);\n   *     expect(fn).to.not.throw('good function');\n   *     expect(fn).to.throw(ReferenceError, /bad function/);\n   *     expect(fn).to.throw(err);\n   *\n   * Please note that when a throw expectation is negated, it will check each\n   * parameter independently, starting with error constructor type. The appropriate way\n   * to check for the existence of a type of error but for a message that does not match\n   * is to use `and`.\n   *\n   *     expect(fn).to.throw(ReferenceError)\n   *        .and.not.throw(/good function/);\n   *\n   * @name throw\n   * @alias throws\n   * @alias Throw\n   * @param {ErrorConstructor} constructor\n   * @param {String|RegExp} expected error message\n   * @param {String} message _optional_\n   * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types\n   * @returns error for chaining (null if no error)\n   * @namespace BDD\n   * @api public\n   */\n\n  function assertThrows (constructor, errMsg, msg) {\n    if (msg) flag(this, 'message', msg);\n    var obj = flag(this, 'object');\n    new Assertion(obj, msg).is.a('function');\n\n    var thrown = false\n      , desiredError = null\n      , name = null\n      , thrownError = null;\n\n    if (arguments.length === 0) {\n      errMsg = null;\n      constructor = null;\n    } else if (constructor && (constructor instanceof RegExp || 'string' === typeof constructor)) {\n      errMsg = constructor;\n      constructor = null;\n    } else if (constructor && constructor instanceof Error) {\n      desiredError = constructor;\n      constructor = null;\n      errMsg = null;\n    } else if (typeof constructor === 'function') {\n      name = constructor.prototype.name;\n      if (!name || (name === 'Error' && constructor !== Error)) {\n        name = constructor.name || (new constructor()).name;\n      }\n    } else {\n      constructor = null;\n    }\n\n    try {\n      obj();\n    } catch (err) {\n      // first, check desired error\n      if (desiredError) {\n        this.assert(\n            err === desiredError\n          , 'expected #{this} to throw #{exp} but #{act} was thrown'\n          , 'expected #{this} to not throw #{exp}'\n          , (desiredError instanceof Error ? desiredError.toString() : desiredError)\n          , (err instanceof Error ? err.toString() : err)\n        );\n\n        flag(this, 'object', err);\n        return this;\n      }\n\n      // next, check constructor\n      if (constructor) {\n        this.assert(\n            err instanceof constructor\n          , 'expected #{this} to throw #{exp} but #{act} was thrown'\n          , 'expected #{this} to not throw #{exp} but #{act} was thrown'\n          , name\n          , (err instanceof Error ? err.toString() : err)\n        );\n\n        if (!errMsg) {\n          flag(this, 'object', err);\n          return this;\n        }\n      }\n\n      // next, check message\n      var message = 'error' === _.type(err) && \"message\" in err\n        ? err.message\n        : '' + err;\n\n      if ((message != null) && errMsg && errMsg instanceof RegExp) {\n        this.assert(\n            errMsg.exec(message)\n          , 'expected #{this} to throw error matching #{exp} but got #{act}'\n          , 'expected #{this} to throw error not matching #{exp}'\n          , errMsg\n          , message\n        );\n\n        flag(this, 'object', err);\n        return this;\n      } else if ((message != null) && errMsg && 'string' === typeof errMsg) {\n        this.assert(\n            ~message.indexOf(errMsg)\n          , 'expected #{this} to throw error including #{exp} but got #{act}'\n          , 'expected #{this} to throw error not including #{act}'\n          , errMsg\n          , message\n        );\n\n        flag(this, 'object', err);\n        return this;\n      } else {\n        thrown = true;\n        thrownError = err;\n      }\n    }\n\n    var actuallyGot = ''\n      , expectedThrown = name !== null\n        ? name\n        : desiredError\n          ? '#{exp}' //_.inspect(desiredError)\n          : 'an error';\n\n    if (thrown) {\n      actuallyGot = ' but #{act} was thrown'\n    }\n\n    this.assert(\n        thrown === true\n      , 'expected #{this} to throw ' + expectedThrown + actuallyGot\n      , 'expected #{this} to not throw ' + expectedThrown + actuallyGot\n      , (desiredError instanceof Error ? desiredError.toString() : desiredError)\n      , (thrownError instanceof Error ? thrownError.toString() : thrownError)\n    );\n\n    flag(this, 'object', thrownError);\n  };\n\n  Assertion.addMethod('throw', assertThrows);\n  Assertion.addMethod('throws', assertThrows);\n  Assertion.addMethod('Throw', assertThrows);\n\n  /**\n   * ### .respondTo(method)\n   *\n   * Asserts that the object or class target will respond to a method.\n   *\n   *     Klass.prototype.bar = function(){};\n   *     expect(Klass).to.respondTo('bar');\n   *     expect(obj).to.respondTo('bar');\n   *\n   * To check if a constructor will respond to a static function,\n   * set the `itself` flag.\n   *\n   *     Klass.baz = function(){};\n   *     expect(Klass).itself.to.respondTo('baz');\n   *\n   * @name respondTo\n   * @alias respondsTo\n   * @param {String} method\n   * @param {String} message _optional_\n   * @namespace BDD\n   * @api public\n   */\n\n  function respondTo (method, msg) {\n    if (msg) flag(this, 'message', msg);\n    var obj = flag(this, 'object')\n      , itself = flag(this, 'itself')\n      , context = ('function' === _.type(obj) && !itself)\n        ? obj.prototype[method]\n        : obj[method];\n\n    this.assert(\n        'function' === typeof context\n      , 'expected #{this} to respond to ' + _.inspect(method)\n      , 'expected #{this} to not respond to ' + _.inspect(method)\n    );\n  }\n\n  Assertion.addMethod('respondTo', respondTo);\n  Assertion.addMethod('respondsTo', respondTo);\n\n  /**\n   * ### .itself\n   *\n   * Sets the `itself` flag, later used by the `respondTo` assertion.\n   *\n   *     function Foo() {}\n   *     Foo.bar = function() {}\n   *     Foo.prototype.baz = function() {}\n   *\n   *     expect(Foo).itself.to.respondTo('bar');\n   *     expect(Foo).itself.not.to.respondTo('baz');\n   *\n   * @name itself\n   * @namespace BDD\n   * @api public\n   */\n\n  Assertion.addProperty('itself', function () {\n    flag(this, 'itself', true);\n  });\n\n  /**\n   * ### .satisfy(method)\n   *\n   * Asserts that the target passes a given truth test.\n   *\n   *     expect(1).to.satisfy(function(num) { return num > 0; });\n   *\n   * @name satisfy\n   * @alias satisfies\n   * @param {Function} matcher\n   * @param {String} message _optional_\n   * @namespace BDD\n   * @api public\n   */\n\n  function satisfy (matcher, msg) {\n    if (msg) flag(this, 'message', msg);\n    var obj = flag(this, 'object');\n    var result = matcher(obj);\n    this.assert(\n        result\n      , 'expected #{this} to satisfy ' + _.objDisplay(matcher)\n      , 'expected #{this} to not satisfy' + _.objDisplay(matcher)\n      , this.negate ? false : true\n      , result\n    );\n  }\n\n  Assertion.addMethod('satisfy', satisfy);\n  Assertion.addMethod('satisfies', satisfy);\n\n  /**\n   * ### .closeTo(expected, delta)\n   *\n   * Asserts that the target is equal `expected`, to within a +/- `delta` range.\n   *\n   *     expect(1.5).to.be.closeTo(1, 0.5);\n   *\n   * @name closeTo\n   * @alias approximately\n   * @param {Number} expected\n   * @param {Number} delta\n   * @param {String} message _optional_\n   * @namespace BDD\n   * @api public\n   */\n\n  function closeTo(expected, delta, msg) {\n    if (msg) flag(this, 'message', msg);\n    var obj = flag(this, 'object');\n\n    new Assertion(obj, msg).is.a('number');\n    if (_.type(expected) !== 'number' || _.type(delta) !== 'number') {\n      throw new Error('the arguments to closeTo or approximately must be numbers');\n    }\n\n    this.assert(\n        Math.abs(obj - expected) <= delta\n      , 'expected #{this} to be close to ' + expected + ' +/- ' + delta\n      , 'expected #{this} not to be close to ' + expected + ' +/- ' + delta\n    );\n  }\n\n  Assertion.addMethod('closeTo', closeTo);\n  Assertion.addMethod('approximately', closeTo);\n\n  function isSubsetOf(subset, superset, cmp) {\n    return subset.every(function(elem) {\n      if (!cmp) return superset.indexOf(elem) !== -1;\n\n      return superset.some(function(elem2) {\n        return cmp(elem, elem2);\n      });\n    })\n  }\n\n  /**\n   * ### .members(set)\n   *\n   * Asserts that the target is a superset of `set`,\n   * or that the target and `set` have the same strictly-equal (===) members.\n   * Alternately, if the `deep` flag is set, set members are compared for deep\n   * equality.\n   *\n   *     expect([1, 2, 3]).to.include.members([3, 2]);\n   *     expect([1, 2, 3]).to.not.include.members([3, 2, 8]);\n   *\n   *     expect([4, 2]).to.have.members([2, 4]);\n   *     expect([5, 2]).to.not.have.members([5, 2, 1]);\n   *\n   *     expect([{ id: 1 }]).to.deep.include.members([{ id: 1 }]);\n   *\n   * @name members\n   * @param {Array} set\n   * @param {String} message _optional_\n   * @namespace BDD\n   * @api public\n   */\n\n  Assertion.addMethod('members', function (subset, msg) {\n    if (msg) flag(this, 'message', msg);\n    var obj = flag(this, 'object');\n\n    new Assertion(obj).to.be.an('array');\n    new Assertion(subset).to.be.an('array');\n\n    var cmp = flag(this, 'deep') ? _.eql : undefined;\n\n    if (flag(this, 'contains')) {\n      return this.assert(\n          isSubsetOf(subset, obj, cmp)\n        , 'expected #{this} to be a superset of #{act}'\n        , 'expected #{this} to not be a superset of #{act}'\n        , obj\n        , subset\n      );\n    }\n\n    this.assert(\n        isSubsetOf(obj, subset, cmp) && isSubsetOf(subset, obj, cmp)\n        , 'expected #{this} to have the same members as #{act}'\n        , 'expected #{this} to not have the same members as #{act}'\n        , obj\n        , subset\n    );\n  });\n\n  /**\n   * ### .oneOf(list)\n   *\n   * Assert that a value appears somewhere in the top level of array `list`.\n   *\n   *     expect('a').to.be.oneOf(['a', 'b', 'c']);\n   *     expect(9).to.not.be.oneOf(['z']);\n   *     expect([3]).to.not.be.oneOf([1, 2, [3]]);\n   *\n   *     var three = [3];\n   *     // for object-types, contents are not compared\n   *     expect(three).to.not.be.oneOf([1, 2, [3]]);\n   *     // comparing references works\n   *     expect(three).to.be.oneOf([1, 2, three]);\n   *\n   * @name oneOf\n   * @param {Array<*>} list\n   * @param {String} message _optional_\n   * @namespace BDD\n   * @api public\n   */\n\n  function oneOf (list, msg) {\n    if (msg) flag(this, 'message', msg);\n    var expected = flag(this, 'object');\n    new Assertion(list).to.be.an('array');\n\n    this.assert(\n        list.indexOf(expected) > -1\n      , 'expected #{this} to be one of #{exp}'\n      , 'expected #{this} to not be one of #{exp}'\n      , list\n      , expected\n    );\n  }\n\n  Assertion.addMethod('oneOf', oneOf);\n\n\n  /**\n   * ### .change(function)\n   *\n   * Asserts that a function changes an object property\n   *\n   *     var obj = { val: 10 };\n   *     var fn = function() { obj.val += 3 };\n   *     var noChangeFn = function() { return 'foo' + 'bar'; }\n   *     expect(fn).to.change(obj, 'val');\n   *     expect(noChangeFn).to.not.change(obj, 'val')\n   *\n   * @name change\n   * @alias changes\n   * @alias Change\n   * @param {String} object\n   * @param {String} property name\n   * @param {String} message _optional_\n   * @namespace BDD\n   * @api public\n   */\n\n  function assertChanges (object, prop, msg) {\n    if (msg) flag(this, 'message', msg);\n    var fn = flag(this, 'object');\n    new Assertion(object, msg).to.have.property(prop);\n    new Assertion(fn).is.a('function');\n\n    var initial = object[prop];\n    fn();\n\n    this.assert(\n      initial !== object[prop]\n      , 'expected .' + prop + ' to change'\n      , 'expected .' + prop + ' to not change'\n    );\n  }\n\n  Assertion.addChainableMethod('change', assertChanges);\n  Assertion.addChainableMethod('changes', assertChanges);\n\n  /**\n   * ### .increase(function)\n   *\n   * Asserts that a function increases an object property\n   *\n   *     var obj = { val: 10 };\n   *     var fn = function() { obj.val = 15 };\n   *     expect(fn).to.increase(obj, 'val');\n   *\n   * @name increase\n   * @alias increases\n   * @alias Increase\n   * @param {String} object\n   * @param {String} property name\n   * @param {String} message _optional_\n   * @namespace BDD\n   * @api public\n   */\n\n  function assertIncreases (object, prop, msg) {\n    if (msg) flag(this, 'message', msg);\n    var fn = flag(this, 'object');\n    new Assertion(object, msg).to.have.property(prop);\n    new Assertion(fn).is.a('function');\n\n    var initial = object[prop];\n    fn();\n\n    this.assert(\n      object[prop] - initial > 0\n      , 'expected .' + prop + ' to increase'\n      , 'expected .' + prop + ' to not increase'\n    );\n  }\n\n  Assertion.addChainableMethod('increase', assertIncreases);\n  Assertion.addChainableMethod('increases', assertIncreases);\n\n  /**\n   * ### .decrease(function)\n   *\n   * Asserts that a function decreases an object property\n   *\n   *     var obj = { val: 10 };\n   *     var fn = function() { obj.val = 5 };\n   *     expect(fn).to.decrease(obj, 'val');\n   *\n   * @name decrease\n   * @alias decreases\n   * @alias Decrease\n   * @param {String} object\n   * @param {String} property name\n   * @param {String} message _optional_\n   * @namespace BDD\n   * @api public\n   */\n\n  function assertDecreases (object, prop, msg) {\n    if (msg) flag(this, 'message', msg);\n    var fn = flag(this, 'object');\n    new Assertion(object, msg).to.have.property(prop);\n    new Assertion(fn).is.a('function');\n\n    var initial = object[prop];\n    fn();\n\n    this.assert(\n      object[prop] - initial < 0\n      , 'expected .' + prop + ' to decrease'\n      , 'expected .' + prop + ' to not decrease'\n    );\n  }\n\n  Assertion.addChainableMethod('decrease', assertDecreases);\n  Assertion.addChainableMethod('decreases', assertDecreases);\n\n  /**\n   * ### .extensible\n   *\n   * Asserts that the target is extensible (can have new properties added to\n   * it).\n   *\n   *     var nonExtensibleObject = Object.preventExtensions({});\n   *     var sealedObject = Object.seal({});\n   *     var frozenObject = Object.freeze({});\n   *\n   *     expect({}).to.be.extensible;\n   *     expect(nonExtensibleObject).to.not.be.extensible;\n   *     expect(sealedObject).to.not.be.extensible;\n   *     expect(frozenObject).to.not.be.extensible;\n   *\n   * @name extensible\n   * @namespace BDD\n   * @api public\n   */\n\n  Assertion.addProperty('extensible', function() {\n    var obj = flag(this, 'object');\n\n    // In ES5, if the argument to this method is not an object (a primitive), then it will cause a TypeError.\n    // In ES6, a non-object argument will be treated as if it was a non-extensible ordinary object, simply return false.\n    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isExtensible\n    // The following provides ES6 behavior when a TypeError is thrown under ES5.\n\n    var isExtensible;\n\n    try {\n      isExtensible = Object.isExtensible(obj);\n    } catch (err) {\n      if (err instanceof TypeError) isExtensible = false;\n      else throw err;\n    }\n\n    this.assert(\n      isExtensible\n      , 'expected #{this} to be extensible'\n      , 'expected #{this} to not be extensible'\n    );\n  });\n\n  /**\n   * ### .sealed\n   *\n   * Asserts that the target is sealed (cannot have new properties added to it\n   * and its existing properties cannot be removed).\n   *\n   *     var sealedObject = Object.seal({});\n   *     var frozenObject = Object.freeze({});\n   *\n   *     expect(sealedObject).to.be.sealed;\n   *     expect(frozenObject).to.be.sealed;\n   *     expect({}).to.not.be.sealed;\n   *\n   * @name sealed\n   * @namespace BDD\n   * @api public\n   */\n\n  Assertion.addProperty('sealed', function() {\n    var obj = flag(this, 'object');\n\n    // In ES5, if the argument to this method is not an object (a primitive), then it will cause a TypeError.\n    // In ES6, a non-object argument will be treated as if it was a sealed ordinary object, simply return true.\n    // See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isSealed\n    // The following provides ES6 behavior when a TypeError is thrown under ES5.\n\n    var isSealed;\n\n    try {\n      isSealed = Object.isSealed(obj);\n    } catch (err) {\n      if (err instanceof TypeError) isSealed = true;\n      else throw err;\n    }\n\n    this.assert(\n      isSealed\n      , 'expected #{this} to be sealed'\n      , 'expected #{this} to not be sealed'\n    );\n  });\n\n  /**\n   * ### .frozen\n   *\n   * Asserts that the target is frozen (cannot have new properties added to it\n   * and its existing properties cannot be modified).\n   *\n   *     var frozenObject = Object.freeze({});\n   *\n   *     expect(frozenObject).to.be.frozen;\n   *     expect({}).to.not.be.frozen;\n   *\n   * @name frozen\n   * @namespace BDD\n   * @api public\n   */\n\n  Assertion.addProperty('frozen', function() {\n    var obj = flag(this, 'object');\n\n    // In ES5, if the argument to this method is not an object (a primitive), then it will cause a TypeError.\n    // In ES6, a non-object argument will be treated as if it was a frozen ordinary object, simply return true.\n    // See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isFrozen\n    // The following provides ES6 behavior when a TypeError is thrown under ES5.\n\n    var isFrozen;\n\n    try {\n      isFrozen = Object.isFrozen(obj);\n    } catch (err) {\n      if (err instanceof TypeError) isFrozen = true;\n      else throw err;\n    }\n\n    this.assert(\n      isFrozen\n      , 'expected #{this} to be frozen'\n      , 'expected #{this} to not be frozen'\n    );\n  });\n};\n","/*!\n * chai\n * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\n\nmodule.exports = function (chai, util) {\n\n  /*!\n   * Chai dependencies.\n   */\n\n  var Assertion = chai.Assertion\n    , flag = util.flag;\n\n  /*!\n   * Module export.\n   */\n\n  /**\n   * ### assert(expression, message)\n   *\n   * Write your own test expressions.\n   *\n   *     assert('foo' !== 'bar', 'foo is not bar');\n   *     assert(Array.isArray([]), 'empty arrays are arrays');\n   *\n   * @param {Mixed} expression to test for truthiness\n   * @param {String} message to display on error\n   * @name assert\n   * @namespace Assert\n   * @api public\n   */\n\n  var assert = chai.assert = function (express, errmsg) {\n    var test = new Assertion(null, null, chai.assert);\n    test.assert(\n        express\n      , errmsg\n      , '[ negation message unavailable ]'\n    );\n  };\n\n  /**\n   * ### .fail(actual, expected, [message], [operator])\n   *\n   * Throw a failure. Node.js `assert` module-compatible.\n   *\n   * @name fail\n   * @param {Mixed} actual\n   * @param {Mixed} expected\n   * @param {String} message\n   * @param {String} operator\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.fail = function (actual, expected, message, operator) {\n    message = message || 'assert.fail()';\n    throw new chai.AssertionError(message, {\n        actual: actual\n      , expected: expected\n      , operator: operator\n    }, assert.fail);\n  };\n\n  /**\n   * ### .isOk(object, [message])\n   *\n   * Asserts that `object` is truthy.\n   *\n   *     assert.isOk('everything', 'everything is ok');\n   *     assert.isOk(false, 'this will fail');\n   *\n   * @name isOk\n   * @alias ok\n   * @param {Mixed} object to test\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isOk = function (val, msg) {\n    new Assertion(val, msg).is.ok;\n  };\n\n  /**\n   * ### .isNotOk(object, [message])\n   *\n   * Asserts that `object` is falsy.\n   *\n   *     assert.isNotOk('everything', 'this will fail');\n   *     assert.isNotOk(false, 'this will pass');\n   *\n   * @name isNotOk\n   * @alias notOk\n   * @param {Mixed} object to test\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isNotOk = function (val, msg) {\n    new Assertion(val, msg).is.not.ok;\n  };\n\n  /**\n   * ### .equal(actual, expected, [message])\n   *\n   * Asserts non-strict equality (`==`) of `actual` and `expected`.\n   *\n   *     assert.equal(3, '3', '== coerces values to strings');\n   *\n   * @name equal\n   * @param {Mixed} actual\n   * @param {Mixed} expected\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.equal = function (act, exp, msg) {\n    var test = new Assertion(act, msg, assert.equal);\n\n    test.assert(\n        exp == flag(test, 'object')\n      , 'expected #{this} to equal #{exp}'\n      , 'expected #{this} to not equal #{act}'\n      , exp\n      , act\n    );\n  };\n\n  /**\n   * ### .notEqual(actual, expected, [message])\n   *\n   * Asserts non-strict inequality (`!=`) of `actual` and `expected`.\n   *\n   *     assert.notEqual(3, 4, 'these numbers are not equal');\n   *\n   * @name notEqual\n   * @param {Mixed} actual\n   * @param {Mixed} expected\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.notEqual = function (act, exp, msg) {\n    var test = new Assertion(act, msg, assert.notEqual);\n\n    test.assert(\n        exp != flag(test, 'object')\n      , 'expected #{this} to not equal #{exp}'\n      , 'expected #{this} to equal #{act}'\n      , exp\n      , act\n    );\n  };\n\n  /**\n   * ### .strictEqual(actual, expected, [message])\n   *\n   * Asserts strict equality (`===`) of `actual` and `expected`.\n   *\n   *     assert.strictEqual(true, true, 'these booleans are strictly equal');\n   *\n   * @name strictEqual\n   * @param {Mixed} actual\n   * @param {Mixed} expected\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.strictEqual = function (act, exp, msg) {\n    new Assertion(act, msg).to.equal(exp);\n  };\n\n  /**\n   * ### .notStrictEqual(actual, expected, [message])\n   *\n   * Asserts strict inequality (`!==`) of `actual` and `expected`.\n   *\n   *     assert.notStrictEqual(3, '3', 'no coercion for strict equality');\n   *\n   * @name notStrictEqual\n   * @param {Mixed} actual\n   * @param {Mixed} expected\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.notStrictEqual = function (act, exp, msg) {\n    new Assertion(act, msg).to.not.equal(exp);\n  };\n\n  /**\n   * ### .deepEqual(actual, expected, [message])\n   *\n   * Asserts that `actual` is deeply equal to `expected`.\n   *\n   *     assert.deepEqual({ tea: 'green' }, { tea: 'green' });\n   *\n   * @name deepEqual\n   * @param {Mixed} actual\n   * @param {Mixed} expected\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.deepEqual = function (act, exp, msg) {\n    new Assertion(act, msg).to.eql(exp);\n  };\n\n  /**\n   * ### .notDeepEqual(actual, expected, [message])\n   *\n   * Assert that `actual` is not deeply equal to `expected`.\n   *\n   *     assert.notDeepEqual({ tea: 'green' }, { tea: 'jasmine' });\n   *\n   * @name notDeepEqual\n   * @param {Mixed} actual\n   * @param {Mixed} expected\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.notDeepEqual = function (act, exp, msg) {\n    new Assertion(act, msg).to.not.eql(exp);\n  };\n\n   /**\n   * ### .isAbove(valueToCheck, valueToBeAbove, [message])\n   *\n   * Asserts `valueToCheck` is strictly greater than (>) `valueToBeAbove`\n   *\n   *     assert.isAbove(5, 2, '5 is strictly greater than 2');\n   *\n   * @name isAbove\n   * @param {Mixed} valueToCheck\n   * @param {Mixed} valueToBeAbove\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isAbove = function (val, abv, msg) {\n    new Assertion(val, msg).to.be.above(abv);\n  };\n\n   /**\n   * ### .isAtLeast(valueToCheck, valueToBeAtLeast, [message])\n   *\n   * Asserts `valueToCheck` is greater than or equal to (>=) `valueToBeAtLeast`\n   *\n   *     assert.isAtLeast(5, 2, '5 is greater or equal to 2');\n   *     assert.isAtLeast(3, 3, '3 is greater or equal to 3');\n   *\n   * @name isAtLeast\n   * @param {Mixed} valueToCheck\n   * @param {Mixed} valueToBeAtLeast\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isAtLeast = function (val, atlst, msg) {\n    new Assertion(val, msg).to.be.least(atlst);\n  };\n\n   /**\n   * ### .isBelow(valueToCheck, valueToBeBelow, [message])\n   *\n   * Asserts `valueToCheck` is strictly less than (<) `valueToBeBelow`\n   *\n   *     assert.isBelow(3, 6, '3 is strictly less than 6');\n   *\n   * @name isBelow\n   * @param {Mixed} valueToCheck\n   * @param {Mixed} valueToBeBelow\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isBelow = function (val, blw, msg) {\n    new Assertion(val, msg).to.be.below(blw);\n  };\n\n   /**\n   * ### .isAtMost(valueToCheck, valueToBeAtMost, [message])\n   *\n   * Asserts `valueToCheck` is less than or equal to (<=) `valueToBeAtMost`\n   *\n   *     assert.isAtMost(3, 6, '3 is less than or equal to 6');\n   *     assert.isAtMost(4, 4, '4 is less than or equal to 4');\n   *\n   * @name isAtMost\n   * @param {Mixed} valueToCheck\n   * @param {Mixed} valueToBeAtMost\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isAtMost = function (val, atmst, msg) {\n    new Assertion(val, msg).to.be.most(atmst);\n  };\n\n  /**\n   * ### .isTrue(value, [message])\n   *\n   * Asserts that `value` is true.\n   *\n   *     var teaServed = true;\n   *     assert.isTrue(teaServed, 'the tea has been served');\n   *\n   * @name isTrue\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isTrue = function (val, msg) {\n    new Assertion(val, msg).is['true'];\n  };\n\n  /**\n   * ### .isNotTrue(value, [message])\n   *\n   * Asserts that `value` is not true.\n   *\n   *     var tea = 'tasty chai';\n   *     assert.isNotTrue(tea, 'great, time for tea!');\n   *\n   * @name isNotTrue\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isNotTrue = function (val, msg) {\n    new Assertion(val, msg).to.not.equal(true);\n  };\n\n  /**\n   * ### .isFalse(value, [message])\n   *\n   * Asserts that `value` is false.\n   *\n   *     var teaServed = false;\n   *     assert.isFalse(teaServed, 'no tea yet? hmm...');\n   *\n   * @name isFalse\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isFalse = function (val, msg) {\n    new Assertion(val, msg).is['false'];\n  };\n\n  /**\n   * ### .isNotFalse(value, [message])\n   *\n   * Asserts that `value` is not false.\n   *\n   *     var tea = 'tasty chai';\n   *     assert.isNotFalse(tea, 'great, time for tea!');\n   *\n   * @name isNotFalse\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isNotFalse = function (val, msg) {\n    new Assertion(val, msg).to.not.equal(false);\n  };\n\n  /**\n   * ### .isNull(value, [message])\n   *\n   * Asserts that `value` is null.\n   *\n   *     assert.isNull(err, 'there was no error');\n   *\n   * @name isNull\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isNull = function (val, msg) {\n    new Assertion(val, msg).to.equal(null);\n  };\n\n  /**\n   * ### .isNotNull(value, [message])\n   *\n   * Asserts that `value` is not null.\n   *\n   *     var tea = 'tasty chai';\n   *     assert.isNotNull(tea, 'great, time for tea!');\n   *\n   * @name isNotNull\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isNotNull = function (val, msg) {\n    new Assertion(val, msg).to.not.equal(null);\n  };\n\n  /**\n   * ### .isNaN\n   * Asserts that value is NaN\n   *\n   *    assert.isNaN('foo', 'foo is NaN');\n   *\n   * @name isNaN\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isNaN = function (val, msg) {\n    new Assertion(val, msg).to.be.NaN;\n  };\n\n  /**\n   * ### .isNotNaN\n   * Asserts that value is not NaN\n   *\n   *    assert.isNotNaN(4, '4 is not NaN');\n   *\n   * @name isNotNaN\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n  assert.isNotNaN = function (val, msg) {\n    new Assertion(val, msg).not.to.be.NaN;\n  };\n\n  /**\n   * ### .isUndefined(value, [message])\n   *\n   * Asserts that `value` is `undefined`.\n   *\n   *     var tea;\n   *     assert.isUndefined(tea, 'no tea defined');\n   *\n   * @name isUndefined\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isUndefined = function (val, msg) {\n    new Assertion(val, msg).to.equal(undefined);\n  };\n\n  /**\n   * ### .isDefined(value, [message])\n   *\n   * Asserts that `value` is not `undefined`.\n   *\n   *     var tea = 'cup of chai';\n   *     assert.isDefined(tea, 'tea has been defined');\n   *\n   * @name isDefined\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isDefined = function (val, msg) {\n    new Assertion(val, msg).to.not.equal(undefined);\n  };\n\n  /**\n   * ### .isFunction(value, [message])\n   *\n   * Asserts that `value` is a function.\n   *\n   *     function serveTea() { return 'cup of tea'; };\n   *     assert.isFunction(serveTea, 'great, we can have tea now');\n   *\n   * @name isFunction\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isFunction = function (val, msg) {\n    new Assertion(val, msg).to.be.a('function');\n  };\n\n  /**\n   * ### .isNotFunction(value, [message])\n   *\n   * Asserts that `value` is _not_ a function.\n   *\n   *     var serveTea = [ 'heat', 'pour', 'sip' ];\n   *     assert.isNotFunction(serveTea, 'great, we have listed the steps');\n   *\n   * @name isNotFunction\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isNotFunction = function (val, msg) {\n    new Assertion(val, msg).to.not.be.a('function');\n  };\n\n  /**\n   * ### .isObject(value, [message])\n   *\n   * Asserts that `value` is an object of type 'Object' (as revealed by `Object.prototype.toString`).\n   * _The assertion does not match subclassed objects._\n   *\n   *     var selection = { name: 'Chai', serve: 'with spices' };\n   *     assert.isObject(selection, 'tea selection is an object');\n   *\n   * @name isObject\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isObject = function (val, msg) {\n    new Assertion(val, msg).to.be.a('object');\n  };\n\n  /**\n   * ### .isNotObject(value, [message])\n   *\n   * Asserts that `value` is _not_ an object of type 'Object' (as revealed by `Object.prototype.toString`).\n   *\n   *     var selection = 'chai'\n   *     assert.isNotObject(selection, 'tea selection is not an object');\n   *     assert.isNotObject(null, 'null is not an object');\n   *\n   * @name isNotObject\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isNotObject = function (val, msg) {\n    new Assertion(val, msg).to.not.be.a('object');\n  };\n\n  /**\n   * ### .isArray(value, [message])\n   *\n   * Asserts that `value` is an array.\n   *\n   *     var menu = [ 'green', 'chai', 'oolong' ];\n   *     assert.isArray(menu, 'what kind of tea do we want?');\n   *\n   * @name isArray\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isArray = function (val, msg) {\n    new Assertion(val, msg).to.be.an('array');\n  };\n\n  /**\n   * ### .isNotArray(value, [message])\n   *\n   * Asserts that `value` is _not_ an array.\n   *\n   *     var menu = 'green|chai|oolong';\n   *     assert.isNotArray(menu, 'what kind of tea do we want?');\n   *\n   * @name isNotArray\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isNotArray = function (val, msg) {\n    new Assertion(val, msg).to.not.be.an('array');\n  };\n\n  /**\n   * ### .isString(value, [message])\n   *\n   * Asserts that `value` is a string.\n   *\n   *     var teaOrder = 'chai';\n   *     assert.isString(teaOrder, 'order placed');\n   *\n   * @name isString\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isString = function (val, msg) {\n    new Assertion(val, msg).to.be.a('string');\n  };\n\n  /**\n   * ### .isNotString(value, [message])\n   *\n   * Asserts that `value` is _not_ a string.\n   *\n   *     var teaOrder = 4;\n   *     assert.isNotString(teaOrder, 'order placed');\n   *\n   * @name isNotString\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isNotString = function (val, msg) {\n    new Assertion(val, msg).to.not.be.a('string');\n  };\n\n  /**\n   * ### .isNumber(value, [message])\n   *\n   * Asserts that `value` is a number.\n   *\n   *     var cups = 2;\n   *     assert.isNumber(cups, 'how many cups');\n   *\n   * @name isNumber\n   * @param {Number} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isNumber = function (val, msg) {\n    new Assertion(val, msg).to.be.a('number');\n  };\n\n  /**\n   * ### .isNotNumber(value, [message])\n   *\n   * Asserts that `value` is _not_ a number.\n   *\n   *     var cups = '2 cups please';\n   *     assert.isNotNumber(cups, 'how many cups');\n   *\n   * @name isNotNumber\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isNotNumber = function (val, msg) {\n    new Assertion(val, msg).to.not.be.a('number');\n  };\n\n  /**\n   * ### .isBoolean(value, [message])\n   *\n   * Asserts that `value` is a boolean.\n   *\n   *     var teaReady = true\n   *       , teaServed = false;\n   *\n   *     assert.isBoolean(teaReady, 'is the tea ready');\n   *     assert.isBoolean(teaServed, 'has tea been served');\n   *\n   * @name isBoolean\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isBoolean = function (val, msg) {\n    new Assertion(val, msg).to.be.a('boolean');\n  };\n\n  /**\n   * ### .isNotBoolean(value, [message])\n   *\n   * Asserts that `value` is _not_ a boolean.\n   *\n   *     var teaReady = 'yep'\n   *       , teaServed = 'nope';\n   *\n   *     assert.isNotBoolean(teaReady, 'is the tea ready');\n   *     assert.isNotBoolean(teaServed, 'has tea been served');\n   *\n   * @name isNotBoolean\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isNotBoolean = function (val, msg) {\n    new Assertion(val, msg).to.not.be.a('boolean');\n  };\n\n  /**\n   * ### .typeOf(value, name, [message])\n   *\n   * Asserts that `value`'s type is `name`, as determined by\n   * `Object.prototype.toString`.\n   *\n   *     assert.typeOf({ tea: 'chai' }, 'object', 'we have an object');\n   *     assert.typeOf(['chai', 'jasmine'], 'array', 'we have an array');\n   *     assert.typeOf('tea', 'string', 'we have a string');\n   *     assert.typeOf(/tea/, 'regexp', 'we have a regular expression');\n   *     assert.typeOf(null, 'null', 'we have a null');\n   *     assert.typeOf(undefined, 'undefined', 'we have an undefined');\n   *\n   * @name typeOf\n   * @param {Mixed} value\n   * @param {String} name\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.typeOf = function (val, type, msg) {\n    new Assertion(val, msg).to.be.a(type);\n  };\n\n  /**\n   * ### .notTypeOf(value, name, [message])\n   *\n   * Asserts that `value`'s type is _not_ `name`, as determined by\n   * `Object.prototype.toString`.\n   *\n   *     assert.notTypeOf('tea', 'number', 'strings are not numbers');\n   *\n   * @name notTypeOf\n   * @param {Mixed} value\n   * @param {String} typeof name\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.notTypeOf = function (val, type, msg) {\n    new Assertion(val, msg).to.not.be.a(type);\n  };\n\n  /**\n   * ### .instanceOf(object, constructor, [message])\n   *\n   * Asserts that `value` is an instance of `constructor`.\n   *\n   *     var Tea = function (name) { this.name = name; }\n   *       , chai = new Tea('chai');\n   *\n   *     assert.instanceOf(chai, Tea, 'chai is an instance of tea');\n   *\n   * @name instanceOf\n   * @param {Object} object\n   * @param {Constructor} constructor\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.instanceOf = function (val, type, msg) {\n    new Assertion(val, msg).to.be.instanceOf(type);\n  };\n\n  /**\n   * ### .notInstanceOf(object, constructor, [message])\n   *\n   * Asserts `value` is not an instance of `constructor`.\n   *\n   *     var Tea = function (name) { this.name = name; }\n   *       , chai = new String('chai');\n   *\n   *     assert.notInstanceOf(chai, Tea, 'chai is not an instance of tea');\n   *\n   * @name notInstanceOf\n   * @param {Object} object\n   * @param {Constructor} constructor\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.notInstanceOf = function (val, type, msg) {\n    new Assertion(val, msg).to.not.be.instanceOf(type);\n  };\n\n  /**\n   * ### .include(haystack, needle, [message])\n   *\n   * Asserts that `haystack` includes `needle`. Works\n   * for strings and arrays.\n   *\n   *     assert.include('foobar', 'bar', 'foobar contains string \"bar\"');\n   *     assert.include([ 1, 2, 3 ], 3, 'array contains value');\n   *\n   * @name include\n   * @param {Array|String} haystack\n   * @param {Mixed} needle\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.include = function (exp, inc, msg) {\n    new Assertion(exp, msg, assert.include).include(inc);\n  };\n\n  /**\n   * ### .notInclude(haystack, needle, [message])\n   *\n   * Asserts that `haystack` does not include `needle`. Works\n   * for strings and arrays.\n   *\n   *     assert.notInclude('foobar', 'baz', 'string not include substring');\n   *     assert.notInclude([ 1, 2, 3 ], 4, 'array not include contain value');\n   *\n   * @name notInclude\n   * @param {Array|String} haystack\n   * @param {Mixed} needle\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.notInclude = function (exp, inc, msg) {\n    new Assertion(exp, msg, assert.notInclude).not.include(inc);\n  };\n\n  /**\n   * ### .match(value, regexp, [message])\n   *\n   * Asserts that `value` matches the regular expression `regexp`.\n   *\n   *     assert.match('foobar', /^foo/, 'regexp matches');\n   *\n   * @name match\n   * @param {Mixed} value\n   * @param {RegExp} regexp\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.match = function (exp, re, msg) {\n    new Assertion(exp, msg).to.match(re);\n  };\n\n  /**\n   * ### .notMatch(value, regexp, [message])\n   *\n   * Asserts that `value` does not match the regular expression `regexp`.\n   *\n   *     assert.notMatch('foobar', /^foo/, 'regexp does not match');\n   *\n   * @name notMatch\n   * @param {Mixed} value\n   * @param {RegExp} regexp\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.notMatch = function (exp, re, msg) {\n    new Assertion(exp, msg).to.not.match(re);\n  };\n\n  /**\n   * ### .property(object, property, [message])\n   *\n   * Asserts that `object` has a property named by `property`.\n   *\n   *     assert.property({ tea: { green: 'matcha' }}, 'tea');\n   *\n   * @name property\n   * @param {Object} object\n   * @param {String} property\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.property = function (obj, prop, msg) {\n    new Assertion(obj, msg).to.have.property(prop);\n  };\n\n  /**\n   * ### .notProperty(object, property, [message])\n   *\n   * Asserts that `object` does _not_ have a property named by `property`.\n   *\n   *     assert.notProperty({ tea: { green: 'matcha' }}, 'coffee');\n   *\n   * @name notProperty\n   * @param {Object} object\n   * @param {String} property\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.notProperty = function (obj, prop, msg) {\n    new Assertion(obj, msg).to.not.have.property(prop);\n  };\n\n  /**\n   * ### .deepProperty(object, property, [message])\n   *\n   * Asserts that `object` has a property named by `property`, which can be a\n   * string using dot- and bracket-notation for deep reference.\n   *\n   *     assert.deepProperty({ tea: { green: 'matcha' }}, 'tea.green');\n   *\n   * @name deepProperty\n   * @param {Object} object\n   * @param {String} property\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.deepProperty = function (obj, prop, msg) {\n    new Assertion(obj, msg).to.have.deep.property(prop);\n  };\n\n  /**\n   * ### .notDeepProperty(object, property, [message])\n   *\n   * Asserts that `object` does _not_ have a property named by `property`, which\n   * can be a string using dot- and bracket-notation for deep reference.\n   *\n   *     assert.notDeepProperty({ tea: { green: 'matcha' }}, 'tea.oolong');\n   *\n   * @name notDeepProperty\n   * @param {Object} object\n   * @param {String} property\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.notDeepProperty = function (obj, prop, msg) {\n    new Assertion(obj, msg).to.not.have.deep.property(prop);\n  };\n\n  /**\n   * ### .propertyVal(object, property, value, [message])\n   *\n   * Asserts that `object` has a property named by `property` with value given\n   * by `value`.\n   *\n   *     assert.propertyVal({ tea: 'is good' }, 'tea', 'is good');\n   *\n   * @name propertyVal\n   * @param {Object} object\n   * @param {String} property\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.propertyVal = function (obj, prop, val, msg) {\n    new Assertion(obj, msg).to.have.property(prop, val);\n  };\n\n  /**\n   * ### .propertyNotVal(object, property, value, [message])\n   *\n   * Asserts that `object` has a property named by `property`, but with a value\n   * different from that given by `value`.\n   *\n   *     assert.propertyNotVal({ tea: 'is good' }, 'tea', 'is bad');\n   *\n   * @name propertyNotVal\n   * @param {Object} object\n   * @param {String} property\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.propertyNotVal = function (obj, prop, val, msg) {\n    new Assertion(obj, msg).to.not.have.property(prop, val);\n  };\n\n  /**\n   * ### .deepPropertyVal(object, property, value, [message])\n   *\n   * Asserts that `object` has a property named by `property` with value given\n   * by `value`. `property` can use dot- and bracket-notation for deep\n   * reference.\n   *\n   *     assert.deepPropertyVal({ tea: { green: 'matcha' }}, 'tea.green', 'matcha');\n   *\n   * @name deepPropertyVal\n   * @param {Object} object\n   * @param {String} property\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.deepPropertyVal = function (obj, prop, val, msg) {\n    new Assertion(obj, msg).to.have.deep.property(prop, val);\n  };\n\n  /**\n   * ### .deepPropertyNotVal(object, property, value, [message])\n   *\n   * Asserts that `object` has a property named by `property`, but with a value\n   * different from that given by `value`. `property` can use dot- and\n   * bracket-notation for deep reference.\n   *\n   *     assert.deepPropertyNotVal({ tea: { green: 'matcha' }}, 'tea.green', 'konacha');\n   *\n   * @name deepPropertyNotVal\n   * @param {Object} object\n   * @param {String} property\n   * @param {Mixed} value\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.deepPropertyNotVal = function (obj, prop, val, msg) {\n    new Assertion(obj, msg).to.not.have.deep.property(prop, val);\n  };\n\n  /**\n   * ### .lengthOf(object, length, [message])\n   *\n   * Asserts that `object` has a `length` property with the expected value.\n   *\n   *     assert.lengthOf([1,2,3], 3, 'array has length of 3');\n   *     assert.lengthOf('foobar', 6, 'string has length of 6');\n   *\n   * @name lengthOf\n   * @param {Mixed} object\n   * @param {Number} length\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.lengthOf = function (exp, len, msg) {\n    new Assertion(exp, msg).to.have.length(len);\n  };\n\n  /**\n   * ### .throws(function, [constructor/string/regexp], [string/regexp], [message])\n   *\n   * Asserts that `function` will throw an error that is an instance of\n   * `constructor`, or alternately that it will throw an error with message\n   * matching `regexp`.\n   *\n   *     assert.throws(fn, 'function throws a reference error');\n   *     assert.throws(fn, /function throws a reference error/);\n   *     assert.throws(fn, ReferenceError);\n   *     assert.throws(fn, ReferenceError, 'function throws a reference error');\n   *     assert.throws(fn, ReferenceError, /function throws a reference error/);\n   *\n   * @name throws\n   * @alias throw\n   * @alias Throw\n   * @param {Function} function\n   * @param {ErrorConstructor} constructor\n   * @param {RegExp} regexp\n   * @param {String} message\n   * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.throws = function (fn, errt, errs, msg) {\n    if ('string' === typeof errt || errt instanceof RegExp) {\n      errs = errt;\n      errt = null;\n    }\n\n    var assertErr = new Assertion(fn, msg).to.throw(errt, errs);\n    return flag(assertErr, 'object');\n  };\n\n  /**\n   * ### .doesNotThrow(function, [constructor/regexp], [message])\n   *\n   * Asserts that `function` will _not_ throw an error that is an instance of\n   * `constructor`, or alternately that it will not throw an error with message\n   * matching `regexp`.\n   *\n   *     assert.doesNotThrow(fn, Error, 'function does not throw');\n   *\n   * @name doesNotThrow\n   * @param {Function} function\n   * @param {ErrorConstructor} constructor\n   * @param {RegExp} regexp\n   * @param {String} message\n   * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.doesNotThrow = function (fn, type, msg) {\n    if ('string' === typeof type) {\n      msg = type;\n      type = null;\n    }\n\n    new Assertion(fn, msg).to.not.Throw(type);\n  };\n\n  /**\n   * ### .operator(val1, operator, val2, [message])\n   *\n   * Compares two values using `operator`.\n   *\n   *     assert.operator(1, '<', 2, 'everything is ok');\n   *     assert.operator(1, '>', 2, 'this will fail');\n   *\n   * @name operator\n   * @param {Mixed} val1\n   * @param {String} operator\n   * @param {Mixed} val2\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.operator = function (val, operator, val2, msg) {\n    var ok;\n    switch(operator) {\n      case '==':\n        ok = val == val2;\n        break;\n      case '===':\n        ok = val === val2;\n        break;\n      case '>':\n        ok = val > val2;\n        break;\n      case '>=':\n        ok = val >= val2;\n        break;\n      case '<':\n        ok = val < val2;\n        break;\n      case '<=':\n        ok = val <= val2;\n        break;\n      case '!=':\n        ok = val != val2;\n        break;\n      case '!==':\n        ok = val !== val2;\n        break;\n      default:\n        throw new Error('Invalid operator \"' + operator + '\"');\n    }\n    var test = new Assertion(ok, msg);\n    test.assert(\n        true === flag(test, 'object')\n      , 'expected ' + util.inspect(val) + ' to be ' + operator + ' ' + util.inspect(val2)\n      , 'expected ' + util.inspect(val) + ' to not be ' + operator + ' ' + util.inspect(val2) );\n  };\n\n  /**\n   * ### .closeTo(actual, expected, delta, [message])\n   *\n   * Asserts that the target is equal `expected`, to within a +/- `delta` range.\n   *\n   *     assert.closeTo(1.5, 1, 0.5, 'numbers are close');\n   *\n   * @name closeTo\n   * @param {Number} actual\n   * @param {Number} expected\n   * @param {Number} delta\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.closeTo = function (act, exp, delta, msg) {\n    new Assertion(act, msg).to.be.closeTo(exp, delta);\n  };\n\n  /**\n   * ### .approximately(actual, expected, delta, [message])\n   *\n   * Asserts that the target is equal `expected`, to within a +/- `delta` range.\n   *\n   *     assert.approximately(1.5, 1, 0.5, 'numbers are close');\n   *\n   * @name approximately\n   * @param {Number} actual\n   * @param {Number} expected\n   * @param {Number} delta\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.approximately = function (act, exp, delta, msg) {\n    new Assertion(act, msg).to.be.approximately(exp, delta);\n  };\n\n  /**\n   * ### .sameMembers(set1, set2, [message])\n   *\n   * Asserts that `set1` and `set2` have the same members.\n   * Order is not taken into account.\n   *\n   *     assert.sameMembers([ 1, 2, 3 ], [ 2, 1, 3 ], 'same members');\n   *\n   * @name sameMembers\n   * @param {Array} set1\n   * @param {Array} set2\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.sameMembers = function (set1, set2, msg) {\n    new Assertion(set1, msg).to.have.same.members(set2);\n  }\n\n  /**\n   * ### .sameDeepMembers(set1, set2, [message])\n   *\n   * Asserts that `set1` and `set2` have the same members - using a deep equality checking.\n   * Order is not taken into account.\n   *\n   *     assert.sameDeepMembers([ {b: 3}, {a: 2}, {c: 5} ], [ {c: 5}, {b: 3}, {a: 2} ], 'same deep members');\n   *\n   * @name sameDeepMembers\n   * @param {Array} set1\n   * @param {Array} set2\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.sameDeepMembers = function (set1, set2, msg) {\n    new Assertion(set1, msg).to.have.same.deep.members(set2);\n  }\n\n  /**\n   * ### .includeMembers(superset, subset, [message])\n   *\n   * Asserts that `subset` is included in `superset`.\n   * Order is not taken into account.\n   *\n   *     assert.includeMembers([ 1, 2, 3 ], [ 2, 1 ], 'include members');\n   *\n   * @name includeMembers\n   * @param {Array} superset\n   * @param {Array} subset\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.includeMembers = function (superset, subset, msg) {\n    new Assertion(superset, msg).to.include.members(subset);\n  }\n\n  /**\n   * ### .includeDeepMembers(superset, subset, [message])\n   *\n   * Asserts that `subset` is included in `superset` - using deep equality checking.\n   * Order is not taken into account.\n   * Duplicates are ignored.\n   *\n   *     assert.includeDeepMembers([ {a: 1}, {b: 2}, {c: 3} ], [ {b: 2}, {a: 1}, {b: 2} ], 'include deep members');\n   *\n   * @name includeDeepMembers\n   * @param {Array} superset\n   * @param {Array} subset\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.includeDeepMembers = function (superset, subset, msg) {\n    new Assertion(superset, msg).to.include.deep.members(subset);\n  }\n\n  /**\n   * ### .oneOf(inList, list, [message])\n   *\n   * Asserts that non-object, non-array value `inList` appears in the flat array `list`.\n   *\n   *     assert.oneOf(1, [ 2, 1 ], 'Not found in list');\n   *\n   * @name oneOf\n   * @param {*} inList\n   * @param {Array<*>} list\n   * @param {String} message\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.oneOf = function (inList, list, msg) {\n    new Assertion(inList, msg).to.be.oneOf(list);\n  }\n\n   /**\n   * ### .changes(function, object, property)\n   *\n   * Asserts that a function changes the value of a property\n   *\n   *     var obj = { val: 10 };\n   *     var fn = function() { obj.val = 22 };\n   *     assert.changes(fn, obj, 'val');\n   *\n   * @name changes\n   * @param {Function} modifier function\n   * @param {Object} object\n   * @param {String} property name\n   * @param {String} message _optional_\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.changes = function (fn, obj, prop) {\n    new Assertion(fn).to.change(obj, prop);\n  }\n\n   /**\n   * ### .doesNotChange(function, object, property)\n   *\n   * Asserts that a function does not changes the value of a property\n   *\n   *     var obj = { val: 10 };\n   *     var fn = function() { console.log('foo'); };\n   *     assert.doesNotChange(fn, obj, 'val');\n   *\n   * @name doesNotChange\n   * @param {Function} modifier function\n   * @param {Object} object\n   * @param {String} property name\n   * @param {String} message _optional_\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.doesNotChange = function (fn, obj, prop) {\n    new Assertion(fn).to.not.change(obj, prop);\n  }\n\n   /**\n   * ### .increases(function, object, property)\n   *\n   * Asserts that a function increases an object property\n   *\n   *     var obj = { val: 10 };\n   *     var fn = function() { obj.val = 13 };\n   *     assert.increases(fn, obj, 'val');\n   *\n   * @name increases\n   * @param {Function} modifier function\n   * @param {Object} object\n   * @param {String} property name\n   * @param {String} message _optional_\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.increases = function (fn, obj, prop) {\n    new Assertion(fn).to.increase(obj, prop);\n  }\n\n   /**\n   * ### .doesNotIncrease(function, object, property)\n   *\n   * Asserts that a function does not increase object property\n   *\n   *     var obj = { val: 10 };\n   *     var fn = function() { obj.val = 8 };\n   *     assert.doesNotIncrease(fn, obj, 'val');\n   *\n   * @name doesNotIncrease\n   * @param {Function} modifier function\n   * @param {Object} object\n   * @param {String} property name\n   * @param {String} message _optional_\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.doesNotIncrease = function (fn, obj, prop) {\n    new Assertion(fn).to.not.increase(obj, prop);\n  }\n\n   /**\n   * ### .decreases(function, object, property)\n   *\n   * Asserts that a function decreases an object property\n   *\n   *     var obj = { val: 10 };\n   *     var fn = function() { obj.val = 5 };\n   *     assert.decreases(fn, obj, 'val');\n   *\n   * @name decreases\n   * @param {Function} modifier function\n   * @param {Object} object\n   * @param {String} property name\n   * @param {String} message _optional_\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.decreases = function (fn, obj, prop) {\n    new Assertion(fn).to.decrease(obj, prop);\n  }\n\n   /**\n   * ### .doesNotDecrease(function, object, property)\n   *\n   * Asserts that a function does not decreases an object property\n   *\n   *     var obj = { val: 10 };\n   *     var fn = function() { obj.val = 15 };\n   *     assert.doesNotDecrease(fn, obj, 'val');\n   *\n   * @name doesNotDecrease\n   * @param {Function} modifier function\n   * @param {Object} object\n   * @param {String} property name\n   * @param {String} message _optional_\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.doesNotDecrease = function (fn, obj, prop) {\n    new Assertion(fn).to.not.decrease(obj, prop);\n  }\n\n  /*!\n   * ### .ifError(object)\n   *\n   * Asserts if value is not a false value, and throws if it is a true value.\n   * This is added to allow for chai to be a drop-in replacement for Node's\n   * assert class.\n   *\n   *     var err = new Error('I am a custom error');\n   *     assert.ifError(err); // Rethrows err!\n   *\n   * @name ifError\n   * @param {Object} object\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.ifError = function (val) {\n    if (val) {\n      throw(val);\n    }\n  };\n\n  /**\n   * ### .isExtensible(object)\n   *\n   * Asserts that `object` is extensible (can have new properties added to it).\n   *\n   *     assert.isExtensible({});\n   *\n   * @name isExtensible\n   * @alias extensible\n   * @param {Object} object\n   * @param {String} message _optional_\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isExtensible = function (obj, msg) {\n    new Assertion(obj, msg).to.be.extensible;\n  };\n\n  /**\n   * ### .isNotExtensible(object)\n   *\n   * Asserts that `object` is _not_ extensible.\n   *\n   *     var nonExtensibleObject = Object.preventExtensions({});\n   *     var sealedObject = Object.seal({});\n   *     var frozenObject = Object.freese({});\n   *\n   *     assert.isNotExtensible(nonExtensibleObject);\n   *     assert.isNotExtensible(sealedObject);\n   *     assert.isNotExtensible(frozenObject);\n   *\n   * @name isNotExtensible\n   * @alias notExtensible\n   * @param {Object} object\n   * @param {String} message _optional_\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isNotExtensible = function (obj, msg) {\n    new Assertion(obj, msg).to.not.be.extensible;\n  };\n\n  /**\n   * ### .isSealed(object)\n   *\n   * Asserts that `object` is sealed (cannot have new properties added to it\n   * and its existing properties cannot be removed).\n   *\n   *     var sealedObject = Object.seal({});\n   *     var frozenObject = Object.seal({});\n   *\n   *     assert.isSealed(sealedObject);\n   *     assert.isSealed(frozenObject);\n   *\n   * @name isSealed\n   * @alias sealed\n   * @param {Object} object\n   * @param {String} message _optional_\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isSealed = function (obj, msg) {\n    new Assertion(obj, msg).to.be.sealed;\n  };\n\n  /**\n   * ### .isNotSealed(object)\n   *\n   * Asserts that `object` is _not_ sealed.\n   *\n   *     assert.isNotSealed({});\n   *\n   * @name isNotSealed\n   * @alias notSealed\n   * @param {Object} object\n   * @param {String} message _optional_\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isNotSealed = function (obj, msg) {\n    new Assertion(obj, msg).to.not.be.sealed;\n  };\n\n  /**\n   * ### .isFrozen(object)\n   *\n   * Asserts that `object` is frozen (cannot have new properties added to it\n   * and its existing properties cannot be modified).\n   *\n   *     var frozenObject = Object.freeze({});\n   *     assert.frozen(frozenObject);\n   *\n   * @name isFrozen\n   * @alias frozen\n   * @param {Object} object\n   * @param {String} message _optional_\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isFrozen = function (obj, msg) {\n    new Assertion(obj, msg).to.be.frozen;\n  };\n\n  /**\n   * ### .isNotFrozen(object)\n   *\n   * Asserts that `object` is _not_ frozen.\n   *\n   *     assert.isNotFrozen({});\n   *\n   * @name isNotFrozen\n   * @alias notFrozen\n   * @param {Object} object\n   * @param {String} message _optional_\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.isNotFrozen = function (obj, msg) {\n    new Assertion(obj, msg).to.not.be.frozen;\n  };\n\n  /*!\n   * Aliases.\n   */\n\n  (function alias(name, as){\n    assert[as] = assert[name];\n    return alias;\n  })\n  ('isOk', 'ok')\n  ('isNotOk', 'notOk')\n  ('throws', 'throw')\n  ('throws', 'Throw')\n  ('isExtensible', 'extensible')\n  ('isNotExtensible', 'notExtensible')\n  ('isSealed', 'sealed')\n  ('isNotSealed', 'notSealed')\n  ('isFrozen', 'frozen')\n  ('isNotFrozen', 'notFrozen');\n};\n","/*!\n * chai\n * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\nmodule.exports = function (chai, util) {\n  chai.expect = function (val, message) {\n    return new chai.Assertion(val, message);\n  };\n\n  /**\n   * ### .fail(actual, expected, [message], [operator])\n   *\n   * Throw a failure.\n   *\n   * @name fail\n   * @param {Mixed} actual\n   * @param {Mixed} expected\n   * @param {String} message\n   * @param {String} operator\n   * @namespace Expect\n   * @api public\n   */\n\n  chai.expect.fail = function (actual, expected, message, operator) {\n    message = message || 'expect.fail()';\n    throw new chai.AssertionError(message, {\n        actual: actual\n      , expected: expected\n      , operator: operator\n    }, chai.expect.fail);\n  };\n};\n","/*!\n * chai\n * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\nmodule.exports = function (chai, util) {\n  var Assertion = chai.Assertion;\n\n  function loadShould () {\n    // explicitly define this method as function as to have it's name to include as `ssfi`\n    function shouldGetter() {\n      if (this instanceof String || this instanceof Number || this instanceof Boolean ) {\n        return new Assertion(this.valueOf(), null, shouldGetter);\n      }\n      return new Assertion(this, null, shouldGetter);\n    }\n    function shouldSetter(value) {\n      // See https://github.com/chaijs/chai/issues/86: this makes\n      // `whatever.should = someValue` actually set `someValue`, which is\n      // especially useful for `global.should = require('chai').should()`.\n      //\n      // Note that we have to use [[DefineProperty]] instead of [[Put]]\n      // since otherwise we would trigger this very setter!\n      Object.defineProperty(this, 'should', {\n        value: value,\n        enumerable: true,\n        configurable: true,\n        writable: true\n      });\n    }\n    // modify Object.prototype to have `should`\n    Object.defineProperty(Object.prototype, 'should', {\n      set: shouldSetter\n      , get: shouldGetter\n      , configurable: true\n    });\n\n    var should = {};\n\n    /**\n     * ### .fail(actual, expected, [message], [operator])\n     *\n     * Throw a failure.\n     *\n     * @name fail\n     * @param {Mixed} actual\n     * @param {Mixed} expected\n     * @param {String} message\n     * @param {String} operator\n     * @namespace Should\n     * @api public\n     */\n\n    should.fail = function (actual, expected, message, operator) {\n      message = message || 'should.fail()';\n      throw new chai.AssertionError(message, {\n          actual: actual\n        , expected: expected\n        , operator: operator\n      }, should.fail);\n    };\n\n    /**\n     * ### .equal(actual, expected, [message])\n     *\n     * Asserts non-strict equality (`==`) of `actual` and `expected`.\n     *\n     *     should.equal(3, '3', '== coerces values to strings');\n     *\n     * @name equal\n     * @param {Mixed} actual\n     * @param {Mixed} expected\n     * @param {String} message\n     * @namespace Should\n     * @api public\n     */\n\n    should.equal = function (val1, val2, msg) {\n      new Assertion(val1, msg).to.equal(val2);\n    };\n\n    /**\n     * ### .throw(function, [constructor/string/regexp], [string/regexp], [message])\n     *\n     * Asserts that `function` will throw an error that is an instance of\n     * `constructor`, or alternately that it will throw an error with message\n     * matching `regexp`.\n     *\n     *     should.throw(fn, 'function throws a reference error');\n     *     should.throw(fn, /function throws a reference error/);\n     *     should.throw(fn, ReferenceError);\n     *     should.throw(fn, ReferenceError, 'function throws a reference error');\n     *     should.throw(fn, ReferenceError, /function throws a reference error/);\n     *\n     * @name throw\n     * @alias Throw\n     * @param {Function} function\n     * @param {ErrorConstructor} constructor\n     * @param {RegExp} regexp\n     * @param {String} message\n     * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types\n     * @namespace Should\n     * @api public\n     */\n\n    should.Throw = function (fn, errt, errs, msg) {\n      new Assertion(fn, msg).to.Throw(errt, errs);\n    };\n\n    /**\n     * ### .exist\n     *\n     * Asserts that the target is neither `null` nor `undefined`.\n     *\n     *     var foo = 'hi';\n     *\n     *     should.exist(foo, 'foo exists');\n     *\n     * @name exist\n     * @namespace Should\n     * @api public\n     */\n\n    should.exist = function (val, msg) {\n      new Assertion(val, msg).to.exist;\n    }\n\n    // negation\n    should.not = {}\n\n    /**\n     * ### .not.equal(actual, expected, [message])\n     *\n     * Asserts non-strict inequality (`!=`) of `actual` and `expected`.\n     *\n     *     should.not.equal(3, 4, 'these numbers are not equal');\n     *\n     * @name not.equal\n     * @param {Mixed} actual\n     * @param {Mixed} expected\n     * @param {String} message\n     * @namespace Should\n     * @api public\n     */\n\n    should.not.equal = function (val1, val2, msg) {\n      new Assertion(val1, msg).to.not.equal(val2);\n    };\n\n    /**\n     * ### .throw(function, [constructor/regexp], [message])\n     *\n     * Asserts that `function` will _not_ throw an error that is an instance of\n     * `constructor`, or alternately that it will not throw an error with message\n     * matching `regexp`.\n     *\n     *     should.not.throw(fn, Error, 'function does not throw');\n     *\n     * @name not.throw\n     * @alias not.Throw\n     * @param {Function} function\n     * @param {ErrorConstructor} constructor\n     * @param {RegExp} regexp\n     * @param {String} message\n     * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types\n     * @namespace Should\n     * @api public\n     */\n\n    should.not.Throw = function (fn, errt, errs, msg) {\n      new Assertion(fn, msg).to.not.Throw(errt, errs);\n    };\n\n    /**\n     * ### .not.exist\n     *\n     * Asserts that the target is neither `null` nor `undefined`.\n     *\n     *     var bar = null;\n     *\n     *     should.not.exist(bar, 'bar does not exist');\n     *\n     * @name not.exist\n     * @namespace Should\n     * @api public\n     */\n\n    should.not.exist = function (val, msg) {\n      new Assertion(val, msg).to.not.exist;\n    }\n\n    should['throw'] = should['Throw'];\n    should.not['throw'] = should.not['Throw'];\n\n    return should;\n  };\n\n  chai.should = loadShould;\n  chai.Should = loadShould;\n};\n","/*!\n * Chai - addChainingMethod utility\n * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\n/*!\n * Module dependencies\n */\n\nvar transferFlags = require('./transferFlags');\nvar flag = require('./flag');\nvar config = require('../config');\n\n/*!\n * Module variables\n */\n\n// Check whether `__proto__` is supported\nvar hasProtoSupport = '__proto__' in Object;\n\n// Without `__proto__` support, this module will need to add properties to a function.\n// However, some Function.prototype methods cannot be overwritten,\n// and there seems no easy cross-platform way to detect them (@see chaijs/chai/issues/69).\nvar excludeNames = /^(?:length|name|arguments|caller)$/;\n\n// Cache `Function` properties\nvar call  = Function.prototype.call,\n    apply = Function.prototype.apply;\n\n/**\n * ### addChainableMethod (ctx, name, method, chainingBehavior)\n *\n * Adds a method to an object, such that the method can also be chained.\n *\n *     utils.addChainableMethod(chai.Assertion.prototype, 'foo', function (str) {\n *       var obj = utils.flag(this, 'object');\n *       new chai.Assertion(obj).to.be.equal(str);\n *     });\n *\n * Can also be accessed directly from `chai.Assertion`.\n *\n *     chai.Assertion.addChainableMethod('foo', fn, chainingBehavior);\n *\n * The result can then be used as both a method assertion, executing both `method` and\n * `chainingBehavior`, or as a language chain, which only executes `chainingBehavior`.\n *\n *     expect(fooStr).to.be.foo('bar');\n *     expect(fooStr).to.be.foo.equal('foo');\n *\n * @param {Object} ctx object to which the method is added\n * @param {String} name of method to add\n * @param {Function} method function to be used for `name`, when called\n * @param {Function} chainingBehavior function to be called every time the property is accessed\n * @namespace Utils\n * @name addChainableMethod\n * @api public\n */\n\nmodule.exports = function (ctx, name, method, chainingBehavior) {\n  if (typeof chainingBehavior !== 'function') {\n    chainingBehavior = function () { };\n  }\n\n  var chainableBehavior = {\n      method: method\n    , chainingBehavior: chainingBehavior\n  };\n\n  // save the methods so we can overwrite them later, if we need to.\n  if (!ctx.__methods) {\n    ctx.__methods = {};\n  }\n  ctx.__methods[name] = chainableBehavior;\n\n  Object.defineProperty(ctx, name,\n    { get: function () {\n        chainableBehavior.chainingBehavior.call(this);\n\n        var assert = function assert() {\n          var old_ssfi = flag(this, 'ssfi');\n          if (old_ssfi && config.includeStack === false)\n            flag(this, 'ssfi', assert);\n          var result = chainableBehavior.method.apply(this, arguments);\n          return result === undefined ? this : result;\n        };\n\n        // Use `__proto__` if available\n        if (hasProtoSupport) {\n          // Inherit all properties from the object by replacing the `Function` prototype\n          var prototype = assert.__proto__ = Object.create(this);\n          // Restore the `call` and `apply` methods from `Function`\n          prototype.call = call;\n          prototype.apply = apply;\n        }\n        // Otherwise, redefine all properties (slow!)\n        else {\n          var asserterNames = Object.getOwnPropertyNames(ctx);\n          asserterNames.forEach(function (asserterName) {\n            if (!excludeNames.test(asserterName)) {\n              var pd = Object.getOwnPropertyDescriptor(ctx, asserterName);\n              Object.defineProperty(assert, asserterName, pd);\n            }\n          });\n        }\n\n        transferFlags(this, assert);\n        return assert;\n      }\n    , configurable: true\n  });\n};\n","/*!\n * Chai - addMethod utility\n * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\nvar config = require('../config');\n\n/**\n * ### .addMethod (ctx, name, method)\n *\n * Adds a method to the prototype of an object.\n *\n *     utils.addMethod(chai.Assertion.prototype, 'foo', function (str) {\n *       var obj = utils.flag(this, 'object');\n *       new chai.Assertion(obj).to.be.equal(str);\n *     });\n *\n * Can also be accessed directly from `chai.Assertion`.\n *\n *     chai.Assertion.addMethod('foo', fn);\n *\n * Then can be used as any other assertion.\n *\n *     expect(fooStr).to.be.foo('bar');\n *\n * @param {Object} ctx object to which the method is added\n * @param {String} name of method to add\n * @param {Function} method function to be used for name\n * @namespace Utils\n * @name addMethod\n * @api public\n */\nvar flag = require('./flag');\n\nmodule.exports = function (ctx, name, method) {\n  ctx[name] = function () {\n    var old_ssfi = flag(this, 'ssfi');\n    if (old_ssfi && config.includeStack === false)\n      flag(this, 'ssfi', ctx[name]);\n    var result = method.apply(this, arguments);\n    return result === undefined ? this : result;\n  };\n};\n","/*!\n * Chai - addProperty utility\n * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\nvar config = require('../config');\nvar flag = require('./flag');\n\n/**\n * ### addProperty (ctx, name, getter)\n *\n * Adds a property to the prototype of an object.\n *\n *     utils.addProperty(chai.Assertion.prototype, 'foo', function () {\n *       var obj = utils.flag(this, 'object');\n *       new chai.Assertion(obj).to.be.instanceof(Foo);\n *     });\n *\n * Can also be accessed directly from `chai.Assertion`.\n *\n *     chai.Assertion.addProperty('foo', fn);\n *\n * Then can be used as any other assertion.\n *\n *     expect(myFoo).to.be.foo;\n *\n * @param {Object} ctx object to which the property is added\n * @param {String} name of property to add\n * @param {Function} getter function to be used for name\n * @namespace Utils\n * @name addProperty\n * @api public\n */\n\nmodule.exports = function (ctx, name, getter) {\n  Object.defineProperty(ctx, name,\n    { get: function addProperty() {\n        var old_ssfi = flag(this, 'ssfi');\n        if (old_ssfi && config.includeStack === false)\n          flag(this, 'ssfi', addProperty);\n\n        var result = getter.call(this);\n        return result === undefined ? this : result;\n      }\n    , configurable: true\n  });\n};\n","/*!\n * Chai - expectTypes utility\n * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\n/**\n * ### expectTypes(obj, types)\n *\n * Ensures that the object being tested against is of a valid type.\n *\n *     utils.expectTypes(this, ['array', 'object', 'string']);\n *\n * @param {Mixed} obj constructed Assertion\n * @param {Array} type A list of allowed types for this assertion\n * @namespace Utils\n * @name expectTypes\n * @api public\n */\n\nvar AssertionError = require('assertion-error');\nvar flag = require('./flag');\nvar type = require('type-detect');\n\nmodule.exports = function (obj, types) {\n  var obj = flag(obj, 'object');\n  types = types.map(function (t) { return t.toLowerCase(); });\n  types.sort();\n\n  // Transforms ['lorem', 'ipsum'] into 'a lirum, or an ipsum'\n  var str = types.map(function (t, index) {\n    var art = ~[ 'a', 'e', 'i', 'o', 'u' ].indexOf(t.charAt(0)) ? 'an' : 'a';\n    var or = types.length > 1 && index === types.length - 1 ? 'or ' : '';\n    return or + art + ' ' + t;\n  }).join(', ');\n\n  if (!types.some(function (expected) { return type(obj) === expected; })) {\n    throw new AssertionError(\n      'object tested must be ' + str + ', but ' + type(obj) + ' given'\n    );\n  }\n};\n","/*!\n * Chai - flag utility\n * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\n/**\n * ### flag(object, key, [value])\n *\n * Get or set a flag value on an object. If a\n * value is provided it will be set, else it will\n * return the currently set value or `undefined` if\n * the value is not set.\n *\n *     utils.flag(this, 'foo', 'bar'); // setter\n *     utils.flag(this, 'foo'); // getter, returns `bar`\n *\n * @param {Object} object constructed Assertion\n * @param {String} key\n * @param {Mixed} value (optional)\n * @namespace Utils\n * @name flag\n * @api private\n */\n\nmodule.exports = function (obj, key, value) {\n  var flags = obj.__flags || (obj.__flags = Object.create(null));\n  if (arguments.length === 3) {\n    flags[key] = value;\n  } else {\n    return flags[key];\n  }\n};\n","/*!\n * Chai - getActual utility\n * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\n/**\n * # getActual(object, [actual])\n *\n * Returns the `actual` value for an Assertion\n *\n * @param {Object} object (constructed Assertion)\n * @param {Arguments} chai.Assertion.prototype.assert arguments\n * @namespace Utils\n * @name getActual\n */\n\nmodule.exports = function (obj, args) {\n  return args.length > 4 ? args[4] : obj._obj;\n};\n","/*!\n * Chai - getEnumerableProperties utility\n * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\n/**\n * ### .getEnumerableProperties(object)\n *\n * This allows the retrieval of enumerable property names of an object,\n * inherited or not.\n *\n * @param {Object} object\n * @returns {Array}\n * @namespace Utils\n * @name getEnumerableProperties\n * @api public\n */\n\nmodule.exports = function getEnumerableProperties(object) {\n  var result = [];\n  for (var name in object) {\n    result.push(name);\n  }\n  return result;\n};\n","/*!\n * Chai - message composition utility\n * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\n/*!\n * Module dependancies\n */\n\nvar flag = require('./flag')\n  , getActual = require('./getActual')\n  , inspect = require('./inspect')\n  , objDisplay = require('./objDisplay');\n\n/**\n * ### .getMessage(object, message, negateMessage)\n *\n * Construct the error message based on flags\n * and template tags. Template tags will return\n * a stringified inspection of the object referenced.\n *\n * Message template tags:\n * - `#{this}` current asserted object\n * - `#{act}` actual value\n * - `#{exp}` expected value\n *\n * @param {Object} object (constructed Assertion)\n * @param {Arguments} chai.Assertion.prototype.assert arguments\n * @namespace Utils\n * @name getMessage\n * @api public\n */\n\nmodule.exports = function (obj, args) {\n  var negate = flag(obj, 'negate')\n    , val = flag(obj, 'object')\n    , expected = args[3]\n    , actual = getActual(obj, args)\n    , msg = negate ? args[2] : args[1]\n    , flagMsg = flag(obj, 'message');\n\n  if(typeof msg === \"function\") msg = msg();\n  msg = msg || '';\n  msg = msg\n    .replace(/#\\{this\\}/g, function () { return objDisplay(val); })\n    .replace(/#\\{act\\}/g, function () { return objDisplay(actual); })\n    .replace(/#\\{exp\\}/g, function () { return objDisplay(expected); });\n\n  return flagMsg ? flagMsg + ': ' + msg : msg;\n};\n","/*!\n * Chai - getName utility\n * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\n/**\n * # getName(func)\n *\n * Gets the name of a function, in a cross-browser way.\n *\n * @param {Function} a function (usually a constructor)\n * @namespace Utils\n * @name getName\n */\n\nmodule.exports = function (func) {\n  if (func.name) return func.name;\n\n  var match = /^\\s?function ([^(]*)\\(/.exec(func);\n  return match && match[1] ? match[1] : \"\";\n};\n","/*!\n * Chai - getPathInfo utility\n * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\nvar hasProperty = require('./hasProperty');\n\n/**\n * ### .getPathInfo(path, object)\n *\n * This allows the retrieval of property info in an\n * object given a string path.\n *\n * The path info consists of an object with the\n * following properties:\n *\n * * parent - The parent object of the property referenced by `path`\n * * name - The name of the final property, a number if it was an array indexer\n * * value - The value of the property, if it exists, otherwise `undefined`\n * * exists - Whether the property exists or not\n *\n * @param {String} path\n * @param {Object} object\n * @returns {Object} info\n * @namespace Utils\n * @name getPathInfo\n * @api public\n */\n\nmodule.exports = function getPathInfo(path, obj) {\n  var parsed = parsePath(path),\n      last = parsed[parsed.length - 1];\n\n  var info = {\n    parent: parsed.length > 1 ? _getPathValue(parsed, obj, parsed.length - 1) : obj,\n    name: last.p || last.i,\n    value: _getPathValue(parsed, obj)\n  };\n  info.exists = hasProperty(info.name, info.parent);\n\n  return info;\n};\n\n\n/*!\n * ## parsePath(path)\n *\n * Helper function used to parse string object\n * paths. Use in conjunction with `_getPathValue`.\n *\n *      var parsed = parsePath('myobject.property.subprop');\n *\n * ### Paths:\n *\n * * Can be as near infinitely deep and nested\n * * Arrays are also valid using the formal `myobject.document[3].property`.\n * * Literal dots and brackets (not delimiter) must be backslash-escaped.\n *\n * @param {String} path\n * @returns {Object} parsed\n * @api private\n */\n\nfunction parsePath (path) {\n  var str = path.replace(/([^\\\\])\\[/g, '$1.[')\n    , parts = str.match(/(\\\\\\.|[^.]+?)+/g);\n  return parts.map(function (value) {\n    var re = /^\\[(\\d+)\\]$/\n      , mArr = re.exec(value);\n    if (mArr) return { i: parseFloat(mArr[1]) };\n    else return { p: value.replace(/\\\\([.\\[\\]])/g, '$1') };\n  });\n}\n\n\n/*!\n * ## _getPathValue(parsed, obj)\n *\n * Helper companion function for `.parsePath` that returns\n * the value located at the parsed address.\n *\n *      var value = getPathValue(parsed, obj);\n *\n * @param {Object} parsed definition from `parsePath`.\n * @param {Object} object to search against\n * @param {Number} object to search against\n * @returns {Object|Undefined} value\n * @api private\n */\n\nfunction _getPathValue (parsed, obj, index) {\n  var tmp = obj\n    , res;\n\n  index = (index === undefined ? parsed.length : index);\n\n  for (var i = 0, l = index; i < l; i++) {\n    var part = parsed[i];\n    if (tmp) {\n      if ('undefined' !== typeof part.p)\n        tmp = tmp[part.p];\n      else if ('undefined' !== typeof part.i)\n        tmp = tmp[part.i];\n      if (i == (l - 1)) res = tmp;\n    } else {\n      res = undefined;\n    }\n  }\n  return res;\n}\n","/*!\n * Chai - getPathValue utility\n * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>\n * @see https://github.com/logicalparadox/filtr\n * MIT Licensed\n */\n\nvar getPathInfo = require('./getPathInfo');\n\n/**\n * ### .getPathValue(path, object)\n *\n * This allows the retrieval of values in an\n * object given a string path.\n *\n *     var obj = {\n *         prop1: {\n *             arr: ['a', 'b', 'c']\n *           , str: 'Hello'\n *         }\n *       , prop2: {\n *             arr: [ { nested: 'Universe' } ]\n *           , str: 'Hello again!'\n *         }\n *     }\n *\n * The following would be the results.\n *\n *     getPathValue('prop1.str', obj); // Hello\n *     getPathValue('prop1.att[2]', obj); // b\n *     getPathValue('prop2.arr[0].nested', obj); // Universe\n *\n * @param {String} path\n * @param {Object} object\n * @returns {Object} value or `undefined`\n * @namespace Utils\n * @name getPathValue\n * @api public\n */\nmodule.exports = function(path, obj) {\n  var info = getPathInfo(path, obj);\n  return info.value;\n};\n","/*!\n * Chai - getProperties utility\n * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\n/**\n * ### .getProperties(object)\n *\n * This allows the retrieval of property names of an object, enumerable or not,\n * inherited or not.\n *\n * @param {Object} object\n * @returns {Array}\n * @namespace Utils\n * @name getProperties\n * @api public\n */\n\nmodule.exports = function getProperties(object) {\n  var result = Object.getOwnPropertyNames(object);\n\n  function addProperty(property) {\n    if (result.indexOf(property) === -1) {\n      result.push(property);\n    }\n  }\n\n  var proto = Object.getPrototypeOf(object);\n  while (proto !== null) {\n    Object.getOwnPropertyNames(proto).forEach(addProperty);\n    proto = Object.getPrototypeOf(proto);\n  }\n\n  return result;\n};\n","/*!\n * Chai - hasProperty utility\n * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\nvar type = require('type-detect');\n\n/**\n * ### .hasProperty(object, name)\n *\n * This allows checking whether an object has\n * named property or numeric array index.\n *\n * Basically does the same thing as the `in`\n * operator but works properly with natives\n * and null/undefined values.\n *\n *     var obj = {\n *         arr: ['a', 'b', 'c']\n *       , str: 'Hello'\n *     }\n *\n * The following would be the results.\n *\n *     hasProperty('str', obj);  // true\n *     hasProperty('constructor', obj);  // true\n *     hasProperty('bar', obj);  // false\n *\n *     hasProperty('length', obj.str); // true\n *     hasProperty(1, obj.str);  // true\n *     hasProperty(5, obj.str);  // false\n *\n *     hasProperty('length', obj.arr);  // true\n *     hasProperty(2, obj.arr);  // true\n *     hasProperty(3, obj.arr);  // false\n *\n * @param {Objuect} object\n * @param {String|Number} name\n * @returns {Boolean} whether it exists\n * @namespace Utils\n * @name getPathInfo\n * @api public\n */\n\nvar literals = {\n    'number': Number\n  , 'string': String\n};\n\nmodule.exports = function hasProperty(name, obj) {\n  var ot = type(obj);\n\n  // Bad Object, obviously no props at all\n  if(ot === 'null' || ot === 'undefined')\n    return false;\n\n  // The `in` operator does not work with certain literals\n  // box these before the check\n  if(literals[ot] && typeof obj !== 'object')\n    obj = new literals[ot](obj);\n\n  return name in obj;\n};\n","/*!\n * chai\n * Copyright(c) 2011 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\n/*!\n * Main exports\n */\n\nvar exports = module.exports = {};\n\n/*!\n * test utility\n */\n\nexports.test = require('./test');\n\n/*!\n * type utility\n */\n\nexports.type = require('type-detect');\n\n/*!\n * expectTypes utility\n */\nexports.expectTypes = require('./expectTypes');\n\n/*!\n * message utility\n */\n\nexports.getMessage = require('./getMessage');\n\n/*!\n * actual utility\n */\n\nexports.getActual = require('./getActual');\n\n/*!\n * Inspect util\n */\n\nexports.inspect = require('./inspect');\n\n/*!\n * Object Display util\n */\n\nexports.objDisplay = require('./objDisplay');\n\n/*!\n * Flag utility\n */\n\nexports.flag = require('./flag');\n\n/*!\n * Flag transferring utility\n */\n\nexports.transferFlags = require('./transferFlags');\n\n/*!\n * Deep equal utility\n */\n\nexports.eql = require('deep-eql');\n\n/*!\n * Deep path value\n */\n\nexports.getPathValue = require('./getPathValue');\n\n/*!\n * Deep path info\n */\n\nexports.getPathInfo = require('./getPathInfo');\n\n/*!\n * Check if a property exists\n */\n\nexports.hasProperty = require('./hasProperty');\n\n/*!\n * Function name\n */\n\nexports.getName = require('./getName');\n\n/*!\n * add Property\n */\n\nexports.addProperty = require('./addProperty');\n\n/*!\n * add Method\n */\n\nexports.addMethod = require('./addMethod');\n\n/*!\n * overwrite Property\n */\n\nexports.overwriteProperty = require('./overwriteProperty');\n\n/*!\n * overwrite Method\n */\n\nexports.overwriteMethod = require('./overwriteMethod');\n\n/*!\n * Add a chainable method\n */\n\nexports.addChainableMethod = require('./addChainableMethod');\n\n/*!\n * Overwrite chainable method\n */\n\nexports.overwriteChainableMethod = require('./overwriteChainableMethod');\n","// This is (almost) directly from Node.js utils\n// https://github.com/joyent/node/blob/f8c335d0caf47f16d31413f89aa28eda3878e3aa/lib/util.js\n\nvar getName = require('./getName');\nvar getProperties = require('./getProperties');\nvar getEnumerableProperties = require('./getEnumerableProperties');\n\nmodule.exports = inspect;\n\n/**\n * Echos the value of a value. Trys to print the value out\n * in the best way possible given the different types.\n *\n * @param {Object} obj The object to print out.\n * @param {Boolean} showHidden Flag that shows hidden (not enumerable)\n *    properties of objects.\n * @param {Number} depth Depth in which to descend in object. Default is 2.\n * @param {Boolean} colors Flag to turn on ANSI escape codes to color the\n *    output. Default is false (no coloring).\n * @namespace Utils\n * @name inspect\n */\nfunction inspect(obj, showHidden, depth, colors) {\n  var ctx = {\n    showHidden: showHidden,\n    seen: [],\n    stylize: function (str) { return str; }\n  };\n  return formatValue(ctx, obj, (typeof depth === 'undefined' ? 2 : depth));\n}\n\n// Returns true if object is a DOM element.\nvar isDOMElement = function (object) {\n  if (typeof HTMLElement === 'object') {\n    return object instanceof HTMLElement;\n  } else {\n    return object &&\n      typeof object === 'object' &&\n      object.nodeType === 1 &&\n      typeof object.nodeName === 'string';\n  }\n};\n\nfunction formatValue(ctx, value, recurseTimes) {\n  // Provide a hook for user-specified inspect functions.\n  // Check that value is an object with an inspect function on it\n  if (value && typeof value.inspect === 'function' &&\n      // Filter out the util module, it's inspect function is special\n      value.inspect !== exports.inspect &&\n      // Also filter out any prototype objects using the circular check.\n      !(value.constructor && value.constructor.prototype === value)) {\n    var ret = value.inspect(recurseTimes);\n    if (typeof ret !== 'string') {\n      ret = formatValue(ctx, ret, recurseTimes);\n    }\n    return ret;\n  }\n\n  // Primitive types cannot have properties\n  var primitive = formatPrimitive(ctx, value);\n  if (primitive) {\n    return primitive;\n  }\n\n  // If this is a DOM element, try to get the outer HTML.\n  if (isDOMElement(value)) {\n    if ('outerHTML' in value) {\n      return value.outerHTML;\n      // This value does not have an outerHTML attribute,\n      //   it could still be an XML element\n    } else {\n      // Attempt to serialize it\n      try {\n        if (document.xmlVersion) {\n          var xmlSerializer = new XMLSerializer();\n          return xmlSerializer.serializeToString(value);\n        } else {\n          // Firefox 11- do not support outerHTML\n          //   It does, however, support innerHTML\n          //   Use the following to render the element\n          var ns = \"http://www.w3.org/1999/xhtml\";\n          var container = document.createElementNS(ns, '_');\n\n          container.appendChild(value.cloneNode(false));\n          html = container.innerHTML\n            .replace('><', '>' + value.innerHTML + '<');\n          container.innerHTML = '';\n          return html;\n        }\n      } catch (err) {\n        // This could be a non-native DOM implementation,\n        //   continue with the normal flow:\n        //   printing the element as if it is an object.\n      }\n    }\n  }\n\n  // Look up the keys of the object.\n  var visibleKeys = getEnumerableProperties(value);\n  var keys = ctx.showHidden ? getProperties(value) : visibleKeys;\n\n  // Some type of object without properties can be shortcutted.\n  // In IE, errors have a single `stack` property, or if they are vanilla `Error`,\n  // a `stack` plus `description` property; ignore those for consistency.\n  if (keys.length === 0 || (isError(value) && (\n      (keys.length === 1 && keys[0] === 'stack') ||\n      (keys.length === 2 && keys[0] === 'description' && keys[1] === 'stack')\n     ))) {\n    if (typeof value === 'function') {\n      var name = getName(value);\n      var nameSuffix = name ? ': ' + name : '';\n      return ctx.stylize('[Function' + nameSuffix + ']', 'special');\n    }\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    }\n    if (isDate(value)) {\n      return ctx.stylize(Date.prototype.toUTCString.call(value), 'date');\n    }\n    if (isError(value)) {\n      return formatError(value);\n    }\n  }\n\n  var base = '', array = false, braces = ['{', '}'];\n\n  // Make Array say that they are Array\n  if (isArray(value)) {\n    array = true;\n    braces = ['[', ']'];\n  }\n\n  // Make functions say that they are functions\n  if (typeof value === 'function') {\n    var name = getName(value);\n    var nameSuffix = name ? ': ' + name : '';\n    base = ' [Function' + nameSuffix + ']';\n  }\n\n  // Make RegExps say that they are RegExps\n  if (isRegExp(value)) {\n    base = ' ' + RegExp.prototype.toString.call(value);\n  }\n\n  // Make dates with properties first say the date\n  if (isDate(value)) {\n    base = ' ' + Date.prototype.toUTCString.call(value);\n  }\n\n  // Make error with message first say the error\n  if (isError(value)) {\n    return formatError(value);\n  }\n\n  if (keys.length === 0 && (!array || value.length == 0)) {\n    return braces[0] + base + braces[1];\n  }\n\n  if (recurseTimes < 0) {\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    } else {\n      return ctx.stylize('[Object]', 'special');\n    }\n  }\n\n  ctx.seen.push(value);\n\n  var output;\n  if (array) {\n    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);\n  } else {\n    output = keys.map(function(key) {\n      return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);\n    });\n  }\n\n  ctx.seen.pop();\n\n  return reduceToSingleString(output, base, braces);\n}\n\n\nfunction formatPrimitive(ctx, value) {\n  switch (typeof value) {\n    case 'undefined':\n      return ctx.stylize('undefined', 'undefined');\n\n    case 'string':\n      var simple = '\\'' + JSON.stringify(value).replace(/^\"|\"$/g, '')\n                                               .replace(/'/g, \"\\\\'\")\n                                               .replace(/\\\\\"/g, '\"') + '\\'';\n      return ctx.stylize(simple, 'string');\n\n    case 'number':\n      if (value === 0 && (1/value) === -Infinity) {\n        return ctx.stylize('-0', 'number');\n      }\n      return ctx.stylize('' + value, 'number');\n\n    case 'boolean':\n      return ctx.stylize('' + value, 'boolean');\n  }\n  // For some reason typeof null is \"object\", so special case here.\n  if (value === null) {\n    return ctx.stylize('null', 'null');\n  }\n}\n\n\nfunction formatError(value) {\n  return '[' + Error.prototype.toString.call(value) + ']';\n}\n\n\nfunction formatArray(ctx, value, recurseTimes, visibleKeys, keys) {\n  var output = [];\n  for (var i = 0, l = value.length; i < l; ++i) {\n    if (Object.prototype.hasOwnProperty.call(value, String(i))) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n          String(i), true));\n    } else {\n      output.push('');\n    }\n  }\n  keys.forEach(function(key) {\n    if (!key.match(/^\\d+$/)) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n          key, true));\n    }\n  });\n  return output;\n}\n\n\nfunction formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {\n  var name, str;\n  if (value.__lookupGetter__) {\n    if (value.__lookupGetter__(key)) {\n      if (value.__lookupSetter__(key)) {\n        str = ctx.stylize('[Getter/Setter]', 'special');\n      } else {\n        str = ctx.stylize('[Getter]', 'special');\n      }\n    } else {\n      if (value.__lookupSetter__(key)) {\n        str = ctx.stylize('[Setter]', 'special');\n      }\n    }\n  }\n  if (visibleKeys.indexOf(key) < 0) {\n    name = '[' + key + ']';\n  }\n  if (!str) {\n    if (ctx.seen.indexOf(value[key]) < 0) {\n      if (recurseTimes === null) {\n        str = formatValue(ctx, value[key], null);\n      } else {\n        str = formatValue(ctx, value[key], recurseTimes - 1);\n      }\n      if (str.indexOf('\\n') > -1) {\n        if (array) {\n          str = str.split('\\n').map(function(line) {\n            return '  ' + line;\n          }).join('\\n').substr(2);\n        } else {\n          str = '\\n' + str.split('\\n').map(function(line) {\n            return '   ' + line;\n          }).join('\\n');\n        }\n      }\n    } else {\n      str = ctx.stylize('[Circular]', 'special');\n    }\n  }\n  if (typeof name === 'undefined') {\n    if (array && key.match(/^\\d+$/)) {\n      return str;\n    }\n    name = JSON.stringify('' + key);\n    if (name.match(/^\"([a-zA-Z_][a-zA-Z_0-9]*)\"$/)) {\n      name = name.substr(1, name.length - 2);\n      name = ctx.stylize(name, 'name');\n    } else {\n      name = name.replace(/'/g, \"\\\\'\")\n                 .replace(/\\\\\"/g, '\"')\n                 .replace(/(^\"|\"$)/g, \"'\");\n      name = ctx.stylize(name, 'string');\n    }\n  }\n\n  return name + ': ' + str;\n}\n\n\nfunction reduceToSingleString(output, base, braces) {\n  var numLinesEst = 0;\n  var length = output.reduce(function(prev, cur) {\n    numLinesEst++;\n    if (cur.indexOf('\\n') >= 0) numLinesEst++;\n    return prev + cur.length + 1;\n  }, 0);\n\n  if (length > 60) {\n    return braces[0] +\n           (base === '' ? '' : base + '\\n ') +\n           ' ' +\n           output.join(',\\n  ') +\n           ' ' +\n           braces[1];\n  }\n\n  return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];\n}\n\nfunction isArray(ar) {\n  return Array.isArray(ar) ||\n         (typeof ar === 'object' && objectToString(ar) === '[object Array]');\n}\n\nfunction isRegExp(re) {\n  return typeof re === 'object' && objectToString(re) === '[object RegExp]';\n}\n\nfunction isDate(d) {\n  return typeof d === 'object' && objectToString(d) === '[object Date]';\n}\n\nfunction isError(e) {\n  return typeof e === 'object' && objectToString(e) === '[object Error]';\n}\n\nfunction objectToString(o) {\n  return Object.prototype.toString.call(o);\n}\n","/*!\n * Chai - flag utility\n * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\n/*!\n * Module dependancies\n */\n\nvar inspect = require('./inspect');\nvar config = require('../config');\n\n/**\n * ### .objDisplay (object)\n *\n * Determines if an object or an array matches\n * criteria to be inspected in-line for error\n * messages or should be truncated.\n *\n * @param {Mixed} javascript object to inspect\n * @name objDisplay\n * @namespace Utils\n * @api public\n */\n\nmodule.exports = function (obj) {\n  var str = inspect(obj)\n    , type = Object.prototype.toString.call(obj);\n\n  if (config.truncateThreshold && str.length >= config.truncateThreshold) {\n    if (type === '[object Function]') {\n      return !obj.name || obj.name === ''\n        ? '[Function]'\n        : '[Function: ' + obj.name + ']';\n    } else if (type === '[object Array]') {\n      return '[ Array(' + obj.length + ') ]';\n    } else if (type === '[object Object]') {\n      var keys = Object.keys(obj)\n        , kstr = keys.length > 2\n          ? keys.splice(0, 2).join(', ') + ', ...'\n          : keys.join(', ');\n      return '{ Object (' + kstr + ') }';\n    } else {\n      return str;\n    }\n  } else {\n    return str;\n  }\n};\n","/*!\n * Chai - overwriteChainableMethod utility\n * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\n/**\n * ### overwriteChainableMethod (ctx, name, method, chainingBehavior)\n *\n * Overwites an already existing chainable method\n * and provides access to the previous function or\n * property.  Must return functions to be used for\n * name.\n *\n *     utils.overwriteChainableMethod(chai.Assertion.prototype, 'length',\n *       function (_super) {\n *       }\n *     , function (_super) {\n *       }\n *     );\n *\n * Can also be accessed directly from `chai.Assertion`.\n *\n *     chai.Assertion.overwriteChainableMethod('foo', fn, fn);\n *\n * Then can be used as any other assertion.\n *\n *     expect(myFoo).to.have.length(3);\n *     expect(myFoo).to.have.length.above(3);\n *\n * @param {Object} ctx object whose method / property is to be overwritten\n * @param {String} name of method / property to overwrite\n * @param {Function} method function that returns a function to be used for name\n * @param {Function} chainingBehavior function that returns a function to be used for property\n * @namespace Utils\n * @name overwriteChainableMethod\n * @api public\n */\n\nmodule.exports = function (ctx, name, method, chainingBehavior) {\n  var chainableBehavior = ctx.__methods[name];\n\n  var _chainingBehavior = chainableBehavior.chainingBehavior;\n  chainableBehavior.chainingBehavior = function () {\n    var result = chainingBehavior(_chainingBehavior).call(this);\n    return result === undefined ? this : result;\n  };\n\n  var _method = chainableBehavior.method;\n  chainableBehavior.method = function () {\n    var result = method(_method).apply(this, arguments);\n    return result === undefined ? this : result;\n  };\n};\n","/*!\n * Chai - overwriteMethod utility\n * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\n/**\n * ### overwriteMethod (ctx, name, fn)\n *\n * Overwites an already existing method and provides\n * access to previous function. Must return function\n * to be used for name.\n *\n *     utils.overwriteMethod(chai.Assertion.prototype, 'equal', function (_super) {\n *       return function (str) {\n *         var obj = utils.flag(this, 'object');\n *         if (obj instanceof Foo) {\n *           new chai.Assertion(obj.value).to.equal(str);\n *         } else {\n *           _super.apply(this, arguments);\n *         }\n *       }\n *     });\n *\n * Can also be accessed directly from `chai.Assertion`.\n *\n *     chai.Assertion.overwriteMethod('foo', fn);\n *\n * Then can be used as any other assertion.\n *\n *     expect(myFoo).to.equal('bar');\n *\n * @param {Object} ctx object whose method is to be overwritten\n * @param {String} name of method to overwrite\n * @param {Function} method function that returns a function to be used for name\n * @namespace Utils\n * @name overwriteMethod\n * @api public\n */\n\nmodule.exports = function (ctx, name, method) {\n  var _method = ctx[name]\n    , _super = function () { return this; };\n\n  if (_method && 'function' === typeof _method)\n    _super = _method;\n\n  ctx[name] = function () {\n    var result = method(_super).apply(this, arguments);\n    return result === undefined ? this : result;\n  }\n};\n","/*!\n * Chai - overwriteProperty utility\n * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\n/**\n * ### overwriteProperty (ctx, name, fn)\n *\n * Overwites an already existing property getter and provides\n * access to previous value. Must return function to use as getter.\n *\n *     utils.overwriteProperty(chai.Assertion.prototype, 'ok', function (_super) {\n *       return function () {\n *         var obj = utils.flag(this, 'object');\n *         if (obj instanceof Foo) {\n *           new chai.Assertion(obj.name).to.equal('bar');\n *         } else {\n *           _super.call(this);\n *         }\n *       }\n *     });\n *\n *\n * Can also be accessed directly from `chai.Assertion`.\n *\n *     chai.Assertion.overwriteProperty('foo', fn);\n *\n * Then can be used as any other assertion.\n *\n *     expect(myFoo).to.be.ok;\n *\n * @param {Object} ctx object whose property is to be overwritten\n * @param {String} name of property to overwrite\n * @param {Function} getter function that returns a getter function to be used for name\n * @namespace Utils\n * @name overwriteProperty\n * @api public\n */\n\nmodule.exports = function (ctx, name, getter) {\n  var _get = Object.getOwnPropertyDescriptor(ctx, name)\n    , _super = function () {};\n\n  if (_get && 'function' === typeof _get.get)\n    _super = _get.get\n\n  Object.defineProperty(ctx, name,\n    { get: function () {\n        var result = getter(_super).call(this);\n        return result === undefined ? this : result;\n      }\n    , configurable: true\n  });\n};\n","/*!\n * Chai - test utility\n * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\n/*!\n * Module dependancies\n */\n\nvar flag = require('./flag');\n\n/**\n * # test(object, expression)\n *\n * Test and object for expression.\n *\n * @param {Object} object (constructed Assertion)\n * @param {Arguments} chai.Assertion.prototype.assert arguments\n * @namespace Utils\n * @name test\n */\n\nmodule.exports = function (obj, args) {\n  var negate = flag(obj, 'negate')\n    , expr = args[0];\n  return negate ? !expr : expr;\n};\n","/*!\n * Chai - transferFlags utility\n * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\n/**\n * ### transferFlags(assertion, object, includeAll = true)\n *\n * Transfer all the flags for `assertion` to `object`. If\n * `includeAll` is set to `false`, then the base Chai\n * assertion flags (namely `object`, `ssfi`, and `message`)\n * will not be transferred.\n *\n *\n *     var newAssertion = new Assertion();\n *     utils.transferFlags(assertion, newAssertion);\n *\n *     var anotherAsseriton = new Assertion(myObj);\n *     utils.transferFlags(assertion, anotherAssertion, false);\n *\n * @param {Assertion} assertion the assertion to transfer the flags from\n * @param {Object} object the object to transfer the flags to; usually a new assertion\n * @param {Boolean} includeAll\n * @namespace Utils\n * @name transferFlags\n * @api private\n */\n\nmodule.exports = function (assertion, object, includeAll) {\n  var flags = assertion.__flags || (assertion.__flags = Object.create(null));\n\n  if (!object.__flags) {\n    object.__flags = Object.create(null);\n  }\n\n  includeAll = arguments.length === 3 ? includeAll : true;\n\n  for (var flag in flags) {\n    if (includeAll ||\n        (flag !== 'object' && flag !== 'ssfi' && flag != 'message')) {\n      object.__flags[flag] = flags[flag];\n    }\n  }\n};\n","module.exports = require('./lib/eql');\n","/*!\n * deep-eql\n * Copyright(c) 2013 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\n/*!\n * Module dependencies\n */\n\nvar type = require('type-detect');\n\n/*!\n * Buffer.isBuffer browser shim\n */\n\nvar Buffer;\ntry { Buffer = require('buffer').Buffer; }\ncatch(ex) {\n  Buffer = {};\n  Buffer.isBuffer = function() { return false; }\n}\n\n/*!\n * Primary Export\n */\n\nmodule.exports = deepEqual;\n\n/**\n * Assert super-strict (egal) equality between\n * two objects of any type.\n *\n * @param {Mixed} a\n * @param {Mixed} b\n * @param {Array} memoised (optional)\n * @return {Boolean} equal match\n */\n\nfunction deepEqual(a, b, m) {\n  if (sameValue(a, b)) {\n    return true;\n  } else if ('date' === type(a)) {\n    return dateEqual(a, b);\n  } else if ('regexp' === type(a)) {\n    return regexpEqual(a, b);\n  } else if (Buffer.isBuffer(a)) {\n    return bufferEqual(a, b);\n  } else if ('arguments' === type(a)) {\n    return argumentsEqual(a, b, m);\n  } else if (!typeEqual(a, b)) {\n    return false;\n  } else if (('object' !== type(a) && 'object' !== type(b))\n  && ('array' !== type(a) && 'array' !== type(b))) {\n    return sameValue(a, b);\n  } else {\n    return objectEqual(a, b, m);\n  }\n}\n\n/*!\n * Strict (egal) equality test. Ensures that NaN always\n * equals NaN and `-0` does not equal `+0`.\n *\n * @param {Mixed} a\n * @param {Mixed} b\n * @return {Boolean} equal match\n */\n\nfunction sameValue(a, b) {\n  if (a === b) return a !== 0 || 1 / a === 1 / b;\n  return a !== a && b !== b;\n}\n\n/*!\n * Compare the types of two given objects and\n * return if they are equal. Note that an Array\n * has a type of `array` (not `object`) and arguments\n * have a type of `arguments` (not `array`/`object`).\n *\n * @param {Mixed} a\n * @param {Mixed} b\n * @return {Boolean} result\n */\n\nfunction typeEqual(a, b) {\n  return type(a) === type(b);\n}\n\n/*!\n * Compare two Date objects by asserting that\n * the time values are equal using `saveValue`.\n *\n * @param {Date} a\n * @param {Date} b\n * @return {Boolean} result\n */\n\nfunction dateEqual(a, b) {\n  if ('date' !== type(b)) return false;\n  return sameValue(a.getTime(), b.getTime());\n}\n\n/*!\n * Compare two regular expressions by converting them\n * to string and checking for `sameValue`.\n *\n * @param {RegExp} a\n * @param {RegExp} b\n * @return {Boolean} result\n */\n\nfunction regexpEqual(a, b) {\n  if ('regexp' !== type(b)) return false;\n  return sameValue(a.toString(), b.toString());\n}\n\n/*!\n * Assert deep equality of two `arguments` objects.\n * Unfortunately, these must be sliced to arrays\n * prior to test to ensure no bad behavior.\n *\n * @param {Arguments} a\n * @param {Arguments} b\n * @param {Array} memoize (optional)\n * @return {Boolean} result\n */\n\nfunction argumentsEqual(a, b, m) {\n  if ('arguments' !== type(b)) return false;\n  a = [].slice.call(a);\n  b = [].slice.call(b);\n  return deepEqual(a, b, m);\n}\n\n/*!\n * Get enumerable properties of a given object.\n *\n * @param {Object} a\n * @return {Array} property names\n */\n\nfunction enumerable(a) {\n  var res = [];\n  for (var key in a) res.push(key);\n  return res;\n}\n\n/*!\n * Simple equality for flat iterable objects\n * such as Arrays or Node.js buffers.\n *\n * @param {Iterable} a\n * @param {Iterable} b\n * @return {Boolean} result\n */\n\nfunction iterableEqual(a, b) {\n  if (a.length !==  b.length) return false;\n\n  var i = 0;\n  var match = true;\n\n  for (; i < a.length; i++) {\n    if (a[i] !== b[i]) {\n      match = false;\n      break;\n    }\n  }\n\n  return match;\n}\n\n/*!\n * Extension to `iterableEqual` specifically\n * for Node.js Buffers.\n *\n * @param {Buffer} a\n * @param {Mixed} b\n * @return {Boolean} result\n */\n\nfunction bufferEqual(a, b) {\n  if (!Buffer.isBuffer(b)) return false;\n  return iterableEqual(a, b);\n}\n\n/*!\n * Block for `objectEqual` ensuring non-existing\n * values don't get in.\n *\n * @param {Mixed} object\n * @return {Boolean} result\n */\n\nfunction isValue(a) {\n  return a !== null && a !== undefined;\n}\n\n/*!\n * Recursively check the equality of two objects.\n * Once basic sameness has been established it will\n * defer to `deepEqual` for each enumerable key\n * in the object.\n *\n * @param {Mixed} a\n * @param {Mixed} b\n * @return {Boolean} result\n */\n\nfunction objectEqual(a, b, m) {\n  if (!isValue(a) || !isValue(b)) {\n    return false;\n  }\n\n  if (a.prototype !== b.prototype) {\n    return false;\n  }\n\n  var i;\n  if (m) {\n    for (i = 0; i < m.length; i++) {\n      if ((m[i][0] === a && m[i][1] === b)\n      ||  (m[i][0] === b && m[i][1] === a)) {\n        return true;\n      }\n    }\n  } else {\n    m = [];\n  }\n\n  try {\n    var ka = enumerable(a);\n    var kb = enumerable(b);\n  } catch (ex) {\n    return false;\n  }\n\n  ka.sort();\n  kb.sort();\n\n  if (!iterableEqual(ka, kb)) {\n    return false;\n  }\n\n  m.push([ a, b ]);\n\n  var key;\n  for (i = ka.length - 1; i >= 0; i--) {\n    key = ka[i];\n    if (!deepEqual(a[key], b[key], m)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n","module.exports = require('./lib/type');\n","/*!\n * type-detect\n * Copyright(c) 2013 jake luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\n/*!\n * Primary Exports\n */\n\nvar exports = module.exports = getType;\n\n/*!\n * Detectable javascript natives\n */\n\nvar natives = {\n    '[object Array]': 'array'\n  , '[object RegExp]': 'regexp'\n  , '[object Function]': 'function'\n  , '[object Arguments]': 'arguments'\n  , '[object Date]': 'date'\n};\n\n/**\n * ### typeOf (obj)\n *\n * Use several different techniques to determine\n * the type of object being tested.\n *\n *\n * @param {Mixed} object\n * @return {String} object type\n * @api public\n */\n\nfunction getType (obj) {\n  var str = Object.prototype.toString.call(obj);\n  if (natives[str]) return natives[str];\n  if (obj === null) return 'null';\n  if (obj === undefined) return 'undefined';\n  if (obj === Object(obj)) return 'object';\n  return typeof obj;\n}\n\nexports.Library = Library;\n\n/**\n * ### Library\n *\n * Create a repository for custom type detection.\n *\n * ```js\n * var lib = new type.Library;\n * ```\n *\n */\n\nfunction Library () {\n  this.tests = {};\n}\n\n/**\n * #### .of (obj)\n *\n * Expose replacement `typeof` detection to the library.\n *\n * ```js\n * if ('string' === lib.of('hello world')) {\n *   // ...\n * }\n * ```\n *\n * @param {Mixed} object to test\n * @return {String} type\n */\n\nLibrary.prototype.of = getType;\n\n/**\n * #### .define (type, test)\n *\n * Add a test to for the `.test()` assertion.\n *\n * Can be defined as a regular expression:\n *\n * ```js\n * lib.define('int', /^[0-9]+$/);\n * ```\n *\n * ... or as a function:\n *\n * ```js\n * lib.define('bln', function (obj) {\n *   if ('boolean' === lib.of(obj)) return true;\n *   var blns = [ 'yes', 'no', 'true', 'false', 1, 0 ];\n *   if ('string' === lib.of(obj)) obj = obj.toLowerCase();\n *   return !! ~blns.indexOf(obj);\n * });\n * ```\n *\n * @param {String} type\n * @param {RegExp|Function} test\n * @api public\n */\n\nLibrary.prototype.define = function (type, test) {\n  if (arguments.length === 1) return this.tests[type];\n  this.tests[type] = test;\n  return this;\n};\n\n/**\n * #### .test (obj, test)\n *\n * Assert that an object is of type. Will first\n * check natives, and if that does not pass it will\n * use the user defined custom tests.\n *\n * ```js\n * assert(lib.test('1', 'int'));\n * assert(lib.test('yes', 'bln'));\n * ```\n *\n * @param {Mixed} object\n * @param {String} type\n * @return {Boolean} result\n * @api public\n */\n\nLibrary.prototype.test = function (obj, type) {\n  if (type === getType(obj)) return true;\n  var test = this.tests[type];\n\n  if (test && 'regexp' === getType(test)) {\n    return test.test(obj);\n  } else if (test && 'function' === getType(test)) {\n    return test(obj);\n  } else {\n    throw new ReferenceError('Type test \"' + type + '\" not defined or invalid.');\n  }\n};\n","exports.read = function (buffer, offset, isLE, mLen, nBytes) {\n  var e, m\n  var eLen = nBytes * 8 - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var nBits = -7\n  var i = isLE ? (nBytes - 1) : 0\n  var d = isLE ? -1 : 1\n  var s = buffer[offset + i]\n\n  i += d\n\n  e = s & ((1 << (-nBits)) - 1)\n  s >>= (-nBits)\n  nBits += eLen\n  for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & ((1 << (-nBits)) - 1)\n  e >>= (-nBits)\n  nBits += mLen\n  for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias\n  } else if (e === eMax) {\n    return m ? NaN : ((s ? -1 : 1) * Infinity)\n  } else {\n    m = m + Math.pow(2, mLen)\n    e = e - eBias\n  }\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c\n  var eLen = nBytes * 8 - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n  var i = isLE ? 0 : (nBytes - 1)\n  var d = isLE ? 1 : -1\n  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n  value = Math.abs(value)\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0\n    e = eMax\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2)\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--\n      c *= 2\n    }\n    if (e + eBias >= 1) {\n      value += rt / c\n    } else {\n      value += rt * Math.pow(2, 1 - eBias)\n    }\n    if (value * c >= 2) {\n      e++\n      c /= 2\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0\n      e = eMax\n    } else if (e + eBias >= 1) {\n      m = (value * c - 1) * Math.pow(2, mLen)\n      e = e + eBias\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n      e = 0\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = (e << mLen) | m\n  eLen += mLen\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128\n}\n","var toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n  return toString.call(arr) == '[object Array]';\n};\n","/*!\n * type-detect\n * Copyright(c) 2013 jake luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\n/*!\n * Primary Exports\n */\n\nvar exports = module.exports = getType;\n\n/**\n * ### typeOf (obj)\n *\n * Use several different techniques to determine\n * the type of object being tested.\n *\n *\n * @param {Mixed} object\n * @return {String} object type\n * @api public\n */\nvar objectTypeRegexp = /^\\[object (.*)\\]$/;\n\nfunction getType(obj) {\n  var type = Object.prototype.toString.call(obj).match(objectTypeRegexp)[1].toLowerCase();\n  // Let \"new String('')\" return 'object'\n  if (typeof Promise === 'function' && obj instanceof Promise) return 'promise';\n  // PhantomJS has type \"DOMWindow\" for null\n  if (obj === null) return 'null';\n  // PhantomJS has type \"DOMWindow\" for undefined\n  if (obj === undefined) return 'undefined';\n  return type;\n}\n\nexports.Library = Library;\n\n/**\n * ### Library\n *\n * Create a repository for custom type detection.\n *\n * ```js\n * var lib = new type.Library;\n * ```\n *\n */\n\nfunction Library() {\n  if (!(this instanceof Library)) return new Library();\n  this.tests = {};\n}\n\n/**\n * #### .of (obj)\n *\n * Expose replacement `typeof` detection to the library.\n *\n * ```js\n * if ('string' === lib.of('hello world')) {\n *   // ...\n * }\n * ```\n *\n * @param {Mixed} object to test\n * @return {String} type\n */\n\nLibrary.prototype.of = getType;\n\n/**\n * #### .define (type, test)\n *\n * Add a test to for the `.test()` assertion.\n *\n * Can be defined as a regular expression:\n *\n * ```js\n * lib.define('int', /^[0-9]+$/);\n * ```\n *\n * ... or as a function:\n *\n * ```js\n * lib.define('bln', function (obj) {\n *   if ('boolean' === lib.of(obj)) return true;\n *   var blns = [ 'yes', 'no', 'true', 'false', 1, 0 ];\n *   if ('string' === lib.of(obj)) obj = obj.toLowerCase();\n *   return !! ~blns.indexOf(obj);\n * });\n * ```\n *\n * @param {String} type\n * @param {RegExp|Function} test\n * @api public\n */\n\nLibrary.prototype.define = function(type, test) {\n  if (arguments.length === 1) return this.tests[type];\n  this.tests[type] = test;\n  return this;\n};\n\n/**\n * #### .test (obj, test)\n *\n * Assert that an object is of type. Will first\n * check natives, and if that does not pass it will\n * use the user defined custom tests.\n *\n * ```js\n * assert(lib.test('1', 'int'));\n * assert(lib.test('yes', 'bln'));\n * ```\n *\n * @param {Mixed} object\n * @param {String} type\n * @return {Boolean} result\n * @api public\n */\n\nLibrary.prototype.test = function(obj, type) {\n  if (type === getType(obj)) return true;\n  var test = this.tests[type];\n\n  if (test && 'regexp' === getType(test)) {\n    return test.test(obj);\n  } else if (test && 'function' === getType(test)) {\n    return test(obj);\n  } else {\n    throw new ReferenceError('Type test \"' + type + '\" not defined or invalid.');\n  }\n};\n","//     Underscore.js 1.8.3\n//     http://underscorejs.org\n//     (c) 2009-2015 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n//     Underscore may be freely distributed under the MIT license.\n\n(function() {\n\n  // Baseline setup\n  // --------------\n\n  // Establish the root object, `window` in the browser, or `exports` on the server.\n  var root = this;\n\n  // Save the previous value of the `_` variable.\n  var previousUnderscore = root._;\n\n  // Save bytes in the minified (but not gzipped) version:\n  var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype;\n\n  // Create quick reference variables for speed access to core prototypes.\n  var\n    push             = ArrayProto.push,\n    slice            = ArrayProto.slice,\n    toString         = ObjProto.toString,\n    hasOwnProperty   = ObjProto.hasOwnProperty;\n\n  // All **ECMAScript 5** native function implementations that we hope to use\n  // are declared here.\n  var\n    nativeIsArray      = Array.isArray,\n    nativeKeys         = Object.keys,\n    nativeBind         = FuncProto.bind,\n    nativeCreate       = Object.create;\n\n  // Naked function reference for surrogate-prototype-swapping.\n  var Ctor = function(){};\n\n  // Create a safe reference to the Underscore object for use below.\n  var _ = function(obj) {\n    if (obj instanceof _) return obj;\n    if (!(this instanceof _)) return new _(obj);\n    this._wrapped = obj;\n  };\n\n  // Export the Underscore object for **Node.js**, with\n  // backwards-compatibility for the old `require()` API. If we're in\n  // the browser, add `_` as a global object.\n  if (typeof exports !== 'undefined') {\n    if (typeof module !== 'undefined' && module.exports) {\n      exports = module.exports = _;\n    }\n    exports._ = _;\n  } else {\n    root._ = _;\n  }\n\n  // Current version.\n  _.VERSION = '1.8.3';\n\n  // Internal function that returns an efficient (for current engines) version\n  // of the passed-in callback, to be repeatedly applied in other Underscore\n  // functions.\n  var optimizeCb = function(func, context, argCount) {\n    if (context === void 0) return func;\n    switch (argCount == null ? 3 : argCount) {\n      case 1: return function(value) {\n        return func.call(context, value);\n      };\n      case 2: return function(value, other) {\n        return func.call(context, value, other);\n      };\n      case 3: return function(value, index, collection) {\n        return func.call(context, value, index, collection);\n      };\n      case 4: return function(accumulator, value, index, collection) {\n        return func.call(context, accumulator, value, index, collection);\n      };\n    }\n    return function() {\n      return func.apply(context, arguments);\n    };\n  };\n\n  // A mostly-internal function to generate callbacks that can be applied\n  // to each element in a collection, returning the desired result — either\n  // identity, an arbitrary callback, a property matcher, or a property accessor.\n  var cb = function(value, context, argCount) {\n    if (value == null) return _.identity;\n    if (_.isFunction(value)) return optimizeCb(value, context, argCount);\n    if (_.isObject(value)) return _.matcher(value);\n    return _.property(value);\n  };\n  _.iteratee = function(value, context) {\n    return cb(value, context, Infinity);\n  };\n\n  // An internal function for creating assigner functions.\n  var createAssigner = function(keysFunc, undefinedOnly) {\n    return function(obj) {\n      var length = arguments.length;\n      if (length < 2 || obj == null) return obj;\n      for (var index = 1; index < length; index++) {\n        var source = arguments[index],\n            keys = keysFunc(source),\n            l = keys.length;\n        for (var i = 0; i < l; i++) {\n          var key = keys[i];\n          if (!undefinedOnly || obj[key] === void 0) obj[key] = source[key];\n        }\n      }\n      return obj;\n    };\n  };\n\n  // An internal function for creating a new object that inherits from another.\n  var baseCreate = function(prototype) {\n    if (!_.isObject(prototype)) return {};\n    if (nativeCreate) return nativeCreate(prototype);\n    Ctor.prototype = prototype;\n    var result = new Ctor;\n    Ctor.prototype = null;\n    return result;\n  };\n\n  var property = function(key) {\n    return function(obj) {\n      return obj == null ? void 0 : obj[key];\n    };\n  };\n\n  // Helper for collection methods to determine whether a collection\n  // should be iterated as an array or as an object\n  // Related: http://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength\n  // Avoids a very nasty iOS 8 JIT bug on ARM-64. #2094\n  var MAX_ARRAY_INDEX = Math.pow(2, 53) - 1;\n  var getLength = property('length');\n  var isArrayLike = function(collection) {\n    var length = getLength(collection);\n    return typeof length == 'number' && length >= 0 && length <= MAX_ARRAY_INDEX;\n  };\n\n  // Collection Functions\n  // --------------------\n\n  // The cornerstone, an `each` implementation, aka `forEach`.\n  // Handles raw objects in addition to array-likes. Treats all\n  // sparse array-likes as if they were dense.\n  _.each = _.forEach = function(obj, iteratee, context) {\n    iteratee = optimizeCb(iteratee, context);\n    var i, length;\n    if (isArrayLike(obj)) {\n      for (i = 0, length = obj.length; i < length; i++) {\n        iteratee(obj[i], i, obj);\n      }\n    } else {\n      var keys = _.keys(obj);\n      for (i = 0, length = keys.length; i < length; i++) {\n        iteratee(obj[keys[i]], keys[i], obj);\n      }\n    }\n    return obj;\n  };\n\n  // Return the results of applying the iteratee to each element.\n  _.map = _.collect = function(obj, iteratee, context) {\n    iteratee = cb(iteratee, context);\n    var keys = !isArrayLike(obj) && _.keys(obj),\n        length = (keys || obj).length,\n        results = Array(length);\n    for (var index = 0; index < length; index++) {\n      var currentKey = keys ? keys[index] : index;\n      results[index] = iteratee(obj[currentKey], currentKey, obj);\n    }\n    return results;\n  };\n\n  // Create a reducing function iterating left or right.\n  function createReduce(dir) {\n    // Optimized iterator function as using arguments.length\n    // in the main function will deoptimize the, see #1991.\n    function iterator(obj, iteratee, memo, keys, index, length) {\n      for (; index >= 0 && index < length; index += dir) {\n        var currentKey = keys ? keys[index] : index;\n        memo = iteratee(memo, obj[currentKey], currentKey, obj);\n      }\n      return memo;\n    }\n\n    return function(obj, iteratee, memo, context) {\n      iteratee = optimizeCb(iteratee, context, 4);\n      var keys = !isArrayLike(obj) && _.keys(obj),\n          length = (keys || obj).length,\n          index = dir > 0 ? 0 : length - 1;\n      // Determine the initial value if none is provided.\n      if (arguments.length < 3) {\n        memo = obj[keys ? keys[index] : index];\n        index += dir;\n      }\n      return iterator(obj, iteratee, memo, keys, index, length);\n    };\n  }\n\n  // **Reduce** builds up a single result from a list of values, aka `inject`,\n  // or `foldl`.\n  _.reduce = _.foldl = _.inject = createReduce(1);\n\n  // The right-associative version of reduce, also known as `foldr`.\n  _.reduceRight = _.foldr = createReduce(-1);\n\n  // Return the first value which passes a truth test. Aliased as `detect`.\n  _.find = _.detect = function(obj, predicate, context) {\n    var key;\n    if (isArrayLike(obj)) {\n      key = _.findIndex(obj, predicate, context);\n    } else {\n      key = _.findKey(obj, predicate, context);\n    }\n    if (key !== void 0 && key !== -1) return obj[key];\n  };\n\n  // Return all the elements that pass a truth test.\n  // Aliased as `select`.\n  _.filter = _.select = function(obj, predicate, context) {\n    var results = [];\n    predicate = cb(predicate, context);\n    _.each(obj, function(value, index, list) {\n      if (predicate(value, index, list)) results.push(value);\n    });\n    return results;\n  };\n\n  // Return all the elements for which a truth test fails.\n  _.reject = function(obj, predicate, context) {\n    return _.filter(obj, _.negate(cb(predicate)), context);\n  };\n\n  // Determine whether all of the elements match a truth test.\n  // Aliased as `all`.\n  _.every = _.all = function(obj, predicate, context) {\n    predicate = cb(predicate, context);\n    var keys = !isArrayLike(obj) && _.keys(obj),\n        length = (keys || obj).length;\n    for (var index = 0; index < length; index++) {\n      var currentKey = keys ? keys[index] : index;\n      if (!predicate(obj[currentKey], currentKey, obj)) return false;\n    }\n    return true;\n  };\n\n  // Determine if at least one element in the object matches a truth test.\n  // Aliased as `any`.\n  _.some = _.any = function(obj, predicate, context) {\n    predicate = cb(predicate, context);\n    var keys = !isArrayLike(obj) && _.keys(obj),\n        length = (keys || obj).length;\n    for (var index = 0; index < length; index++) {\n      var currentKey = keys ? keys[index] : index;\n      if (predicate(obj[currentKey], currentKey, obj)) return true;\n    }\n    return false;\n  };\n\n  // Determine if the array or object contains a given item (using `===`).\n  // Aliased as `includes` and `include`.\n  _.contains = _.includes = _.include = function(obj, item, fromIndex, guard) {\n    if (!isArrayLike(obj)) obj = _.values(obj);\n    if (typeof fromIndex != 'number' || guard) fromIndex = 0;\n    return _.indexOf(obj, item, fromIndex) >= 0;\n  };\n\n  // Invoke a method (with arguments) on every item in a collection.\n  _.invoke = function(obj, method) {\n    var args = slice.call(arguments, 2);\n    var isFunc = _.isFunction(method);\n    return _.map(obj, function(value) {\n      var func = isFunc ? method : value[method];\n      return func == null ? func : func.apply(value, args);\n    });\n  };\n\n  // Convenience version of a common use case of `map`: fetching a property.\n  _.pluck = function(obj, key) {\n    return _.map(obj, _.property(key));\n  };\n\n  // Convenience version of a common use case of `filter`: selecting only objects\n  // containing specific `key:value` pairs.\n  _.where = function(obj, attrs) {\n    return _.filter(obj, _.matcher(attrs));\n  };\n\n  // Convenience version of a common use case of `find`: getting the first object\n  // containing specific `key:value` pairs.\n  _.findWhere = function(obj, attrs) {\n    return _.find(obj, _.matcher(attrs));\n  };\n\n  // Return the maximum element (or element-based computation).\n  _.max = function(obj, iteratee, context) {\n    var result = -Infinity, lastComputed = -Infinity,\n        value, computed;\n    if (iteratee == null && obj != null) {\n      obj = isArrayLike(obj) ? obj : _.values(obj);\n      for (var i = 0, length = obj.length; i < length; i++) {\n        value = obj[i];\n        if (value > result) {\n          result = value;\n        }\n      }\n    } else {\n      iteratee = cb(iteratee, context);\n      _.each(obj, function(value, index, list) {\n        computed = iteratee(value, index, list);\n        if (computed > lastComputed || computed === -Infinity && result === -Infinity) {\n          result = value;\n          lastComputed = computed;\n        }\n      });\n    }\n    return result;\n  };\n\n  // Return the minimum element (or element-based computation).\n  _.min = function(obj, iteratee, context) {\n    var result = Infinity, lastComputed = Infinity,\n        value, computed;\n    if (iteratee == null && obj != null) {\n      obj = isArrayLike(obj) ? obj : _.values(obj);\n      for (var i = 0, length = obj.length; i < length; i++) {\n        value = obj[i];\n        if (value < result) {\n          result = value;\n        }\n      }\n    } else {\n      iteratee = cb(iteratee, context);\n      _.each(obj, function(value, index, list) {\n        computed = iteratee(value, index, list);\n        if (computed < lastComputed || computed === Infinity && result === Infinity) {\n          result = value;\n          lastComputed = computed;\n        }\n      });\n    }\n    return result;\n  };\n\n  // Shuffle a collection, using the modern version of the\n  // [Fisher-Yates shuffle](http://en.wikipedia.org/wiki/Fisher–Yates_shuffle).\n  _.shuffle = function(obj) {\n    var set = isArrayLike(obj) ? obj : _.values(obj);\n    var length = set.length;\n    var shuffled = Array(length);\n    for (var index = 0, rand; index < length; index++) {\n      rand = _.random(0, index);\n      if (rand !== index) shuffled[index] = shuffled[rand];\n      shuffled[rand] = set[index];\n    }\n    return shuffled;\n  };\n\n  // Sample **n** random values from a collection.\n  // If **n** is not specified, returns a single random element.\n  // The internal `guard` argument allows it to work with `map`.\n  _.sample = function(obj, n, guard) {\n    if (n == null || guard) {\n      if (!isArrayLike(obj)) obj = _.values(obj);\n      return obj[_.random(obj.length - 1)];\n    }\n    return _.shuffle(obj).slice(0, Math.max(0, n));\n  };\n\n  // Sort the object's values by a criterion produced by an iteratee.\n  _.sortBy = function(obj, iteratee, context) {\n    iteratee = cb(iteratee, context);\n    return _.pluck(_.map(obj, function(value, index, list) {\n      return {\n        value: value,\n        index: index,\n        criteria: iteratee(value, index, list)\n      };\n    }).sort(function(left, right) {\n      var a = left.criteria;\n      var b = right.criteria;\n      if (a !== b) {\n        if (a > b || a === void 0) return 1;\n        if (a < b || b === void 0) return -1;\n      }\n      return left.index - right.index;\n    }), 'value');\n  };\n\n  // An internal function used for aggregate \"group by\" operations.\n  var group = function(behavior) {\n    return function(obj, iteratee, context) {\n      var result = {};\n      iteratee = cb(iteratee, context);\n      _.each(obj, function(value, index) {\n        var key = iteratee(value, index, obj);\n        behavior(result, value, key);\n      });\n      return result;\n    };\n  };\n\n  // Groups the object's values by a criterion. Pass either a string attribute\n  // to group by, or a function that returns the criterion.\n  _.groupBy = group(function(result, value, key) {\n    if (_.has(result, key)) result[key].push(value); else result[key] = [value];\n  });\n\n  // Indexes the object's values by a criterion, similar to `groupBy`, but for\n  // when you know that your index values will be unique.\n  _.indexBy = group(function(result, value, key) {\n    result[key] = value;\n  });\n\n  // Counts instances of an object that group by a certain criterion. Pass\n  // either a string attribute to count by, or a function that returns the\n  // criterion.\n  _.countBy = group(function(result, value, key) {\n    if (_.has(result, key)) result[key]++; else result[key] = 1;\n  });\n\n  // Safely create a real, live array from anything iterable.\n  _.toArray = function(obj) {\n    if (!obj) return [];\n    if (_.isArray(obj)) return slice.call(obj);\n    if (isArrayLike(obj)) return _.map(obj, _.identity);\n    return _.values(obj);\n  };\n\n  // Return the number of elements in an object.\n  _.size = function(obj) {\n    if (obj == null) return 0;\n    return isArrayLike(obj) ? obj.length : _.keys(obj).length;\n  };\n\n  // Split a collection into two arrays: one whose elements all satisfy the given\n  // predicate, and one whose elements all do not satisfy the predicate.\n  _.partition = function(obj, predicate, context) {\n    predicate = cb(predicate, context);\n    var pass = [], fail = [];\n    _.each(obj, function(value, key, obj) {\n      (predicate(value, key, obj) ? pass : fail).push(value);\n    });\n    return [pass, fail];\n  };\n\n  // Array Functions\n  // ---------------\n\n  // Get the first element of an array. Passing **n** will return the first N\n  // values in the array. Aliased as `head` and `take`. The **guard** check\n  // allows it to work with `_.map`.\n  _.first = _.head = _.take = function(array, n, guard) {\n    if (array == null) return void 0;\n    if (n == null || guard) return array[0];\n    return _.initial(array, array.length - n);\n  };\n\n  // Returns everything but the last entry of the array. Especially useful on\n  // the arguments object. Passing **n** will return all the values in\n  // the array, excluding the last N.\n  _.initial = function(array, n, guard) {\n    return slice.call(array, 0, Math.max(0, array.length - (n == null || guard ? 1 : n)));\n  };\n\n  // Get the last element of an array. Passing **n** will return the last N\n  // values in the array.\n  _.last = function(array, n, guard) {\n    if (array == null) return void 0;\n    if (n == null || guard) return array[array.length - 1];\n    return _.rest(array, Math.max(0, array.length - n));\n  };\n\n  // Returns everything but the first entry of the array. Aliased as `tail` and `drop`.\n  // Especially useful on the arguments object. Passing an **n** will return\n  // the rest N values in the array.\n  _.rest = _.tail = _.drop = function(array, n, guard) {\n    return slice.call(array, n == null || guard ? 1 : n);\n  };\n\n  // Trim out all falsy values from an array.\n  _.compact = function(array) {\n    return _.filter(array, _.identity);\n  };\n\n  // Internal implementation of a recursive `flatten` function.\n  var flatten = function(input, shallow, strict, startIndex) {\n    var output = [], idx = 0;\n    for (var i = startIndex || 0, length = getLength(input); i < length; i++) {\n      var value = input[i];\n      if (isArrayLike(value) && (_.isArray(value) || _.isArguments(value))) {\n        //flatten current level of array or arguments object\n        if (!shallow) value = flatten(value, shallow, strict);\n        var j = 0, len = value.length;\n        output.length += len;\n        while (j < len) {\n          output[idx++] = value[j++];\n        }\n      } else if (!strict) {\n        output[idx++] = value;\n      }\n    }\n    return output;\n  };\n\n  // Flatten out an array, either recursively (by default), or just one level.\n  _.flatten = function(array, shallow) {\n    return flatten(array, shallow, false);\n  };\n\n  // Return a version of the array that does not contain the specified value(s).\n  _.without = function(array) {\n    return _.difference(array, slice.call(arguments, 1));\n  };\n\n  // Produce a duplicate-free version of the array. If the array has already\n  // been sorted, you have the option of using a faster algorithm.\n  // Aliased as `unique`.\n  _.uniq = _.unique = function(array, isSorted, iteratee, context) {\n    if (!_.isBoolean(isSorted)) {\n      context = iteratee;\n      iteratee = isSorted;\n      isSorted = false;\n    }\n    if (iteratee != null) iteratee = cb(iteratee, context);\n    var result = [];\n    var seen = [];\n    for (var i = 0, length = getLength(array); i < length; i++) {\n      var value = array[i],\n          computed = iteratee ? iteratee(value, i, array) : value;\n      if (isSorted) {\n        if (!i || seen !== computed) result.push(value);\n        seen = computed;\n      } else if (iteratee) {\n        if (!_.contains(seen, computed)) {\n          seen.push(computed);\n          result.push(value);\n        }\n      } else if (!_.contains(result, value)) {\n        result.push(value);\n      }\n    }\n    return result;\n  };\n\n  // Produce an array that contains the union: each distinct element from all of\n  // the passed-in arrays.\n  _.union = function() {\n    return _.uniq(flatten(arguments, true, true));\n  };\n\n  // Produce an array that contains every item shared between all the\n  // passed-in arrays.\n  _.intersection = function(array) {\n    var result = [];\n    var argsLength = arguments.length;\n    for (var i = 0, length = getLength(array); i < length; i++) {\n      var item = array[i];\n      if (_.contains(result, item)) continue;\n      for (var j = 1; j < argsLength; j++) {\n        if (!_.contains(arguments[j], item)) break;\n      }\n      if (j === argsLength) result.push(item);\n    }\n    return result;\n  };\n\n  // Take the difference between one array and a number of other arrays.\n  // Only the elements present in just the first array will remain.\n  _.difference = function(array) {\n    var rest = flatten(arguments, true, true, 1);\n    return _.filter(array, function(value){\n      return !_.contains(rest, value);\n    });\n  };\n\n  // Zip together multiple lists into a single array -- elements that share\n  // an index go together.\n  _.zip = function() {\n    return _.unzip(arguments);\n  };\n\n  // Complement of _.zip. Unzip accepts an array of arrays and groups\n  // each array's elements on shared indices\n  _.unzip = function(array) {\n    var length = array && _.max(array, getLength).length || 0;\n    var result = Array(length);\n\n    for (var index = 0; index < length; index++) {\n      result[index] = _.pluck(array, index);\n    }\n    return result;\n  };\n\n  // Converts lists into objects. Pass either a single array of `[key, value]`\n  // pairs, or two parallel arrays of the same length -- one of keys, and one of\n  // the corresponding values.\n  _.object = function(list, values) {\n    var result = {};\n    for (var i = 0, length = getLength(list); i < length; i++) {\n      if (values) {\n        result[list[i]] = values[i];\n      } else {\n        result[list[i][0]] = list[i][1];\n      }\n    }\n    return result;\n  };\n\n  // Generator function to create the findIndex and findLastIndex functions\n  function createPredicateIndexFinder(dir) {\n    return function(array, predicate, context) {\n      predicate = cb(predicate, context);\n      var length = getLength(array);\n      var index = dir > 0 ? 0 : length - 1;\n      for (; index >= 0 && index < length; index += dir) {\n        if (predicate(array[index], index, array)) return index;\n      }\n      return -1;\n    };\n  }\n\n  // Returns the first index on an array-like that passes a predicate test\n  _.findIndex = createPredicateIndexFinder(1);\n  _.findLastIndex = createPredicateIndexFinder(-1);\n\n  // Use a comparator function to figure out the smallest index at which\n  // an object should be inserted so as to maintain order. Uses binary search.\n  _.sortedIndex = function(array, obj, iteratee, context) {\n    iteratee = cb(iteratee, context, 1);\n    var value = iteratee(obj);\n    var low = 0, high = getLength(array);\n    while (low < high) {\n      var mid = Math.floor((low + high) / 2);\n      if (iteratee(array[mid]) < value) low = mid + 1; else high = mid;\n    }\n    return low;\n  };\n\n  // Generator function to create the indexOf and lastIndexOf functions\n  function createIndexFinder(dir, predicateFind, sortedIndex) {\n    return function(array, item, idx) {\n      var i = 0, length = getLength(array);\n      if (typeof idx == 'number') {\n        if (dir > 0) {\n            i = idx >= 0 ? idx : Math.max(idx + length, i);\n        } else {\n            length = idx >= 0 ? Math.min(idx + 1, length) : idx + length + 1;\n        }\n      } else if (sortedIndex && idx && length) {\n        idx = sortedIndex(array, item);\n        return array[idx] === item ? idx : -1;\n      }\n      if (item !== item) {\n        idx = predicateFind(slice.call(array, i, length), _.isNaN);\n        return idx >= 0 ? idx + i : -1;\n      }\n      for (idx = dir > 0 ? i : length - 1; idx >= 0 && idx < length; idx += dir) {\n        if (array[idx] === item) return idx;\n      }\n      return -1;\n    };\n  }\n\n  // Return the position of the first occurrence of an item in an array,\n  // or -1 if the item is not included in the array.\n  // If the array is large and already in sort order, pass `true`\n  // for **isSorted** to use binary search.\n  _.indexOf = createIndexFinder(1, _.findIndex, _.sortedIndex);\n  _.lastIndexOf = createIndexFinder(-1, _.findLastIndex);\n\n  // Generate an integer Array containing an arithmetic progression. A port of\n  // the native Python `range()` function. See\n  // [the Python documentation](http://docs.python.org/library/functions.html#range).\n  _.range = function(start, stop, step) {\n    if (stop == null) {\n      stop = start || 0;\n      start = 0;\n    }\n    step = step || 1;\n\n    var length = Math.max(Math.ceil((stop - start) / step), 0);\n    var range = Array(length);\n\n    for (var idx = 0; idx < length; idx++, start += step) {\n      range[idx] = start;\n    }\n\n    return range;\n  };\n\n  // Function (ahem) Functions\n  // ------------------\n\n  // Determines whether to execute a function as a constructor\n  // or a normal function with the provided arguments\n  var executeBound = function(sourceFunc, boundFunc, context, callingContext, args) {\n    if (!(callingContext instanceof boundFunc)) return sourceFunc.apply(context, args);\n    var self = baseCreate(sourceFunc.prototype);\n    var result = sourceFunc.apply(self, args);\n    if (_.isObject(result)) return result;\n    return self;\n  };\n\n  // Create a function bound to a given object (assigning `this`, and arguments,\n  // optionally). Delegates to **ECMAScript 5**'s native `Function.bind` if\n  // available.\n  _.bind = function(func, context) {\n    if (nativeBind && func.bind === nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));\n    if (!_.isFunction(func)) throw new TypeError('Bind must be called on a function');\n    var args = slice.call(arguments, 2);\n    var bound = function() {\n      return executeBound(func, bound, context, this, args.concat(slice.call(arguments)));\n    };\n    return bound;\n  };\n\n  // Partially apply a function by creating a version that has had some of its\n  // arguments pre-filled, without changing its dynamic `this` context. _ acts\n  // as a placeholder, allowing any combination of arguments to be pre-filled.\n  _.partial = function(func) {\n    var boundArgs = slice.call(arguments, 1);\n    var bound = function() {\n      var position = 0, length = boundArgs.length;\n      var args = Array(length);\n      for (var i = 0; i < length; i++) {\n        args[i] = boundArgs[i] === _ ? arguments[position++] : boundArgs[i];\n      }\n      while (position < arguments.length) args.push(arguments[position++]);\n      return executeBound(func, bound, this, this, args);\n    };\n    return bound;\n  };\n\n  // Bind a number of an object's methods to that object. Remaining arguments\n  // are the method names to be bound. Useful for ensuring that all callbacks\n  // defined on an object belong to it.\n  _.bindAll = function(obj) {\n    var i, length = arguments.length, key;\n    if (length <= 1) throw new Error('bindAll must be passed function names');\n    for (i = 1; i < length; i++) {\n      key = arguments[i];\n      obj[key] = _.bind(obj[key], obj);\n    }\n    return obj;\n  };\n\n  // Memoize an expensive function by storing its results.\n  _.memoize = function(func, hasher) {\n    var memoize = function(key) {\n      var cache = memoize.cache;\n      var address = '' + (hasher ? hasher.apply(this, arguments) : key);\n      if (!_.has(cache, address)) cache[address] = func.apply(this, arguments);\n      return cache[address];\n    };\n    memoize.cache = {};\n    return memoize;\n  };\n\n  // Delays a function for the given number of milliseconds, and then calls\n  // it with the arguments supplied.\n  _.delay = function(func, wait) {\n    var args = slice.call(arguments, 2);\n    return setTimeout(function(){\n      return func.apply(null, args);\n    }, wait);\n  };\n\n  // Defers a function, scheduling it to run after the current call stack has\n  // cleared.\n  _.defer = _.partial(_.delay, _, 1);\n\n  // Returns a function, that, when invoked, will only be triggered at most once\n  // during a given window of time. Normally, the throttled function will run\n  // as much as it can, without ever going more than once per `wait` duration;\n  // but if you'd like to disable the execution on the leading edge, pass\n  // `{leading: false}`. To disable execution on the trailing edge, ditto.\n  _.throttle = function(func, wait, options) {\n    var context, args, result;\n    var timeout = null;\n    var previous = 0;\n    if (!options) options = {};\n    var later = function() {\n      previous = options.leading === false ? 0 : _.now();\n      timeout = null;\n      result = func.apply(context, args);\n      if (!timeout) context = args = null;\n    };\n    return function() {\n      var now = _.now();\n      if (!previous && options.leading === false) previous = now;\n      var remaining = wait - (now - previous);\n      context = this;\n      args = arguments;\n      if (remaining <= 0 || remaining > wait) {\n        if (timeout) {\n          clearTimeout(timeout);\n          timeout = null;\n        }\n        previous = now;\n        result = func.apply(context, args);\n        if (!timeout) context = args = null;\n      } else if (!timeout && options.trailing !== false) {\n        timeout = setTimeout(later, remaining);\n      }\n      return result;\n    };\n  };\n\n  // Returns a function, that, as long as it continues to be invoked, will not\n  // be triggered. The function will be called after it stops being called for\n  // N milliseconds. If `immediate` is passed, trigger the function on the\n  // leading edge, instead of the trailing.\n  _.debounce = function(func, wait, immediate) {\n    var timeout, args, context, timestamp, result;\n\n    var later = function() {\n      var last = _.now() - timestamp;\n\n      if (last < wait && last >= 0) {\n        timeout = setTimeout(later, wait - last);\n      } else {\n        timeout = null;\n        if (!immediate) {\n          result = func.apply(context, args);\n          if (!timeout) context = args = null;\n        }\n      }\n    };\n\n    return function() {\n      context = this;\n      args = arguments;\n      timestamp = _.now();\n      var callNow = immediate && !timeout;\n      if (!timeout) timeout = setTimeout(later, wait);\n      if (callNow) {\n        result = func.apply(context, args);\n        context = args = null;\n      }\n\n      return result;\n    };\n  };\n\n  // Returns the first function passed as an argument to the second,\n  // allowing you to adjust arguments, run code before and after, and\n  // conditionally execute the original function.\n  _.wrap = function(func, wrapper) {\n    return _.partial(wrapper, func);\n  };\n\n  // Returns a negated version of the passed-in predicate.\n  _.negate = function(predicate) {\n    return function() {\n      return !predicate.apply(this, arguments);\n    };\n  };\n\n  // Returns a function that is the composition of a list of functions, each\n  // consuming the return value of the function that follows.\n  _.compose = function() {\n    var args = arguments;\n    var start = args.length - 1;\n    return function() {\n      var i = start;\n      var result = args[start].apply(this, arguments);\n      while (i--) result = args[i].call(this, result);\n      return result;\n    };\n  };\n\n  // Returns a function that will only be executed on and after the Nth call.\n  _.after = function(times, func) {\n    return function() {\n      if (--times < 1) {\n        return func.apply(this, arguments);\n      }\n    };\n  };\n\n  // Returns a function that will only be executed up to (but not including) the Nth call.\n  _.before = function(times, func) {\n    var memo;\n    return function() {\n      if (--times > 0) {\n        memo = func.apply(this, arguments);\n      }\n      if (times <= 1) func = null;\n      return memo;\n    };\n  };\n\n  // Returns a function that will be executed at most one time, no matter how\n  // often you call it. Useful for lazy initialization.\n  _.once = _.partial(_.before, 2);\n\n  // Object Functions\n  // ----------------\n\n  // Keys in IE < 9 that won't be iterated by `for key in ...` and thus missed.\n  var hasEnumBug = !{toString: null}.propertyIsEnumerable('toString');\n  var nonEnumerableProps = ['valueOf', 'isPrototypeOf', 'toString',\n                      'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];\n\n  function collectNonEnumProps(obj, keys) {\n    var nonEnumIdx = nonEnumerableProps.length;\n    var constructor = obj.constructor;\n    var proto = (_.isFunction(constructor) && constructor.prototype) || ObjProto;\n\n    // Constructor is a special case.\n    var prop = 'constructor';\n    if (_.has(obj, prop) && !_.contains(keys, prop)) keys.push(prop);\n\n    while (nonEnumIdx--) {\n      prop = nonEnumerableProps[nonEnumIdx];\n      if (prop in obj && obj[prop] !== proto[prop] && !_.contains(keys, prop)) {\n        keys.push(prop);\n      }\n    }\n  }\n\n  // Retrieve the names of an object's own properties.\n  // Delegates to **ECMAScript 5**'s native `Object.keys`\n  _.keys = function(obj) {\n    if (!_.isObject(obj)) return [];\n    if (nativeKeys) return nativeKeys(obj);\n    var keys = [];\n    for (var key in obj) if (_.has(obj, key)) keys.push(key);\n    // Ahem, IE < 9.\n    if (hasEnumBug) collectNonEnumProps(obj, keys);\n    return keys;\n  };\n\n  // Retrieve all the property names of an object.\n  _.allKeys = function(obj) {\n    if (!_.isObject(obj)) return [];\n    var keys = [];\n    for (var key in obj) keys.push(key);\n    // Ahem, IE < 9.\n    if (hasEnumBug) collectNonEnumProps(obj, keys);\n    return keys;\n  };\n\n  // Retrieve the values of an object's properties.\n  _.values = function(obj) {\n    var keys = _.keys(obj);\n    var length = keys.length;\n    var values = Array(length);\n    for (var i = 0; i < length; i++) {\n      values[i] = obj[keys[i]];\n    }\n    return values;\n  };\n\n  // Returns the results of applying the iteratee to each element of the object\n  // In contrast to _.map it returns an object\n  _.mapObject = function(obj, iteratee, context) {\n    iteratee = cb(iteratee, context);\n    var keys =  _.keys(obj),\n          length = keys.length,\n          results = {},\n          currentKey;\n      for (var index = 0; index < length; index++) {\n        currentKey = keys[index];\n        results[currentKey] = iteratee(obj[currentKey], currentKey, obj);\n      }\n      return results;\n  };\n\n  // Convert an object into a list of `[key, value]` pairs.\n  _.pairs = function(obj) {\n    var keys = _.keys(obj);\n    var length = keys.length;\n    var pairs = Array(length);\n    for (var i = 0; i < length; i++) {\n      pairs[i] = [keys[i], obj[keys[i]]];\n    }\n    return pairs;\n  };\n\n  // Invert the keys and values of an object. The values must be serializable.\n  _.invert = function(obj) {\n    var result = {};\n    var keys = _.keys(obj);\n    for (var i = 0, length = keys.length; i < length; i++) {\n      result[obj[keys[i]]] = keys[i];\n    }\n    return result;\n  };\n\n  // Return a sorted list of the function names available on the object.\n  // Aliased as `methods`\n  _.functions = _.methods = function(obj) {\n    var names = [];\n    for (var key in obj) {\n      if (_.isFunction(obj[key])) names.push(key);\n    }\n    return names.sort();\n  };\n\n  // Extend a given object with all the properties in passed-in object(s).\n  _.extend = createAssigner(_.allKeys);\n\n  // Assigns a given object with all the own properties in the passed-in object(s)\n  // (https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/assign)\n  _.extendOwn = _.assign = createAssigner(_.keys);\n\n  // Returns the first key on an object that passes a predicate test\n  _.findKey = function(obj, predicate, context) {\n    predicate = cb(predicate, context);\n    var keys = _.keys(obj), key;\n    for (var i = 0, length = keys.length; i < length; i++) {\n      key = keys[i];\n      if (predicate(obj[key], key, obj)) return key;\n    }\n  };\n\n  // Return a copy of the object only containing the whitelisted properties.\n  _.pick = function(object, oiteratee, context) {\n    var result = {}, obj = object, iteratee, keys;\n    if (obj == null) return result;\n    if (_.isFunction(oiteratee)) {\n      keys = _.allKeys(obj);\n      iteratee = optimizeCb(oiteratee, context);\n    } else {\n      keys = flatten(arguments, false, false, 1);\n      iteratee = function(value, key, obj) { return key in obj; };\n      obj = Object(obj);\n    }\n    for (var i = 0, length = keys.length; i < length; i++) {\n      var key = keys[i];\n      var value = obj[key];\n      if (iteratee(value, key, obj)) result[key] = value;\n    }\n    return result;\n  };\n\n   // Return a copy of the object without the blacklisted properties.\n  _.omit = function(obj, iteratee, context) {\n    if (_.isFunction(iteratee)) {\n      iteratee = _.negate(iteratee);\n    } else {\n      var keys = _.map(flatten(arguments, false, false, 1), String);\n      iteratee = function(value, key) {\n        return !_.contains(keys, key);\n      };\n    }\n    return _.pick(obj, iteratee, context);\n  };\n\n  // Fill in a given object with default properties.\n  _.defaults = createAssigner(_.allKeys, true);\n\n  // Creates an object that inherits from the given prototype object.\n  // If additional properties are provided then they will be added to the\n  // created object.\n  _.create = function(prototype, props) {\n    var result = baseCreate(prototype);\n    if (props) _.extendOwn(result, props);\n    return result;\n  };\n\n  // Create a (shallow-cloned) duplicate of an object.\n  _.clone = function(obj) {\n    if (!_.isObject(obj)) return obj;\n    return _.isArray(obj) ? obj.slice() : _.extend({}, obj);\n  };\n\n  // Invokes interceptor with the obj, and then returns obj.\n  // The primary purpose of this method is to \"tap into\" a method chain, in\n  // order to perform operations on intermediate results within the chain.\n  _.tap = function(obj, interceptor) {\n    interceptor(obj);\n    return obj;\n  };\n\n  // Returns whether an object has a given set of `key:value` pairs.\n  _.isMatch = function(object, attrs) {\n    var keys = _.keys(attrs), length = keys.length;\n    if (object == null) return !length;\n    var obj = Object(object);\n    for (var i = 0; i < length; i++) {\n      var key = keys[i];\n      if (attrs[key] !== obj[key] || !(key in obj)) return false;\n    }\n    return true;\n  };\n\n\n  // Internal recursive comparison function for `isEqual`.\n  var eq = function(a, b, aStack, bStack) {\n    // Identical objects are equal. `0 === -0`, but they aren't identical.\n    // See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal).\n    if (a === b) return a !== 0 || 1 / a === 1 / b;\n    // A strict comparison is necessary because `null == undefined`.\n    if (a == null || b == null) return a === b;\n    // Unwrap any wrapped objects.\n    if (a instanceof _) a = a._wrapped;\n    if (b instanceof _) b = b._wrapped;\n    // Compare `[[Class]]` names.\n    var className = toString.call(a);\n    if (className !== toString.call(b)) return false;\n    switch (className) {\n      // Strings, numbers, regular expressions, dates, and booleans are compared by value.\n      case '[object RegExp]':\n      // RegExps are coerced to strings for comparison (Note: '' + /a/i === '/a/i')\n      case '[object String]':\n        // Primitives and their corresponding object wrappers are equivalent; thus, `\"5\"` is\n        // equivalent to `new String(\"5\")`.\n        return '' + a === '' + b;\n      case '[object Number]':\n        // `NaN`s are equivalent, but non-reflexive.\n        // Object(NaN) is equivalent to NaN\n        if (+a !== +a) return +b !== +b;\n        // An `egal` comparison is performed for other numeric values.\n        return +a === 0 ? 1 / +a === 1 / b : +a === +b;\n      case '[object Date]':\n      case '[object Boolean]':\n        // Coerce dates and booleans to numeric primitive values. Dates are compared by their\n        // millisecond representations. Note that invalid dates with millisecond representations\n        // of `NaN` are not equivalent.\n        return +a === +b;\n    }\n\n    var areArrays = className === '[object Array]';\n    if (!areArrays) {\n      if (typeof a != 'object' || typeof b != 'object') return false;\n\n      // Objects with different constructors are not equivalent, but `Object`s or `Array`s\n      // from different frames are.\n      var aCtor = a.constructor, bCtor = b.constructor;\n      if (aCtor !== bCtor && !(_.isFunction(aCtor) && aCtor instanceof aCtor &&\n                               _.isFunction(bCtor) && bCtor instanceof bCtor)\n                          && ('constructor' in a && 'constructor' in b)) {\n        return false;\n      }\n    }\n    // Assume equality for cyclic structures. The algorithm for detecting cyclic\n    // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.\n\n    // Initializing stack of traversed objects.\n    // It's done here since we only need them for objects and arrays comparison.\n    aStack = aStack || [];\n    bStack = bStack || [];\n    var length = aStack.length;\n    while (length--) {\n      // Linear search. Performance is inversely proportional to the number of\n      // unique nested structures.\n      if (aStack[length] === a) return bStack[length] === b;\n    }\n\n    // Add the first object to the stack of traversed objects.\n    aStack.push(a);\n    bStack.push(b);\n\n    // Recursively compare objects and arrays.\n    if (areArrays) {\n      // Compare array lengths to determine if a deep comparison is necessary.\n      length = a.length;\n      if (length !== b.length) return false;\n      // Deep compare the contents, ignoring non-numeric properties.\n      while (length--) {\n        if (!eq(a[length], b[length], aStack, bStack)) return false;\n      }\n    } else {\n      // Deep compare objects.\n      var keys = _.keys(a), key;\n      length = keys.length;\n      // Ensure that both objects contain the same number of properties before comparing deep equality.\n      if (_.keys(b).length !== length) return false;\n      while (length--) {\n        // Deep compare each member\n        key = keys[length];\n        if (!(_.has(b, key) && eq(a[key], b[key], aStack, bStack))) return false;\n      }\n    }\n    // Remove the first object from the stack of traversed objects.\n    aStack.pop();\n    bStack.pop();\n    return true;\n  };\n\n  // Perform a deep comparison to check if two objects are equal.\n  _.isEqual = function(a, b) {\n    return eq(a, b);\n  };\n\n  // Is a given array, string, or object empty?\n  // An \"empty\" object has no enumerable own-properties.\n  _.isEmpty = function(obj) {\n    if (obj == null) return true;\n    if (isArrayLike(obj) && (_.isArray(obj) || _.isString(obj) || _.isArguments(obj))) return obj.length === 0;\n    return _.keys(obj).length === 0;\n  };\n\n  // Is a given value a DOM element?\n  _.isElement = function(obj) {\n    return !!(obj && obj.nodeType === 1);\n  };\n\n  // Is a given value an array?\n  // Delegates to ECMA5's native Array.isArray\n  _.isArray = nativeIsArray || function(obj) {\n    return toString.call(obj) === '[object Array]';\n  };\n\n  // Is a given variable an object?\n  _.isObject = function(obj) {\n    var type = typeof obj;\n    return type === 'function' || type === 'object' && !!obj;\n  };\n\n  // Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp, isError.\n  _.each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp', 'Error'], function(name) {\n    _['is' + name] = function(obj) {\n      return toString.call(obj) === '[object ' + name + ']';\n    };\n  });\n\n  // Define a fallback version of the method in browsers (ahem, IE < 9), where\n  // there isn't any inspectable \"Arguments\" type.\n  if (!_.isArguments(arguments)) {\n    _.isArguments = function(obj) {\n      return _.has(obj, 'callee');\n    };\n  }\n\n  // Optimize `isFunction` if appropriate. Work around some typeof bugs in old v8,\n  // IE 11 (#1621), and in Safari 8 (#1929).\n  if (typeof /./ != 'function' && typeof Int8Array != 'object') {\n    _.isFunction = function(obj) {\n      return typeof obj == 'function' || false;\n    };\n  }\n\n  // Is a given object a finite number?\n  _.isFinite = function(obj) {\n    return isFinite(obj) && !isNaN(parseFloat(obj));\n  };\n\n  // Is the given value `NaN`? (NaN is the only number which does not equal itself).\n  _.isNaN = function(obj) {\n    return _.isNumber(obj) && obj !== +obj;\n  };\n\n  // Is a given value a boolean?\n  _.isBoolean = function(obj) {\n    return obj === true || obj === false || toString.call(obj) === '[object Boolean]';\n  };\n\n  // Is a given value equal to null?\n  _.isNull = function(obj) {\n    return obj === null;\n  };\n\n  // Is a given variable undefined?\n  _.isUndefined = function(obj) {\n    return obj === void 0;\n  };\n\n  // Shortcut function for checking if an object has a given property directly\n  // on itself (in other words, not on a prototype).\n  _.has = function(obj, key) {\n    return obj != null && hasOwnProperty.call(obj, key);\n  };\n\n  // Utility Functions\n  // -----------------\n\n  // Run Underscore.js in *noConflict* mode, returning the `_` variable to its\n  // previous owner. Returns a reference to the Underscore object.\n  _.noConflict = function() {\n    root._ = previousUnderscore;\n    return this;\n  };\n\n  // Keep the identity function around for default iteratees.\n  _.identity = function(value) {\n    return value;\n  };\n\n  // Predicate-generating functions. Often useful outside of Underscore.\n  _.constant = function(value) {\n    return function() {\n      return value;\n    };\n  };\n\n  _.noop = function(){};\n\n  _.property = property;\n\n  // Generates a function for a given object that returns a given property.\n  _.propertyOf = function(obj) {\n    return obj == null ? function(){} : function(key) {\n      return obj[key];\n    };\n  };\n\n  // Returns a predicate for checking whether an object has a given set of\n  // `key:value` pairs.\n  _.matcher = _.matches = function(attrs) {\n    attrs = _.extendOwn({}, attrs);\n    return function(obj) {\n      return _.isMatch(obj, attrs);\n    };\n  };\n\n  // Run a function **n** times.\n  _.times = function(n, iteratee, context) {\n    var accum = Array(Math.max(0, n));\n    iteratee = optimizeCb(iteratee, context, 1);\n    for (var i = 0; i < n; i++) accum[i] = iteratee(i);\n    return accum;\n  };\n\n  // Return a random integer between min and max (inclusive).\n  _.random = function(min, max) {\n    if (max == null) {\n      max = min;\n      min = 0;\n    }\n    return min + Math.floor(Math.random() * (max - min + 1));\n  };\n\n  // A (possibly faster) way to get the current timestamp as an integer.\n  _.now = Date.now || function() {\n    return new Date().getTime();\n  };\n\n   // List of HTML entities for escaping.\n  var escapeMap = {\n    '&': '&amp;',\n    '<': '&lt;',\n    '>': '&gt;',\n    '\"': '&quot;',\n    \"'\": '&#x27;',\n    '`': '&#x60;'\n  };\n  var unescapeMap = _.invert(escapeMap);\n\n  // Functions for escaping and unescaping strings to/from HTML interpolation.\n  var createEscaper = function(map) {\n    var escaper = function(match) {\n      return map[match];\n    };\n    // Regexes for identifying a key that needs to be escaped\n    var source = '(?:' + _.keys(map).join('|') + ')';\n    var testRegexp = RegExp(source);\n    var replaceRegexp = RegExp(source, 'g');\n    return function(string) {\n      string = string == null ? '' : '' + string;\n      return testRegexp.test(string) ? string.replace(replaceRegexp, escaper) : string;\n    };\n  };\n  _.escape = createEscaper(escapeMap);\n  _.unescape = createEscaper(unescapeMap);\n\n  // If the value of the named `property` is a function then invoke it with the\n  // `object` as context; otherwise, return it.\n  _.result = function(object, property, fallback) {\n    var value = object == null ? void 0 : object[property];\n    if (value === void 0) {\n      value = fallback;\n    }\n    return _.isFunction(value) ? value.call(object) : value;\n  };\n\n  // Generate a unique integer id (unique within the entire client session).\n  // Useful for temporary DOM ids.\n  var idCounter = 0;\n  _.uniqueId = function(prefix) {\n    var id = ++idCounter + '';\n    return prefix ? prefix + id : id;\n  };\n\n  // By default, Underscore uses ERB-style template delimiters, change the\n  // following template settings to use alternative delimiters.\n  _.templateSettings = {\n    evaluate    : /<%([\\s\\S]+?)%>/g,\n    interpolate : /<%=([\\s\\S]+?)%>/g,\n    escape      : /<%-([\\s\\S]+?)%>/g\n  };\n\n  // When customizing `templateSettings`, if you don't want to define an\n  // interpolation, evaluation or escaping regex, we need one that is\n  // guaranteed not to match.\n  var noMatch = /(.)^/;\n\n  // Certain characters need to be escaped so that they can be put into a\n  // string literal.\n  var escapes = {\n    \"'\":      \"'\",\n    '\\\\':     '\\\\',\n    '\\r':     'r',\n    '\\n':     'n',\n    '\\u2028': 'u2028',\n    '\\u2029': 'u2029'\n  };\n\n  var escaper = /\\\\|'|\\r|\\n|\\u2028|\\u2029/g;\n\n  var escapeChar = function(match) {\n    return '\\\\' + escapes[match];\n  };\n\n  // JavaScript micro-templating, similar to John Resig's implementation.\n  // Underscore templating handles arbitrary delimiters, preserves whitespace,\n  // and correctly escapes quotes within interpolated code.\n  // NB: `oldSettings` only exists for backwards compatibility.\n  _.template = function(text, settings, oldSettings) {\n    if (!settings && oldSettings) settings = oldSettings;\n    settings = _.defaults({}, settings, _.templateSettings);\n\n    // Combine delimiters into one regular expression via alternation.\n    var matcher = RegExp([\n      (settings.escape || noMatch).source,\n      (settings.interpolate || noMatch).source,\n      (settings.evaluate || noMatch).source\n    ].join('|') + '|$', 'g');\n\n    // Compile the template source, escaping string literals appropriately.\n    var index = 0;\n    var source = \"__p+='\";\n    text.replace(matcher, function(match, escape, interpolate, evaluate, offset) {\n      source += text.slice(index, offset).replace(escaper, escapeChar);\n      index = offset + match.length;\n\n      if (escape) {\n        source += \"'+\\n((__t=(\" + escape + \"))==null?'':_.escape(__t))+\\n'\";\n      } else if (interpolate) {\n        source += \"'+\\n((__t=(\" + interpolate + \"))==null?'':__t)+\\n'\";\n      } else if (evaluate) {\n        source += \"';\\n\" + evaluate + \"\\n__p+='\";\n      }\n\n      // Adobe VMs need the match returned to produce the correct offest.\n      return match;\n    });\n    source += \"';\\n\";\n\n    // If a variable is not specified, place data values in local scope.\n    if (!settings.variable) source = 'with(obj||{}){\\n' + source + '}\\n';\n\n    source = \"var __t,__p='',__j=Array.prototype.join,\" +\n      \"print=function(){__p+=__j.call(arguments,'');};\\n\" +\n      source + 'return __p;\\n';\n\n    try {\n      var render = new Function(settings.variable || 'obj', '_', source);\n    } catch (e) {\n      e.source = source;\n      throw e;\n    }\n\n    var template = function(data) {\n      return render.call(this, data, _);\n    };\n\n    // Provide the compiled source as a convenience for precompilation.\n    var argument = settings.variable || 'obj';\n    template.source = 'function(' + argument + '){\\n' + source + '}';\n\n    return template;\n  };\n\n  // Add a \"chain\" function. Start chaining a wrapped Underscore object.\n  _.chain = function(obj) {\n    var instance = _(obj);\n    instance._chain = true;\n    return instance;\n  };\n\n  // OOP\n  // ---------------\n  // If Underscore is called as a function, it returns a wrapped object that\n  // can be used OO-style. This wrapper holds altered versions of all the\n  // underscore functions. Wrapped objects may be chained.\n\n  // Helper function to continue chaining intermediate results.\n  var result = function(instance, obj) {\n    return instance._chain ? _(obj).chain() : obj;\n  };\n\n  // Add your own custom functions to the Underscore object.\n  _.mixin = function(obj) {\n    _.each(_.functions(obj), function(name) {\n      var func = _[name] = obj[name];\n      _.prototype[name] = function() {\n        var args = [this._wrapped];\n        push.apply(args, arguments);\n        return result(this, func.apply(_, args));\n      };\n    });\n  };\n\n  // Add all of the Underscore functions to the wrapper object.\n  _.mixin(_);\n\n  // Add all mutator Array functions to the wrapper.\n  _.each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {\n    var method = ArrayProto[name];\n    _.prototype[name] = function() {\n      var obj = this._wrapped;\n      method.apply(obj, arguments);\n      if ((name === 'shift' || name === 'splice') && obj.length === 0) delete obj[0];\n      return result(this, obj);\n    };\n  });\n\n  // Add all accessor Array functions to the wrapper.\n  _.each(['concat', 'join', 'slice'], function(name) {\n    var method = ArrayProto[name];\n    _.prototype[name] = function() {\n      return result(this, method.apply(this._wrapped, arguments));\n    };\n  });\n\n  // Extracts the result from a wrapped and chained object.\n  _.prototype.value = function() {\n    return this._wrapped;\n  };\n\n  // Provide unwrapping proxy for some methods used in engine operations\n  // such as arithmetic and JSON stringification.\n  _.prototype.valueOf = _.prototype.toJSON = _.prototype.value;\n\n  _.prototype.toString = function() {\n    return '' + this._wrapped;\n  };\n\n  // AMD registration happens at the end for compatibility with AMD loaders\n  // that may not enforce next-turn semantics on modules. Even though general\n  // practice for AMD registration is to be anonymous, underscore registers\n  // as a named module because, like jQuery, it is a base library that is\n  // popular enough to be bundled in a third party lib, but not be part of\n  // an AMD load request. Those cases could generate an error when an\n  // anonymous define() is called outside of a loader request.\n  if (typeof define === 'function' && define.amd) {\n    define('underscore', [], function() {\n      return _;\n    });\n  }\n}.call(this));\n","'use strict';\n\nconst xapiErrorLevels = Object.freeze({\n  MAY_VIOLATION:    'MAY_VIOLATION',\n  MUST_VIOLATION:   'MUST_VIOLATION',\n  SHOULD_VIOLATION: 'SHOULD_VIOLATION'\n});\n\nconst xapiValidationErrors = Object.freeze({\n  ACTIVITIES_MUST_NOT_BE_NULL_MAP_OBJECTS:          'Activities must be non-null map objects',\n  ACTOR_MUST_BE_PROVIDED:                           'Actor must be provided.',\n  AGENT_IFI_PROPERTIES_MUST_BE_SPECIFIED:           'Exactly one Inverse Functional Identifier property must be specified for an \"agent\".',\n  AGENT_MUST_BE_NON_NULL_MAP_OBJECT:                '\"agent\" must be a non-null map object',\n  AGENT_MUST_NOT_HAVE_GROUP_CHARACTERISTICS:        'Invalid object with characteristics of a Group when an Agent was expected.',\n  ATTACHMENTS_MUST_BE_NOT_NULL_ARRAY:               '\"attachments\" must be a non-null Array.',\n  ATTACHMENTS_MUST_NOT_BE_NULL_MAP_OBJECTS:         '\"attachment\" instances must be non-null map objects.',\n  AUTHORITY_MUST_BE_NON_NULL_MAP_OBJECT:            'If present, the \"authority\" property must be a non-null map object.',\n  CONTEXT_ACTIVITIES_MUST_BE_ARRAY_OR_ACTIVITY_OBJ: 'Context Activities property values must be an array of Activity Objects or a single Activity Object.',\n  CONTEXT_ACTIVITIES_MUST_BE_NON_NULL_MAP_OBJECT:   'The Context Activities instances must be a non-null map object.',\n  CONTEXT_ACTIVITIES_MUST_NOT_BE_NULL:              '\"Context Activities\" property values must not be null.',\n  CONTEXT_ACTIVITIES_SHOULD_BE_AN_ARRAY:            'Context Activities property values should prefer to be an array of Activities rather than a single Activity object.',\n  CONTEXT_MUST_BE_NON_NUL_MAP_OBJECT:               'If present, the \"context\" property must be a non-null map object.',\n  CORRECT_RESPONSES_PATTERN_MUST_BE_ARRAY:          'If present, the \"correctResponsesPattern\" value must be an Array of strings.',\n  CORRECT_RESPONSES_PATTERN_MUST_BE_STRINGS:        '\"correctResponsesPattern\" items must be strings.',\n  DATE_MUST_BE_VALID:                               'This propertys string value must be conformant to ISO 8601 for Date Times.',\n  DATE_SHOULD_INCLUDE_ZONE_INFORMATION:             'ISO 8601 date time strings used in the xAPI should include time zone information.',\n  DEFINITIONS_MUST_BE_OBJECTS:                      '\"definitions\", when present, must be map objects',\n  DISPLAY_SHOULD_BE_PROVIDED:                       '\"display\" property should be provided.',\n  DURATION_MUST_BE_VALID:                           'If present, the \"duration\" property value must be an ISO 8601 duration',\n  EXTENSIONS_MUST_NOT_BE_NULL:                      'If present, the extensions property must be a non-null map object.',\n  GROUP_AUTHORITY_AGENT_MEMBERS_MUST_BE_TWO:        'If used as a Group, the \"authority\" property must contain a \"member\" property that is an array containing exactly two Agent objects.',\n  GROUP_IFI_PROPERTIES_MUST_BE_SPECIFIED:           'Exactly one Inverse Functional Identifier property must be specified for a \"group\".',\n  GROUP_MEMBER_MUST_BE_ARRAY:                       'If present, the member property of a Group must be an Array',\n  GROUP_MUST_BE_NON_NULL_MAP_OBJECT:                '\"group\" must be a non-null map object',\n  ID_MUST_BE_UNIQUE:                                '\"id\" properties must be unique within each interaction component array',\n  ID_MUST_BE_VALID_UUID_REF:                        '\"id\" property value must be a valid UUID string for statement reference objects.',\n  ID_MUST_BE_VALID:                                 'Id was not a valid UUID',\n  ID_SHOULD_NOT_CONTAIN_WHITESPACES:                '\"id\" properties on interaction components should not contain whitespace',\n  IDS_SHOULD_BE_GENERATED_BY_LRS:                   'Ids should be generated by the Activity Provider, and must be generated by the LRS',\n  IFI_MUST_BE_MBOX_URI:                             '\"mbox\" property was required to be a mailto URI string but was not a string at all.',\n  IFI_MUST_BE_VALID_MBOX_FORMAT:                    '\"mbox\" property was required to be a mailto URI string but did not match the mailto format.',\n  INTERACTION_ACTIVITY_SHOULD_HAVE:                 'Interaction Activity Definitions should have a type property of',\n  INTERACTION_COMPONENT_MUST_NOT_BE_NULL:           'This interaction component collection member must be a non-null map object',\n  INTERACTION_COMPONENT_SHOULD_BE_ARRAY:            'This interaction component collection property should be an array.',\n  INTERACTION_TYPE_MUST_BE_CMI:                     'If present, the \"interactionType\" value must be a CMI interaction type option.',\n  INTERACTION_TYPE_MUST_BE_VALID:                   'This interaction component collection property is not associated with the present interactionType of: ',\n  INVALID_JSON:                                     'Invalid JSON. The statement could not be parsed.',\n  LANGUAGE_MAP_KEY_INVALID:                         'key, Language does not conform to RFC 5646',\n  LANGUAGE_MAP_KEY_MUST_BE_STRING:                  'key: Language Map value should be a String, but was not',\n  LANGUAGE_MAPS_MUST_NOT_BE_NULL:                   'Language Maps, when present, must be non-null map objects',\n  LANGUAGE_MUST_BE_STRING:                          'The language property must be encoded as an RFC 5646 compliant string, but was not.',\n  LENGTH_MUST_BE_INTEGER:                           '\"length\" property must be provided with an integer value',\n  MAX_MUST_BE_GREATER_THAN_MIN:                     'If both \"max\" and \"min\" are present, the max property value should be greater than min',\n  MEMBER_MUST_BE_PROVIDED_FOR_ANONYMOUS_GROUPS:     '\"member\" property must be provided for Anonymous Groups.',\n  MUST_BE_BOOLEAN_PRESENT:                          'property was required to be a Boolean but was absent.',\n  MUST_BE_BOOLEAN:                                  'property, if present, must be a Boolean.',\n  MUST_BE_IRI_STRING:                               'property, if present, should be a IRI-like absolute URI per RFC 3987.',\n  MUST_BE_NUMBER_PRESENT:                           'property was required to be a Number but was absent.',\n  MUST_BE_NUMBER:                                   'property, if present, must be a Number.',\n  MUST_BE_PRESENT:                                  'property was required to be a string but was absent.',\n  MUST_BE_STRING:                                   'property, if present, must be a string.',\n  MUST_BE_URI_PRESENT:                              'property was required to be a URI string but was absent.',\n  MUST_BE_URI_STRING:                               'property, if present, must be a URI string.',\n  OBJECT_MUST_BE_DEFINED:                           '\"object\" property must be provided.',\n  OBJECT_MUST_BE_NON_NULL_MAP_OBJECT:               '\"object\" property must be a non-null map object.',\n  OBJECT_TYPE_MUST_BE_STATEMENT_REF:                '\"objectType\" property value must be \"StatementRef\" for statement reference objects.',\n  OBJECT_TYPE_MUST_BE_VALID_OPTION:                 'object\\'s \"objectType\" did not match a valid option',\n  RAW_MUST_BE_GREATER_THAN_MIN:                     'If both \"raw\" and \"min\" are present, the raw property value should be greater than min',\n  RAW_MUST_BE_LESS_THAN_MAX:                        'If both \"raw\" and \"max\" are present, the raw property value should be less than max',\n  REGISTRATION_MUST_BE_UUID_STRING:                 'If present, the registration property must be a UUID string.',\n  RESULT_MUST_BE_MAP_OBJECT:                        'If present, the result must be a map object',\n  REVISION_MUST_BE_AGENT_OR_GROUP:                  'The revision property must not be used if the Statement\\'s Object is an Agent or Group.',\n  SCALED_MUST_BE_BETWEEN_0_1:                       'If present, the scaled property value must be between 0 and 1',\n  SHA2_MUST_BE_PROVIDED_ON_ATTACHMENT_OBJECTS:      '\"sha2\" property must be provided on attachment objects',\n  SHA2_MUST_CONTAIN_BASE_64_STRING:                 '\"sha2\" property must contain a string with base64 contents',\n  STATEMENT_ARGUMENT_IS_NOT_VALID:                  'Statement argument provided was not a valid object or a valid JSON string.',\n  STATEMENT_ARGUMENT_MUST_BE_PROVIDED:              'No statement argument provided.',\n  STATEMENT_MUST_BE_PARSED_CORRECTLY:               'Null or non-object statement value parsed from provided statment JSON.',\n  STATEMENT_MUST_NOT_BE_NULL:                       'Null statement argument provided.',\n  STATEMENT_REF_MUST_NOT_BE_NULL_MAP_OBJECTS:       'StatementRef instances must be non-null map objects',\n  SUB_STATEMENT_MUST_NOT_CONTAIN_SUB_STATEMENT:     'A SubStatement must not contain a SubStatement',\n  UNEXPECTED:                                       'Unexpected property not permitted',\n  VERB_MUST_BE_PROVIDED:                            'Verb must be provided',\n  VERB_MUST_NOT_BE_NULL:                            'Verb property value must a non-null map object.',\n  VERSION_MUST_COMPLY_SEMANTIC_VERSIONING:          '\"version\" must be a non-null string that complies with Semantic Versioning 1.0.0'\n});\n\nexport {xapiErrorLevels};\nexport {xapiValidationErrors};\n","'use strict';\n\nconst xapiGeneral = Object.freeze({\n  FIRST_REPORT_VERSTION             : '1.0.0',\n  GROUP_AUTHORITY_AGENT_MEMBERS     : 2,\n  INTERACTION_DEFINITION_TYPE       : 'http://adlnet.gov/expapi/activities/cmi.interaction',\n  MAX_SCALED_VALUE                  : 1,\n  MIN_SCALED_VALUE                  : 0,\n  NO_INDEX_FOUND                    : -1,\n  NUMER_OF_SPECIFIED_IFI_PROPERTIES : 1\n});\n\nexport {xapiGeneral};\n","'use strict';\n\nexport const interactionTypes = Object.freeze({\n  CHOICE:       'choice',\n  FILL_IN:      'fill-in',\n  LIKERT:       'likert',\n  LONG_FILL_IN: 'long-fill-in',\n  MATCHING:     'matching',\n  NUMERIC:      'numeric',\n  OTHER:        'other',\n  PERFORMANCE:  'performance',\n  SEQUENCING:   'sequencing',\n  TRUE_FALSE:   'true-false'\n});\n\nexport const xapiValidationInteractionTypes = Object.freeze([\n  interactionTypes.CHOICE,\n  interactionTypes.FILL_IN,\n  interactionTypes.LIKERT,\n  interactionTypes.LONG_FILL_IN,\n  interactionTypes.MATCHING,\n  interactionTypes.NUMERIC,\n  interactionTypes.OTHER,\n  interactionTypes.PERFORMANCE,\n  interactionTypes.SEQUENCING,\n  interactionTypes.TRUE_FALSE\n]);\n","'use strict';\n\nconst properties = Object.freeze({\n  ACCOUNT:                   'account',\n  ACTIVITY:                  'activity',\n  ACTOR:                     'actor',\n  AGENT:                     'agent',\n  ATTACHMENT:                'attachment',\n  ATTACHMENTS:               'attachments',\n  AUTHORITY:                 'authority',\n  CATEGORY:                  'category',\n  CHOICE:                    'choice',\n  CHOICES:                   'choices',\n  COMPLETION:                'completion',\n  CONTENT_TYPE:              'contentType',\n  CONTEXT_ACTIVITIES:        'contextActivities',\n  CONTEXT:                   'context',\n  CORRECT_RESPONSES_PATTERN: 'correctResponsesPattern',\n  DATE_TIME:                 'dateTime',\n  DEFINITION:                'definition',\n  DESCRIPTION:               'description',\n  DISPLAY:                   'display',\n  DURATION:                  'duration',\n  EXTENSIONS:                'extensions',\n  FILE_URL:                  'fileUrl',\n  GROUP:                     'group',\n  GROUPING:                  'grouping',\n  HOME_PAGE:                 'homePage',\n  ID:                        'id',\n  INSTRUCTOR:                'instructor',\n  INTERACTION_COMPONENTS:    'interactionComponents',\n  INTERACTION_TYPE:          'interactionType',\n  LANGUAGE_MAP:              'languageMap',\n  LANGUAGE:                  'language',\n  LENGTH:                    'length',\n  LIKERT:                    'likert',\n  MATCHING:                  'matching',\n  MAX:                       'max',\n  MBOX_SHA_1_SUM:            'mbox_sha1sum',\n  MBOX:                      'mbox',\n  MEMBER:                    'member',\n  MIN:                       'min',\n  MORE_INFO:                 'moreInfo',\n  NAME:                      'name',\n  OBJECT_TYPE:               'objectType',\n  OBJECT:                    'object',\n  OPEN_ID:                   'openID',\n  OTHER:                     'other',\n  PARENT:                    'parent',\n  PERFORMANCE:               'performance',\n  PLATFORM:                  'platform',\n  RAW:                       'raw',\n  REGISTRATION:              'registration',\n  RESPONSE:                  'response',\n  RESULT:                    'result',\n  REVISION:                  'revision',\n  SCALE:                     'scale',\n  SCALED:                    'scaled',\n  SCORE:                     'score',\n  SEQUENCING:                'sequencing',\n  SHA2:                      'sha2',\n  SOURCE:                    'source',\n  STATEMENT_REF:             'statementRef',\n  STATEMENT:                 'statement',\n  STEPS:                     'steps',\n  STORED:                    'stored',\n  SUB_CONTEXT:               'subContext',\n  SUCCESS:                   'success',\n  TARGET:                    'target',\n  TEAM:                      'team',\n  TIMESTAMP:                 'timestamp',\n  TYPE:                      'type',\n  USAGE_TYPE:                'usageType',\n  VERB:                      'verb',\n  VERSION:                   'version'\n});\n\nconst objectTypes = Object.freeze({\n  GROUP:         'Group',\n  AGENT:         'Agent',\n  ACTIVITY:      'Activity',\n  STATEMENT_REF: 'StatementRef',\n  SUB_STATEMENT: 'SubStatement'\n});\n\nconst xapiValidationIfiPropertyNames = Object.freeze([\n  properties.ACCOUNT,\n  properties.MBOX_SHA_1_SUM,\n  properties.MBOX,\n  properties.OPEN_ID\n]);\n\nconst xApiValidObjectTypes = Object.freeze([\n  objectTypes.GROUP,\n  objectTypes.AGENT,\n  objectTypes.ACTIVITY,\n  objectTypes.STATEMENT_REF,\n  objectTypes.SUB_STATEMENT\n]);\n\nconst xapiWhiteListProperties = Object.freeze({\n  IFI: [\n    properties.HOME_PAGE,\n    properties.NAME\n  ],\n  URI: [\n    properties.ID,\n    properties.DISPLAY\n  ],\n  COMPONENT_ARRAY: [\n    properties.ID,\n    properties.DESCRIPTION\n  ],\n  ACTIVITY_DEFINITION: [\n    properties.NAME,\n    properties.DESCRIPTION,\n    properties.TYPE,\n    properties.MORE_INFO,\n    properties.EXTENSIONS,\n    properties.INTERACTION_TYPE,\n    properties.CORRECT_RESPONSES_PATTERN,\n    properties.CHOICES,\n    properties.SCALE,\n    properties.SOURCE,\n    properties.TARGET,\n    properties.STEPS\n  ],\n  ACTIVITY: [\n    properties.OBJECT_TYPE,\n    properties.ID,\n    properties.DEFINITION\n  ],\n  STATEMENT_REF: [\n    properties.ID,\n    properties.OBJECT_TYPE\n  ],\n  SCORE: [\n    properties.SCALED,\n    properties.RAW,\n    properties.MIN,\n    properties.MAX\n  ],\n  RESULT: [\n    properties.SCORE,\n    properties.SUCCESS,\n    properties.COMPLETION,\n    properties.RESPONSE,\n    properties.DURATION,\n    properties.EXTENSIONS\n  ],\n  ATTACHMENT: [\n    properties.USAGE_TYPE,\n    properties.DISPLAY,\n    properties.DESCRIPTION,\n    properties.CONTENT_TYPE,\n    properties.LENGTH,\n    properties.SHA2,\n    properties.FILE_URL\n  ],\n AGENT: [\n   properties.OBJECT_TYPE,\n   properties.NAME,\n   properties.ACCOUNT,\n   properties.MBOX_SHA_1_SUM,\n   properties.MBOX,\n   properties.OPEN_ID\n ],\n GROUP: [\n   properties.OBJECT_TYPE,\n   properties.NAME,\n   properties.MEMBER,\n   properties.ACCOUNT,\n   properties.MBOX_SHA_1_SUM,\n   properties.MBOX,\n   properties.OPEN_ID\n ],\n CONTEXT_ACTIVITIES: [\n   properties.PARENT,\n   properties.GROUPING,\n   properties.CATEGORY,\n   properties.OTHER\n ],\n STATEMENT: [\n   properties.ID,\n   properties.ACTOR,\n   properties.VERB,\n   properties.OBJECT,\n   properties.RESULT,\n   properties.CONTEXT,\n   properties.TIMESTAMP,\n   properties.STORED,\n   properties.AUTHORITY,\n   properties.VERSION,\n   properties.ATTACHMENTS\n ],\n SUB_STATEMENT: [\n   properties.ACTOR,\n   properties.VERB,\n   properties.OBJECT,\n   properties.RESULT,\n   properties.CONTEXT,\n   properties.TIMESTAMP,\n   properties.ATTACHMENTS,\n   properties.OBJECT_TYPE\n ],\n EXTENSIONS: [\n   properties.REGISTRATION,\n   properties.INSTRUCTOR,\n   properties.TEAM,\n   properties.CONTEXT_ACTIVITIES,\n   properties.REVISION,\n   properties.PLATFORM,\n   properties.LANGUAGE,\n   properties.STATEMENT,\n   properties.EXTENSIONS\n ]\n});\n\nexport {properties};\nexport {objectTypes};\nexport {xapiValidationIfiPropertyNames};\nexport {xApiValidObjectTypes};\nexport {xapiWhiteListProperties};\n","'use strict';\n\nconst xapiValidationRegex = Object.freeze({\n  UUID:                /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i,\n  ISO_8601_DURATION:   /^P((\\d+([\\.,]\\d+)?Y)?(\\d+([\\.,]\\d+)?M)?(\\d+([\\.,]\\d+)?W)?(\\d+([\\.,]\\d+)?D)?)?(T(\\d+([\\.,]\\d+)?H)?(\\d+([\\.,]\\d+)?M)?(\\d+([\\.,]\\d+)?S)?)?$/,\n  ISO_8601_DATE_TIME:  /^(\\d{4}|[+\\-]\\d{6})(?:-(\\d{2})(?:-(\\d{2}))?)?(?:T(\\d{2}):(\\d{2})(?::(\\d{2})(?:\\.(\\d{3}))?)?(?:(Z)|([+\\-])(\\d{2})(?::(\\d{2}))?)?)?$/,\n  MAILTO_URI:          /^mailto:/,\n  CONTAINS_WHITESPACE: /\\s/g,\n  SEMVER_1_P_0_P_0:    /^((\\d+)\\.(\\d+)\\.(\\d+))(?:-([\\dA-Za-z\\-]+))?$/,\n  BASE_64:             /^(?:[A-Za-z0-9\\+\\/]{4})*(?:[A-Za-z0-9\\+\\/]{2}==|[A-Za-z0-9\\+\\/]{3}=|[A-Za-z0-9\\+\\/]{4})$/,\n  IRI:                 /^[a-z](?:[\\-a-z0-9\\+\\.])*:(?:\\/\\/(?:(?:%[0-9a-f][0-9a-f]|[\\-a-z0-9\\._~\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF\\u10000-\\u1FFFD\\u20000-\\u2FFFD\\u30000-\\u3FFFD\\u40000-\\u4FFFD\\u50000-\\u5FFFD\\u60000-\\u6FFFD\\u70000-\\u7FFFD\\u80000-\\u8FFFD\\u90000-\\u9FFFD\\uA0000-\\uAFFFD\\uB0000-\\uBFFFD\\uC0000-\\uCFFFD\\uD0000-\\uDFFFD\\uE1000-\\uEFFFD!\\$&'\\(\\)\\*\\+,;=:])*@)?(?:\\[(?:(?:(?:[0-9a-f]{1,4}:){6}(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3})|::(?:[0-9a-f]{1,4}:){5}(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3})|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3})|(?:[0-9a-f]{1,4}:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3})|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3})|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3})|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3})|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|v[0-9a-f]+[\\-a-z0-9\\._~!\\$&'\\(\\)\\*\\+,;=:]+)\\]|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3}|(?:%[0-9a-f][0-9a-f]|[\\-a-z0-9\\._~\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF\\u10000-\\u1FFFD\\u20000-\\u2FFFD\\u30000-\\u3FFFD\\u40000-\\u4FFFD\\u50000-\\u5FFFD\\u60000-\\u6FFFD\\u70000-\\u7FFFD\\u80000-\\u8FFFD\\u90000-\\u9FFFD\\uA0000-\\uAFFFD\\uB0000-\\uBFFFD\\uC0000-\\uCFFFD\\uD0000-\\uDFFFD\\uE1000-\\uEFFFD!\\$&'\\(\\)\\*\\+,;=@])*)(?::[0-9]*)?(?:\\/(?:(?:%[0-9a-f][0-9a-f]|[\\-a-z0-9\\._~\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF\\u10000-\\u1FFFD\\u20000-\\u2FFFD\\u30000-\\u3FFFD\\u40000-\\u4FFFD\\u50000-\\u5FFFD\\u60000-\\u6FFFD\\u70000-\\u7FFFD\\u80000-\\u8FFFD\\u90000-\\u9FFFD\\uA0000-\\uAFFFD\\uB0000-\\uBFFFD\\uC0000-\\uCFFFD\\uD0000-\\uDFFFD\\uE1000-\\uEFFFD!\\$&'\\(\\)\\*\\+,;=:@]))*)*|\\/(?:(?:(?:(?:%[0-9a-f][0-9a-f]|[\\-a-z0-9\\._~\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF\\u10000-\\u1FFFD\\u20000-\\u2FFFD\\u30000-\\u3FFFD\\u40000-\\u4FFFD\\u50000-\\u5FFFD\\u60000-\\u6FFFD\\u70000-\\u7FFFD\\u80000-\\u8FFFD\\u90000-\\u9FFFD\\uA0000-\\uAFFFD\\uB0000-\\uBFFFD\\uC0000-\\uCFFFD\\uD0000-\\uDFFFD\\uE1000-\\uEFFFD!\\$&'\\(\\)\\*\\+,;=:@]))+)(?:\\/(?:(?:%[0-9a-f][0-9a-f]|[\\-a-z0-9\\._~\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF\\u10000-\\u1FFFD\\u20000-\\u2FFFD\\u30000-\\u3FFFD\\u40000-\\u4FFFD\\u50000-\\u5FFFD\\u60000-\\u6FFFD\\u70000-\\u7FFFD\\u80000-\\u8FFFD\\u90000-\\u9FFFD\\uA0000-\\uAFFFD\\uB0000-\\uBFFFD\\uC0000-\\uCFFFD\\uD0000-\\uDFFFD\\uE1000-\\uEFFFD!\\$&'\\(\\)\\*\\+,;=:@]))*)*)?|(?:(?:(?:%[0-9a-f][0-9a-f]|[\\-a-z0-9\\._~\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF\\u10000-\\u1FFFD\\u20000-\\u2FFFD\\u30000-\\u3FFFD\\u40000-\\u4FFFD\\u50000-\\u5FFFD\\u60000-\\u6FFFD\\u70000-\\u7FFFD\\u80000-\\u8FFFD\\u90000-\\u9FFFD\\uA0000-\\uAFFFD\\uB0000-\\uBFFFD\\uC0000-\\uCFFFD\\uD0000-\\uDFFFD\\uE1000-\\uEFFFD!\\$&'\\(\\)\\*\\+,;=:@]))+)(?:\\/(?:(?:%[0-9a-f][0-9a-f]|[\\-a-z0-9\\._~\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF\\u10000-\\u1FFFD\\u20000-\\u2FFFD\\u30000-\\u3FFFD\\u40000-\\u4FFFD\\u50000-\\u5FFFD\\u60000-\\u6FFFD\\u70000-\\u7FFFD\\u80000-\\u8FFFD\\u90000-\\u9FFFD\\uA0000-\\uAFFFD\\uB0000-\\uBFFFD\\uC0000-\\uCFFFD\\uD0000-\\uDFFFD\\uE1000-\\uEFFFD!\\$&'\\(\\)\\*\\+,;=:@]))*)*|(?!(?:%[0-9a-f][0-9a-f]|[\\-a-z0-9\\._~\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF\\u10000-\\u1FFFD\\u20000-\\u2FFFD\\u30000-\\u3FFFD\\u40000-\\u4FFFD\\u50000-\\u5FFFD\\u60000-\\u6FFFD\\u70000-\\u7FFFD\\u80000-\\u8FFFD\\u90000-\\u9FFFD\\uA0000-\\uAFFFD\\uB0000-\\uBFFFD\\uC0000-\\uCFFFD\\uD0000-\\uDFFFD\\uE1000-\\uEFFFD!\\$&'\\(\\)\\*\\+,;=:@])))(?:\\?(?:(?:%[0-9a-f][0-9a-f]|[\\-a-z0-9\\._~\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF\\u10000-\\u1FFFD\\u20000-\\u2FFFD\\u30000-\\u3FFFD\\u40000-\\u4FFFD\\u50000-\\u5FFFD\\u60000-\\u6FFFD\\u70000-\\u7FFFD\\u80000-\\u8FFFD\\u90000-\\u9FFFD\\uA0000-\\uAFFFD\\uB0000-\\uBFFFD\\uC0000-\\uCFFFD\\uD0000-\\uDFFFD\\uE1000-\\uEFFFD!\\$&'\\(\\)\\*\\+,;=:@])|[\\uE000-\\uF8FF\\uF0000-\\uFFFFD|\\u100000-\\u10FFFD\\/\\?])*)?(?:\\#(?:(?:%[0-9a-f][0-9a-f]|[\\-a-z0-9\\._~\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF\\u10000-\\u1FFFD\\u20000-\\u2FFFD\\u30000-\\u3FFFD\\u40000-\\u4FFFD\\u50000-\\u5FFFD\\u60000-\\u6FFFD\\u70000-\\u7FFFD\\u80000-\\u8FFFD\\u90000-\\u9FFFD\\uA0000-\\uAFFFD\\uB0000-\\uBFFFD\\uC0000-\\uCFFFD\\uD0000-\\uDFFFD\\uE1000-\\uEFFFD!\\$&'\\(\\)\\*\\+,;=:@])|[\\/\\?])*)?$/i,\n  BCP_47:              /^(?:(en-GB-oed|i-(?:ami|bnn|default|enochian|hak|klingon|lux|mingo|navajo|pwn|tao|tay|tsu)|sgn-(?:BE-FR|BE-NL|CH-DE))|(art-lojban|cel-gaulish|no-(?:bok|nyn)|zh-(?:guoyu|hakka|min|min-nan|xiang)))$|^(x(?:-[0-9a-z]{1,8})+)$|^(?:((?:[a-z]{2,3}(?:(?:-[a-z]{3}){1,3})?)|[a-z]{4}|[a-z]{5,8})(?:-([a-z]{4}))?(?:-([a-z]{2}|[0-9]{3}))?((?:-(?:[a-z0-9]{5,8}|[0-9][a-z0-9]{3}))*)?((?:-[0-9a-wy-z](?:-[a-z0-9]{2,8}){1,})*)?(-x(?:-[0-9a-z]{1,8})+)?)$/i\n});\n\nconst dateFormatRegexPositions = Object.freeze({\n  YEAR:             1,\n  MONTH:            2,\n  DAY:              3,\n  HOUR:             4,\n  MINUTE:           5,\n  SECOND:           6,\n  MSECOND:          7,\n  ZONE:             8,\n  RELATIVE_TIME:    9,\n  TIME_ZONE_HOUR:   10,\n  TIME_ZONE_MINUTE: 11\n});\n\nexport {xapiValidationRegex};\nexport {dateFormatRegexPositions};\n","'use strict';\n\nconst\n  IS_STRING  = '[object String]',\n  IS_ARRAY   = '[object Array]',\n  IS_BOOLEAN = '[object Boolean]',\n  IS_NUMBER  = '[object Number]'\n;\n\nvar toString = Object.prototype.toString;\nvar xapiValidationUtils;\n\nxapiValidationUtils = {\n  isString(obj) {\n    return toString.call(obj) === IS_STRING;\n  },\n\n  isObject(obj) {\n    return obj === Object(obj);\n  },\n\n  isArray: Array.isArray || function(obj) {\n    return toString.call(obj) === IS_ARRAY;\n  },\n\n  isBoolean(obj) {\n    return obj === true || obj === false || toString.call(obj) === IS_BOOLEAN;\n  },\n\n  isNumber(obj) {\n    return toString.call(obj) === IS_NUMBER;\n  },\n\n  isDefined(obj) {\n    return (obj !== null || obj !== undefined);\n  },\n\n  isNonNullMapObject(target) {\n      return this.isDefined(target) && this.isObject(target) && !this.isArray(target);\n  },\n\n  isValidLanguageTag(target, validLanguageRegex) {\n    // TODO - use more precise 5646 handling, rather than this simplified BCP 47 regex, which combines RFC 5646 and RFC 4647.\n    // return this.isDefined(target) && this.isString(target) && xapiValidationRegex.BCP_47.test(target);\n    return this.isDefined(target) && this.isString(target) && validLanguageRegex.test(target);\n  },\n\n  addPropToTrace(trace, addendum) {\n    return this.isDefined(addendum) ? `${trace}.${addendum}` : trace;\n  },\n\n  addLookupToTrace(trace, key) {\n    return (!this.isDefined(key)) ? trace : (this.isNumber(key) ? `${trace}[${key}]` : `${trace}[\"${key}\"]`);\n  },\n\n  localTraceToString(trace, addendum) {\n    return this.addPropToTrace(trace, addendum);\n  },\n\n  isGroup(actorOrGroup, groupType) {\n    // return (actorOrGroup.member !== null && actorOrGroup.member !== undefined) || actorOrGroup.objectType === objectTypes.GROUP;\n    return (actorOrGroup.member !== null && actorOrGroup.member !== undefined) || actorOrGroup.objectType === groupType;\n  }\n};\n\nexport {xapiValidationUtils};\n","'use strict';\n\nimport {properties, objectTypes, xapiValidationIfiPropertyNames, xApiValidObjectTypes, xapiWhiteListProperties} from './constants/properties';\nimport {xapiErrorLevels, xapiValidationErrors} from './constants/errors';\nimport {xapiValidationInteractionTypes} from './constants/interaction-types';\nimport {xapiValidationRegex, dateFormatRegexPositions} from './constants/regex';\nimport {xapiGeneral} from './constants/general';\nimport {xapiValidationUtils} from './utils/utils';\n\nvar xapiValidation;\n\nfunction makeV1Report(instance, errors) {\n  var version;\n\n  instance = instance || null;\n  errors   = errors   || null;\n  version  = xapiGeneral.FIRST_REPORT_VERSTION;\n  return {instance, errors, version};\n}\n\nfunction makeV1SingleErrorReport(instance, error) {\n  return makeV1Report(instance, error === null || error === undefined ? [] : [error]);\n}\n\nfunction validateAbsenceOfNonWhitelistedProperties(target, allowedProperties, trace, errors) {\n  var localErrors, localTrace, propertyName;\n\n  localErrors = errors || [];\n  localTrace  = trace  || '';\n\n  for (propertyName in target) {\n    if (target.hasOwnProperty(propertyName) && allowedProperties.indexOf(propertyName) === xapiGeneral.NO_INDEX_FOUND) {\n      localErrors.push({\n        trace:   xapiValidationUtils.addPropToTrace(localTrace, propertyName),\n        message: xapiValidationErrors.UNEXPECTED,\n        level:   xapiErrorLevels.MUST_VIOLATION\n      });\n    }\n  }\n\n  return localErrors;\n}\n\nfunction validatePropertyIsString(parent, propertyName, trace, errors, isRequired, violationType) {\n  var localErrors, localTrace, propValue, localViolationType;\n\n  localErrors        = errors || [];\n  localTrace         = trace  || '';\n  propValue          = parent[propertyName],\n  localViolationType = violationType || xapiErrorLevels.MUST_VIOLATION;\n\n  if (propValue !== undefined) {\n    if (propValue === null || !xapiValidationUtils.isString(propValue)) {\n      localErrors.push({\n        trace:   xapiValidationUtils.localTraceToString(localTrace, propertyName),\n        message: `${propertyName} ${xapiValidationErrors.MUST_BE_STRING}`,\n        level:   localViolationType\n      });\n    }\n  } else if (isRequired) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace, propertyName),\n      message: `${propertyName} ${xapiValidationErrors.MUST_BE_PRESENT}`,\n      level:   localViolationType\n    });\n  }\n\n  return localErrors;\n}\n\nfunction validatePropertyIsUri(target, propertyName, trace, errors, isRequired) {\n  var localErrors, localTrace, propValue;\n\n  localErrors = errors || [];\n  localTrace  = trace  || '';\n  propValue   = target[propertyName];\n\n  if (propValue !== undefined) {\n    if (propValue === null || !xapiValidationUtils.isString(propValue)) {\n      localErrors.push({\n        trace:   xapiValidationUtils.localTraceToString(localTrace, propertyName),\n        message: `${propertyName} ${xapiValidationErrors.MUST_BE_URI_STRING}`,\n        level:   xapiErrorLevels.MUST_VIOLATION\n      });\n    } else if (!xapiValidationRegex.IRI.test(propValue)) {\n      localErrors.push({\n        trace:  xapiValidationUtils.localTraceToString(localTrace, propertyName),\n        message: `${propertyName} ${xapiValidationErrors.MUST_BE_IRI_STRING}`,\n        level:   xapiErrorLevels.SHOULD_VIOLATION\n      });\n    }\n  } else if (isRequired) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace, propertyName),\n      message: `${propertyName} ${xapiValidationErrors.MUST_BE_URI_PRESENT}`,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n  }\n  return localErrors;\n}\n\nfunction validatePropertyIsUrl(target, propertyName, trace, errors, isRequired) {\n  // TODO - check whether a formal URL format definition is recommended/enforced for xAPI\n  return validatePropertyIsString(target, propertyName, trace, errors, isRequired);\n}\n\nfunction validatePropertyIsBoolean(parent, propertyName, trace, errors, isRequired) {\n  var localErrors, localTrace, propValue;\n\n  localErrors = errors || [];\n  localTrace  = trace  || '';\n  propValue   = parent[propertyName];\n\n  if (propValue !== undefined) {\n    if (propValue === null || !xapiValidationUtils.isBoolean(propValue)) {\n      localErrors.push({\n        trace:   xapiValidationUtils.localTraceToString(localTrace, propertyName),\n        message: `${propertyName} ${xapiValidationErrors.MUST_BE_BOOLEAN}`,\n        level:   xapiErrorLevels.MUST_VIOLATION\n      });\n    }\n  } else if (isRequired) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace, propertyName),\n      message: `${propertyName} ${xapiValidationErrors.MUST_BE_BOOLEAN_PRESENT}`,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n  }\n  return localErrors;\n}\n\nfunction validatePropertyIsNumber(parent, propertyName, trace, errors, isRequired) {\n  var localErrors, localTrace, propValue;\n\n  localErrors = errors || [];\n  localTrace  = trace  || '';\n  propValue   = parent[propertyName];\n\n    if (propValue !== undefined) {\n      if (propValue === null || !xapiValidationUtils.isNumber(propValue)) {\n        localErrors.push({\n          trace:   xapiValidationUtils.localTraceToString(localTrace, propertyName),\n          message: `${propertyName} ${xapiValidationErrors.MUST_BE_NUMBER}`,\n          level:   xapiErrorLevels.MUST_VIOLATION\n        });\n      }\n    } else if (isRequired) {\n      localErrors.push({\n        trace:   xapiValidationUtils.localTraceToString(localTrace, propertyName),\n        message: `${propertyName} ${xapiValidationErrors.MUST_BE_NUMBER_PRESENT}`,\n        level:   xapiErrorLevels.MUST_VIOLATION\n      });\n    }\n    return localErrors;\n}\n\nfunction validateIFIProperties(target, trace, errors) {\n  var localErrors, localTrace, accountTrace;\n\n  localErrors = errors || [];\n  localTrace  = trace  || '';\n\n  if (target.mbox !== undefined && target.mbox !== null) {\n    if (!xapiValidationUtils.isString(target.mbox)) {\n      localErrors.push({\n        trace: xapiValidationUtils.localTraceToString(localTrace, properties.MBOX),\n        message: xapiValidationErrors.IFI_MUST_BE_MBOX_URI,\n        level: xapiErrorLevels.MUST_VIOLATION\n      });\n    } else if (!xapiValidationRegex.MAILTO_URI.test(target.mbox)) {\n      localErrors.push({\n        trace:   xapiValidationUtils.localTraceToString(localTrace, properties.MBOX),\n        message: xapiValidationErrors.IFI_MUST_BE_VALID_MBOX_FORMAT,\n        level:   xapiErrorLevels.MUST_VIOLATION\n      });\n    }\n  }\n\n  validatePropertyIsString(target, properties.MBOX_SHA_1_SUM, localTrace, localErrors,  /*isRequired*/false);\n  validatePropertyIsUri(target, properties.OPEN_ID, localTrace, localErrors, /*isRequired*/false);\n\n  if (target.account !== undefined && target.account !== null) {\n    accountTrace = xapiValidationUtils.addPropToTrace(localTrace, properties.ACCOUNT);\n    validatePropertyIsUri(target.account, properties.HOME_PAGE,accountTrace, localErrors, /*isRequired*/true);\n    validatePropertyIsString(target.account, properties.NAME, accountTrace, localErrors, /*isRequired*/true);\n    validateAbsenceOfNonWhitelistedProperties(target.account, xapiWhiteListProperties.IFI, accountTrace, localErrors);\n  }\n\n  return localErrors;\n}\n\nfunction getIFIs(target) {\n  var ifis;\n\n  if (target === null || target === undefined) {return [];}\n\n  ifis = xapiValidationIfiPropertyNames.filter((name) => {\n    if (target[name] !== undefined && target[name] !== null) {\n      return {key: name, value: target[name]};\n    }\n  });\n\n  return ifis;\n}\n\nfunction getIFICount(target) {\n  return getIFIs(target).length;\n}\n\nfunction validateExtensions(extensions, trace, errors) {\n  var localErrors, localTrace;\n\n  localErrors = errors || [],\n  localTrace  = trace  || properties.EXTENSIONS;\n\n  if (extensions === undefined) {return localErrors;}\n\n  if (!xapiValidationUtils.isNonNullMapObject(extensions)) {\n    localErrors.push({\n      trace:   localTrace,\n      message: xapiValidationErrors.EXTENSIONS_MUST_NOT_BE_NULL,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n  }\n  // TODO - double-check what further enforceable constraints exist on extension object properties\n  return localErrors;\n}\n\nfunction validateLanguageMap(languageMap, trace, errors) {\n  var localErrors, localTrace, propName, mappedValue;\n\n  localErrors = errors || [];\n  localTrace  = trace  || properties.LANGUAGE_MAP;\n\n  if (languageMap === undefined) {return localErrors;}\n\n  if (!xapiValidationUtils.isNonNullMapObject(languageMap)) {\n    localErrors.push({\n      trace:   xapiValidationUtils.addPropToTrace(localTrace),\n      message: xapiValidationErrors.LANGUAGE_MAPS_MUST_NOT_BE_NULL,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n\n    return localErrors;\n  }\n\n  for (propName in languageMap) {\n\n    if (languageMap.hasOwnProperty(propName)) {\n      if (!xapiValidationUtils.isValidLanguageTag(propName, xapiValidationRegex.BCP_47)) {\n        localErrors.push({\n          trace:   xapiValidationUtils.addPropToTrace(localTrace, propName),\n          message: `${propName} ${xapiValidationErrors.LANGUAGE_MAP_KEY_INVALID}`,\n          level:   xapiErrorLevels.MUST_VIOLATION\n        });\n      }\n\n      mappedValue = languageMap[propName];\n\n      if (mappedValue === null || mappedValue === undefined || !xapiValidationUtils.isString(mappedValue)) {\n        localErrors.push({\n          trace:   xapiValidationUtils.addLookupToTrace(localTrace, propName),\n          message: `${propName} ${xapiValidationErrors.LANGUAGE_MAP_KEY_MUST_BE_STRING}`,\n          level:   xapiErrorLevels.MUST_VIOLATION\n        });\n      }\n    }\n  }\n\n  return localErrors;\n}\n\nfunction validateVerb(verb, trace, errors) {\n  var localErrors, localTrace;\n\n  localErrors = errors || [];\n  localTrace  = trace  || properties.VERB;\n\n  if (verb === undefined) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace),\n      message: xapiValidationErrors.VERB_MUST_BE_PROVIDED,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n\n    return localErrors;\n  }\n\n  if (!xapiValidationUtils.isNonNullMapObject(verb)) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace),\n      message: xapiValidationErrors.VERB_MUST_NOT_BE_NULL,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n\n    return localErrors;\n  }\n\n  validatePropertyIsUri(verb, properties.ID, localTrace, localErrors,  /*isRequired*/true);\n\n  if (verb.display === undefined) {\n    localErrors.push({\n      trace:   xapiValidationUtils.addPropToTrace(localTrace, properties.DISPLAY),\n      message: xapiValidationErrors.DISPLAY_SHOULD_BE_PROVIDED,\n      level:   xapiErrorLevels.SHOULD_VIOLATION\n    });\n  } else {\n    validateLanguageMap(verb.display, xapiValidationUtils.addPropToTrace(localTrace, properties.DISPLAY), localErrors);\n  }\n\n  validateAbsenceOfNonWhitelistedProperties(verb, xapiWhiteListProperties.URI, localTrace, localErrors);\n\n  return localErrors;\n}\n\nfunction validateInteractionComponentArray(components, interactionType, allowedInteractionTypes, trace, errors) {\n  var localErrors, localTrace, isAllowedComponentType, ids, perComponentTrace;\n\n  localErrors            = errors || [];\n  localTrace             = trace  || properties.INTERACTION_COMPONENTS;\n  isAllowedComponentType = allowedInteractionTypes.indexOf(interactionType) !== xapiGeneral.NO_INDEX_FOUND;\n  ids                    = [];\n\n  if (isAllowedComponentType && components !== undefined) {\n    if (components === null || !xapiValidationUtils.isArray(components)) {\n      localErrors.push({\n        trace:   localTrace,\n        message: xapiValidationErrors.INTERACTION_COMPONENT_SHOULD_BE_ARRAY,\n        level:   xapiErrorLevels.SHOULD_VIOLATION\n      });\n    } else {\n      components.forEach((interactionComponent, i) => {\n        perComponentTrace = xapiValidationUtils.addLookupToTrace(localTrace, i);\n\n        if (!xapiValidationUtils.isNonNullMapObject(interactionComponent)) {\n          localErrors.push({\n            trace:   perComponentTrace,\n            message: xapiValidationErrors.INTERACTION_COMPONENT_MUST_NOT_BE_NULL,\n            level:   xapiErrorLevels.MUST_VIOLATION\n          });\n        } else {\n          validatePropertyIsString(interactionComponent, properties.ID, perComponentTrace, localErrors, /*isRequired*/true, xapiErrorLevels.MUST_VIOLATION);\n          if (ids.indexOf(interactionComponent.id) !== xapiGeneral.NO_INDEX_FOUND) {\n            localErrors.push({\n              trace:   xapiValidationUtils.addPropToTrace(perComponentTrace, properties.ID),\n              message: xapiValidationErrors.ID_MUST_BE_UNIQUE,\n              level:   xapiErrorLevels.MUST_VIOLATION\n            });\n          } else {\n            ids.push(interactionComponent.id);\n          }\n\n          if (interactionComponent.id && xapiValidationRegex.CONTAINS_WHITESPACE.test(interactionComponent.id)) {\n            localErrors.push({\n              trace:   xapiValidationUtils.addPropToTrace(perComponentTrace, properties.ID),\n              message: xapiValidationErrors.ID_SHOULD_NOT_CONTAIN_WHITESPACES,\n              level:   xapiErrorLevels.SHOULD_VIOLATION\n            });\n          }\n\n          validateLanguageMap(interactionComponent.description, xapiValidationUtils.addPropToTrace(perComponentTrace, properties.DESCRIPTION), localErrors);\n          validateAbsenceOfNonWhitelistedProperties(interactionComponent, xapiWhiteListProperties.COMPONENT_ARRAY, perComponentTrace, localErrors);\n        }\n      });\n\n    }\n  } else if (interactionType && components) {\n    localErrors.push({\n      trace:   localTrace,\n      message: `${xapiValidationErrors.INTERACTION_TYPE_MUST_BE_VALID} ${interactionType}`,\n      level:   xapiErrorLevels.SHOULD_VIOLATION\n    });\n  }\n\n  return localErrors;\n}\n\nfunction validateActivityDefintion(definition, trace, errors) {\n  var localErrors, localTrace, correctResponsesPatternTrace;\n\n  localErrors                  = errors || [];\n  localTrace                   = trace  || properties.DEFINITION;\n  correctResponsesPatternTrace = xapiValidationUtils.addPropToTrace(localTrace, properties.CORRECT_RESPONSES_PATTERN);\n\n  if (!xapiValidationUtils.isNonNullMapObject(definition)) {\n    localErrors.push({\n      trace:   xapiValidationUtils.addPropToTrace(localTrace),\n      message: xapiValidationErrors.DEFINITIONS_MUST_BE_OBJECTS,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n\n    return localErrors;\n  }\n\n  validateLanguageMap(definition.name, xapiValidationUtils.addPropToTrace(localTrace, properties.NAME), localErrors);\n  validateLanguageMap(definition.description, xapiValidationUtils.addPropToTrace(localTrace, properties.DESCRIPTION), localErrors);\n\n  validatePropertyIsUri(definition, properties.TYPE, localTrace, localErrors,  /*isRequired*/false);\n  validatePropertyIsUrl(definition, properties.MORE_INFO, localTrace, localErrors,  /*isRequired*/false);\n  validateExtensions(definition.extensions, xapiValidationUtils.addPropToTrace(localTrace, properties.EXTENSIONS), localErrors);\n\n  if (definition.interactionType !== undefined) {\n    if (definition.type !== xapiGeneral.INTERACTION_DEFINITION_TYPE) {\n      localErrors.push({\n        trace:   xapiValidationUtils.localTraceToString(localTrace, properties.TYPE),\n        message: `${xapiValidationErrors.INTERACTION_ACTIVITY_SHOULD_HAVE} \"${xapiGeneral.INTERACTION_DEFINITION_TYPE}\"`,\n        level:   xapiErrorLevels.SHOULD_VIOLATION\n      });\n    }\n\n    if (xapiValidationInteractionTypes.indexOf(definition.interactionType) === xapiGeneral.NO_INDEX_FOUND) {\n      localErrors.push({\n        trace:   xapiValidationUtils.localTraceToString(localTrace, properties.INTERACTION_TYPE),\n        message: xapiValidationErrors.INTERACTION_TYPE_MUST_BE_CMI,\n        level:   xapiErrorLevels.MUST_VIOLATION\n      });\n    }\n  }\n\n  if (definition.correctResponsesPattern !== undefined) {\n    if (!xapiValidationUtils.isArray(definition.correctResponsesPattern)) {\n      localErrors.push({\n        trace:   correctResponsesPatternTrace,\n        message: xapiValidationErrors.CORRECT_RESPONSES_PATTERN_MUST_BE_ARRAY,\n        level:   xapiErrorLevels.MUST_VIOLATION\n      });\n    } else {\n      definition.correctResponsesPattern.forEach((response, i) => {\n        if (response === null || response === undefined || !xapiValidationUtils.isString(response)) {\n          localErrors.push({\n            trace:   xapiValidationUtils.addLookupToTrace(correctResponsesPatternTrace, i),\n            message: xapiValidationErrors.CORRECT_RESPONSES_PATTERN_MUST_BE_STRINGS,\n            level:   xapiErrorLevels.MUST_VIOLATION\n          });\n        }\n      });\n    }\n  }\n\n  validateInteractionComponentArray(\n    definition.choices,\n    definition.interactionType,\n    [properties.CHOICE, properties.SEQUENCING],\n    xapiValidationUtils.addPropToTrace(localTrace, properties.CHOICES),\n    localErrors\n  );\n\n  validateInteractionComponentArray(\n    definition.scale,\n    definition.interactionType,\n    [properties.LIKERT],\n    xapiValidationUtils.addPropToTrace(localTrace, properties.SCALE),\n    localErrors\n  );\n\n  validateInteractionComponentArray(\n    definition.source,\n    definition.interactionType,\n    [properties.MATCHING],\n    xapiValidationUtils.addPropToTrace(localTrace, properties.SOURCE),\n    localErrors\n  );\n\n  validateInteractionComponentArray(\n    definition.target,\n    definition.interactionType,\n    [properties.MATCHING],\n    xapiValidationUtils.addPropToTrace(localTrace, properties.TARGET),\n    localErrors\n  );\n\n  validateInteractionComponentArray(\n    definition.steps,\n    definition.interactionType,\n    [properties.PERFORMANCE],\n    xapiValidationUtils.addPropToTrace(localTrace, properties.STEPS),\n    localErrors\n  );\n\n  validateAbsenceOfNonWhitelistedProperties(definition, xapiWhiteListProperties.ACTIVITY_DEFINITION, localTrace, localErrors);\n  return localErrors;\n}\n\nfunction validateActivity(activity, trace, errors) {\n  var localErrors, localTrace;\n\n  localErrors = errors || [];\n  localTrace  = trace  || properties.ACTIVITY;\n\n  if (!xapiValidationUtils.isNonNullMapObject(activity)) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace),\n      message: xapiValidationErrors.ACTIVITIES_MUST_NOT_BE_NULL,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n\n    return localErrors;\n  }\n\n  validatePropertyIsUri(activity, properties.ID, localTrace, localErrors,  /*isRequired*/true);\n\n  if (activity.definition !== undefined) {\n    validateActivityDefintion(\n      activity.definition,\n      xapiValidationUtils.addPropToTrace(localTrace, properties.DEFINITION),\n      localErrors\n    );\n  }\n\n  validateAbsenceOfNonWhitelistedProperties(activity, xapiWhiteListProperties.ACTIVITY, localTrace, localErrors);\n\n  return localErrors;\n}\n\nfunction validateStatementRef(statementRef, trace, errors) {\n  var localErrors, localTrace;\n\n  localErrors = errors || [];\n  localTrace  = trace  || properties.STATEMENT_REF;\n\n  if (!xapiValidationUtils.isNonNullMapObject(statementRef)) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace),\n      message: xapiValidationErrors.STATEMENT_REF_MUST_NOT_BE_NULL_MAP_OBJECTS,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n    return localErrors;\n  }\n\n\n  if (statementRef.objectType !== objectTypes.STATEMENT_REF) {\n    localErrors.push({\n      trace:   xapiValidationUtils.addPropToTrace(localTrace, properties.OBJECT_TYPE),\n      message: xapiValidationErrors.OBJECT_TYPE_MUST_BE_STATEMENT_REF,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n  }\n\n  if (!statementRef.id || !xapiValidationRegex.UUID.test(statementRef.id)) {\n    localErrors.push({\n      trace:   xapiValidationUtils.addPropToTrace(localTrace, properties.ID),\n      message: xapiValidationErrors.ID_MUST_BE_VALID_UUID_REF,\n      level:  xapiErrorLevels.MUST_VIOLATION\n    });\n  }\n\n  validateAbsenceOfNonWhitelistedProperties(statementRef, xapiWhiteListProperties.STATEMENT_REF, localTrace, localErrors);\n\n  return localErrors;\n}\n\nfunction validateScore(score, trace, errors) {\n  var localErrors, localTrace;\n\n  localErrors = errors || [];\n  localTrace  = trace  || properties.SCORE;\n\n  if (score === undefined) {\n      return localErrors;\n  }\n\n  validatePropertyIsNumber(score, properties.SCALED, localTrace, localErrors,  /*isRequired*/false);\n\n  if (score.scaled !== undefined) {\n    if (score.scaled < xapiGeneral.MIN_SCALED_VALUE || score.scaled > xapiGeneral.MAX_SCALED_VALUE) {\n      localErrors.push({\n        trace:   xapiValidationUtils.addPropToTrace(localTrace, properties.SCALED),\n        message: xapiValidationErrors.SCALED_MUST_BE_BETWEEN_0_1,\n        level:   xapiErrorLevels.MUST_VIOLATION\n      });\n    }\n  }\n\n  if (score.min !== undefined) {\n    validatePropertyIsNumber(score, properties.MIN, localTrace, localErrors,  /*isRequired*/false);\n\n      if (score.raw !== undefined && score.raw < score.min) {\n        localErrors.push({\n          trace:   xapiValidationUtils.addPropToTrace(localTrace, properties.RAW),\n          message: xapiValidationErrors.RAW_MUST_BE_GREATER_THAN_MIN,\n          level:   xapiErrorLevels.MUST_VIOLATION\n        });\n      }\n\n      if (score.max !== undefined && score.max < score.min) {\n        localErrors.push({\n          trace:   xapiValidationUtils.addPropToTrace(localTrace, properties.MAX),\n          message: xapiValidationErrors.MAX_MUST_BE_GREATER_THAN_MIN,\n          level:   xapiErrorLevels.MUST_VIOLATION\n        });\n      }\n  }\n\n  if (score.max !== undefined) {\n    validatePropertyIsNumber(score, properties.MAX, localTrace, localErrors,  /*isRequired*/false);\n\n    if (score.raw !== undefined && score.raw > score.max) {\n      localErrors.push({\n        trace:   xapiValidationUtils.addPropToTrace(localTrace, properties.RAW),\n        message: xapiValidationErrors.RAW_MUST_BE_LESS_THAN_MAX,\n        level:   xapiErrorLevels.MUST_VIOLATION\n      });\n    }\n  }\n\n  validatePropertyIsNumber(score, properties.RAW, localTrace, localErrors,  /*isRequired*/false);\n  validateAbsenceOfNonWhitelistedProperties(score, xapiWhiteListProperties.SCORE, localTrace, localErrors);\n\n  return localErrors;\n}\n\nfunction validateResult(result, trace, errors) {\n  var localErrors, localTrace;\n\n  localErrors = errors || [];\n  localTrace  = trace  || properties.RESULT;\n\n  if (result === undefined) {return localErrors;}\n\n  if (!xapiValidationUtils.isNonNullMapObject(result)) {\n    localErrors.push({\n      trace:   xapiValidationUtils.addPropToTrace(localTrace),\n      message: xapiValidationErrors.RESULT_MUST_BE_MAP_OBJECT,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n\n    return localErrors;\n  }\n\n  validateScore(result.score, xapiValidationUtils.addPropToTrace(localTrace, properties.SCORE), localErrors);\n  validatePropertyIsBoolean(result, properties.SUCCESS, localTrace, localErrors,  /*isRequired*/false);\n  validatePropertyIsBoolean(result, properties.COMPLETION, localTrace, localErrors,  /*isRequired*/false);\n  validatePropertyIsString(result, properties.RESPONSE, localTrace, localErrors,  /*isRequired*/false);\n  validateExtensions(result.extensions, xapiValidationUtils.addPropToTrace(localTrace, properties.EXTENSIONS), localErrors);\n\n  if (result.duration !== undefined && (result.duration === null || !xapiValidationUtils.isString(result.duration) || !xapiValidationRegex.ISO_8601_DURATION.test(result.duration))) {\n    localErrors.push({\n      trace:   xapiValidationUtils.addPropToTrace(localTrace, properties.DURATION),\n      message: xapiValidationErrors.DURATION_MUST_BE_VALID,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n  }\n\n  validateAbsenceOfNonWhitelistedProperties(result, xapiWhiteListProperties.RESULT, localTrace, localErrors);\n\n  return localErrors;\n}\n\nfunction validatePropertyIsISO8601String(parent, propertyName, trace, errors) {\n  var localErrors, localTrace, matched, datetime;\n\n  localErrors = errors || [];\n  localTrace  = trace  || properties.DATE_TIME;\n  datetime    = parent[propertyName];\n\n  if (datetime === undefined) {return localErrors;}\n\n  if (datetime === null || !xapiValidationUtils.isString(datetime)) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace, propertyName),\n      message: `${propertyName} ${xapiValidationErrors.MUST_BE_STRING}`,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n\n    return localErrors;\n  }\n\n  matched = xapiValidationRegex.ISO_8601_DATE_TIME.exec(datetime);\n\n  if (matched) {\n    if (!dateIncludesZoneInformation(matched)) {\n      localErrors.push({\n        trace:   xapiValidationUtils.localTraceToString(localTrace, propertyName),\n        message: xapiValidationErrors.DATE_SHOULD_INCLUDE_ZONE_INFORMATION,\n        level:   xapiErrorLevels.SHOULD_VIOLATION\n      });\n    }\n  } else {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace, propertyName),\n      message: xapiValidationErrors.DATE_MUST_BE_VALID,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n  }\n\n  return localErrors;\n}\n\nfunction validateVersion(version, trace, errors) {\n  var localErrors, localTrace;\n\n  localErrors = errors || [];\n  localTrace  = trace  || properties.VERSION;\n\n  if (version === undefined) {return localErrors;}\n\n  if (version === null || !xapiValidationUtils.isString(version) || !xapiValidationRegex.SEMVER_1_P_0_P_0.test(version)) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace),\n      message: xapiValidationErrors.VERSION_MUST_COMPLY_SEMANTIC_VERSIONING,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n  }\n\n  return localErrors;\n}\n\nfunction validateAttachmentObject(attachment, trace, errors) {\n  var localErrors, localTrace;\n\n  localErrors = errors || [];\n  localTrace  = trace || properties.ATTACHMENT;\n\n  if (!xapiValidationUtils.isNonNullMapObject(attachment)) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace),\n      message: xapiValidationErrors.ATTACHMENTS_MUST_NOT_BE_NULL_MAP_OBJECTS,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n\n    return localErrors;\n  }\n\n  if (attachment.display === undefined) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace, properties.DISPLAY),\n      message: xapiValidationErrors.DISPLAY_SHOULD_BE_PROVIDED,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n\n  } else {\n    validateLanguageMap(attachment.display, xapiValidationUtils.addPropToTrace(localTrace, properties.DISPLAY), localErrors);\n  }\n\n  validateLanguageMap(attachment.description, xapiValidationUtils.addPropToTrace(localTrace, properties.DESCRIPTION), localErrors);\n  validatePropertyIsUri(attachment, properties.USAGE_TYPE, localTrace, localErrors, /*isRequired*/true, xapiErrorLevels.MUST_VIOLATION);\n  validatePropertyIsUri(attachment, properties.FILE_URL, localTrace, localErrors,  /*isRequired*/false, xapiErrorLevels.MUST_VIOLATION);\n\n  // TODO - more complete validation for Internet Media Type via RFC 2046\n  validatePropertyIsString(attachment, properties.CONTENT_TYPE, localTrace, localErrors, /*isRequired*/true, xapiErrorLevels.MUST_VIOLATION);\n\n  if (attachment.length === undefined || attachment.length === null || !xapiValidationUtils.isNumber(attachment.length) || (attachment.length % 1 !== 0)) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace, properties.LENGTH),\n      message: xapiValidationErrors.LENGTH_MUST_BE_INTEGER,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n  }\n\n  if (attachment.sha2 === undefined) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace, properties.SHA2),\n      message: xapiValidationErrors.SHA2_MUST_BE_PROVIDED_ON_ATTACHMENT_OBJECTS,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n  } else if (attachment.sha2 === null || !xapiValidationUtils.isString(attachment.sha2) || !xapiValidationRegex.BASE_64.test(attachment.sha2)) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace, properties.SHA2),\n      message: xapiValidationErrors.SHA2_MUST_CONTAIN_BASE_64_STRING,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n  }\n\n  validateAbsenceOfNonWhitelistedProperties(attachment, xapiWhiteListProperties.ATTACHMENT, localTrace, localErrors);\n  return localErrors;\n}\n\nfunction validateAttachments(attachments, trace, errors) {\n  var localErrors, localTrace;\n\n  localErrors = errors || [];\n  localTrace  = trace  || properties.ATTACHMENTS;\n\n  if (attachments === undefined) {return localErrors;}\n\n  if (attachments === null || !xapiValidationUtils.isArray(attachments)) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace),\n      message: xapiValidationErrors.ATTACHMENTS_MUST_BE_NOT_NULL_ARRAY,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n\n    return localErrors;\n  }\n\n  attachments.forEach((attachment, i) => {\n    validateAttachmentObject(attachment, xapiValidationUtils.addLookupToTrace(localTrace, i), localErrors);\n  });\n\n  return localErrors;\n}\n\nfunction validateAgent(agent, trace, errors) {\n  var localErrors, localTrace, ifiCount;\n\n  localErrors = errors || [];\n  localTrace  = trace  || properties.AGENT;\n\n  if (!xapiValidationUtils.isNonNullMapObject(agent)) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace),\n      message: xapiValidationErrors.AGENT_MUST_BE_NON_NULL_MAP_OBJECT,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n    return localErrors;\n  }\n\n  ifiCount = getIFICount(agent);\n\n  if (ifiCount !== xapiGeneral.NUMER_OF_SPECIFIED_IFI_PROPERTIES) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace),\n      message: xapiValidationErrors.AGENT_IFI_PROPERTIES_MUST_BE_SPECIFIED,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n  }\n\n  if (agent.objectType === objectTypes.GROUP) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace),\n      message: xapiValidationErrors.AGENT_MUST_NOT_HAVE_GROUP_CHARACTERISTICS,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n  }\n\n  validateIFIProperties(agent, localTrace, localErrors);\n  validatePropertyIsString(agent, properties.NAME, localTrace, localErrors,  /*isRequired*/false);\n\n  validateAbsenceOfNonWhitelistedProperties(agent, xapiWhiteListProperties.AGENT, localTrace, localErrors);\n\n  return localErrors;\n}\n\nfunction validateGroup(group, trace, errors) {\n  var localErrors, localTrace, memberTrace, ifiCount;\n\n  localErrors = errors || [];\n  localTrace  = trace  || properties.GROUP;\n  memberTrace = xapiValidationUtils.addPropToTrace(localTrace, properties.MEMBER);\n\n  if (!xapiValidationUtils.isNonNullMapObject(group)) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace),\n      message: xapiValidationErrors.GROUP_MUST_BE_NON_NULL_MAP_OBJECT,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n\n    return localErrors;\n  }\n\n  ifiCount = getIFICount(group);\n\n  if (ifiCount === 0) {\n    if (group.member === null || group.member === undefined) {\n      localErrors.push({\n        trace:   memberTrace,\n        message: xapiValidationErrors.MEMBER_MUST_BE_PROVIDED_FOR_ANONYMOUS_GROUPS,\n        level:   xapiErrorLevels.MUST_VIOLATION\n      });\n    }\n  } else if (ifiCount > xapiGeneral.NUMER_OF_SPECIFIED_IFI_PROPERTIES) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace),\n      message: xapiValidationErrors.GROUP_IFI_PROPERTIES_MUST_BE_SPECIFIED,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n  }\n\n  validateIFIProperties(group, localTrace, localErrors);\n\n  validatePropertyIsString(group, properties.NAME, localTrace, localErrors,  /*isRequired*/false);\n\n  if (group.member !== undefined) {\n    if (group.member === null || !xapiValidationUtils.isArray(group.member)) {\n      localErrors.push({\n        trace:   xapiValidationUtils.localTraceToString(localTrace, properties.MEMBER),\n        message: xapiValidationErrors.GROUP_MEMBER_MUST_BE_ARRAY,\n        level:   xapiErrorLevels.MUST_VIOLATION\n      });\n    } else {\n      group.member.forEach((member, i) => {\n        validateAgent(member, xapiValidationUtils.addLookupToTrace(memberTrace, i), localErrors);\n      });\n    }\n  }\n\n  validateAbsenceOfNonWhitelistedProperties(group, xapiWhiteListProperties.GROUP, localTrace, localErrors);\n\n  return localErrors;\n}\n\nfunction validateActor(actor, trace, errors) {\n  var localErrors, localTrace;\n\n  localErrors = errors || [];\n  localTrace  = trace  || properties.ACTOR;\n\n  if (actor === null || actor === undefined) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace),\n      message: xapiValidationErrors.ACTOR_MUST_BE_PROVIDED,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n\n    return localErrors;\n  }\n\n  if (xapiValidationUtils.isGroup(actor, objectTypes.GROUP)) {\n    validateGroup(actor, localTrace, localErrors);\n  } else {\n    validateAgent(actor, localTrace, localErrors);\n  }\n\n  return localErrors;\n}\n\nfunction validateAuthority(authority, trace, errors) {\n  var localErrors, localTrace;\n\n  localErrors = errors || [];\n  localTrace  = trace  || properties.AUTHORITY;\n\n  if (authority === undefined) {\n    return localErrors;\n  }\n\n  if (!xapiValidationUtils.isNonNullMapObject(authority)) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace),\n      message: xapiValidationErrors.AUTHORITY_MUST_BE_NON_NULL_MAP_OBJECT,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n\n    return localErrors;\n  }\n  if (xapiValidationUtils.isGroup(authority, objectTypes.GROUP)) {\n    validateGroup(authority, localTrace, localErrors);\n    if (!authority.member || !authority.member.length || authority.member.length !== xapiGeneral.GROUP_AUTHORITY_AGENT_MEMBERS) {\n      localErrors.push({\n        trace:   xapiValidationUtils.localTraceToString(localTrace, properties.MEMBER),\n        message: xapiValidationErrors.GROUP_AUTHORITY_AGENT_MEMBERS_MUST_BE_TWO,\n        level:   xapiErrorLevels.MUST_VIOLATION\n      });\n    }\n  } else {\n    validateAgent(authority, localTrace, localErrors);\n  }\n\n  return localErrors;\n}\n\nfunction validateContextActivitySubContext(subContext, trace, errors) {\n  var localErrors, localTrace;\n\n  localErrors = errors || [];\n  localTrace  = trace  || properties.SUB_CONTEXT;\n\n  if (subContext === undefined) {return localErrors;}\n\n  if (subContext === null) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace),\n      message: xapiValidationErrors.CONTEXT_ACTIVITIES_MUST_NOT_BE_NULL,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n  } else if (xapiValidationUtils.isArray(subContext)) {\n    subContext.forEach((activity, i) => {\n      validateActivity(activity, xapiValidationUtils.addLookupToTrace(localTrace, i), localErrors);\n    });\n  } else if (xapiValidationUtils.isObject(subContext)) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace),\n      message: xapiValidationErrors.CONTEXT_ACTIVITIES_SHOULD_BE_AN_ARRAY,\n      level:   xapiErrorLevels.SHOULD_VIOLATION\n    });\n\n    validateActivity(subContext, localTrace, localErrors);\n  } else {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace),\n      message: xapiValidationErrors.CONTEXT_ACTIVITIES_MUST_BE_ARRAY_OR_ACTIVITY_OBJ,\n      level:   xapiErrorLevels.MUST_VIOLATION});\n  }\n  return localErrors;\n}\n\nfunction validateContextActivities(contextActivities, trace, errors) {\n  var localErrors, localTrace;\n\n  localErrors = errors || [];\n  localTrace  = trace  || properties.CONTEXT_ACTIVITIES;\n\n  if (contextActivities === undefined) {\n    return localErrors;\n  }\n\n  if (!xapiValidationUtils.isNonNullMapObject(contextActivities)) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace),\n      message: xapiValidationErrors.CONTEXT_ACTIVITIES_MUST_BE_NON_NULL_MAP_OBJECT,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n    return localErrors;\n  }\n\n  validateContextActivitySubContext(contextActivities.parent, xapiValidationUtils.addPropToTrace(localTrace, properties.PARENT), localErrors);\n  validateContextActivitySubContext(contextActivities.grouping, xapiValidationUtils.addPropToTrace(localTrace, properties.GROUPING), localErrors);\n  validateContextActivitySubContext(contextActivities.category, xapiValidationUtils.addPropToTrace(localTrace, properties.CATEGORY), localErrors);\n  validateContextActivitySubContext(contextActivities.other, xapiValidationUtils.addPropToTrace(localTrace, properties.OTHER), localErrors);\n\n  validateAbsenceOfNonWhitelistedProperties(contextActivities, xapiWhiteListProperties.CONTEXT_ACTIVITIES, localTrace, localErrors);\n\n  return localErrors;\n}\n\nfunction validateContext(context, trace, errors, statementObjectObjectType) {\n  var localErrors, localTrace;\n\n  localErrors = errors || [];\n  localTrace = trace || properties.CONTEXT;\n\n  if (context === undefined) {return localErrors;}\n\n  if (!xapiValidationUtils.isNonNullMapObject(context)) {\n    localErrors.push({\n      trace:   localTrace,\n      message: xapiValidationErrors.CONTEXT_MUST_BE_NON_NUL_MAP_OBJECT,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n\n    return localErrors;\n  }\n\n  if (context.registration !== undefined && (context.registration === null || !xapiValidationUtils.isString(context.registration) || !xapiValidationRegex.UUID.test(context.registration))) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace, properties.REGISTRATION),\n      message: xapiValidationErrors.REGISTRATION_MUST_BE_UUID_STRING,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n  }\n\n  if ([objectTypes.GROUP, objectTypes.AGENT].indexOf(statementObjectObjectType) !== xapiGeneral.NO_INDEX_FOUND) {\n    if (context.revision !== undefined) {\n      localErrors.push({\n        trace:   xapiValidationUtils.localTraceToString(localTrace, properties.REVISION),\n        message: xapiValidationErrors.REVISION_MUST_BE_AGENT_OR_GROUP,\n        level:   xapiErrorLevels.MUST_VIOLATION\n      });\n    }\n\n    if (context.platform !== undefined) {\n      localErrors.push({\n        trace:   xapiValidationUtils.localTraceToString(localTrace, properties.PLATFORM),\n        message: xapiValidationErrors.PLATFORM_MUST_NOT_BE_USED_WITH_REVISION_AGENT_OR_GROUP,\n        level:   xapiErrorLevels.MUST_VIOLATION\n      });\n    }\n  }\n\n  validatePropertyIsString(context, properties.REVISION, localTrace, localErrors, /*isRequired*/false, xapiErrorLevels.MUST_VIOLATION);\n  validatePropertyIsString(context, properties.PLATFORM, localTrace, localErrors, /*isRequired*/false, xapiErrorLevels.MUST_VIOLATION);\n\n  if (context.team !== undefined) {\n      validateGroup(context.team, xapiValidationUtils.addPropToTrace(localTrace, properties.TEAM), localErrors);\n  }\n\n  if (context.contextActivities !== undefined) {\n    validateContextActivities(context.contextActivities, xapiValidationUtils.addPropToTrace(localTrace, properties.CONTEXT_ACTIVITIES), localErrors);\n  }\n\n  if (context.language !== undefined && !xapiValidationUtils.isValidLanguageTag(context.language, xapiValidationRegex.BCP_47)) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace, properties.LANGUAGE),\n      message: xapiValidationErrors.LANGUAGE_MUST_BE_STRING,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n  }\n\n  if (context.statement !== undefined) {\n    validateStatementRef(context.statement, xapiValidationUtils.addPropToTrace(localTrace, properties.STATEMENT), localErrors);\n  }\n\n  if (context.instructor !== undefined) {\n    if (xapiValidationUtils.isGroup(context.instructor, objectTypes.GROUP)) {\n      validateGroup(context.instructor, xapiValidationUtils.addPropToTrace(localTrace, properties.INSTRUCTOR), localErrors);\n    } else {\n      validateAgent(context.instructor, xapiValidationUtils.addPropToTrace(localTrace, properties.INSTRUCTOR), localErrors);\n    }\n  }\n\n  validateExtensions(context.extensions, xapiValidationUtils.addPropToTrace(localTrace, properties.EXTENSIONS), localErrors);\n  validateAbsenceOfNonWhitelistedProperties(context, xapiWhiteListProperties.EXTENSIONS,localTrace,localErrors);\n\n  return localErrors;\n}\n\nfunction validateObject(object, trace, errors, isWithinSubStatement) {\n  var localErrors, localTrace, objectType;\n\n  localErrors = errors || [];\n  localTrace  = trace  || properties.OBJECT;\n\n  if (object === undefined) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace),\n      message: xapiValidationErrors.OBJECT_MUST_BE_DEFINED,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n\n    return localErrors;\n  }\n\n  if (!xapiValidationUtils.isNonNullMapObject(object)) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace),\n      message: xapiValidationErrors.OBJECT_MUST_BE_NON_NULL_MAP_OBJECT,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n\n    return localErrors;\n  }\n\n  validatePropertyIsString(object, properties.OBJECT_TYPE, localTrace, localErrors, /*isRequired*/true, xapiErrorLevels.SHOULD_VIOLATION);\n\n  objectType = object.objectType || objectTypes.ACTIVITY;\n\n  switch (objectType) {\n    case objectTypes.ACTIVITY:\n      validateActivity(object, localTrace, localErrors);\n      break;\n    case objectTypes.AGENT:\n      validateAgent(object, localTrace, localErrors);\n      break;\n    case objectTypes.GROUP:\n      validateGroup(object, localTrace, localErrors);\n      break;\n    case objectTypes.STATEMENT_REF:\n      validateStatementRef(object, localTrace, localErrors);\n      break;\n    case objectTypes.SUB_STATEMENT:\n      if (isWithinSubStatement) {\n        localErrors.push({\n          trace:   xapiValidationUtils.localTraceToString(localTrace, properties.OBJECT_TYPE),\n          message: xapiValidationErrors.SUB_STATEMENT_MUST_NOT_CONTAIN_SUB_STATEMENT,\n          level:   xapiErrorLevels.MUST_VIOLATION\n        });\n      }\n      validate(object, localTrace, localErrors,  /*isSubStatement*/true);\n      break;\n    default:\n      localErrors.push({\n        trace:   xapiValidationUtils.localTraceToString(localTrace, properties.OBJECT_TYPE),\n        message: `${xapiValidationErrors.OBJECT_TYPE_MUST_BE_VALID_OPTION} ${xApiValidObjectTypes.toString()}`,\n        level:   xapiErrorLevels.MUST_VIOLATION\n      });\n  }\n\n  return localErrors;\n}\n\nfunction validate(statement, trace, errors, isSubStatement) {\n  var localErrors, localTrace, statementObjectObjectType, whitelistedProperties;\n\n  localErrors = errors || [];\n  localTrace  = trace  || properties.STATEMENT;\n\n  whitelistedProperties = xapiWhiteListProperties.STATEMENT;\n\n  if (!xapiValidationUtils.isNonNullMapObject(statement)) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace),\n      message: xapiValidationErrors.STATEMENT_REF_MUST_NOT_BE_NULL_MAP_OBJECTS,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n\n    return localErrors;\n  }\n\n  if (!isSubStatement) {\n    if (statement.id === null || statement.id === undefined || !xapiValidationUtils.isString(statement.id)) {\n      localErrors.push({\n        trace:   xapiValidationUtils.localTraceToString(localTrace, properties.ID),\n        message: xapiValidationErrors.IDS_SHOULD_BE_GENERATED_BY_LRS,\n        level:   xapiErrorLevels.SHOULD_VIOLATION\n      });\n    } else if (!xapiValidationRegex.UUID.test(statement.id)) {\n      localErrors.push({\n        trace:   xapiValidationUtils.localTraceToString(localTrace, properties.ID),\n        message: xapiValidationErrors.ID_MUST_BE_VALID,\n        level:   xapiErrorLevels.MUST_VIOLATION\n      });\n    }\n  } else {\n    whitelistedProperties = xapiWhiteListProperties.SUB_STATEMENT;\n  }\n\n  validateActor(statement.actor, xapiValidationUtils.addPropToTrace(localTrace, properties.ACTOR), localErrors);\n  validateVerb(statement.verb, xapiValidationUtils.addPropToTrace(localTrace, properties.VERB), localErrors);\n  validateObject(statement.object, xapiValidationUtils.addPropToTrace(localTrace, properties.OBJECT), localErrors, isSubStatement);\n  validateResult(statement.result, xapiValidationUtils.addPropToTrace(localTrace, properties.RESULT), localErrors);\n\n  statementObjectObjectType = statement.object && statement.object.objectType ? statement.object.objectType : objectTypes.ACTIVITY;\n\n  validateContext(statement.context, xapiValidationUtils.addPropToTrace(localTrace, properties.CONTEXT), localErrors, statementObjectObjectType);\n  validatePropertyIsISO8601String(statement, properties.TIMESTAMP, localTrace, localErrors);\n  validatePropertyIsISO8601String(statement, properties.STORED, localTrace, localErrors);\n\n  validateAuthority(statement.authority, xapiValidationUtils.addPropToTrace(localTrace, properties.AUTHORITY), localErrors);\n  validateVersion(statement.version, xapiValidationUtils.addPropToTrace(localTrace, properties.VERSION), localErrors);\n  validateAttachments(statement.attachments, xapiValidationUtils.addPropToTrace(localTrace, properties.ATTACHMENTS), localErrors);\n\n  validateAbsenceOfNonWhitelistedProperties(statement, whitelistedProperties, localTrace, localErrors);\n\n  return localErrors;\n}\n\nfunction makeStatementReport(statement) {\n  var localErrors;\n\n  localErrors = [];\n  validate(statement, properties.STATEMENT, localErrors,  /*isRequired*/false);\n\n  return makeV1Report(statement, localErrors);\n}\n\nfunction validateAmbiguousTypeStatement(statement) {\n  var statementObject;\n\n  if (statement === undefined) {\n    return makeV1SingleErrorReport(/*instance*/null, {\n      trace:   properties.STATEMENT,\n      message: xapiValidationErrors.STATEMENT_ARGUMENT_MUST_BE_PROVIDED,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n  }\n\n  if (statement === null) {\n    return makeV1SingleErrorReport(/*instance*/null, {\n      trace:   properties.STATEMENT,\n      message: xapiValidationErrors.STATEMENT_MUST_NOT_BE_NULL,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n  }\n\n  if (xapiValidationUtils.isString(statement)) {\n    try {\n      statementObject = JSON.parse(statement);\n      if (statementObject === null || !xapiValidationUtils.isObject(statementObject) || xapiValidationUtils.isArray(statementObject)) {\n        return makeV1SingleErrorReport(statementObject, {\n          trace:   properties.STATEMENT,\n          message: xapiValidationErrors.STATEMENT_MUST_BE_PARSED_CORRECTLY,\n          level:   xapiErrorLevels.MUST_VIOLATION\n        });\n      }\n    } catch (e) {\n      return makeV1SingleErrorReport(statementObject, {\n        trace:   properties.STATEMENT,\n        message: `${xapiValidationErrors.INVALID_JSON}: ${e.message}`,\n        level:   xapiErrorLevels.MUST_VIOLATION\n      });\n    }\n\n    return makeStatementReport(statementObject);\n  }\n\n  if (xapiValidationUtils.isObject(statement) && !xapiValidationUtils.isArray(statement)) {\n    return makeStatementReport(statement);\n  }\n\n  return makeV1SingleErrorReport(/*instance*/null, {\n    trace:   properties.STATEMENT,\n    message: xapiValidationErrors.STATEMENT_ARGUMENT_IS_NOT_VALID,\n    level:   xapiErrorLevels.MUST_VIOLATION\n  });\n}\n\nfunction dateIncludesZoneInformation(matched) {\n  return matched[dateFormatRegexPositions.ZONE] ||\n          (matched[dateFormatRegexPositions.RELATIVE_TIME] && matched[dateFormatRegexPositions.TIME_ZONE_HOUR]);\n}\n\nxapiValidation = {\n  validateStatement: validateAmbiguousTypeStatement\n};\n\nmodule.exports = xapiValidation;\n","import {_} from 'underscore';\nimport {expect} from 'chai';\nimport {xapiValidator} from '../src/xapiValidator';\n// var xapiValidator = require('../xapiValidator');\n\ndescribe(\"xapiValidator\", function() {\n  describe(\"#validateStatement\", function() {\n\n    function reportHasErrorWithTracePrefix(report, prefix, targetLevel) {\n      if (report === null || report === undefined || report.errors === null || report.errors === undefined) {\n        return false;\n      }\n      var hasTargetLevel = targetLevel !== null && targetLevel !== undefined;\n      return _.any(report.errors, function(err) {\n        var foundPrefix = err.trace.indexOf(prefix) === 0;\n        return hasTargetLevel ? targetLevel === err.level && foundPrefix : foundPrefix;\n      });\n    }\n\n    describe(\"when passed no arguments\", function() {\n      it(\"returns non-null report\", function() {\n        var result = xapiValidator.validateStatement();\n        expect(result).to.be.not.null;\n        expect(result).to.be.a(\"Object\");\n      });\n\n      it(\"includes one error\", function() {\n        var result = xapiValidator.validateStatement();\n        var errors = result.errors;\n        expect(errors).to.be.instanceOf(Array);\n        expect(errors).to.have.length(1);\n        expect(errors[0]).to.have.property(\"message\")\n          .that.is.a('string')\n          .that.equals('No statement argument provided.');\n        expect(errors[0]).to.have.property(\"level\")\n          .that.equals(\"MUST_VIOLATION\");\n      });\n\n      it(\"has a null instance property in the report\", function() {\n        expect(xapiValidator.validateStatement())\n          .to.have.property(\"instance\")\n            .that.is.null;\n      });\n    });\n\n    describe(\"when passed a null argument\", function() {\n      it(\"returns non-null report\", function() {\n        var result = xapiValidator.validateStatement(null);\n        expect(result).to.be.not.null;\n        expect(result).to.be.a(\"Object\");\n        expect(result).to.have.property(\"errors\")\n          .that.is.a(\"Array\");\n        expect(result).to.have.property(\"instance\");\n      });\n\n      it(\"includes one error\", function() {\n        var result = xapiValidator.validateStatement(null);\n        var errors = result.errors;\n        expect(errors).to.be.instanceOf(Array);\n        expect(errors).to.have.length(1);\n        expect(errors[0]).to.have.property(\"message\")\n          .that.is.a('string')\n          .that.equals('Null statement argument provided.');\n        expect(errors[0]).to.have.property(\"level\")\n          .that.equals(\"MUST_VIOLATION\");\n      });\n\n      it(\"has a null instance property in the report\", function() {\n        expect(xapiValidator.validateStatement(null))\n          .to.have.property(\"instance\")\n            .that.is.null;\n      });\n    });\n\n    describe(\"when passed a json string argument\", function() {\n      var minimalJsonString = \"{\\\"id\\\":\\\"whatever\\\"}\";\n      it(\"returns non-null report\", function() {\n        var result = xapiValidator.validateStatement(minimalJsonString);\n        expect(result).to.be.not.null;\n        expect(result).to.be.a(\"Object\");\n        expect(result).to.have.property(\"errors\")\n          .that.is.a(\"Array\");\n        expect(result).to.have.property(\"instance\");\n      });\n\n      it(\"has an instance property with the deserialized JSON in the report\", function() {\n        var result = xapiValidator.validateStatement(minimalJsonString);\n        expect(result).to.have.property(\"instance\")\n          .that.is.an(\"Object\")\n          .that.deep.equals({\"id\":\"whatever\"});\n      });\n    });\n\n    describe(\"when passed a json string argument encoding null\", function() {\n      var minimalJsonString = \"null\";\n      it(\"returns non-null report\", function() {\n        var result = xapiValidator.validateStatement(minimalJsonString);\n        expect(result).to.be.not.null;\n        expect(result).to.be.a(\"Object\");\n        expect(result).to.have.property(\"errors\")\n          .that.is.a(\"Array\");\n        expect(result).to.have.property(\"instance\");\n      });\n\n      it(\"includes one error\", function() {\n        var result = xapiValidator.validateStatement(minimalJsonString);\n        var errors = result.errors;\n        expect(errors).to.be.instanceOf(Array);\n        expect(errors).to.have.length(1);\n        expect(errors[0]).to.have.property(\"message\");\n        expect(errors[0]).to.have.property(\"level\")\n          .that.equals(\"MUST_VIOLATION\");\n      });\n\n      it(\"has an instance property with null value\", function() {\n        var result = xapiValidator.validateStatement(minimalJsonString);\n        expect(result).to.have.property(\"instance\")\n          .that.is.null;\n      });\n    });\n\n    describe(\"when passed an invalid json string argument\", function() {\n      var minimalJsonString = \"derp\";\n      it(\"returns non-null report\", function() {\n        var result = xapiValidator.validateStatement(minimalJsonString);\n        expect(result).to.be.not.null;\n        expect(result).to.be.a(\"Object\");\n        expect(result).to.have.property(\"errors\")\n          .that.is.a(\"Array\");\n        expect(result).to.have.property(\"instance\");\n      });\n\n      it(\"includes one error\", function() {\n        var result = xapiValidator.validateStatement(minimalJsonString);\n        var errors = result.errors;\n        expect(errors).to.be.instanceOf(Array);\n        expect(errors).to.have.length(1);\n        expect(errors[0]).to.have.property(\"message\");\n        expect(errors[0]).to.have.property(\"level\")\n          .that.equals(\"MUST_VIOLATION\");\n      });\n\n      it(\"has an instance property with null value\", function() {\n        var result = xapiValidator.validateStatement(minimalJsonString);\n        expect(result).to.have.property(\"instance\")\n          .that.is.null;\n      });\n    });\n\n    describe(\"when passed a statement object\", function() {\n      var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n          actor : {mbox:\"mailto:agent@example.com\"},\n          verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n          object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"}};\n      it(\"returns non-null report\", function() {\n        var result = xapiValidator.validateStatement(inputStatement);\n        expect(result).to.be.not.null;\n        expect(result).to.be.a(\"Object\");\n        expect(result).to.have.property(\"errors\")\n          .that.is.a(\"Array\");\n        expect(result).to.have.property(\"instance\");\n      });\n\n      it(\"has an instance property that matches the input object\", function() {\n        var result = xapiValidator.validateStatement(inputStatement);\n        expect(result).to.have.property(\"instance\")\n          .that.deep.equals(inputStatement);\n      });\n    });\n\n    describe(\"when given a null id property\", function() {\n      var inputStatement = {id : null ,\n          actor : {mbox:\"mailto:agent@example.com\"},\n          verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n          object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"}};\n      it(\"has an error about the id property\", function() {\n        var result = xapiValidator.validateStatement(inputStatement);\n        expect(reportHasErrorWithTracePrefix(result, \"statement.id\")).to.be.true;\n      });\n    });\n\n    describe(\"when given an invalid UUID id property\", function() {\n      var inputStatement = {id : \"abc123\",\n          actor : {mbox:\"mailto:agent@example.com\"},\n          verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n          object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"}};\n      it(\"has an error about the id property\", function() {\n        var result = xapiValidator.validateStatement(inputStatement);\n        expect(reportHasErrorWithTracePrefix(result, \"statement.id\")).to.be.true;\n      });\n    });\n\n    describe(\"when given a valid UUID id property\", function() {\n      var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\",\n          actor : {mbox:\"mailto:agent@example.com\"},\n          verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n          object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"}};\n      it(\"has an error about the id property\", function() {\n        var result = xapiValidator.validateStatement(inputStatement);\n        expect(reportHasErrorWithTracePrefix(result, \"statement.id\")).to.be.false;\n      });\n    });\n\n    describe(\"when given a null actor property\", function() {\n      var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n          actor : null,\n          verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n          object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"}};\n      it(\"has an error about the actor property\", function() {\n        var result = xapiValidator.validateStatement(inputStatement);\n        expect(reportHasErrorWithTracePrefix(result, \"statement.actor\")).to.be.true;\n      });\n    });\n\n    describe(\"when given an empty non-null actor property\", function() {\n      var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n          actor : {},\n          verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n          object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"}};\n      it(\"has an error about the actor property\", function() {\n        var result = xapiValidator.validateStatement(inputStatement);\n        expect(reportHasErrorWithTracePrefix(result, \"statement.actor\")).to.be.true;\n      });\n    });\n\n    describe(\"when given an otherwise valid actor\", function() {\n      var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n          actor : {mbox:\"mailto:group@example.com\"},\n          verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n          object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"}};\n      it(\"the name property is optional\", function() {\n        var result = xapiValidator.validateStatement(inputStatement);\n        expect(result.errors).to.have.property(\"length\", 0);\n      });\n\n      it(\"the name property produces no errors when a simple string\", function() {\n        inputStatement.actor.name = \"hello\";\n        var result = xapiValidator.validateStatement(inputStatement);\n        expect(result.errors).to.have.property(\"length\", 0);\n      });\n\n      it(\"the name property produces no errors when a simple string\", function() {\n        inputStatement.actor.name = 1.23;\n        var result = xapiValidator.validateStatement(inputStatement);\n        expect(reportHasErrorWithTracePrefix(result, \"statement.actor.name\")).to.be.true;\n        expect(result.errors).to.have.property(\"length\", 1);\n      });\n    });\n\n    describe(\"when given an actor with an objectType of 'Group'\", function() {\n      var moreValidStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n          actor : {objectType:\"Group\", member:[]},\n          verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n          object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"}};\n      it(\"the member property has no errors about it when present\", function() {\n        var result = xapiValidator.validateStatement(moreValidStatement);\n        expect(reportHasErrorWithTracePrefix(result, \"statement.actor.member\")).to.be.false;\n      });\n\n      it(\"the member property is required to be present if the actor is unidentified, and produces an error when absent\", function() {\n        var inputInvalidStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n          actor : {objectType:\"Group\"},\n          verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n          object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"}};\n        var result = xapiValidator.validateStatement(inputInvalidStatement);\n        expect(reportHasErrorWithTracePrefix(result, \"statement.actor.member\")).to.be.true;\n      });\n\n      it(\"the member property is not required to be present if the actor is identified\", function() {\n        var result = xapiValidator.validateStatement({id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n          actor : {objectType:\"Group\", mbox:\"mailto:group@example.com\"},\n          verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n          object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"}});\n        expect(reportHasErrorWithTracePrefix(result, \"statement.actor.member\")).to.be.false;\n      });\n\n      it(\"the member property is allowed to be present if the actor is identified\", function() {\n        var result = xapiValidator.validateStatement({id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\",\n          actor : {objectType:\"Group\", mbox:\"mailto:group@example.com\", member:[]},\n          verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n          object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"}});\n        expect(reportHasErrorWithTracePrefix(result, \"statement.actor.member\")).to.be.false;\n      });\n    });\n\n    describe(\"when given an actor with a members property\", function() {\n      var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n          actor : {member:[]},\n          verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n          object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"}};\n      it(\"the member property has no errors about it when present but empty\", function() {\n        expect(xapiValidator.validateStatement(inputStatement).errors).to.be.empty;\n      });\n\n      it(\"the member property has no errors when populated with a simple agent\", function() {\n        inputStatement.actor.member = [{mbox:\"mailto:group@example.com\"}];\n        expect(xapiValidator.validateStatement(inputStatement).errors).to.be.empty;\n      });\n\n      it(\"the member property reports an error when populated with a Group object via objectType\", function() {\n        inputStatement.actor.member = [{mbox:\"mailto:group@example.com\", objectType:\"Group\"}];\n        expect(xapiValidator.validateStatement(inputStatement).errors)\n          .to.have.property(\"length\", 1);\n      });\n\n      it(\"the member property's agent reports an error when given an account missing its homePage\", function() {\n        inputStatement.actor.member = [{account:{name:\"bob\"}}];\n        expect(reportHasErrorWithTracePrefix(xapiValidator.validateStatement(inputStatement), \"statement.actor.member[0].account.homePage\")).to.be.true;\n      });\n\n      it(\"the member property's agent reports an error when given an account missing its name\", function() {\n        inputStatement.actor.member = [{account:{homePage:\"http://example.com\"}}];\n        expect(reportHasErrorWithTracePrefix(xapiValidator.validateStatement(inputStatement), \"statement.actor.member[0].account.name\")).to.be.true;\n      });\n\n      it(\"the member property's agent reports an error when given an account with an all-lowercase homepage\", function() {\n        inputStatement.actor.member = [{account:{homepage:\"http://example.com\", name:\"bob\"}}];\n        var report = xapiValidator.validateStatement(inputStatement);\n        expect(reportHasErrorWithTracePrefix(report, \"statement.actor.member[0].account.homepage\")).to.be.true;\n        expect(report.errors)\n          .to.have.property(\"length\", 2);\n      });\n\n      it(\"the member property's agent reports no error when given a full account\", function() {\n        inputStatement.actor.member = [{account:{homePage:\"http://example.com\", name: \"bob\"}}];\n        expect(xapiValidator.validateStatement(inputStatement).errors)\n          .to.have.property(\"length\", 0);\n      });\n\n      it(\"the member property's agent reports no error when given a valid mbox\", function() {\n        inputStatement.actor.member = [{mbox:\"mailto:bob@example.com\"}];\n        expect(xapiValidator.validateStatement(inputStatement).errors)\n          .to.have.property(\"length\", 0);\n      });\n\n      it(\"the member property's agent reports an error when given an invalid mbox\", function() {\n        inputStatement.actor.member = [{mbox:\"SOMETHINGWRONG:bob@example.com\"}];\n        var results = xapiValidator.validateStatement(inputStatement);\n        expect(reportHasErrorWithTracePrefix(results, \"statement.actor.member[0].mbox\")).to.be.true;\n        expect(results.errors).to.have.property(\"length\", 1);\n      });\n\n      it(\"the member property reports an error when populated with a Group object via member\", function() {\n        inputStatement.actor.member = [{mbox:\"mailto:group@example.com\", member:[]}];\n        expect(xapiValidator.validateStatement(inputStatement).errors)\n          .to.have.property(\"length\", 1);\n      });\n\n    });\n\n    describe(\"when given a statement without a verb property\", function() {\n      it(\"reports an error\", function() {\n        var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n          actor : {member:[]},\n          object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"}};\n        var results = xapiValidator.validateStatement(inputStatement);\n        expect(results.errors).to.have.property(\"length\", 1);\n        expect(reportHasErrorWithTracePrefix(results, \"statement.verb\")).to.be.true;\n      });\n    });\n\n    describe(\"when given a verb without an id property\", function() {\n      it(\"reports an error\", function() {\n        var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n          actor : {member:[]},\n          verb: { \"display\":{\"en-US\":\"created\"}},\n          object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"}};\n        var results = xapiValidator.validateStatement(inputStatement);\n        expect(results.errors).to.have.property(\"length\", 1);\n        expect(reportHasErrorWithTracePrefix(results, \"statement.verb.id\", \"MUST_VIOLATION\")).to.be.true;\n      });\n    });\n\n    describe(\"when given a verb with a non-string id property\", function() {\n      it(\"reports an error\", function() {\n        var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n          actor : {member:[]},\n          verb: { \"id\":12.34, \"display\":{\"en-US\":\"created\"}},\n          object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"}};\n        var results = xapiValidator.validateStatement(inputStatement);\n        expect(results.errors).to.have.property(\"length\", 1);\n        expect(reportHasErrorWithTracePrefix(results, \"statement.verb.id\", \"MUST_VIOLATION\")).to.be.true;\n      });\n    });\n\n    describe(\"when given a verb with a relative URI id property\", function() {\n      it(\"reports an SHOULD_VIOLATION error\", function() {\n        var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n          actor : {member:[]},\n          verb: { \"id\":\"fragment\", \"display\":{\"en-US\":\"created\"}},\n          object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"}};\n        var results = xapiValidator.validateStatement(inputStatement);\n        expect(results.errors).to.have.property(\"length\", 1);\n        expect(reportHasErrorWithTracePrefix(results, \"statement.verb.id\", \"SHOULD_VIOLATION\")).to.be.true;\n      });\n    });\n\n    describe(\"when given a verb without a display property\", function() {\n      it(\"reports an error\", function() {\n        var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n          actor : {member:[]},\n          verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\"},\n          object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"}};\n        var results = xapiValidator.validateStatement(inputStatement);\n        expect(results.errors).to.have.property(\"length\", 1);\n        expect(reportHasErrorWithTracePrefix(results, \"statement.verb.display\", \"SHOULD_VIOLATION\")).to.be.true;\n      });\n    });\n\n    describe(\"when given a verb with an empty display property\", function() {\n      it(\"reports no errors\", function() {\n        var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n          actor : {member:[]},\n          verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", display : {}},\n          object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"}};\n        expect(xapiValidator.validateStatement(inputStatement).errors).to.have.property(\"length\", 0);\n      });\n    });\n\n    describe(\"when given a verb.display with RFC 5646 key and string value\", function() {\n      it(\"reports no errors\", function() {\n        var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n          actor : {member:[]},\n          verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", display : {\"en-US\":\"created\"}},\n          object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"}};\n        expect(xapiValidator.validateStatement(inputStatement).errors).to.have.property(\"length\", 0);\n      });\n    });\n\n    describe(\"when given a verb.display with RFC 5646 key and non-string value\", function() {\n      it(\"reports an error\", function() {\n        var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n          actor : {member:[]},\n          verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", display : {\"en-US\": 1.23}},\n          object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"}};\n        var results = xapiValidator.validateStatement(inputStatement);\n        expect(results.errors).to.have.property(\"length\", 1);\n        expect(reportHasErrorWithTracePrefix(results, \"statement.verb.display[\\\"en-US\\\"]\", \"MUST_VIOLATION\")).to.be.true;\n      });\n    });\n\n    describe(\"when given a verb.display with invalid key and string value\", function() {\n      it(\"reports an error\", function() {\n        var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n          actor : {member:[]},\n          verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", display : {\"123totallyWrong\":\"created\"}},\n          object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"}};\n        var results = xapiValidator.validateStatement(inputStatement);\n        expect(results.errors).to.have.property(\"length\", 1);\n        expect(reportHasErrorWithTracePrefix(results, \"statement.verb.display.123totallyWrong\", \"MUST_VIOLATION\")).to.be.true;\n      });\n    });\n\n    describe(\"when the object property is absent\", function() {\n      it(\"reports a MUST_VIOLATION error\", function() {\n        var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n          actor : {member:[]},\n          verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", display : {\"en-US\":\"created\"}}};\n        var results = xapiValidator.validateStatement(inputStatement);\n        expect(results.errors).to.have.property(\"length\", 1);\n        expect(reportHasErrorWithTracePrefix(results, \"statement.object\", \"MUST_VIOLATION\")).to.be.true;\n      });\n    });\n\n    describe(\"when the object property is null\", function() {\n      it(\"reports a MUST_VIOLATION error\", function() {\n        var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n          actor : {member:[]},\n          verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", display : {\"en-US\":\"created\"}},\n          object : null};\n        var results = xapiValidator.validateStatement(inputStatement);\n        expect(results.errors).to.have.property(\"length\", 1);\n        expect(reportHasErrorWithTracePrefix(results, \"statement.object\", \"MUST_VIOLATION\")).to.be.true;\n      });\n    });\n\n    describe(\"when the object lacks an objectType property\", function() {\n      it(\"reports a SHOULD_VIOLATION error\", function() {\n        var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n          actor : {member:[]},\n          verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", display : {\"en-US\":\"created\"}},\n          object : {id : \"http://example.com/myUniqueId\"}};\n        var results = xapiValidator.validateStatement(inputStatement);\n        expect(results.errors).to.have.property(\"length\", 1);\n        expect(reportHasErrorWithTracePrefix(results, \"statement.object.objectType\", \"SHOULD_VIOLATION\")).to.be.true;\n      });\n    });\n\n    describe(\"when the object is an activity with a null definition property\", function() {\n      it(\"reports a MUST_VIOLATION error\", function() {\n        var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n          actor : {member:[]},\n          verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", display : {\"en-US\":\"created\"}},\n          object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\",\n            definition: null}};\n        var results = xapiValidator.validateStatement(inputStatement);\n        expect(results.errors).to.have.property(\"length\", 1);\n        expect(reportHasErrorWithTracePrefix(results, \"statement.object.definition\", \"MUST_VIOLATION\")).to.be.true;\n      });\n    });\n\n    describe(\"when the object is an activity with an array definition property\", function() {\n      it(\"reports a MUST_VIOLATION error\", function() {\n        var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n          actor : {member:[]},\n          verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", display : {\"en-US\":\"created\"}},\n          object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\",\n            definition: []}};\n        var results = xapiValidator.validateStatement(inputStatement);\n        expect(results.errors).to.have.property(\"length\", 1);\n        expect(reportHasErrorWithTracePrefix(results, \"statement.object.definition\", \"MUST_VIOLATION\")).to.be.true;\n      });\n    });\n\n    describe(\"when the object is an Activity with a definition\", function() {\n      it(\"an array for the name property produces a must violation error.\", function() {\n        var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n          actor : {member:[]},\n          verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", display : {\"en-US\":\"created\"}},\n          object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\",\n            definition:{name:[]}}};\n        var results = xapiValidator.validateStatement(inputStatement);\n        expect(results.errors).to.have.property(\"length\", 1);\n        expect(reportHasErrorWithTracePrefix(results, \"statement.object.definition.name\", \"MUST_VIOLATION\")).to.be.true;\n      });\n\n      it(\"a number for the name property produces a must violation error.\", function() {\n        var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n          actor : {member:[]},\n          verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", display : {\"en-US\":\"created\"}},\n          object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\",\n            definition:{name:1.23}}};\n        var results = xapiValidator.validateStatement(inputStatement);\n        expect(results.errors).to.have.property(\"length\", 1);\n        expect(reportHasErrorWithTracePrefix(results, \"statement.object.definition.name\", \"MUST_VIOLATION\")).to.be.true;\n      });\n\n      it(\"an invalid language Map key for the name property produces a must violation error.\", function() {\n        var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n          actor : {member:[]},\n          verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", display : {\"en-US\":\"created\"}},\n          object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\",\n            definition:{name:{\"123 totally not a language code\" : \"created\"}}}};\n        var results = xapiValidator.validateStatement(inputStatement);\n        expect(results.errors).to.have.property(\"length\", 1);\n        expect(reportHasErrorWithTracePrefix(results, \"statement.object.definition.name\", \"MUST_VIOLATION\")).to.be.true;\n      });\n\n      it(\"a CMI interactionType value produces no errors\", function() {\n        var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n          actor : {member:[]},\n          verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", display : {\"en-US\":\"created\"}},\n          object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\",\n            definition:{type:\"http://adlnet.gov/expapi/activities/cmi.interaction\", interactionType:\"true-false\"}}};\n        var results = xapiValidator.validateStatement(inputStatement);\n        expect(results.errors).to.have.property(\"length\", 0);\n        expect(reportHasErrorWithTracePrefix(results, \"statement.object.definition.name\", \"MUST_VIOLATION\")).to.be.false;\n      });\n\n\n\n      it(\"a non-CMI interactionType value produces an error\", function() {\n        var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n          actor : {member:[]},\n          verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", display : {\"en-US\":\"created\"}},\n          object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\",\n            definition:{type:\"http://adlnet.gov/expapi/activities/cmi.interaction\", interactionType:\"graphicGapMatchInteraction\"}}};\n        var results = xapiValidator.validateStatement(inputStatement);\n        expect(results.errors).to.have.property(\"length\", 1);\n        expect(reportHasErrorWithTracePrefix(results, \"statement.object.definition.interactionType\", \"MUST_VIOLATION\")).to.be.true;\n      });\n\n      it(\"a numeric correctResponsesPattern value produces an error\", function() {\n        var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n          actor : {member:[]},\n          verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", display : {\"en-US\":\"created\"}},\n          object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\",\n            definition:{correctResponsesPattern: 1.23}}};\n        var results = xapiValidator.validateStatement(inputStatement);\n        expect(results.errors).to.have.property(\"length\", 1);\n        expect(reportHasErrorWithTracePrefix(results, \"statement.object.definition.correctResponsesPattern\", \"MUST_VIOLATION\")).to.be.true;\n      });\n\n      it(\"a flat string correctResponsesPattern value produces an error\", function() {\n        var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n          actor : {member:[]},\n          verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", display : {\"en-US\":\"created\"}},\n          object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\",\n            definition:{correctResponsesPattern: \"1.23\"}}};\n        var results = xapiValidator.validateStatement(inputStatement);\n        expect(results.errors).to.have.property(\"length\", 1);\n        expect(reportHasErrorWithTracePrefix(results, \"statement.object.definition.correctResponsesPattern\", \"MUST_VIOLATION\")).to.be.true;\n      });\n\n      it(\"a nested number in a correctResponsesPattern Array value produces an error\", function() {\n        var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n          actor : {member:[]},\n          verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", display : {\"en-US\":\"created\"}},\n          object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\",\n            definition:{correctResponsesPattern: [1.23]}}};\n        var results = xapiValidator.validateStatement(inputStatement);\n        expect(results.errors).to.have.property(\"length\", 1);\n        expect(reportHasErrorWithTracePrefix(results, \"statement.object.definition.correctResponsesPattern[0]\", \"MUST_VIOLATION\")).to.be.true;\n      });\n\n      it(\"a nested string in a correctResponsesPattern Array value produces no errors\", function() {\n        var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n          actor : {member:[]},\n          verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", display : {\"en-US\":\"created\"}},\n          object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\",\n            definition:{correctResponsesPattern: [\"1.23\"]}}};\n        var results = xapiValidator.validateStatement(inputStatement);\n        expect(results.errors).to.have.property(\"length\", 0);\n        expect(reportHasErrorWithTracePrefix(results, \"statement.object.definition.correctResponsesPattern\", \"MUST_VIOLATION\")).to.be.false;\n      });\n\n      it(\"an interaction activity without the standard \\\"http://adlnet.gov/expapi/activities/cmi.interaction\\\" value for the type property should produce a SHOULD error\", function() {\n        var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n          actor : {member:[]},\n          verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", display : {\"en-US\":\"created\"}},\n          object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\",\n            definition:{type:\"http://example.com/somethingElse\", interactionType:\"choice\", choices:[]}}\n        };\n        var results = xapiValidator.validateStatement(inputStatement);\n        expect(results.errors).to.have.property(\"length\", 1);\n        expect(reportHasErrorWithTracePrefix(results, \"statement.object.definition.type\", \"SHOULD_VIOLATION\")).to.be.true;\n      });\n\n      it(\"an interaction component array property not associated with the current interactionType produces an error\", function() {\n        var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n          actor : {member:[]},\n          verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", display : {\"en-US\":\"created\"}},\n          object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\",\n            definition:{type:\"http://adlnet.gov/expapi/activities/cmi.interaction\", interactionType:\"choice\", steps:[]}}\n        };\n        var results = xapiValidator.validateStatement(inputStatement);\n        expect(results.errors).to.have.property(\"length\", 1);\n        expect(reportHasErrorWithTracePrefix(results, \"statement.object.definition.steps\", \"SHOULD_VIOLATION\")).to.be.true;\n      });\n\n      it(\"an interaction component with whitespace in the id property produces an error\", function() {\n        var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n          actor : {member:[]},\n          verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", display : {\"en-US\":\"created\"}},\n          object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\",\n            definition:{type:\"http://adlnet.gov/expapi/activities/cmi.interaction\", interactionType:\"choice\",\n                choices:[{id:\"hello invalid id\", description:{}}]}}\n        };\n        var results = xapiValidator.validateStatement(inputStatement);\n        expect(results.errors).to.have.property(\"length\", 1);\n        expect(reportHasErrorWithTracePrefix(results, \"statement.object.definition.choices[0]\", \"SHOULD_VIOLATION\")).to.be.true;\n      });\n\n      it(\"an interaction component with repeated non-unique id produces an error\", function() {\n        var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n          actor : {member:[]},\n          verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", display : {\"en-US\":\"created\"}},\n          object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\",\n            definition:{type:\"http://adlnet.gov/expapi/activities/cmi.interaction\", interactionType:\"choice\",\n                choices:[{id:\"idA\", description:{}}, {id:\"idA\", description:{}}]}}\n        };\n        var results = xapiValidator.validateStatement(inputStatement);\n        expect(results.errors).to.have.property(\"length\", 1);\n        expect(reportHasErrorWithTracePrefix(results, \"statement.object.definition.choices[1]\", \"MUST_VIOLATION\")).to.be.true;\n      });\n\n      describe(\"given a statement reference type object\", function() {\n        it(\"reports a MUST error when the id property is missing\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {objectType:\"StatementRef\"}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.object.id\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"reports a MUST error when the id property is not a UUID\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id: \"not a UUID\", objectType:\"StatementRef\"}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.object.id\", \"MUST_VIOLATION\")).to.be.true;\n        });\n      });\n\n      describe(\"given a substatement type object\", function() {\n          it(\"should not report an error when valid\", function() {\n              var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\",\n                    actor : {mbox:\"mailto:agent@example.com\"},\n                    verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                    object : { objectType:\"SubStatement\",\n                      actor : { mbox:\"mailto:agent@example.com\"},\n                      verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                      object: { id : \"http://example.com/myUniqueId\", objectType:\"Activity\"}}};\n                var results = xapiValidator.validateStatement(inputStatement);\n\n                expect(results.errors).to.have.property(\"length\", 0);\n          });\n\n          it(\"reports a MUST error when the id property is present\", function() {\n              var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\",\n                  actor : {mbox:\"mailto:agent@example.com\"},\n                  verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                  object : { id: \"fd41c918-b88b-4b20-a0a5-a4c32391aaa1\",\n                    objectType:\"SubStatement\",\n                    actor : { mbox:\"mailto:agent@example.com\"},\n                    verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                    object: { id : \"http://example.com/myUniqueId\", objectType:\"Activity\"}}};\n              var results = xapiValidator.validateStatement(inputStatement);\n\n              expect(results.errors).to.have.property(\"length\", 1);\n              expect(reportHasErrorWithTracePrefix(results, \"statement.object.id\", \"MUST_VIOLATION\")).to.be.true;\n          });\n\n          it(\"reports a MUST error when the version property is present\", function() {\n              var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\",\n                    actor : {mbox:\"mailto:agent@example.com\"},\n                    verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                    object : { version: \"1.0.0\",\n                      objectType:\"SubStatement\",\n                      actor : { mbox:\"mailto:agent@example.com\"},\n                      verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                      object: { id : \"http://example.com/myUniqueId\", objectType:\"Activity\"}}};\n                var results = xapiValidator.validateStatement(inputStatement);\n\n                expect(results.errors).to.have.property(\"length\", 1);\n                expect(reportHasErrorWithTracePrefix(results, \"statement.object.version\", \"MUST_VIOLATION\")).to.be.true;\n          });\n\n          it(\"reports a MUST error when the stored property is present\", function() {\n                var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\",\n                      actor : {mbox:\"mailto:agent@example.com\"},\n                      verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                      object : { stored: \"2013-05-28T07:12:57.245Z\",\n                        objectType:\"SubStatement\",\n                        actor : { mbox:\"mailto:agent@example.com\"},\n                        verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                        object: { id : \"http://example.com/myUniqueId\", objectType:\"Activity\"}}};\n                  var results = xapiValidator.validateStatement(inputStatement);\n\n                  expect(results.errors).to.have.property(\"length\", 1);\n                  expect(reportHasErrorWithTracePrefix(results, \"statement.object.stored\", \"MUST_VIOLATION\")).to.be.true;\n          });\n\n          it(\"reports a MUST error when the authority property is present\", function() {\n                var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\",\n                      actor : {mbox:\"mailto:agent@example.com\"},\n                      verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                      object : { authority: { mbox:\"mailto:agent@example.com\" },\n                        objectType:\"SubStatement\",\n                        actor : { mbox:\"mailto:agent@example.com\"},\n                        verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                        object: { id : \"http://example.com/myUniqueId\", objectType:\"Activity\"}}};\n                  var results = xapiValidator.validateStatement(inputStatement);\n\n                  expect(results.errors).to.have.property(\"length\", 1);\n                  expect(reportHasErrorWithTracePrefix(results, \"statement.object.authority\", \"MUST_VIOLATION\")).to.be.true;\n          });\n      });\n\n      describe(\"given a non-Object results property\", function() {\n        it(\"if null, produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                result : null};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.result\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"if an Array, produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                result : []};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.result\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"if an number, produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                result : 1.23};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.result\", \"MUST_VIOLATION\")).to.be.true;\n        });\n      });\n\n      describe(\"given a results property that is an object\", function() {\n        it(\"if empty, all is okay, no properties were required\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                result : {}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 0);\n        });\n\n        it(\"a non-Boolean success property produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                result : {success:123}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.result.success\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"a Boolean success property produces no error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                result : {success:false}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 0);\n        });\n\n        it(\"a non-Boolean completion property produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                result : {completion:123}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.result.completion\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"a Boolean completion property produces no error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                result : {completion:false}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 0);\n\n        });\n\n        it(\"a non-String response property produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                result : {response:123}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.result.response\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"a String response property produces no error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                result : {response:\"idA\"}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 0);\n        });\n\n        it(\"a non-String duration property produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                result : {duration:123}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.result.duration\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"a non-ISO 8601 duration String duration property produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                result : {duration:\"not an ISO compliant duration\"}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.result.duration\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"an ISO 8601 duration String response property produces no error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                result : {duration:\"P3Y6M4DT12H30M5S\"}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 0);\n        });\n\n        it(\"an ISO 8601 duration String response property with fractional seconds produces no error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                result : {duration:\"P3Y6M4DT12H30M5.01S\"}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 0);\n        });\n      });\n\n      describe(\"given a score property on the results\", function() {\n        it(\"a non-Number raw property produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                result : {score:{raw:\"123\"}}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.result.score.raw\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"a Number raw property produces no error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                result : {score:{raw:123}}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 0);\n        });\n\n        it(\"a Number raw property below min produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                result : {score:{raw:123, min:200}}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.result.score.raw\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"a Number raw property above max produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                result : {score:{raw:123, max:100}}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.result.score.raw\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"a Number raw property between min and max produces no error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                result : {score:{raw:123, min:120, max:125}}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 0);\n        });\n\n        it(\"a non-Number scaled property produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                result : {score:{scaled:\"0.5\"}}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.result.score.scaled\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"a Number scaled property produces no error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                result : {score:{scaled:0.5}}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 0);\n        });\n\n        it(\"a Number scaled property below 0 produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                result : {score:{scaled:-0.5}}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.result.score.scaled\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"a Number scaled property above 1 produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                result : {score:{scaled:2}}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.result.score.scaled\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"a non-Number max property produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                result : {score:{max:\"123\"}}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.result.score.max\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"a Number max property produces no error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                result : {score:{max:123}}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 0);\n        });\n\n        it(\"a Number max property below min produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                result : {score:{max:123, min:200}}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.result.score.max\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"a non-Number min property produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                result : {score:{min:\"123\"}}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.result.score.min\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"a Number min property produces no error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                result : {score:{min:123}}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 0);\n        });\n\n        it(\"a Number min property above max produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                result : {score:{max:123, min:200}}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.result.score.max\", \"MUST_VIOLATION\")).to.be.true;\n        });\n      });\n\n      describe(\"for a given defined context property\", function() {\n        it(\"an empty object produces no errors\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                context: {}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 0);\n        });\n\n        it(\"an non-object context value produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                context: 123};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.context\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"an array context value produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                context: []};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.context\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"a non-UUID registration value produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                context: {registration:\"not a UUID\"}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.context.registration\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"a UUID registration value produces no error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                context: {registration:\"ed41c918-b88b-4b20-a0a5-a4c32391aaa0\"}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 0);\n        });\n\n        it(\"an empty map for an instructor value produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                context: {instructor:{}}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.context.instructor\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"an unidentified Agent for an instructor value produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                context: {instructor:{objectType:\"Agent\"}}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.context.instructor\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"an unidentified Group with no member property for an instructor value produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                context: {instructor:{objectType:\"Group\"}}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.context.instructor\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"an Agent instructor value produces no error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                context: {instructor:{mbox:\"mailto:bob@example.com\"}}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 0);\n        });\n\n        it(\"a Group instructor identified by member property produces no error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                context: {instructor:{mbox:\"mailto:bob@example.com\", member:[]}}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 0);\n        });\n\n        it(\"a Group instructor identified by objectType property produces no error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                context: {instructor:{mbox:\"mailto:bob@example.com\", objectType:\"Group\"}}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 0);\n        });\n\n        it(\"if the statement's object is an Agent, the presence of the revision property will result in an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {mbox : \"mailto:bob@example.com\", objectType:\"Agent\"},\n                context: {revision:\"1.0\"}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.context.revision\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"if the statement's object is an Group, the presence of the revision property will result in an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {mbox : \"mailto:group@example.com\", objectType:\"Group\"},\n                context: {revision:\"1.0\"}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.context.revision\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"a String revision property produces no error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                context: {revision:\"1.0\"}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 0);\n        });\n\n        it(\"a non-String numeric revision property will result in an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                context: {revision:1.0}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.context.revision\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"a null revision property will result in an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                context: {revision:null}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.context.revision\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        ///\n        it(\"if the statement's object is an Agent, the presence of the platform property will result in an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {mbox : \"mailto:bob@example.com\", objectType:\"Agent\"},\n                context: {platform:\"1.0\"}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.context.platform\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"if the statement's object is an Group, the presence of the platform property will result in an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {mbox : \"mailto:group@example.com\", objectType:\"Group\"},\n                context: {platform:\"1.0\"}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.context.platform\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"a String platform property produces no error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                context: {platform:\"1.0\"}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 0);\n        });\n\n        it(\"a non-String numeric platform property will result in an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                context: {platform:1.0}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.context.platform\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"a null platform property will result in an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                context: {platform:null}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.context.platform\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"a null team property will result in an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                context: {team:null}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.context.team\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"a Group object team property will result in no error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                context: {team:{objectType:\"Group\", mbox:\"mailto:group@example.com\"}}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 0);\n        });\n\n        it(\"a RFC 5646 string value for the language property will result in no error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                context: {language:\"en-US\"}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 0);\n        });\n\n        it(\"a non-RFC 5646 string value for the language property will result in an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                context: {language:\"123 totally not RFC compliant\"}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.context.language\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"a null value for the language property will result in an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                context: {language:null}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.context.language\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"a non-String value for the language property will result in an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                context: {language:1}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.context.language\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n\n        it(\"a null value for the context's statement property will result in an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                context: {statement:null}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.context.statement\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"an Array value for the context's statement property will result in an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                context: {statement:[]}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.context.statement\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"an empty object value for the context's statement property will result in errors\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                context: {statement:{}}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 2);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.context.statement.objectType\", \"MUST_VIOLATION\")).to.be.true;\n            expect(reportHasErrorWithTracePrefix(results, \"statement.context.statement.id\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"a valid statement reference for the context's statement property will result in no errors\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                context: {statement:{objectType:\"StatementRef\", id:\"abcdc918-b88b-4b20-a0a5-a4c32391aaa0\"}}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 0);\n        });\n      });\n\n      describe(\"for a context property with a contextActivities property\", function() {\n        it(\"a null contextActivities value produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                context: {contextActivities:null}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.context.contextActivities\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"an Array contextActivities value produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                context: {contextActivities:[]}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.context.contextActivities\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"an Numeric contextActivities value produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                context: {contextActivities:1.23}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.context.contextActivities\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"an empty contextActivities object value produces no errors\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                context: {contextActivities:{}}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 0);\n        });\n\n        it(\"a single Activity parent property value produces a SHOULD warning\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                context: {contextActivities:{parent:{id : \"http://example.com/myOtherActivityUniqueId\", objectType:\"Activity\"}}}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.context.contextActivities\", \"SHOULD_VIOLATION\")).to.be.true;\n        });\n\n        it(\"an empty Array parent property value produces no errors\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                context: {contextActivities:{parent:[]}}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 0);\n        });\n\n        it(\"an Array with a valid Activity in the parent property produces no errors\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                context: {contextActivities:{parent:[{id : \"http://example.com/myOtherActivityUniqueId\", objectType:\"Activity\"}]}}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 0);\n        });\n\n        it(\"an Array with a invalid Activity in the parent property produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                context: {contextActivities:{parent:[{objectType:\"Activity\"}]}}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.context.contextActivities.parent[0].id\", \"MUST_VIOLATION\")).to.be.true;\n        });\n      });\n\n      describe(\"given a timestamp property on the statement\", function() {\n        it(\"a null value produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                timestamp: null};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.timestamp\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"a numeric value produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                timestamp: 1.23};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.timestamp\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"a Date value produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                timestamp: new Date()};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.timestamp\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"a String value not in ISO 8601 produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                timestamp: \"totally wrong\"};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.timestamp\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"a String value with ISO 8601 at UTC via Z produces no error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                timestamp: \"2013-05-09T14:45:15Z\"};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 0);\n        });\n\n        it(\"a String value with ISO 8601 at UTC via Z with millisecond precision produces no error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                timestamp: \"2013-05-09T14:45:15.008Z\"};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 0);\n        });\n\n        it(\"a String value with ISO 8601 with a positive timezone offset hour produces no error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                timestamp: \"2013-05-09T14:45:15+01\"};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 0);\n        });\n\n        it(\"a String value with ISO 8601 with a positive timezone offset hour and minutes produces no error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                timestamp: \"2013-05-09T14:45:15+01:02\"};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 0);\n        });\n\n        it(\"a String value with ISO 8601 with a negative timezone offset hour produces no error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                timestamp: \"2013-05-09T14:45:15-01\"};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 0);\n        });\n\n        it(\"a String value with ISO 8601 with a negative timezone offset hour and minutes produces no error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                timestamp: \"2013-05-09T14:45:15-01:02\"};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 0);\n        });\n\n        it(\"a String value with ISO8601 with no timezone offset or Z produces a SHOULD error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                timestamp: \"2013-05-09T14:45:15\"};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.timestamp\", \"SHOULD_VIOLATION\")).to.be.true;\n        });\n      });\n\n      describe(\"given a stored property on the statement\", function() {\n        it(\"a null value produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                stored: null};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.stored\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"a numeric value produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                stored: 1.23};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.stored\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"a Date value produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                stored: new Date()};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.stored\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"a String value not in ISO 8601 produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                stored: \"totally wrong\"};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.stored\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"a String value with ISO 8601 at UTC via Z produces no error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                stored: \"2013-05-09T14:45:15Z\"};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 0);\n        });\n\n        it(\"a String value with ISO 8601 at UTC via Z with millisecond precision produces no error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                stored: \"2013-05-09T14:45:15.008Z\"};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 0);\n        });\n\n        it(\"a String value with ISO 8601 with a positive timezone offset hour produces no error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                stored: \"2013-05-09T14:45:15+01\"};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 0);\n        });\n\n        it(\"a String value with ISO 8601 with a positive timezone offset hour and minutes produces no error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                stored: \"2013-05-09T14:45:15+01:02\"};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 0);\n        });\n\n        it(\"a String value with ISO 8601 with a negative timezone offset hour produces no error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                stored: \"2013-05-09T14:45:15-01\"};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 0);\n        });\n\n        it(\"a String value with ISO 8601 with a negative timezone offset hour and minutes produces no error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                stored: \"2013-05-09T14:45:15-01:02\"};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 0);\n        });\n\n        it(\"a String value with ISO8601 with no timezone offset or Z produces a SHOULD error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                stored: \"2013-05-09T14:45:15\"};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.stored\", \"SHOULD_VIOLATION\")).to.be.true;\n        });\n      });\n\n      describe(\"for a non-object authority property on the statement\", function() {\n        it(\"a null authority value produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                authority: null};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.authority\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"an Array authority value produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                authority: []};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.authority\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"an Numeric authority value produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                authority: []};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.authority\", \"MUST_VIOLATION\")).to.be.true;\n        });\n      });\n\n      describe(\"for an authority property with an object value on the statement\", function() {\n        it(\"an Agent authority value produces no errors\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                authority: {objectType:\"Agent\", mbox:\"mailto:bob@example.com\"}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 0);\n        });\n\n        it(\"an Agent authority value produces an error if an invalid Agent\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                authority: {objectType:\"Agent\"}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.authority\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"an Group authority value with two members produces no errors\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                authority: {objectType:\"Group\", member:[{objectType:\"Agent\", mbox:\"mailto:bob@example.com\"},\n                    {objectType:\"Agent\", mbox:\"mailto:tom@example.com\"}]}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 0);\n        });\n\n        it(\"an Group authority value with less than two members produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                authority: {objectType:\"Group\", member:[{objectType:\"Agent\", mbox:\"mailto:bob@example.com\"}]}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.authority.member\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"an Group authority value with more than two members produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                authority: {objectType:\"Group\", member:[{objectType:\"Agent\", mbox:\"mailto:bob@example.com\"},\n                    {objectType:\"Agent\", mbox:\"mailto:tom@example.com\"},\n                    {objectType:\"Agent\", mbox:\"mailto:frank@example.com\"}]}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.authority.member\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"an Group authority value with an invalid member produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                authority: {objectType:\"Group\", member:[{objectType:\"Agent\", mbox:\"mailto:bob@example.com\"},\n                    {objectType:\"Agent\"}]}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.authority.member[1]\", \"MUST_VIOLATION\")).to.be.true;\n        });\n      });\n\n      describe(\"for an version property on the statement with a non-string value\", function() {\n        it(\"a null value produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                version: null};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.version\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"a numeric value produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                version: 1.0};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.version\", \"MUST_VIOLATION\")).to.be.true;\n        });\n      });\n\n      describe(\"for an version property with a string value\", function() {\n        it(\"a simple semantic version produces no error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                version: \"1.0.0\"};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 0);\n        });\n\n        it(\"a semantic version with intermixed non-numbers in the major/minor/patch produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                version: \"1.0.a\"};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.version\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"a semantic version with valid pre-release info produces no error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                version: \"1.0.0-rc1\"};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 0);\n        });\n\n        it(\"a semantic version with invalid pre-release info produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                version: \"1.0.0-rc.1\"};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.version\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"a semantic version with SemVer 2.0.0 build release info characters not in SemVer 1.0.0 produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                version: \"1.0.0-alpha.1\"};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.version\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"a semantic version with SemVer 2.0.0 build release metadata not in SemVer 1.0.0 produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                version: \"1.0.0-alpha+001\"};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.version\", \"MUST_VIOLATION\")).to.be.true;\n        });\n      });\n\n      describe(\"for an attachments property on the statement with a non-Array value\", function() {\n        it(\"a null value produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                attachments: null};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.attachments\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"a numeric value produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                attachments: 1.0};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.attachments\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"an object map value produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                attachments: {}};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.attachments\", \"MUST_VIOLATION\")).to.be.true;\n        });\n      });\n\n      describe(\"for an attachments property on the statement with an Array value\", function() {\n        it(\"an empty Array produces no error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                attachments: []};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 0);\n        });\n      });\n\n      describe(\"for an attachment object within the attachments property's Array on the statement\", function() {\n        it(\"a null object produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                attachments: [null]};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.attachments[0]\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"minimal valid attachment object produces no error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                attachments: [{usageType:\"http://example.com/usage/info/A\", display:{}, contentType:\"text/plain\", length:11, sha2:\"uU0nuZNNPgilLlLX2n2r+sSE7+N6U4DukIj3rOLvzek=\"}]};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 0);\n        });\n\n        it(\"an absent usageType property object produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                attachments: [{display:{}, contentType:\"text/plain\", length:11, sha2:\"uU0nuZNNPgilLlLX2n2r+sSE7+N6U4DukIj3rOLvzek=\"}]};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.attachments[0].usageType\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"a null usageType property object produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                attachments: [{usageType:null, display:{}, contentType:\"text/plain\", length:11, sha2:\"uU0nuZNNPgilLlLX2n2r+sSE7+N6U4DukIj3rOLvzek=\"}]};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.attachments[0].usageType\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"a numeric usageType property object produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                attachments: [{usageType:123, display:{}, contentType:\"text/plain\", length:11, sha2:\"uU0nuZNNPgilLlLX2n2r+sSE7+N6U4DukIj3rOLvzek=\"}]};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.attachments[0].usageType\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"an object usageType property object produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                attachments: [{usageType:{}, display:{}, contentType:\"text/plain\", length:11, sha2:\"uU0nuZNNPgilLlLX2n2r+sSE7+N6U4DukIj3rOLvzek=\"}]};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.attachments[0].usageType\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"an absent contentType property object produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                attachments: [{usageType:\"http://example.com/usage/info/A\", display:{}, length:11, sha2:\"uU0nuZNNPgilLlLX2n2r+sSE7+N6U4DukIj3rOLvzek=\"}]};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.attachments[0].contentType\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"a null contentType property object produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                attachments: [{usageType:\"http://example.com/usage/info/A\", display:{}, contentType:null, length:11, sha2:\"uU0nuZNNPgilLlLX2n2r+sSE7+N6U4DukIj3rOLvzek=\"}]};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.attachments[0].contentType\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"an absent length property object produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                attachments: [{usageType:\"http://example.com/usage/info/A\", display:{}, contentType:\"text/plain\", sha2:\"uU0nuZNNPgilLlLX2n2r+sSE7+N6U4DukIj3rOLvzek=\"}]};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.attachments[0].length\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"a null length property object produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                attachments: [{usageType:\"http://example.com/usage/info/A\", display:{}, contentType:\"text/plain\", length:null, sha2:\"uU0nuZNNPgilLlLX2n2r+sSE7+N6U4DukIj3rOLvzek=\"}]};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.attachments[0].length\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"a string length property object produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                attachments: [{usageType:\"http://example.com/usage/info/A\", display:{}, contentType:\"text/plain\", length:\"11\", sha2:\"uU0nuZNNPgilLlLX2n2r+sSE7+N6U4DukIj3rOLvzek=\"}]};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.attachments[0].length\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"a non-integer length property object produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                attachments: [{usageType:\"http://example.com/usage/info/A\", display:{}, contentType:\"text/plain\", length:11.5, sha2:\"uU0nuZNNPgilLlLX2n2r+sSE7+N6U4DukIj3rOLvzek=\"}]};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.attachments[0].length\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"a null sha2 property produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                attachments: [{usageType:\"http://example.com/usage/info/A\", display:{}, contentType:\"text/plain\", length:11, sha2:null}]};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.attachments[0].sha2\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"an absent sha2 property produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                attachments: [{usageType:\"http://example.com/usage/info/A\", display:{}, contentType:\"text/plain\", length:11}]};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.attachments[0].sha2\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"a numeric sha2 property produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                attachments: [{usageType:\"http://example.com/usage/info/A\", display:{}, contentType:\"text/plain\", length:11, sha2:1.23}]};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.attachments[0].sha2\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"a non-base64 sha2 property object produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                attachments: [{usageType:\"http://example.com/usage/info/A\", display:{}, contentType:\"text/plain\", length:11, sha2:\"uses ~ - characters &^% not in base64\"}]};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.attachments[0].sha2\", \"MUST_VIOLATION\")).to.be.true;\n        });\n\n        it(\"a null fileUrl property produces an error\", function() {\n            var inputStatement = {id : \"fd41c918-b88b-4b20-a0a5-a4c32391aaa0\" ,\n                actor : {mbox:\"mailto:agent@example.com\"},\n                verb: { \"id\":\"http://adlnet.gov/expapi/verbs/created\", \"display\":{\"en-US\":\"created\"}},\n                object : {id : \"http://example.com/myUniqueId\", objectType:\"Activity\"},\n                attachments: [{usageType:\"http://example.com/usage/info/A\", display:{}, fileUrl:null, contentType:\"text/plain\", length:11, sha2:\"uU0nuZNNPgilLlLX2n2r+sSE7+N6U4DukIj3rOLvzek=\"}]};\n            var results = xapiValidator.validateStatement(inputStatement);\n            expect(results.errors).to.have.property(\"length\", 1);\n            expect(reportHasErrorWithTracePrefix(results, \"statement.attachments[0].fileUrl\", \"MUST_VIOLATION\")).to.be.true;\n        });\n      });\n    });\n  });\n});\n"]} diff --git a/src/constants/errors.js b/src/constants/errors.js new file mode 100644 index 0000000..d6ed3ce --- /dev/null +++ b/src/constants/errors.js @@ -0,0 +1,89 @@ +'use strict'; + +const xapiErrorLevels = Object.freeze({ + MAY_VIOLATION: 'MAY_VIOLATION', + MUST_VIOLATION: 'MUST_VIOLATION', + SHOULD_VIOLATION: 'SHOULD_VIOLATION' +}); + +const xapiValidationErrors = Object.freeze({ + ACTIVITIES_MUST_NOT_BE_NULL_MAP_OBJECTS: 'Activities must be non-null map objects', + ACTOR_MUST_BE_PROVIDED: 'Actor must be provided.', + AGENT_IFI_PROPERTIES_MUST_BE_SPECIFIED: 'Exactly one Inverse Functional Identifier property must be specified for an "agent".', + AGENT_MUST_BE_NON_NULL_MAP_OBJECT: '"agent" must be a non-null map object', + AGENT_MUST_NOT_HAVE_GROUP_CHARACTERISTICS: 'Invalid object with characteristics of a Group when an Agent was expected.', + ATTACHMENTS_MUST_BE_NOT_NULL_ARRAY: '"attachments" must be a non-null Array.', + ATTACHMENTS_MUST_NOT_BE_NULL_MAP_OBJECTS: '"attachment" instances must be non-null map objects.', + AUTHORITY_MUST_BE_NON_NULL_MAP_OBJECT: 'If present, the "authority" property must be a non-null map object.', + CONTEXT_ACTIVITIES_MUST_BE_ARRAY_OR_ACTIVITY_OBJ: 'Context Activities property values must be an array of Activity Objects or a single Activity Object.', + CONTEXT_ACTIVITIES_MUST_BE_NON_NULL_MAP_OBJECT: 'The Context Activities instances must be a non-null map object.', + CONTEXT_ACTIVITIES_MUST_NOT_BE_NULL: '"Context Activities" property values must not be null.', + CONTEXT_ACTIVITIES_SHOULD_BE_AN_ARRAY: 'Context Activities property values should prefer to be an array of Activities rather than a single Activity object.', + CONTEXT_MUST_BE_NON_NUL_MAP_OBJECT: 'If present, the "context" property must be a non-null map object.', + CORRECT_RESPONSES_PATTERN_MUST_BE_ARRAY: 'If present, the "correctResponsesPattern" value must be an Array of strings.', + CORRECT_RESPONSES_PATTERN_MUST_BE_STRINGS: '"correctResponsesPattern" items must be strings.', + DATE_MUST_BE_VALID: 'This propertys string value must be conformant to ISO 8601 for Date Times.', + DATE_SHOULD_INCLUDE_ZONE_INFORMATION: 'ISO 8601 date time strings used in the xAPI should include time zone information.', + DEFINITIONS_MUST_BE_OBJECTS: '"definitions", when present, must be map objects', + DISPLAY_SHOULD_BE_PROVIDED: '"display" property should be provided.', + DURATION_MUST_BE_VALID: 'If present, the "duration" property value must be an ISO 8601 duration', + EXTENSIONS_MUST_NOT_BE_NULL: 'If present, the extensions property must be a non-null map object.', + GROUP_AUTHORITY_AGENT_MEMBERS_MUST_BE_TWO: 'If used as a Group, the "authority" property must contain a "member" property that is an array containing exactly two Agent objects.', + GROUP_IFI_PROPERTIES_MUST_BE_SPECIFIED: 'Exactly one Inverse Functional Identifier property must be specified for a "group".', + GROUP_MEMBER_MUST_BE_ARRAY: 'If present, the member property of a Group must be an Array', + GROUP_MUST_BE_NON_NULL_MAP_OBJECT: '"group" must be a non-null map object', + ID_MUST_BE_UNIQUE: '"id" properties must be unique within each interaction component array', + ID_MUST_BE_VALID_UUID_REF: '"id" property value must be a valid UUID string for statement reference objects.', + ID_MUST_BE_VALID: 'Id was not a valid UUID', + ID_SHOULD_NOT_CONTAIN_WHITESPACES: '"id" properties on interaction components should not contain whitespace', + IDS_SHOULD_BE_GENERATED_BY_LRS: 'Ids should be generated by the Activity Provider, and must be generated by the LRS', + IFI_MUST_BE_MBOX_URI: '"mbox" property was required to be a mailto URI string but was not a string at all.', + IFI_MUST_BE_VALID_MBOX_FORMAT: '"mbox" property was required to be a mailto URI string but did not match the mailto format.', + INTERACTION_ACTIVITY_SHOULD_HAVE: 'Interaction Activity Definitions should have a type property of', + INTERACTION_COMPONENT_MUST_NOT_BE_NULL: 'This interaction component collection member must be a non-null map object', + INTERACTION_COMPONENT_SHOULD_BE_ARRAY: 'This interaction component collection property should be an array.', + INTERACTION_TYPE_MUST_BE_CMI: 'If present, the "interactionType" value must be a CMI interaction type option.', + INTERACTION_TYPE_MUST_BE_VALID: 'This interaction component collection property is not associated with the present interactionType of: ', + INVALID_JSON: 'Invalid JSON. The statement could not be parsed.', + LANGUAGE_MAP_KEY_INVALID: 'key, Language does not conform to RFC 5646', + LANGUAGE_MAP_KEY_MUST_BE_STRING: 'key: Language Map value should be a String, but was not', + LANGUAGE_MAPS_MUST_NOT_BE_NULL: 'Language Maps, when present, must be non-null map objects', + LANGUAGE_MUST_BE_STRING: 'The language property must be encoded as an RFC 5646 compliant string, but was not.', + LENGTH_MUST_BE_INTEGER: '"length" property must be provided with an integer value', + MAX_MUST_BE_GREATER_THAN_MIN: 'If both "max" and "min" are present, the max property value should be greater than min', + MEMBER_MUST_BE_PROVIDED_FOR_ANONYMOUS_GROUPS: '"member" property must be provided for Anonymous Groups.', + MUST_BE_BOOLEAN_PRESENT: 'property was required to be a Boolean but was absent.', + MUST_BE_BOOLEAN: 'property, if present, must be a Boolean.', + MUST_BE_IRI_STRING: 'property, if present, should be a IRI-like absolute URI per RFC 3987.', + MUST_BE_NUMBER_PRESENT: 'property was required to be a Number but was absent.', + MUST_BE_NUMBER: 'property, if present, must be a Number.', + MUST_BE_PRESENT: 'property was required to be a string but was absent.', + MUST_BE_STRING: 'property, if present, must be a string.', + MUST_BE_URI_PRESENT: 'property was required to be a URI string but was absent.', + MUST_BE_URI_STRING: 'property, if present, must be a URI string.', + OBJECT_MUST_BE_DEFINED: '"object" property must be provided.', + OBJECT_MUST_BE_NON_NULL_MAP_OBJECT: '"object" property must be a non-null map object.', + OBJECT_TYPE_MUST_BE_STATEMENT_REF: '"objectType" property value must be "StatementRef" for statement reference objects.', + OBJECT_TYPE_MUST_BE_VALID_OPTION: 'object\'s "objectType" did not match a valid option', + RAW_MUST_BE_GREATER_THAN_MIN: 'If both "raw" and "min" are present, the raw property value should be greater than min', + RAW_MUST_BE_LESS_THAN_MAX: 'If both "raw" and "max" are present, the raw property value should be less than max', + REGISTRATION_MUST_BE_UUID_STRING: 'If present, the registration property must be a UUID string.', + RESULT_MUST_BE_MAP_OBJECT: 'If present, the result must be a map object', + REVISION_MUST_BE_AGENT_OR_GROUP: 'The revision property must not be used if the Statement\'s Object is an Agent or Group.', + SCALED_MUST_BE_BETWEEN_0_1: 'If present, the scaled property value must be between 0 and 1', + SHA2_MUST_BE_PROVIDED_ON_ATTACHMENT_OBJECTS: '"sha2" property must be provided on attachment objects', + SHA2_MUST_CONTAIN_BASE_64_STRING: '"sha2" property must contain a string with base64 contents', + STATEMENT_ARGUMENT_IS_NOT_VALID: 'Statement argument provided was not a valid object or a valid JSON string.', + STATEMENT_ARGUMENT_MUST_BE_PROVIDED: 'No statement argument provided.', + STATEMENT_MUST_BE_PARSED_CORRECTLY: 'Null or non-object statement value parsed from provided statment JSON.', + STATEMENT_MUST_NOT_BE_NULL: 'Null statement argument provided.', + STATEMENT_REF_MUST_NOT_BE_NULL_MAP_OBJECTS: 'StatementRef instances must be non-null map objects', + SUB_STATEMENT_MUST_NOT_CONTAIN_SUB_STATEMENT: 'A SubStatement must not contain a SubStatement', + UNEXPECTED: 'Unexpected property not permitted', + VERB_MUST_BE_PROVIDED: 'Verb must be provided', + VERB_MUST_NOT_BE_NULL: 'Verb property value must a non-null map object.', + VERSION_MUST_COMPLY_SEMANTIC_VERSIONING: '"version" must be a non-null string that complies with Semantic Versioning 1.0.0' +}); + +export {xapiErrorLevels}; +export {xapiValidationErrors}; diff --git a/src/constants/general.js b/src/constants/general.js new file mode 100644 index 0000000..0a0fd99 --- /dev/null +++ b/src/constants/general.js @@ -0,0 +1,13 @@ +'use strict'; + +const xapiGeneral = Object.freeze({ + FIRST_REPORT_VERSTION : '1.0.0', + GROUP_AUTHORITY_AGENT_MEMBERS : 2, + INTERACTION_DEFINITION_TYPE : 'http://adlnet.gov/expapi/activities/cmi.interaction', + MAX_SCALED_VALUE : 1, + MIN_SCALED_VALUE : 0, + NO_INDEX_FOUND : -1, + NUMER_OF_SPECIFIED_IFI_PROPERTIES : 1 +}); + +export {xapiGeneral}; diff --git a/src/constants/interaction-types.js b/src/constants/interaction-types.js new file mode 100644 index 0000000..af3eced --- /dev/null +++ b/src/constants/interaction-types.js @@ -0,0 +1,27 @@ +'use strict'; + +export const interactionTypes = Object.freeze({ + CHOICE: 'choice', + FILL_IN: 'fill-in', + LIKERT: 'likert', + LONG_FILL_IN: 'long-fill-in', + MATCHING: 'matching', + NUMERIC: 'numeric', + OTHER: 'other', + PERFORMANCE: 'performance', + SEQUENCING: 'sequencing', + TRUE_FALSE: 'true-false' +}); + +export const xapiValidationInteractionTypes = Object.freeze([ + interactionTypes.CHOICE, + interactionTypes.FILL_IN, + interactionTypes.LIKERT, + interactionTypes.LONG_FILL_IN, + interactionTypes.MATCHING, + interactionTypes.NUMERIC, + interactionTypes.OTHER, + interactionTypes.PERFORMANCE, + interactionTypes.SEQUENCING, + interactionTypes.TRUE_FALSE +]); diff --git a/src/constants/properties.js b/src/constants/properties.js new file mode 100644 index 0000000..8f20330 --- /dev/null +++ b/src/constants/properties.js @@ -0,0 +1,223 @@ +'use strict'; + +const properties = Object.freeze({ + ACCOUNT: 'account', + ACTIVITY: 'activity', + ACTOR: 'actor', + AGENT: 'agent', + ATTACHMENT: 'attachment', + ATTACHMENTS: 'attachments', + AUTHORITY: 'authority', + CATEGORY: 'category', + CHOICE: 'choice', + CHOICES: 'choices', + COMPLETION: 'completion', + CONTENT_TYPE: 'contentType', + CONTEXT_ACTIVITIES: 'contextActivities', + CONTEXT: 'context', + CORRECT_RESPONSES_PATTERN: 'correctResponsesPattern', + DATE_TIME: 'dateTime', + DEFINITION: 'definition', + DESCRIPTION: 'description', + DISPLAY: 'display', + DURATION: 'duration', + EXTENSIONS: 'extensions', + FILE_URL: 'fileUrl', + GROUP: 'group', + GROUPING: 'grouping', + HOME_PAGE: 'homePage', + ID: 'id', + INSTRUCTOR: 'instructor', + INTERACTION_COMPONENTS: 'interactionComponents', + INTERACTION_TYPE: 'interactionType', + LANGUAGE_MAP: 'languageMap', + LANGUAGE: 'language', + LENGTH: 'length', + LIKERT: 'likert', + MATCHING: 'matching', + MAX: 'max', + MBOX_SHA_1_SUM: 'mbox_sha1sum', + MBOX: 'mbox', + MEMBER: 'member', + MIN: 'min', + MORE_INFO: 'moreInfo', + NAME: 'name', + OBJECT_TYPE: 'objectType', + OBJECT: 'object', + OPEN_ID: 'openID', + OTHER: 'other', + PARENT: 'parent', + PERFORMANCE: 'performance', + PLATFORM: 'platform', + RAW: 'raw', + REGISTRATION: 'registration', + RESPONSE: 'response', + RESULT: 'result', + REVISION: 'revision', + SCALE: 'scale', + SCALED: 'scaled', + SCORE: 'score', + SEQUENCING: 'sequencing', + SHA2: 'sha2', + SOURCE: 'source', + STATEMENT_REF: 'statementRef', + STATEMENT: 'statement', + STEPS: 'steps', + STORED: 'stored', + SUB_CONTEXT: 'subContext', + SUCCESS: 'success', + TARGET: 'target', + TEAM: 'team', + TIMESTAMP: 'timestamp', + TYPE: 'type', + USAGE_TYPE: 'usageType', + VERB: 'verb', + VERSION: 'version' +}); + +const objectTypes = Object.freeze({ + GROUP: 'Group', + AGENT: 'Agent', + ACTIVITY: 'Activity', + STATEMENT_REF: 'StatementRef', + SUB_STATEMENT: 'SubStatement' +}); + +const xapiValidationIfiPropertyNames = Object.freeze([ + properties.ACCOUNT, + properties.MBOX_SHA_1_SUM, + properties.MBOX, + properties.OPEN_ID +]); + +const xApiValidObjectTypes = Object.freeze([ + objectTypes.GROUP, + objectTypes.AGENT, + objectTypes.ACTIVITY, + objectTypes.STATEMENT_REF, + objectTypes.SUB_STATEMENT +]); + +const xapiWhiteListProperties = Object.freeze({ + IFI: [ + properties.HOME_PAGE, + properties.NAME + ], + URI: [ + properties.ID, + properties.DISPLAY + ], + COMPONENT_ARRAY: [ + properties.ID, + properties.DESCRIPTION + ], + ACTIVITY_DEFINITION: [ + properties.NAME, + properties.DESCRIPTION, + properties.TYPE, + properties.MORE_INFO, + properties.EXTENSIONS, + properties.INTERACTION_TYPE, + properties.CORRECT_RESPONSES_PATTERN, + properties.CHOICES, + properties.SCALE, + properties.SOURCE, + properties.TARGET, + properties.STEPS + ], + ACTIVITY: [ + properties.OBJECT_TYPE, + properties.ID, + properties.DEFINITION + ], + STATEMENT_REF: [ + properties.ID, + properties.OBJECT_TYPE + ], + SCORE: [ + properties.SCALED, + properties.RAW, + properties.MIN, + properties.MAX + ], + RESULT: [ + properties.SCORE, + properties.SUCCESS, + properties.COMPLETION, + properties.RESPONSE, + properties.DURATION, + properties.EXTENSIONS + ], + ATTACHMENT: [ + properties.USAGE_TYPE, + properties.DISPLAY, + properties.DESCRIPTION, + properties.CONTENT_TYPE, + properties.LENGTH, + properties.SHA2, + properties.FILE_URL + ], + AGENT: [ + properties.OBJECT_TYPE, + properties.NAME, + properties.ACCOUNT, + properties.MBOX_SHA_1_SUM, + properties.MBOX, + properties.OPEN_ID + ], + GROUP: [ + properties.OBJECT_TYPE, + properties.NAME, + properties.MEMBER, + properties.ACCOUNT, + properties.MBOX_SHA_1_SUM, + properties.MBOX, + properties.OPEN_ID + ], + CONTEXT_ACTIVITIES: [ + properties.PARENT, + properties.GROUPING, + properties.CATEGORY, + properties.OTHER + ], + STATEMENT: [ + properties.ID, + properties.ACTOR, + properties.VERB, + properties.OBJECT, + properties.RESULT, + properties.CONTEXT, + properties.TIMESTAMP, + properties.STORED, + properties.AUTHORITY, + properties.VERSION, + properties.ATTACHMENTS + ], + SUB_STATEMENT: [ + properties.ACTOR, + properties.VERB, + properties.OBJECT, + properties.RESULT, + properties.CONTEXT, + properties.TIMESTAMP, + properties.ATTACHMENTS, + properties.OBJECT_TYPE + ], + EXTENSIONS: [ + properties.REGISTRATION, + properties.INSTRUCTOR, + properties.TEAM, + properties.CONTEXT_ACTIVITIES, + properties.REVISION, + properties.PLATFORM, + properties.LANGUAGE, + properties.STATEMENT, + properties.EXTENSIONS + ] +}); + +export {properties}; +export {objectTypes}; +export {xapiValidationIfiPropertyNames}; +export {xApiValidObjectTypes}; +export {xapiWhiteListProperties}; diff --git a/src/constants/regex.js b/src/constants/regex.js new file mode 100644 index 0000000..d2edb1d --- /dev/null +++ b/src/constants/regex.js @@ -0,0 +1,30 @@ +'use strict'; + +const xapiValidationRegex = Object.freeze({ + UUID: /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i, + ISO_8601_DURATION: /^P((\d+([\.,]\d+)?Y)?(\d+([\.,]\d+)?M)?(\d+([\.,]\d+)?W)?(\d+([\.,]\d+)?D)?)?(T(\d+([\.,]\d+)?H)?(\d+([\.,]\d+)?M)?(\d+([\.,]\d+)?S)?)?$/, + ISO_8601_DATE_TIME: /^(\d{4}|[+\-]\d{6})(?:-(\d{2})(?:-(\d{2}))?)?(?:T(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{3}))?)?(?:(Z)|([+\-])(\d{2})(?::(\d{2}))?)?)?$/, + MAILTO_URI: /^mailto:/, + CONTAINS_WHITESPACE: /\s/g, + SEMVER_1_P_0_P_0: /^((\d+)\.(\d+)\.(\d+))(?:-([\dA-Za-z\-]+))?$/, + BASE_64: /^(?:[A-Za-z0-9\+\/]{4})*(?:[A-Za-z0-9\+\/]{2}==|[A-Za-z0-9\+\/]{3}=|[A-Za-z0-9\+\/]{4})$/, + IRI: /^[a-z](?:[\-a-z0-9\+\.])*:(?:\/\/(?:(?:%[0-9a-f][0-9a-f]|[\-a-z0-9\._~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF\u10000-\u1FFFD\u20000-\u2FFFD\u30000-\u3FFFD\u40000-\u4FFFD\u50000-\u5FFFD\u60000-\u6FFFD\u70000-\u7FFFD\u80000-\u8FFFD\u90000-\u9FFFD\uA0000-\uAFFFD\uB0000-\uBFFFD\uC0000-\uCFFFD\uD0000-\uDFFFD\uE1000-\uEFFFD!\$&'\(\)\*\+,;=:])*@)?(?:\[(?:(?:(?:[0-9a-f]{1,4}:){6}(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3})|::(?:[0-9a-f]{1,4}:){5}(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3})|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3})|(?:[0-9a-f]{1,4}:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3})|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3})|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3})|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3})|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|v[0-9a-f]+[\-a-z0-9\._~!\$&'\(\)\*\+,;=:]+)\]|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3}|(?:%[0-9a-f][0-9a-f]|[\-a-z0-9\._~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF\u10000-\u1FFFD\u20000-\u2FFFD\u30000-\u3FFFD\u40000-\u4FFFD\u50000-\u5FFFD\u60000-\u6FFFD\u70000-\u7FFFD\u80000-\u8FFFD\u90000-\u9FFFD\uA0000-\uAFFFD\uB0000-\uBFFFD\uC0000-\uCFFFD\uD0000-\uDFFFD\uE1000-\uEFFFD!\$&'\(\)\*\+,;=@])*)(?::[0-9]*)?(?:\/(?:(?:%[0-9a-f][0-9a-f]|[\-a-z0-9\._~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF\u10000-\u1FFFD\u20000-\u2FFFD\u30000-\u3FFFD\u40000-\u4FFFD\u50000-\u5FFFD\u60000-\u6FFFD\u70000-\u7FFFD\u80000-\u8FFFD\u90000-\u9FFFD\uA0000-\uAFFFD\uB0000-\uBFFFD\uC0000-\uCFFFD\uD0000-\uDFFFD\uE1000-\uEFFFD!\$&'\(\)\*\+,;=:@]))*)*|\/(?:(?:(?:(?:%[0-9a-f][0-9a-f]|[\-a-z0-9\._~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF\u10000-\u1FFFD\u20000-\u2FFFD\u30000-\u3FFFD\u40000-\u4FFFD\u50000-\u5FFFD\u60000-\u6FFFD\u70000-\u7FFFD\u80000-\u8FFFD\u90000-\u9FFFD\uA0000-\uAFFFD\uB0000-\uBFFFD\uC0000-\uCFFFD\uD0000-\uDFFFD\uE1000-\uEFFFD!\$&'\(\)\*\+,;=:@]))+)(?:\/(?:(?:%[0-9a-f][0-9a-f]|[\-a-z0-9\._~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF\u10000-\u1FFFD\u20000-\u2FFFD\u30000-\u3FFFD\u40000-\u4FFFD\u50000-\u5FFFD\u60000-\u6FFFD\u70000-\u7FFFD\u80000-\u8FFFD\u90000-\u9FFFD\uA0000-\uAFFFD\uB0000-\uBFFFD\uC0000-\uCFFFD\uD0000-\uDFFFD\uE1000-\uEFFFD!\$&'\(\)\*\+,;=:@]))*)*)?|(?:(?:(?:%[0-9a-f][0-9a-f]|[\-a-z0-9\._~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF\u10000-\u1FFFD\u20000-\u2FFFD\u30000-\u3FFFD\u40000-\u4FFFD\u50000-\u5FFFD\u60000-\u6FFFD\u70000-\u7FFFD\u80000-\u8FFFD\u90000-\u9FFFD\uA0000-\uAFFFD\uB0000-\uBFFFD\uC0000-\uCFFFD\uD0000-\uDFFFD\uE1000-\uEFFFD!\$&'\(\)\*\+,;=:@]))+)(?:\/(?:(?:%[0-9a-f][0-9a-f]|[\-a-z0-9\._~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF\u10000-\u1FFFD\u20000-\u2FFFD\u30000-\u3FFFD\u40000-\u4FFFD\u50000-\u5FFFD\u60000-\u6FFFD\u70000-\u7FFFD\u80000-\u8FFFD\u90000-\u9FFFD\uA0000-\uAFFFD\uB0000-\uBFFFD\uC0000-\uCFFFD\uD0000-\uDFFFD\uE1000-\uEFFFD!\$&'\(\)\*\+,;=:@]))*)*|(?!(?:%[0-9a-f][0-9a-f]|[\-a-z0-9\._~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF\u10000-\u1FFFD\u20000-\u2FFFD\u30000-\u3FFFD\u40000-\u4FFFD\u50000-\u5FFFD\u60000-\u6FFFD\u70000-\u7FFFD\u80000-\u8FFFD\u90000-\u9FFFD\uA0000-\uAFFFD\uB0000-\uBFFFD\uC0000-\uCFFFD\uD0000-\uDFFFD\uE1000-\uEFFFD!\$&'\(\)\*\+,;=:@])))(?:\?(?:(?:%[0-9a-f][0-9a-f]|[\-a-z0-9\._~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF\u10000-\u1FFFD\u20000-\u2FFFD\u30000-\u3FFFD\u40000-\u4FFFD\u50000-\u5FFFD\u60000-\u6FFFD\u70000-\u7FFFD\u80000-\u8FFFD\u90000-\u9FFFD\uA0000-\uAFFFD\uB0000-\uBFFFD\uC0000-\uCFFFD\uD0000-\uDFFFD\uE1000-\uEFFFD!\$&'\(\)\*\+,;=:@])|[\uE000-\uF8FF\uF0000-\uFFFFD|\u100000-\u10FFFD\/\?])*)?(?:\#(?:(?:%[0-9a-f][0-9a-f]|[\-a-z0-9\._~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF\u10000-\u1FFFD\u20000-\u2FFFD\u30000-\u3FFFD\u40000-\u4FFFD\u50000-\u5FFFD\u60000-\u6FFFD\u70000-\u7FFFD\u80000-\u8FFFD\u90000-\u9FFFD\uA0000-\uAFFFD\uB0000-\uBFFFD\uC0000-\uCFFFD\uD0000-\uDFFFD\uE1000-\uEFFFD!\$&'\(\)\*\+,;=:@])|[\/\?])*)?$/i, + BCP_47: /^(?:(en-GB-oed|i-(?:ami|bnn|default|enochian|hak|klingon|lux|mingo|navajo|pwn|tao|tay|tsu)|sgn-(?:BE-FR|BE-NL|CH-DE))|(art-lojban|cel-gaulish|no-(?:bok|nyn)|zh-(?:guoyu|hakka|min|min-nan|xiang)))$|^(x(?:-[0-9a-z]{1,8})+)$|^(?:((?:[a-z]{2,3}(?:(?:-[a-z]{3}){1,3})?)|[a-z]{4}|[a-z]{5,8})(?:-([a-z]{4}))?(?:-([a-z]{2}|[0-9]{3}))?((?:-(?:[a-z0-9]{5,8}|[0-9][a-z0-9]{3}))*)?((?:-[0-9a-wy-z](?:-[a-z0-9]{2,8}){1,})*)?(-x(?:-[0-9a-z]{1,8})+)?)$/i +}); + +const dateFormatRegexPositions = Object.freeze({ + YEAR: 1, + MONTH: 2, + DAY: 3, + HOUR: 4, + MINUTE: 5, + SECOND: 6, + MSECOND: 7, + ZONE: 8, + RELATIVE_TIME: 9, + TIME_ZONE_HOUR: 10, + TIME_ZONE_MINUTE: 11 +}); + +export {xapiValidationRegex}; +export {dateFormatRegexPositions}; diff --git a/src/utils/utils.js b/src/utils/utils.js new file mode 100644 index 0000000..ff5bbe2 --- /dev/null +++ b/src/utils/utils.js @@ -0,0 +1,66 @@ +'use strict'; + +const + IS_STRING = '[object String]', + IS_ARRAY = '[object Array]', + IS_BOOLEAN = '[object Boolean]', + IS_NUMBER = '[object Number]' +; + +var toString = Object.prototype.toString; +var xapiValidationUtils; + +xapiValidationUtils = { + isString(obj) { + return toString.call(obj) === IS_STRING; + }, + + isObject(obj) { + return obj === Object(obj); + }, + + isArray: Array.isArray || function(obj) { + return toString.call(obj) === IS_ARRAY; + }, + + isBoolean(obj) { + return obj === true || obj === false || toString.call(obj) === IS_BOOLEAN; + }, + + isNumber(obj) { + return toString.call(obj) === IS_NUMBER; + }, + + isDefined(obj) { + return (obj !== null || obj !== undefined); + }, + + isNonNullMapObject(target) { + return this.isDefined(target) && this.isObject(target) && !this.isArray(target); + }, + + isValidLanguageTag(target, validLanguageRegex) { + // TODO - use more precise 5646 handling, rather than this simplified BCP 47 regex, which combines RFC 5646 and RFC 4647. + // return this.isDefined(target) && this.isString(target) && xapiValidationRegex.BCP_47.test(target); + return this.isDefined(target) && this.isString(target) && validLanguageRegex.test(target); + }, + + addPropToTrace(trace, addendum) { + return this.isDefined(addendum) ? `${trace}.${addendum}` : trace; + }, + + addLookupToTrace(trace, key) { + return (!this.isDefined(key)) ? trace : (this.isNumber(key) ? `${trace}[${key}]` : `${trace}["${key}"]`); + }, + + localTraceToString(trace, addendum) { + return this.addPropToTrace(trace, addendum); + }, + + isGroup(actorOrGroup, groupType) { + // return (actorOrGroup.member !== null && actorOrGroup.member !== undefined) || actorOrGroup.objectType === objectTypes.GROUP; + return (actorOrGroup.member !== null && actorOrGroup.member !== undefined) || actorOrGroup.objectType === groupType; + } +}; + +export {xapiValidationUtils}; diff --git a/src/xapiValidator-old.js b/src/xapiValidator-old.js new file mode 100644 index 0000000..37ec62c --- /dev/null +++ b/src/xapiValidator-old.js @@ -0,0 +1,875 @@ +// UMD flavor "commonjsStrictGlobal.js" from https://github.com/umdjs/umd +(function (root, factory) { + "use strict"; + if (typeof exports === 'object') { + // CommonJS + factory(exports); + } else if (typeof define === 'function' && define.amd) { + // AMD. Register as an anonymous module. + define(['exports'], function (exports) { + root.xapiValidator = exports; + factory(exports); + }); + } else { + // Browser globals + root.xapiValidator = {}; + factory(root.xapiValidator); + } +} (this, function (exports) { + "use strict"; + var MUST_VIOLATION = "MUST_VIOLATION", + SHOULD_VIOLATION = "SHOULD_VIOLATION", + MAY_VIOLATION = "MAY_VIOLATION", + toString = Object.prototype.toString, + uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i, + iso8601DurationRegex = /^P((\d+([\.,]\d+)?Y)?(\d+([\.,]\d+)?M)?(\d+([\.,]\d+)?W)?(\d+([\.,]\d+)?D)?)?(T(\d+([\.,]\d+)?H)?(\d+([\.,]\d+)?M)?(\d+([\.,]\d+)?S)?)?$/, + iso8601DateTimeRegex, + mailtoUriRegex = /^mailto:/, + semVer1p0p0Regex = /^((\d+)\.(\d+)\.(\d+))(?:-([\dA-Za-z\-]+))?$/, + base64Regex = /^(?:[A-Za-z0-9\+\/]{4})*(?:[A-Za-z0-9\+\/]{2}==|[A-Za-z0-9\+\/]{3}=|[A-Za-z0-9\+\/]{4})$/, + iriRegex, + bcp47Regex, + isArray, + ifiPropertyNames = ["mbox", "mbox_sha1sum", "openID", "account"], + cmiInteractionTypes = ["true-false", "choice", "fill-in", + "long-fill-in", "matching", "performance", + "sequencing", "likert", "numeric", + "other"]; + iriRegex = /^[a-z](?:[\-a-z0-9\+\.])*:(?:\/\/(?:(?:%[0-9a-f][0-9a-f]|[\-a-z0-9\._~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF\u10000-\u1FFFD\u20000-\u2FFFD\u30000-\u3FFFD\u40000-\u4FFFD\u50000-\u5FFFD\u60000-\u6FFFD\u70000-\u7FFFD\u80000-\u8FFFD\u90000-\u9FFFD\uA0000-\uAFFFD\uB0000-\uBFFFD\uC0000-\uCFFFD\uD0000-\uDFFFD\uE1000-\uEFFFD!\$&'\(\)\*\+,;=:])*@)?(?:\[(?:(?:(?:[0-9a-f]{1,4}:){6}(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3})|::(?:[0-9a-f]{1,4}:){5}(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3})|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3})|(?:[0-9a-f]{1,4}:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3})|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3})|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3})|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3})|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|v[0-9a-f]+[\-a-z0-9\._~!\$&'\(\)\*\+,;=:]+)\]|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3}|(?:%[0-9a-f][0-9a-f]|[\-a-z0-9\._~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF\u10000-\u1FFFD\u20000-\u2FFFD\u30000-\u3FFFD\u40000-\u4FFFD\u50000-\u5FFFD\u60000-\u6FFFD\u70000-\u7FFFD\u80000-\u8FFFD\u90000-\u9FFFD\uA0000-\uAFFFD\uB0000-\uBFFFD\uC0000-\uCFFFD\uD0000-\uDFFFD\uE1000-\uEFFFD!\$&'\(\)\*\+,;=@])*)(?::[0-9]*)?(?:\/(?:(?:%[0-9a-f][0-9a-f]|[\-a-z0-9\._~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF\u10000-\u1FFFD\u20000-\u2FFFD\u30000-\u3FFFD\u40000-\u4FFFD\u50000-\u5FFFD\u60000-\u6FFFD\u70000-\u7FFFD\u80000-\u8FFFD\u90000-\u9FFFD\uA0000-\uAFFFD\uB0000-\uBFFFD\uC0000-\uCFFFD\uD0000-\uDFFFD\uE1000-\uEFFFD!\$&'\(\)\*\+,;=:@]))*)*|\/(?:(?:(?:(?:%[0-9a-f][0-9a-f]|[\-a-z0-9\._~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF\u10000-\u1FFFD\u20000-\u2FFFD\u30000-\u3FFFD\u40000-\u4FFFD\u50000-\u5FFFD\u60000-\u6FFFD\u70000-\u7FFFD\u80000-\u8FFFD\u90000-\u9FFFD\uA0000-\uAFFFD\uB0000-\uBFFFD\uC0000-\uCFFFD\uD0000-\uDFFFD\uE1000-\uEFFFD!\$&'\(\)\*\+,;=:@]))+)(?:\/(?:(?:%[0-9a-f][0-9a-f]|[\-a-z0-9\._~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF\u10000-\u1FFFD\u20000-\u2FFFD\u30000-\u3FFFD\u40000-\u4FFFD\u50000-\u5FFFD\u60000-\u6FFFD\u70000-\u7FFFD\u80000-\u8FFFD\u90000-\u9FFFD\uA0000-\uAFFFD\uB0000-\uBFFFD\uC0000-\uCFFFD\uD0000-\uDFFFD\uE1000-\uEFFFD!\$&'\(\)\*\+,;=:@]))*)*)?|(?:(?:(?:%[0-9a-f][0-9a-f]|[\-a-z0-9\._~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF\u10000-\u1FFFD\u20000-\u2FFFD\u30000-\u3FFFD\u40000-\u4FFFD\u50000-\u5FFFD\u60000-\u6FFFD\u70000-\u7FFFD\u80000-\u8FFFD\u90000-\u9FFFD\uA0000-\uAFFFD\uB0000-\uBFFFD\uC0000-\uCFFFD\uD0000-\uDFFFD\uE1000-\uEFFFD!\$&'\(\)\*\+,;=:@]))+)(?:\/(?:(?:%[0-9a-f][0-9a-f]|[\-a-z0-9\._~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF\u10000-\u1FFFD\u20000-\u2FFFD\u30000-\u3FFFD\u40000-\u4FFFD\u50000-\u5FFFD\u60000-\u6FFFD\u70000-\u7FFFD\u80000-\u8FFFD\u90000-\u9FFFD\uA0000-\uAFFFD\uB0000-\uBFFFD\uC0000-\uCFFFD\uD0000-\uDFFFD\uE1000-\uEFFFD!\$&'\(\)\*\+,;=:@]))*)*|(?!(?:%[0-9a-f][0-9a-f]|[\-a-z0-9\._~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF\u10000-\u1FFFD\u20000-\u2FFFD\u30000-\u3FFFD\u40000-\u4FFFD\u50000-\u5FFFD\u60000-\u6FFFD\u70000-\u7FFFD\u80000-\u8FFFD\u90000-\u9FFFD\uA0000-\uAFFFD\uB0000-\uBFFFD\uC0000-\uCFFFD\uD0000-\uDFFFD\uE1000-\uEFFFD!\$&'\(\)\*\+,;=:@])))(?:\?(?:(?:%[0-9a-f][0-9a-f]|[\-a-z0-9\._~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF\u10000-\u1FFFD\u20000-\u2FFFD\u30000-\u3FFFD\u40000-\u4FFFD\u50000-\u5FFFD\u60000-\u6FFFD\u70000-\u7FFFD\u80000-\u8FFFD\u90000-\u9FFFD\uA0000-\uAFFFD\uB0000-\uBFFFD\uC0000-\uCFFFD\uD0000-\uDFFFD\uE1000-\uEFFFD!\$&'\(\)\*\+,;=:@])|[\uE000-\uF8FF\uF0000-\uFFFFD|\u100000-\u10FFFD\/\?])*)?(?:\#(?:(?:%[0-9a-f][0-9a-f]|[\-a-z0-9\._~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF\u10000-\u1FFFD\u20000-\u2FFFD\u30000-\u3FFFD\u40000-\u4FFFD\u50000-\u5FFFD\u60000-\u6FFFD\u70000-\u7FFFD\u80000-\u8FFFD\u90000-\u9FFFD\uA0000-\uAFFFD\uB0000-\uBFFFD\uC0000-\uCFFFD\uD0000-\uDFFFD\uE1000-\uEFFFD!\$&'\(\)\*\+,;=:@])|[\/\?])*)?$/i; + + // 1 YYYY 2 MM 3 DD 4 HH 5 mm 6 ss 7 msec 8 Z 9 ± 10 tzHH 11 tzmm + iso8601DateTimeRegex = /^(\d{4}|[+\-]\d{6})(?:-(\d{2})(?:-(\d{2}))?)?(?:T(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{3}))?)?(?:(Z)|([+\-])(\d{2})(?::(\d{2}))?)?)?$/; + + bcp47Regex = /^(?:(en-GB-oed|i-(?:ami|bnn|default|enochian|hak|klingon|lux|mingo|navajo|pwn|tao|tay|tsu)|sgn-(?:BE-FR|BE-NL|CH-DE))|(art-lojban|cel-gaulish|no-(?:bok|nyn)|zh-(?:guoyu|hakka|min|min-nan|xiang)))$|^(x(?:-[0-9a-z]{1,8})+)$|^(?:((?:[a-z]{2,3}(?:(?:-[a-z]{3}){1,3})?)|[a-z]{4}|[a-z]{5,8})(?:-([a-z]{4}))?(?:-([a-z]{2}|[0-9]{3}))?((?:-(?:[a-z0-9]{5,8}|[0-9][a-z0-9]{3}))*)?((?:-[0-9a-wy-z](?:-[a-z0-9]{2,8}){1,})*)?(-x(?:-[0-9a-z]{1,8})+)?)$/i; + + function isString(obj) { + return toString.call(obj) === '[object String]'; + } + + function isObject(obj) { + return obj === Object(obj); + } + + isArray = Array.isArray || function (obj) { + return toString.call(obj) === '[object Array]'; + }; + + function isBoolean(obj) { + return obj === true || obj === false || toString.call(obj) === '[object Boolean]'; + } + + function isNumber(obj) { + return toString.call(obj) === '[object Number]'; + } + + function isNonNullMapObject(target) { + return target !== null && isObject(target) && !isArray(target); + } + + function isValidLanguageTag(target) { + // TODO - use more precise 5646 handling, rather than this simplified BCP 47 regex, which combines RFC 5646 and RFC 4647. + return target !== undefined && target !== null && isString(target) && bcp47Regex.test(target); + } + + function addPropToTrace(trace, addendum) { + if (addendum !== null && addendum !== undefined) { + return trace + "." + addendum; + } + return trace; + } + + function addLookupToTrace(trace, key) { + if (key === null || key === undefined) { + return trace; + } + if (isString(key)) { + return trace + "[\"" + key + "\"]"; + } + return trace + "[" + key + "]"; + } + + function localTraceToString(trace, addendum) { + return addPropToTrace(trace, addendum); + } + + function Report(instance, errors, version) { + this.instance = instance === null || instance === undefined ? null : instance; + this.errors = errors === null || errors === undefined ? [] : errors; + this.version = version; + } + + function ValidationError(trace, message, level) { + this.trace = trace; + this.message = message; + this.level = level; + } + + function makeV1Report(instance, errors) { + return new Report(instance, errors, "1.0.0"); + } + + function makeV1SingleErrorReport(instance, error) { + return makeV1Report(instance, error === null || error === undefined ? [] : + [error]); + } + + function validateAbsenceOfNonWhitelistedProperties(target, allowedProperties, trace, errors) { + var localErrors = errors || [], + localTrace = trace || "", + propertyName; + for (propertyName in target) { + if (target.hasOwnProperty(propertyName) && allowedProperties.indexOf(propertyName) === -1) { + localErrors.push(new ValidationError(addPropToTrace(localTrace, propertyName), "Unexpected property not permitted", MUST_VIOLATION)); + } + } + return localErrors; + } + + function validatePropertyIsString(parent, propertyName, trace, errors, isRequired, violationType) { + var localErrors = errors || [], + localTrace = trace || "", + propValue = parent[propertyName], + localViolationType = violationType || MUST_VIOLATION; + if (propValue !== undefined) { + if (propValue === null || !isString(propValue)) { + localErrors.push(new ValidationError(localTraceToString(localTrace, propertyName), propertyName + " property, if present, must be a string.", localViolationType)); + } + } else if (isRequired) { + localErrors.push(new ValidationError(localTraceToString(localTrace, propertyName), propertyName + " property was required to be a string but was absent.", localViolationType)); + } + return localErrors; + } + + function validatePropertyIsUri(target, propertyName, trace, errors, isRequired) { + var localErrors = errors || [], + localTrace = trace || "", + propValue = target[propertyName]; + if (propValue !== undefined) { + if (propValue === null || !isString(propValue)) { + localErrors.push(new ValidationError(localTraceToString(localTrace, propertyName), propertyName + " property, if present, must be a URI string.", MUST_VIOLATION)); + } else if (!iriRegex.test(propValue)) { + localErrors.push(new ValidationError(localTraceToString(localTrace, propertyName), propertyName + " property, if present, should be a IRI-like absolute URI per RFC 3987.", SHOULD_VIOLATION)); + } + } else if (isRequired) { + localErrors.push(new ValidationError(localTraceToString(localTrace, propertyName), propertyName + " property was required to be a URI string but was absent.", MUST_VIOLATION)); + } + return localErrors; + } + + function validatePropertyIsUrl(target, propertyName, trace, errors, isRequired) { + // TODO - check whether a formal URL format definition is recommended/enforced for xAPI + return validatePropertyIsString(target, propertyName, trace, errors, isRequired); + } + + function validatePropertyIsBoolean(parent, propertyName, trace, errors, isRequired) { + var localErrors = errors || [], + localTrace = trace || "", + propValue = parent[propertyName]; + if (propValue !== undefined) { + if (propValue === null || !isBoolean(propValue)) { + localErrors.push(new ValidationError(localTraceToString(localTrace, propertyName), propertyName + " property, if present, must be a Boolean.", MUST_VIOLATION)); + } + } else if (isRequired) { + localErrors.push(new ValidationError(localTraceToString(localTrace, propertyName), propertyName + " property was required to be a Boolean but was absent.", MUST_VIOLATION)); + } + return localErrors; + } + + function validatePropertyIsNumber(parent, propertyName, trace, errors, isRequired) { + var localErrors = errors || [], + localTrace = trace || "", + propValue = parent[propertyName]; + if (propValue !== undefined) { + if (propValue === null || !isNumber(propValue)) { + localErrors.push(new ValidationError(localTraceToString(localTrace, propertyName), propertyName + " property, if present, must be a Number.", MUST_VIOLATION)); + } + } else if (isRequired) { + localErrors.push(new ValidationError(localTraceToString(localTrace, propertyName), propertyName + " property was required to be a Number but was absent.", MUST_VIOLATION)); + } + return localErrors; + } + + function validateIFIProperties(target, trace, errors) { + var localErrors = errors || [], + localTrace = trace || "", + accountTrace; + if (target.mbox !== undefined && target.mbox !== null) { + if (!isString(target.mbox)) { + localErrors.push(new ValidationError(localTraceToString(localTrace, "mbox"), "mbox property was required to be a mailto URI string but was not a string at all.", MUST_VIOLATION)); + } else if (!mailtoUriRegex.test(target.mbox)) { + localErrors.push(new ValidationError(localTraceToString(localTrace, "mbox"), "mbox property was required to be a mailto URI string but did not match the mailto format.", MUST_VIOLATION)); + } + } + validatePropertyIsString(target, "mbox_sha1sum", localTrace, localErrors, false); + validatePropertyIsUri(target, "openID", localTrace, localErrors, false); + if (target.account !== undefined && target.account !== null) { + accountTrace = addPropToTrace(localTrace, "account"); + validatePropertyIsUri(target.account, "homePage", accountTrace, localErrors, true); + validatePropertyIsString(target.account, "name", accountTrace, localErrors, true); + validateAbsenceOfNonWhitelistedProperties(target.account, ["homePage", "name"], accountTrace, localErrors); + } + return localErrors; + } + + function getIFIs(target) { + var ifis = [], + i, + propName, + propValue; + if (target === null || target === undefined) { + return ifis; + } + for (i = 0; i < ifiPropertyNames.length; i += 1) { + propName = ifiPropertyNames[i]; + propValue = target[propName]; + if (propValue !== undefined && propValue !== null) { + ifis.push({ key: propName, value: propValue }); + } + } + return ifis; + } + + function getIFICount(target) { + return getIFIs(target).length; + } + + function validateExtensions(extensions, trace, errors) { + var localErrors = errors || [], + localTrace = trace || "extensions"; + if (extensions === undefined) { + return localErrors; + } + if (!isNonNullMapObject(extensions)) { + localErrors.push(new ValidationError(localTrace, "If present, the extensions property must be a non-null map object.", MUST_VIOLATION)); + } + // TODO - double-check what further enforceable constraints exist on extension object properties + return localErrors; + } + + function validateLanguageMap(languageMap, trace, errors) { + var localErrors = errors || [], + localTrace = trace || "languageMap", + propName, + mappedValue; + if (languageMap === undefined) { + return localErrors; + } + if (!isNonNullMapObject(languageMap)) { + localErrors.push(new ValidationError(addPropToTrace(localTrace), "Language Maps, when present, must be non-null map objects", MUST_VIOLATION)); + return localErrors; + } + for (propName in languageMap) { + if (languageMap.hasOwnProperty(propName)) { + + if (!isValidLanguageTag(propName)) { + localErrors.push(new ValidationError(addPropToTrace(localTrace, propName), "Language Map key " + propName + "does not conform to RFC 5646.", MUST_VIOLATION)); + } + mappedValue = languageMap[propName]; + if (mappedValue === null || mappedValue === undefined || !isString(mappedValue)) { + localErrors.push(new ValidationError(addLookupToTrace(localTrace, propName), "Language Map value for key " + propName + "should be a String, but was not.", MUST_VIOLATION)); + } + } + } + return localErrors; + } + + function validateVerb(verb, trace, errors) { + var localErrors = errors || [], + localTrace = trace || "verb"; + if (verb === undefined) { + localErrors.push(new ValidationError(localTraceToString(localTrace), "verb property must be provided.", MUST_VIOLATION)); + return localErrors; + } + if (!isNonNullMapObject(verb)) { + localErrors.push(new ValidationError(localTraceToString(localTrace), "verb property value must a non-null map object.", MUST_VIOLATION)); + return localErrors; + } + validatePropertyIsUri(verb, "id", localTrace, localErrors, true); + if (verb.display === undefined) { + localErrors.push(new ValidationError(addPropToTrace(localTrace, "display"), "display property should be provided.", SHOULD_VIOLATION)); + } else { + validateLanguageMap(verb.display, addPropToTrace(localTrace, "display"), localErrors); + } + + validateAbsenceOfNonWhitelistedProperties(verb, ["id", "display"], localTrace, localErrors); + + return localErrors; + } + + function validateInteractionComponentArray(components, interactionType, allowedInteractionTypes, trace, errors) { + var localErrors = errors || [], + localTrace = trace || "interactionComponents", + isAllowedComponentType = allowedInteractionTypes.indexOf(interactionType) !== -1, + ids = [], + interactionComponent, + perComponentTrace, + i; + if (isAllowedComponentType && components !== undefined) { + if (components === null || !isArray(components)) { + localErrors.push(new ValidationError(localTrace, "This interaction component collection property should be an array.", SHOULD_VIOLATION)); + } else { + for (i = 0; i < components.length; i += 1) { + interactionComponent = components[i]; + perComponentTrace = addLookupToTrace(localTrace, i); + if (!isNonNullMapObject(interactionComponent)) { + localErrors.push(new ValidationError(perComponentTrace, "This interaction component collection member must be a non-null map object", MUST_VIOLATION)); + } else { + validatePropertyIsString(interactionComponent, "id", perComponentTrace, localErrors, true, MUST_VIOLATION); + if (ids.indexOf(interactionComponent.id) !== -1) { + localErrors.push(new ValidationError(addPropToTrace(perComponentTrace, "id"), "id properties must be unique within each interaction component array", MUST_VIOLATION)); + } else { + ids.push(interactionComponent.id); + } + if (interactionComponent.id && /\s/g.test(interactionComponent.id)) { + localErrors.push(new ValidationError(addPropToTrace(perComponentTrace, "id"), "id properties on interaction components should not contain whitespace", SHOULD_VIOLATION)); + } + validateLanguageMap(interactionComponent.description, addPropToTrace(perComponentTrace, "description"), localErrors); + + validateAbsenceOfNonWhitelistedProperties(interactionComponent, ["id", "description"], perComponentTrace, localErrors); + } + } + } + } else if (interactionType && components) { + localErrors.push(new ValidationError(localTrace, "This interaction component collection property is not associated with the present interactionType of " + interactionType, SHOULD_VIOLATION)); + } + return localErrors; + } + + function validateActivityDefintion(definition, trace, errors) { + var localErrors = errors || [], + localTrace = trace || "definition", + correctResponsesPatternTrace = addPropToTrace(localTrace, "correctResponsesPattern"), + crpLen, + i, + crpItem; + + if (!isNonNullMapObject(definition)) { + localErrors.push(new ValidationError(addPropToTrace(localTrace), "definitions, when present, must be map objects", MUST_VIOLATION)); + return localErrors; + } + + validateLanguageMap(definition.name, addPropToTrace(localTrace, "name"), localErrors); + validateLanguageMap(definition.description, addPropToTrace(localTrace, "description"), localErrors); + + validatePropertyIsUri(definition, "type", localTrace, localErrors, false); + validatePropertyIsUrl(definition, "moreInfo", localTrace, localErrors, false); + validateExtensions(definition.extensions, addPropToTrace(localTrace, "extensions"), localErrors); + + if (definition.interactionType !== undefined) { + if (definition.type !== "http://adlnet.gov/expapi/activities/cmi.interaction") { + localErrors.push(new ValidationError(localTraceToString(localTrace, "type"), "Interaction Activity Definitions should have a type property of \"http://adlnet.gov/expapi/activities/cmi.interaction\" ", SHOULD_VIOLATION)); + } + if (cmiInteractionTypes.indexOf(definition.interactionType) === -1) { + localErrors.push(new ValidationError(localTraceToString(localTrace, "interactionType"), "If present, the interactionType value must be a CMI interaction type option.", MUST_VIOLATION)); + } + } + + if (definition.correctResponsesPattern !== undefined) { + if (!isArray(definition.correctResponsesPattern)) { + localErrors.push(new ValidationError(correctResponsesPatternTrace, "If present, the correctResponsesPattern value must be an Array of strings.", MUST_VIOLATION)); + } else { + crpLen = definition.correctResponsesPattern.length; + for (i = 0; i < crpLen; i+=1) { + crpItem = definition.correctResponsesPattern[i]; + if (crpItem === null || crpItem === undefined || !isString(crpItem)) { + localErrors.push(new ValidationError(addLookupToTrace(correctResponsesPatternTrace, i), "correctResponsesPattern items must be strings.", MUST_VIOLATION)); + } + } + } + } + validateInteractionComponentArray(definition.choices, definition.interactionType, ["choice", "sequencing"], addPropToTrace(localTrace, "choices"), localErrors); + validateInteractionComponentArray(definition.scale, definition.interactionType, ["likert"], addPropToTrace(localTrace, "scale"), localErrors); + validateInteractionComponentArray(definition.source, definition.interactionType, ["matching"], addPropToTrace(localTrace, "source"), localErrors); + validateInteractionComponentArray(definition.target, definition.interactionType, ["matching"], addPropToTrace(localTrace, "target"), localErrors); + validateInteractionComponentArray(definition.steps, definition.interactionType, ["performance"], addPropToTrace(localTrace, "steps"), localErrors); + + validateAbsenceOfNonWhitelistedProperties(definition, + ["name", "description", "type", "moreInfo", "extensions", "interactionType", "correctResponsesPattern", "choices", "scale", "source", "target", "steps"], + localTrace, localErrors); + return localErrors; + } + + function validateActivity(activity, trace, errors) { + var localErrors = errors || [], + localTrace = trace || "activity"; + if (!isNonNullMapObject(activity)) { + localErrors.push(new ValidationError(localTraceToString(localTrace), "Activities must be non-null map objects", MUST_VIOLATION)); + return localErrors; + } + validatePropertyIsUri(activity, "id", localTrace, localErrors, true); + + if (activity.definition !== undefined) { + validateActivityDefintion(activity.definition, addPropToTrace(localTrace, "definition"), localErrors); + } + validateAbsenceOfNonWhitelistedProperties(activity, ["objectType", "id", "definition"], localTrace, localErrors); + return localErrors; + } + + function validateStatementRef(statementRef, trace, errors) { + var localErrors = errors || [], + localTrace = trace || "statementRef"; + if (!isNonNullMapObject(statementRef)) { + localErrors.push(new ValidationError(localTraceToString(localTrace), "StatementRef instances must be non-null map objects.", MUST_VIOLATION)); + return localErrors; + } + if (statementRef.objectType !== "StatementRef") { + localErrors.push(new ValidationError(addPropToTrace(localTrace, "objectType"), "objectType property value must be 'StatementRef' for statement reference objects.", MUST_VIOLATION)); + } + if (!statementRef.id || !uuidRegex.test(statementRef.id)) { + localErrors.push(new ValidationError(addPropToTrace(localTrace, "id"), "id property value must be a valid UUID string for statement reference objects.", MUST_VIOLATION)); + } + validateAbsenceOfNonWhitelistedProperties(statementRef, ["id", "objectType"], localTrace, localErrors); + return localErrors; + } + + + function validateScore(score, trace, errors) { + var localErrors = errors || [], + localTrace = trace || "score"; + if (score === undefined) { + return localErrors; + } + validatePropertyIsNumber(score, "scaled", localTrace, localErrors, false); + if (score.scaled !== undefined) { + if (score.scaled < 0 || score.scaled > 1) { + localErrors.push(new ValidationError(addPropToTrace(localTrace, "scaled"), "If present, the scaled property value must be between 0 and 1", MUST_VIOLATION)); + } + } + if (score.min !== undefined) { + validatePropertyIsNumber(score, "min", localTrace, localErrors, false); + if (score.raw !== undefined && score.raw < score.min) { + localErrors.push(new ValidationError(addPropToTrace(localTrace, "raw"), "If both 'raw' and 'min' are present, the raw property value should be greater than min", MUST_VIOLATION)); + } + if (score.max !== undefined && score.max < score.min) { + localErrors.push(new ValidationError(addPropToTrace(localTrace, "max"), "If both 'max' and 'min' are present, the max property value should be greater than min", MUST_VIOLATION)); + } + } + if (score.max !== undefined) { + validatePropertyIsNumber(score, "max", localTrace, localErrors, false); + if (score.raw !== undefined && score.raw > score.max) { + localErrors.push(new ValidationError(addPropToTrace(localTrace, "raw"), "If both 'raw' and 'max' are present, the raw property value should be less than max", MUST_VIOLATION)); + } + } + validatePropertyIsNumber(score, "raw", localTrace, localErrors, false); + validateAbsenceOfNonWhitelistedProperties(score, ["scaled", "raw", "min", "max"], localTrace, localErrors); + return localErrors; + } + + function validateResult(result, trace, errors) { + var localErrors = errors || [], + localTrace = trace || "result"; + if (result === undefined) { + return localErrors; + } + if (!isNonNullMapObject(result)) { + localErrors.push(new ValidationError(addPropToTrace(localTrace), "If present, the result must be a map object", MUST_VIOLATION)); + return localErrors; + } + validateScore(result.score, addPropToTrace(localTrace, "score"), localErrors); + validatePropertyIsBoolean(result, "success", localTrace, localErrors, false); + validatePropertyIsBoolean(result, "completion", localTrace, localErrors, false); + validatePropertyIsString(result, "response", localTrace, localErrors, false); + validateExtensions(result.extensions, addPropToTrace(localTrace, "extensions"), localErrors); + if (result.duration !== undefined && (result.duration === null || !isString(result.duration) || !iso8601DurationRegex.test(result.duration))) { + localErrors.push(new ValidationError(addPropToTrace(localTrace, "duration"), "If present, the duration property value must be an ISO 8601 duration", MUST_VIOLATION)); + } + validateAbsenceOfNonWhitelistedProperties(result, ["score", "success", "completion", "response", "duration", "extensions"], localTrace, localErrors); + + return localErrors; + } + + + function validatePropertyIsISO8601String(parent, propertyName, trace, errors) { + var localErrors = errors || [], + localTrace = trace || "datetime", + matched, + datetime = parent[propertyName]; + if (datetime === undefined) { + return localErrors; + } + if (datetime === null || !isString(datetime)) { + localErrors.push(new ValidationError(localTraceToString(localTrace, propertyName), "This property must be a string value, but was null or another value type.", MUST_VIOLATION)); + return localErrors; + } + matched = iso8601DateTimeRegex.exec(datetime); + if (matched) { + if (!(matched[8] || (matched[9] && matched[10]))) { + localErrors.push(new ValidationError(localTraceToString(localTrace, propertyName), "ISO 8601 date time strings used in the xAPI should include time zone information.", SHOULD_VIOLATION)); + } + } else { + localErrors.push(new ValidationError(localTraceToString(localTrace, propertyName), "This property's string value must be conformant to ISO 8601 for Date Times.", MUST_VIOLATION)); + } + + return localErrors; + } + + + + function validateVersion(version, trace, errors) { + var localErrors = errors || [], + localTrace = trace || "version"; + if (version === undefined) { + return localErrors; + } + if (version === null || !isString(version) || !semVer1p0p0Regex.test(version)) { + localErrors.push(new ValidationError(localTraceToString(localTrace), "version must be a non-null string that complies with Semantic Versioning 1.0.0", MUST_VIOLATION)); + } + return localErrors; + } + + function validateAttachmentObject(attachment, trace, errors) { + var localErrors = errors || [], + localTrace = trace || "attachment"; + if (!isNonNullMapObject(attachment)) { + localErrors.push(new ValidationError(localTraceToString(localTrace), "attachment instances must be non-null map objects.", MUST_VIOLATION)); + return localErrors; + } + if (attachment.display === undefined) { + localErrors.push(new ValidationError(localTraceToString(localTrace, "display"), "display property must be provided.", MUST_VIOLATION)); + } else { + validateLanguageMap(attachment.display, addPropToTrace(localTrace, "display"), localErrors); + } + validateLanguageMap(attachment.description, addPropToTrace(localTrace, "description"), localErrors); + + validatePropertyIsUri(attachment, "usageType", localTrace, localErrors, true, MUST_VIOLATION); + validatePropertyIsUri(attachment, "fileUrl", localTrace, localErrors, false, MUST_VIOLATION); + + // TODO - more complete validation for Internet Media Type via RFC 2046 + validatePropertyIsString(attachment, "contentType", localTrace, localErrors, true, MUST_VIOLATION); + if (attachment.length === undefined || attachment.length === null || !isNumber(attachment.length) || !(attachment.length % 1 === 0)) { + localErrors.push(new ValidationError(localTraceToString(localTrace, "length"), "length property must be provided with an integer value", MUST_VIOLATION)); + } + + if (attachment.sha2 === undefined) { + localErrors.push(new ValidationError(localTraceToString(localTrace, "sha2"), "sha2 property must be provided on attachment objects", MUST_VIOLATION)); + } else if (attachment.sha2 === null || !isString(attachment.sha2) || !base64Regex.test(attachment.sha2)) { + localErrors.push(new ValidationError(localTraceToString(localTrace, "sha2"), "sha2 property must contain a string with bas64 contents", MUST_VIOLATION)); + } + + validateAbsenceOfNonWhitelistedProperties(attachment, ["usageType", "display", "description", "contentType", "length", "sha2", "fileUrl"], localTrace, localErrors); + return localErrors; + } + + function validateAttachments(attachments, trace, errors) { + var localErrors = errors || [], + localTrace = trace || "attachments", + numAttachments, + i; + if (attachments === undefined) { + return localErrors; + } + if (attachments === null || !isArray(attachments)) { + localErrors.push(new ValidationError(localTraceToString(localTrace), "attachments must be a non-null Array.", MUST_VIOLATION)); + return localErrors; + } + numAttachments = attachments.length; + for (i = 0; i < numAttachments; i+=1) { + validateAttachmentObject(attachments[i], addLookupToTrace(localTrace, i), localErrors); + } + return localErrors; + } + + function isGroup(actorOrGroup) { + return (actorOrGroup.member !== null && actorOrGroup.member !== undefined) || actorOrGroup.objectType === "Group"; + } + + function validateAgent(agent, trace, errors) { + var localErrors = errors || [], + localTrace = trace || "agent", + ifiCount; + if (!isNonNullMapObject(agent)) { + localErrors.push(new ValidationError(localTraceToString(localTrace), "Agent must be a non-null map object", MUST_VIOLATION)); + return localErrors; + } + + ifiCount = getIFICount(agent); + + if (ifiCount !== 1) { + localErrors.push(new ValidationError(localTraceToString(localTrace), "Exactly one Inverse Functional Identifier property must be specified.", MUST_VIOLATION)); + } + if (agent.objectType === "Group") { + localErrors.push(new ValidationError(localTraceToString(localTrace), "Invalid object with characteristics of a Group when an Agent was expected.", MUST_VIOLATION)); + } + validateIFIProperties(agent, localTrace, localErrors); + validatePropertyIsString(agent, "name", localTrace, localErrors, false); + + validateAbsenceOfNonWhitelistedProperties(agent, ["objectType", "name"].concat(ifiPropertyNames), localTrace, localErrors); + + return localErrors; + } + + function validateGroup(group, trace, errors) { + var localErrors = errors || [], + localTrace = trace || "group", + memberTrace = addPropToTrace(localTrace, "member"), + ifiCount, + numMembers, + i; + if (!isNonNullMapObject(group)) { + localErrors.push(new ValidationError(localTraceToString(localTrace), "Group must be a non-null map object", MUST_VIOLATION)); + return localErrors; + } + + ifiCount = getIFICount(group); + if (ifiCount === 0) { + if (group.member === null || group.member === undefined) { + localErrors.push(new ValidationError(memberTrace, "member property must be provided for Anonymous Groups.", MUST_VIOLATION)); + } + } else if (ifiCount > 1) { + localErrors.push(new ValidationError(localTraceToString(localTrace), "Only one Inverse Functional Identifier property must be specified.", MUST_VIOLATION)); + } + validateIFIProperties(group, localTrace, localErrors); + validatePropertyIsString(group, "name", localTrace, localErrors, false); + + if (group.member !== undefined) { + if (group.member === null || !isArray(group.member)) { + localErrors.push(new ValidationError(localTraceToString(localTrace, "member"), "If present, the member property of a Group must be an Array", MUST_VIOLATION)); + } else { + numMembers = group.member.length; + for (i = 0; i < numMembers; i+=1) { + validateAgent(group.member[i], addLookupToTrace(memberTrace, i), localErrors); + } + } + } + + validateAbsenceOfNonWhitelistedProperties(group, ["objectType", "name", "member"].concat(ifiPropertyNames), localTrace, localErrors); + + return localErrors; + } + + function validateActor(actor, trace, errors) { + var localErrors = errors || [], + localTrace = trace || "actor"; + if (actor === null || actor === undefined) { + localErrors.push(new ValidationError(localTraceToString(localTrace), "Actor must be provided.", MUST_VIOLATION)); + return localErrors; + } + if (isGroup(actor)) { + validateGroup(actor, localTrace, localErrors); + } else { + validateAgent(actor, localTrace, localErrors); + } + return localErrors; + } + + function validateAuthority(authority, trace, errors) { + var localErrors = errors || [], + localTrace = trace || "authority"; + if (authority === undefined) { + return localErrors; + } + if (!isNonNullMapObject(authority)) { + localErrors.push(new ValidationError(localTraceToString(localTrace), "If present, the authority property must be a non-null map object.", MUST_VIOLATION)); + return localErrors; + } + if (isGroup(authority)) { + validateGroup(authority, localTrace, localErrors); + if (!authority.member || !authority.member.length || authority.member.length !== 2) { + localErrors.push(new ValidationError(localTraceToString(localTrace, "member"), "If used as a Group, the authority property must contain a member property that is an array containing exactly two Agent objects.", MUST_VIOLATION)); + } + } else { + validateAgent(authority, localTrace, localErrors); + } + return localErrors; + } + + function validateContextActivitySubContext(subContext, trace, errors) { + var localErrors = errors || [], + localTrace = trace || "subContext", + numActivities, + i; + if (subContext === undefined) { + return localErrors; + } + if (subContext === null) { + localErrors.push(new ValidationError(localTraceToString(localTrace), "Context Activities property values must not be null.", MUST_VIOLATION)); + } else if (isArray(subContext)) { + numActivities = subContext.length; + for (i = 0; i < numActivities; i+=1) { + validateActivity(subContext[i], addLookupToTrace(localTrace, i), localErrors); + } + } else if (isObject(subContext)) { + localErrors.push(new ValidationError(localTraceToString(localTrace), "Context Activities property values should prefer to be an array of Activities rather than a single Activity object.", SHOULD_VIOLATION)); + validateActivity(subContext, localTrace, localErrors); + } else { + localErrors.push(new ValidationError(localTraceToString(localTrace), "Context Activities property values must be an array of Activity Objects or a single Activity Object.", MUST_VIOLATION)); + } + return localErrors; + } + + function validateContextActivities(contextActivities, trace, errors) { + var localErrors = errors || [], + localTrace = trace || "contextActivities"; + if (contextActivities === undefined) { + return localErrors; + } + if (!isNonNullMapObject(contextActivities)) { + localErrors.push(new ValidationError(localTraceToString(localTrace), "The Context Activities instances must be a non-null map object.", MUST_VIOLATION)); + return localErrors; + } + validateContextActivitySubContext(contextActivities.parent, addPropToTrace(localTrace, "parent"), localErrors); + validateContextActivitySubContext(contextActivities.grouping, addPropToTrace(localTrace, "grouping"), localErrors); + validateContextActivitySubContext(contextActivities.category, addPropToTrace(localTrace, "category"), localErrors); + validateContextActivitySubContext(contextActivities.other, addPropToTrace(localTrace, "other"), localErrors); + + validateAbsenceOfNonWhitelistedProperties(contextActivities, ["parent", "grouping", "category", "other"], localTrace, localErrors); + return localErrors; + } + + function validateContext(context, trace, errors, statementObjectObjectType) { + var localErrors = errors || [], + localTrace = trace || "context"; + if (context === undefined) { + return localErrors; + } + if (!isNonNullMapObject(context)) { + localErrors.push(new ValidationError(localTrace, "If present, the context must be a non-null map object.", MUST_VIOLATION)); + return localErrors; + } + if (context.registration !== undefined && (context.registration === null || !isString(context.registration) || !uuidRegex.test(context.registration))) { + localErrors.push(new ValidationError(localTraceToString(localTrace, "registration"), "If present, the registration property must be a UUID string.", MUST_VIOLATION)); + } + if (["Group", "Agent"].indexOf(statementObjectObjectType) !== -1) { + if (context.revision !== undefined) { + localErrors.push(new ValidationError(localTraceToString(localTrace, "revision"), "The revision property must not be used if the Statement's Object is an Agent or Group.", MUST_VIOLATION)); + } + if (context.platform !== undefined) { + localErrors.push(new ValidationError(localTraceToString(localTrace, "platform"), "The platform property must not be used if the Statement's Object is an Agent or Group.", MUST_VIOLATION)); + } + } + + validatePropertyIsString(context, "revision", localTrace, localErrors, false, MUST_VIOLATION); + validatePropertyIsString(context, "platform", localTrace, localErrors, false, MUST_VIOLATION); + if (context.team !== undefined) { + validateGroup(context.team, addPropToTrace(localTrace, "team"), localErrors); + } + if (context.contextActivities !== undefined) { + validateContextActivities(context.contextActivities, addPropToTrace(localTrace, "contextActivities"), localErrors); + } + if (context.language !== undefined && !isValidLanguageTag(context.language)) { + localErrors.push(new ValidationError(localTraceToString(localTrace, "language"), "The language property must be encoded as an RFC 5646 compliant string, but was not.", MUST_VIOLATION)); + } + if (context.statement !== undefined) { + validateStatementRef(context.statement, addPropToTrace(localTrace, "statement"), localErrors); + } + + if (context.instructor !== undefined) { + if (isGroup(context.instructor)) { + validateGroup(context.instructor, addPropToTrace(localTrace, "instructor"), localErrors); + } else { + validateAgent(context.instructor, addPropToTrace(localTrace, "instructor"), localErrors); + } + } + validateExtensions(context.extensions, addPropToTrace(localTrace, "extensions"), localErrors); + validateAbsenceOfNonWhitelistedProperties(context, + ["registration", "instructor", "team", "contextActivities", "revision", "platform", "language", "statement", "extensions"], + localTrace, localErrors); + return localErrors; + } + + function validateObject(object, trace, errors, isWithinSubStatement) { + var localErrors = errors || [], + localTrace = trace || "object", + objectType; + if (object === undefined) { + localErrors.push(new ValidationError(localTraceToString(localTrace), "object property must be provided.", MUST_VIOLATION)); + return localErrors; + } + if (!isNonNullMapObject(object)) { + localErrors.push(new ValidationError(localTraceToString(localTrace), "object property must be a non-null map object.", MUST_VIOLATION)); + return localErrors; + } + validatePropertyIsString(object, "objectType", localTrace, localErrors, true, SHOULD_VIOLATION); + objectType = object.objectType || "Activity"; + if (objectType === "Activity") { + validateActivity(object, localTrace, localErrors); + } else if (objectType === "Agent") { + validateAgent(object, localTrace, localErrors); + } else if (objectType === "Group") { + validateGroup(object, localTrace, localErrors); + } else if (objectType === "StatementRef") { + validateStatementRef(object, localTrace, localErrors); + } else if (objectType === "SubStatement") { + if (isWithinSubStatement) { + localErrors.push(new ValidationError(localTraceToString(localTrace, "objectType"), "A SubStatement must not contain a SubStatement", MUST_VIOLATION)); + } + validateStatement(object, localTrace, localErrors, true); + } else { + localErrors.push(new ValidationError(localTraceToString(localTrace, "objectType"), "object's objectType did not match a valid option ['Activity', 'Agent', 'Group', 'StatementRef', 'SubStatement']", MUST_VIOLATION)); + } + return localErrors; + } + + function validateStatement(statement, trace, errors, isSubStatement) { + var localErrors = errors || [], + localTrace = trace || "statement", + statementObjectObjectType, + whitelistedProperties = ["id", "actor", "verb", "object", "result", "context", "timestamp", "stored", "authority", "version", "attachments"]; + + if (!isNonNullMapObject(statement)) { + localErrors.push(new ValidationError(localTraceToString(localTrace), "Statements must be non-null map objects", MUST_VIOLATION)); + return localErrors; + } + + if (!isSubStatement) { + if (statement.id === null || statement.id === undefined || !isString(statement.id)) { + localErrors.push(new ValidationError(localTraceToString(localTrace, "id"), "Ids should be generated by the Activity Provider, and must be generated by the LRS", SHOULD_VIOLATION)); + } else if (!uuidRegex.test(statement.id)) { + localErrors.push(new ValidationError(localTraceToString(localTrace, "id"), "Id was not a valid UUID", MUST_VIOLATION)); + } + } else { + whitelistedProperties = ["actor", "verb", "object", "result", "context", "timestamp", "attachments", "objectType"]; + } + + validateActor(statement.actor, addPropToTrace(localTrace, "actor"), localErrors); + validateVerb(statement.verb, addPropToTrace(localTrace, "verb"), localErrors); + validateObject(statement.object, addPropToTrace(localTrace, "object"), localErrors, isSubStatement); + validateResult(statement.result, addPropToTrace(localTrace, "result"), localErrors); + + statementObjectObjectType = statement.object && statement.object.objectType ? statement.object.objectType : "Activity"; + validateContext(statement.context, addPropToTrace(localTrace, "context"), localErrors, statementObjectObjectType); + validatePropertyIsISO8601String(statement, "timestamp", localTrace, localErrors); + validatePropertyIsISO8601String(statement, "stored", localTrace, localErrors); + + validateAuthority(statement.authority, addPropToTrace(localTrace, "authority"), localErrors); + validateVersion(statement.version, addPropToTrace(localTrace, "version"), localErrors); + validateAttachments(statement.attachments, addPropToTrace(localTrace, "attachments"), localErrors); + + validateAbsenceOfNonWhitelistedProperties(statement, whitelistedProperties, localTrace, localErrors); + + return localErrors; + } + + function makeStatementReport(statement) { + var localErrors = []; + validateStatement(statement, "statement", localErrors, false); + return makeV1Report(statement, localErrors); + } + + function validateAmbiguousTypeStatement(statement) { + var statementObject; + if (statement === undefined) { + return makeV1SingleErrorReport(null, new ValidationError("statement", "No statement argument provided.", MUST_VIOLATION)); + } + if (statement === null) { + return makeV1SingleErrorReport(null, new ValidationError("statement", "Null statement argument provided.", MUST_VIOLATION)); + } + if (isString(statement)) { + try { + statementObject = JSON.parse(statement); + if (statementObject === null || !isObject(statementObject) || isArray(statementObject)) { + return makeV1SingleErrorReport(statementObject, new ValidationError("statement", "Null or non-object statement value parsed from provided statment JSON.", MUST_VIOLATION)); + } + } catch (e) { + return makeV1SingleErrorReport(statementObject, new ValidationError("statement", "Invalid JSON. The statement could not be parsed: " + e.message, MUST_VIOLATION)); + } + return makeStatementReport(statementObject); + } + if (isObject(statement) && !isArray(statement)) { + return makeStatementReport(statement); + } + return makeV1SingleErrorReport(null, new ValidationError("statement", "Statement argument provided was not a valid object or a valid JSON string.", MUST_VIOLATION)); + } + + exports.validateStatement = validateAmbiguousTypeStatement; +})); diff --git a/src/xapiValidator.js b/src/xapiValidator.js new file mode 100644 index 0000000..9311e2c --- /dev/null +++ b/src/xapiValidator.js @@ -0,0 +1,1286 @@ +'use strict'; + +import {properties, objectTypes, xapiValidationIfiPropertyNames, xApiValidObjectTypes, xapiWhiteListProperties} from './constants/properties'; +import {xapiErrorLevels, xapiValidationErrors} from './constants/errors'; +import {xapiValidationInteractionTypes} from './constants/interaction-types'; +import {xapiValidationRegex, dateFormatRegexPositions} from './constants/regex'; +import {xapiGeneral} from './constants/general'; +import {xapiValidationUtils} from './utils/utils'; + +var xapiValidation; + +function makeV1Report(instance, errors) { + var version; + + instance = instance || null; + errors = errors || null; + version = xapiGeneral.FIRST_REPORT_VERSTION; + return {instance, errors, version}; +} + +function makeV1SingleErrorReport(instance, error) { + return makeV1Report(instance, error === null || error === undefined ? [] : [error]); +} + +function validateAbsenceOfNonWhitelistedProperties(target, allowedProperties, trace, errors) { + var localErrors, localTrace, propertyName; + + localErrors = errors || []; + localTrace = trace || ''; + + for (propertyName in target) { + if (target.hasOwnProperty(propertyName) && allowedProperties.indexOf(propertyName) === xapiGeneral.NO_INDEX_FOUND) { + localErrors.push({ + trace: xapiValidationUtils.addPropToTrace(localTrace, propertyName), + message: xapiValidationErrors.UNEXPECTED, + level: xapiErrorLevels.MUST_VIOLATION + }); + } + } + + return localErrors; +} + +function validatePropertyIsString(parent, propertyName, trace, errors, isRequired, violationType) { + var localErrors, localTrace, propValue, localViolationType; + + localErrors = errors || []; + localTrace = trace || ''; + propValue = parent[propertyName], + localViolationType = violationType || xapiErrorLevels.MUST_VIOLATION; + + if (propValue !== undefined) { + if (propValue === null || !xapiValidationUtils.isString(propValue)) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace, propertyName), + message: `${propertyName} ${xapiValidationErrors.MUST_BE_STRING}`, + level: localViolationType + }); + } + } else if (isRequired) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace, propertyName), + message: `${propertyName} ${xapiValidationErrors.MUST_BE_PRESENT}`, + level: localViolationType + }); + } + + return localErrors; +} + +function validatePropertyIsUri(target, propertyName, trace, errors, isRequired) { + var localErrors, localTrace, propValue; + + localErrors = errors || []; + localTrace = trace || ''; + propValue = target[propertyName]; + + if (propValue !== undefined) { + if (propValue === null || !xapiValidationUtils.isString(propValue)) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace, propertyName), + message: `${propertyName} ${xapiValidationErrors.MUST_BE_URI_STRING}`, + level: xapiErrorLevels.MUST_VIOLATION + }); + } else if (!xapiValidationRegex.IRI.test(propValue)) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace, propertyName), + message: `${propertyName} ${xapiValidationErrors.MUST_BE_IRI_STRING}`, + level: xapiErrorLevels.SHOULD_VIOLATION + }); + } + } else if (isRequired) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace, propertyName), + message: `${propertyName} ${xapiValidationErrors.MUST_BE_URI_PRESENT}`, + level: xapiErrorLevels.MUST_VIOLATION + }); + } + return localErrors; +} + +function validatePropertyIsUrl(target, propertyName, trace, errors, isRequired) { + // TODO - check whether a formal URL format definition is recommended/enforced for xAPI + return validatePropertyIsString(target, propertyName, trace, errors, isRequired); +} + +function validatePropertyIsBoolean(parent, propertyName, trace, errors, isRequired) { + var localErrors, localTrace, propValue; + + localErrors = errors || []; + localTrace = trace || ''; + propValue = parent[propertyName]; + + if (propValue !== undefined) { + if (propValue === null || !xapiValidationUtils.isBoolean(propValue)) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace, propertyName), + message: `${propertyName} ${xapiValidationErrors.MUST_BE_BOOLEAN}`, + level: xapiErrorLevels.MUST_VIOLATION + }); + } + } else if (isRequired) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace, propertyName), + message: `${propertyName} ${xapiValidationErrors.MUST_BE_BOOLEAN_PRESENT}`, + level: xapiErrorLevels.MUST_VIOLATION + }); + } + return localErrors; +} + +function validatePropertyIsNumber(parent, propertyName, trace, errors, isRequired) { + var localErrors, localTrace, propValue; + + localErrors = errors || []; + localTrace = trace || ''; + propValue = parent[propertyName]; + + if (propValue !== undefined) { + if (propValue === null || !xapiValidationUtils.isNumber(propValue)) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace, propertyName), + message: `${propertyName} ${xapiValidationErrors.MUST_BE_NUMBER}`, + level: xapiErrorLevels.MUST_VIOLATION + }); + } + } else if (isRequired) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace, propertyName), + message: `${propertyName} ${xapiValidationErrors.MUST_BE_NUMBER_PRESENT}`, + level: xapiErrorLevels.MUST_VIOLATION + }); + } + return localErrors; +} + +function validateIFIProperties(target, trace, errors) { + var localErrors, localTrace, accountTrace; + + localErrors = errors || []; + localTrace = trace || ''; + + if (target.mbox !== undefined && target.mbox !== null) { + if (!xapiValidationUtils.isString(target.mbox)) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace, properties.MBOX), + message: xapiValidationErrors.IFI_MUST_BE_MBOX_URI, + level: xapiErrorLevels.MUST_VIOLATION + }); + } else if (!xapiValidationRegex.MAILTO_URI.test(target.mbox)) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace, properties.MBOX), + message: xapiValidationErrors.IFI_MUST_BE_VALID_MBOX_FORMAT, + level: xapiErrorLevels.MUST_VIOLATION + }); + } + } + + validatePropertyIsString(target, properties.MBOX_SHA_1_SUM, localTrace, localErrors, /*isRequired*/false); + validatePropertyIsUri(target, properties.OPEN_ID, localTrace, localErrors, /*isRequired*/false); + + if (target.account !== undefined && target.account !== null) { + accountTrace = xapiValidationUtils.addPropToTrace(localTrace, properties.ACCOUNT); + validatePropertyIsUri(target.account, properties.HOME_PAGE,accountTrace, localErrors, /*isRequired*/true); + validatePropertyIsString(target.account, properties.NAME, accountTrace, localErrors, /*isRequired*/true); + validateAbsenceOfNonWhitelistedProperties(target.account, xapiWhiteListProperties.IFI, accountTrace, localErrors); + } + + return localErrors; +} + +function getIFIs(target) { + var ifis; + + if (target === null || target === undefined) {return [];} + + ifis = xapiValidationIfiPropertyNames.filter((name) => { + if (target[name] !== undefined && target[name] !== null) { + return {key: name, value: target[name]}; + } + }); + + return ifis; +} + +function getIFICount(target) { + return getIFIs(target).length; +} + +function validateExtensions(extensions, trace, errors) { + var localErrors, localTrace; + + localErrors = errors || [], + localTrace = trace || properties.EXTENSIONS; + + if (extensions === undefined) {return localErrors;} + + if (!xapiValidationUtils.isNonNullMapObject(extensions)) { + localErrors.push({ + trace: localTrace, + message: xapiValidationErrors.EXTENSIONS_MUST_NOT_BE_NULL, + level: xapiErrorLevels.MUST_VIOLATION + }); + } + // TODO - double-check what further enforceable constraints exist on extension object properties + return localErrors; +} + +function validateLanguageMap(languageMap, trace, errors) { + var localErrors, localTrace, propName, mappedValue; + + localErrors = errors || []; + localTrace = trace || properties.LANGUAGE_MAP; + + if (languageMap === undefined) {return localErrors;} + + if (!xapiValidationUtils.isNonNullMapObject(languageMap)) { + localErrors.push({ + trace: xapiValidationUtils.addPropToTrace(localTrace), + message: xapiValidationErrors.LANGUAGE_MAPS_MUST_NOT_BE_NULL, + level: xapiErrorLevels.MUST_VIOLATION + }); + + return localErrors; + } + + for (propName in languageMap) { + + if (languageMap.hasOwnProperty(propName)) { + if (!xapiValidationUtils.isValidLanguageTag(propName, xapiValidationRegex.BCP_47)) { + localErrors.push({ + trace: xapiValidationUtils.addPropToTrace(localTrace, propName), + message: `${propName} ${xapiValidationErrors.LANGUAGE_MAP_KEY_INVALID}`, + level: xapiErrorLevels.MUST_VIOLATION + }); + } + + mappedValue = languageMap[propName]; + + if (mappedValue === null || mappedValue === undefined || !xapiValidationUtils.isString(mappedValue)) { + localErrors.push({ + trace: xapiValidationUtils.addLookupToTrace(localTrace, propName), + message: `${propName} ${xapiValidationErrors.LANGUAGE_MAP_KEY_MUST_BE_STRING}`, + level: xapiErrorLevels.MUST_VIOLATION + }); + } + } + } + + return localErrors; +} + +function validateVerb(verb, trace, errors) { + var localErrors, localTrace; + + localErrors = errors || []; + localTrace = trace || properties.VERB; + + if (verb === undefined) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace), + message: xapiValidationErrors.VERB_MUST_BE_PROVIDED, + level: xapiErrorLevels.MUST_VIOLATION + }); + + return localErrors; + } + + if (!xapiValidationUtils.isNonNullMapObject(verb)) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace), + message: xapiValidationErrors.VERB_MUST_NOT_BE_NULL, + level: xapiErrorLevels.MUST_VIOLATION + }); + + return localErrors; + } + + validatePropertyIsUri(verb, properties.ID, localTrace, localErrors, /*isRequired*/true); + + if (verb.display === undefined) { + localErrors.push({ + trace: xapiValidationUtils.addPropToTrace(localTrace, properties.DISPLAY), + message: xapiValidationErrors.DISPLAY_SHOULD_BE_PROVIDED, + level: xapiErrorLevels.SHOULD_VIOLATION + }); + } else { + validateLanguageMap(verb.display, xapiValidationUtils.addPropToTrace(localTrace, properties.DISPLAY), localErrors); + } + + validateAbsenceOfNonWhitelistedProperties(verb, xapiWhiteListProperties.URI, localTrace, localErrors); + + return localErrors; +} + +function validateInteractionComponentArray(components, interactionType, allowedInteractionTypes, trace, errors) { + var localErrors, localTrace, isAllowedComponentType, ids, perComponentTrace; + + localErrors = errors || []; + localTrace = trace || properties.INTERACTION_COMPONENTS; + isAllowedComponentType = allowedInteractionTypes.indexOf(interactionType) !== xapiGeneral.NO_INDEX_FOUND; + ids = []; + + if (isAllowedComponentType && components !== undefined) { + if (components === null || !xapiValidationUtils.isArray(components)) { + localErrors.push({ + trace: localTrace, + message: xapiValidationErrors.INTERACTION_COMPONENT_SHOULD_BE_ARRAY, + level: xapiErrorLevels.SHOULD_VIOLATION + }); + } else { + components.forEach((interactionComponent, i) => { + perComponentTrace = xapiValidationUtils.addLookupToTrace(localTrace, i); + + if (!xapiValidationUtils.isNonNullMapObject(interactionComponent)) { + localErrors.push({ + trace: perComponentTrace, + message: xapiValidationErrors.INTERACTION_COMPONENT_MUST_NOT_BE_NULL, + level: xapiErrorLevels.MUST_VIOLATION + }); + } else { + validatePropertyIsString(interactionComponent, properties.ID, perComponentTrace, localErrors, /*isRequired*/true, xapiErrorLevels.MUST_VIOLATION); + if (ids.indexOf(interactionComponent.id) !== xapiGeneral.NO_INDEX_FOUND) { + localErrors.push({ + trace: xapiValidationUtils.addPropToTrace(perComponentTrace, properties.ID), + message: xapiValidationErrors.ID_MUST_BE_UNIQUE, + level: xapiErrorLevels.MUST_VIOLATION + }); + } else { + ids.push(interactionComponent.id); + } + + if (interactionComponent.id && xapiValidationRegex.CONTAINS_WHITESPACE.test(interactionComponent.id)) { + localErrors.push({ + trace: xapiValidationUtils.addPropToTrace(perComponentTrace, properties.ID), + message: xapiValidationErrors.ID_SHOULD_NOT_CONTAIN_WHITESPACES, + level: xapiErrorLevels.SHOULD_VIOLATION + }); + } + + validateLanguageMap(interactionComponent.description, xapiValidationUtils.addPropToTrace(perComponentTrace, properties.DESCRIPTION), localErrors); + validateAbsenceOfNonWhitelistedProperties(interactionComponent, xapiWhiteListProperties.COMPONENT_ARRAY, perComponentTrace, localErrors); + } + }); + + } + } else if (interactionType && components) { + localErrors.push({ + trace: localTrace, + message: `${xapiValidationErrors.INTERACTION_TYPE_MUST_BE_VALID} ${interactionType}`, + level: xapiErrorLevels.SHOULD_VIOLATION + }); + } + + return localErrors; +} + +function validateActivityDefintion(definition, trace, errors) { + var localErrors, localTrace, correctResponsesPatternTrace; + + localErrors = errors || []; + localTrace = trace || properties.DEFINITION; + correctResponsesPatternTrace = xapiValidationUtils.addPropToTrace(localTrace, properties.CORRECT_RESPONSES_PATTERN); + + if (!xapiValidationUtils.isNonNullMapObject(definition)) { + localErrors.push({ + trace: xapiValidationUtils.addPropToTrace(localTrace), + message: xapiValidationErrors.DEFINITIONS_MUST_BE_OBJECTS, + level: xapiErrorLevels.MUST_VIOLATION + }); + + return localErrors; + } + + validateLanguageMap(definition.name, xapiValidationUtils.addPropToTrace(localTrace, properties.NAME), localErrors); + validateLanguageMap(definition.description, xapiValidationUtils.addPropToTrace(localTrace, properties.DESCRIPTION), localErrors); + + validatePropertyIsUri(definition, properties.TYPE, localTrace, localErrors, /*isRequired*/false); + validatePropertyIsUrl(definition, properties.MORE_INFO, localTrace, localErrors, /*isRequired*/false); + validateExtensions(definition.extensions, xapiValidationUtils.addPropToTrace(localTrace, properties.EXTENSIONS), localErrors); + + if (definition.interactionType !== undefined) { + if (definition.type !== xapiGeneral.INTERACTION_DEFINITION_TYPE) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace, properties.TYPE), + message: `${xapiValidationErrors.INTERACTION_ACTIVITY_SHOULD_HAVE} "${xapiGeneral.INTERACTION_DEFINITION_TYPE}"`, + level: xapiErrorLevels.SHOULD_VIOLATION + }); + } + + if (xapiValidationInteractionTypes.indexOf(definition.interactionType) === xapiGeneral.NO_INDEX_FOUND) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace, properties.INTERACTION_TYPE), + message: xapiValidationErrors.INTERACTION_TYPE_MUST_BE_CMI, + level: xapiErrorLevels.MUST_VIOLATION + }); + } + } + + if (definition.correctResponsesPattern !== undefined) { + if (!xapiValidationUtils.isArray(definition.correctResponsesPattern)) { + localErrors.push({ + trace: correctResponsesPatternTrace, + message: xapiValidationErrors.CORRECT_RESPONSES_PATTERN_MUST_BE_ARRAY, + level: xapiErrorLevels.MUST_VIOLATION + }); + } else { + definition.correctResponsesPattern.forEach((response, i) => { + if (response === null || response === undefined || !xapiValidationUtils.isString(response)) { + localErrors.push({ + trace: xapiValidationUtils.addLookupToTrace(correctResponsesPatternTrace, i), + message: xapiValidationErrors.CORRECT_RESPONSES_PATTERN_MUST_BE_STRINGS, + level: xapiErrorLevels.MUST_VIOLATION + }); + } + }); + } + } + + validateInteractionComponentArray( + definition.choices, + definition.interactionType, + [properties.CHOICE, properties.SEQUENCING], + xapiValidationUtils.addPropToTrace(localTrace, properties.CHOICES), + localErrors + ); + + validateInteractionComponentArray( + definition.scale, + definition.interactionType, + [properties.LIKERT], + xapiValidationUtils.addPropToTrace(localTrace, properties.SCALE), + localErrors + ); + + validateInteractionComponentArray( + definition.source, + definition.interactionType, + [properties.MATCHING], + xapiValidationUtils.addPropToTrace(localTrace, properties.SOURCE), + localErrors + ); + + validateInteractionComponentArray( + definition.target, + definition.interactionType, + [properties.MATCHING], + xapiValidationUtils.addPropToTrace(localTrace, properties.TARGET), + localErrors + ); + + validateInteractionComponentArray( + definition.steps, + definition.interactionType, + [properties.PERFORMANCE], + xapiValidationUtils.addPropToTrace(localTrace, properties.STEPS), + localErrors + ); + + validateAbsenceOfNonWhitelistedProperties(definition, xapiWhiteListProperties.ACTIVITY_DEFINITION, localTrace, localErrors); + return localErrors; +} + +function validateActivity(activity, trace, errors) { + var localErrors, localTrace; + + localErrors = errors || []; + localTrace = trace || properties.ACTIVITY; + + if (!xapiValidationUtils.isNonNullMapObject(activity)) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace), + message: xapiValidationErrors.ACTIVITIES_MUST_NOT_BE_NULL, + level: xapiErrorLevels.MUST_VIOLATION + }); + + return localErrors; + } + + validatePropertyIsUri(activity, properties.ID, localTrace, localErrors, /*isRequired*/true); + + if (activity.definition !== undefined) { + validateActivityDefintion( + activity.definition, + xapiValidationUtils.addPropToTrace(localTrace, properties.DEFINITION), + localErrors + ); + } + + validateAbsenceOfNonWhitelistedProperties(activity, xapiWhiteListProperties.ACTIVITY, localTrace, localErrors); + + return localErrors; +} + +function validateStatementRef(statementRef, trace, errors) { + var localErrors, localTrace; + + localErrors = errors || []; + localTrace = trace || properties.STATEMENT_REF; + + if (!xapiValidationUtils.isNonNullMapObject(statementRef)) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace), + message: xapiValidationErrors.STATEMENT_REF_MUST_NOT_BE_NULL_MAP_OBJECTS, + level: xapiErrorLevels.MUST_VIOLATION + }); + return localErrors; + } + + + if (statementRef.objectType !== objectTypes.STATEMENT_REF) { + localErrors.push({ + trace: xapiValidationUtils.addPropToTrace(localTrace, properties.OBJECT_TYPE), + message: xapiValidationErrors.OBJECT_TYPE_MUST_BE_STATEMENT_REF, + level: xapiErrorLevels.MUST_VIOLATION + }); + } + + if (!statementRef.id || !xapiValidationRegex.UUID.test(statementRef.id)) { + localErrors.push({ + trace: xapiValidationUtils.addPropToTrace(localTrace, properties.ID), + message: xapiValidationErrors.ID_MUST_BE_VALID_UUID_REF, + level: xapiErrorLevels.MUST_VIOLATION + }); + } + + validateAbsenceOfNonWhitelistedProperties(statementRef, xapiWhiteListProperties.STATEMENT_REF, localTrace, localErrors); + + return localErrors; +} + +function validateScore(score, trace, errors) { + var localErrors, localTrace; + + localErrors = errors || []; + localTrace = trace || properties.SCORE; + + if (score === undefined) { + return localErrors; + } + + validatePropertyIsNumber(score, properties.SCALED, localTrace, localErrors, /*isRequired*/false); + + if (score.scaled !== undefined) { + if (score.scaled < xapiGeneral.MIN_SCALED_VALUE || score.scaled > xapiGeneral.MAX_SCALED_VALUE) { + localErrors.push({ + trace: xapiValidationUtils.addPropToTrace(localTrace, properties.SCALED), + message: xapiValidationErrors.SCALED_MUST_BE_BETWEEN_0_1, + level: xapiErrorLevels.MUST_VIOLATION + }); + } + } + + if (score.min !== undefined) { + validatePropertyIsNumber(score, properties.MIN, localTrace, localErrors, /*isRequired*/false); + + if (score.raw !== undefined && score.raw < score.min) { + localErrors.push({ + trace: xapiValidationUtils.addPropToTrace(localTrace, properties.RAW), + message: xapiValidationErrors.RAW_MUST_BE_GREATER_THAN_MIN, + level: xapiErrorLevels.MUST_VIOLATION + }); + } + + if (score.max !== undefined && score.max < score.min) { + localErrors.push({ + trace: xapiValidationUtils.addPropToTrace(localTrace, properties.MAX), + message: xapiValidationErrors.MAX_MUST_BE_GREATER_THAN_MIN, + level: xapiErrorLevels.MUST_VIOLATION + }); + } + } + + if (score.max !== undefined) { + validatePropertyIsNumber(score, properties.MAX, localTrace, localErrors, /*isRequired*/false); + + if (score.raw !== undefined && score.raw > score.max) { + localErrors.push({ + trace: xapiValidationUtils.addPropToTrace(localTrace, properties.RAW), + message: xapiValidationErrors.RAW_MUST_BE_LESS_THAN_MAX, + level: xapiErrorLevels.MUST_VIOLATION + }); + } + } + + validatePropertyIsNumber(score, properties.RAW, localTrace, localErrors, /*isRequired*/false); + validateAbsenceOfNonWhitelistedProperties(score, xapiWhiteListProperties.SCORE, localTrace, localErrors); + + return localErrors; +} + +function validateResult(result, trace, errors) { + var localErrors, localTrace; + + localErrors = errors || []; + localTrace = trace || properties.RESULT; + + if (result === undefined) {return localErrors;} + + if (!xapiValidationUtils.isNonNullMapObject(result)) { + localErrors.push({ + trace: xapiValidationUtils.addPropToTrace(localTrace), + message: xapiValidationErrors.RESULT_MUST_BE_MAP_OBJECT, + level: xapiErrorLevels.MUST_VIOLATION + }); + + return localErrors; + } + + validateScore(result.score, xapiValidationUtils.addPropToTrace(localTrace, properties.SCORE), localErrors); + validatePropertyIsBoolean(result, properties.SUCCESS, localTrace, localErrors, /*isRequired*/false); + validatePropertyIsBoolean(result, properties.COMPLETION, localTrace, localErrors, /*isRequired*/false); + validatePropertyIsString(result, properties.RESPONSE, localTrace, localErrors, /*isRequired*/false); + validateExtensions(result.extensions, xapiValidationUtils.addPropToTrace(localTrace, properties.EXTENSIONS), localErrors); + + if (result.duration !== undefined && (result.duration === null || !xapiValidationUtils.isString(result.duration) || !xapiValidationRegex.ISO_8601_DURATION.test(result.duration))) { + localErrors.push({ + trace: xapiValidationUtils.addPropToTrace(localTrace, properties.DURATION), + message: xapiValidationErrors.DURATION_MUST_BE_VALID, + level: xapiErrorLevels.MUST_VIOLATION + }); + } + + validateAbsenceOfNonWhitelistedProperties(result, xapiWhiteListProperties.RESULT, localTrace, localErrors); + + return localErrors; +} + +function validatePropertyIsISO8601String(parent, propertyName, trace, errors) { + var localErrors, localTrace, matched, datetime; + + localErrors = errors || []; + localTrace = trace || properties.DATE_TIME; + datetime = parent[propertyName]; + + if (datetime === undefined) {return localErrors;} + + if (datetime === null || !xapiValidationUtils.isString(datetime)) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace, propertyName), + message: `${propertyName} ${xapiValidationErrors.MUST_BE_STRING}`, + level: xapiErrorLevels.MUST_VIOLATION + }); + + return localErrors; + } + + matched = xapiValidationRegex.ISO_8601_DATE_TIME.exec(datetime); + + if (matched) { + if (!dateIncludesZoneInformation(matched)) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace, propertyName), + message: xapiValidationErrors.DATE_SHOULD_INCLUDE_ZONE_INFORMATION, + level: xapiErrorLevels.SHOULD_VIOLATION + }); + } + } else { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace, propertyName), + message: xapiValidationErrors.DATE_MUST_BE_VALID, + level: xapiErrorLevels.MUST_VIOLATION + }); + } + + return localErrors; +} + +function validateVersion(version, trace, errors) { + var localErrors, localTrace; + + localErrors = errors || []; + localTrace = trace || properties.VERSION; + + if (version === undefined) {return localErrors;} + + if (version === null || !xapiValidationUtils.isString(version) || !xapiValidationRegex.SEMVER_1_P_0_P_0.test(version)) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace), + message: xapiValidationErrors.VERSION_MUST_COMPLY_SEMANTIC_VERSIONING, + level: xapiErrorLevels.MUST_VIOLATION + }); + } + + return localErrors; +} + +function validateAttachmentObject(attachment, trace, errors) { + var localErrors, localTrace; + + localErrors = errors || []; + localTrace = trace || properties.ATTACHMENT; + + if (!xapiValidationUtils.isNonNullMapObject(attachment)) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace), + message: xapiValidationErrors.ATTACHMENTS_MUST_NOT_BE_NULL_MAP_OBJECTS, + level: xapiErrorLevels.MUST_VIOLATION + }); + + return localErrors; + } + + if (attachment.display === undefined) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace, properties.DISPLAY), + message: xapiValidationErrors.DISPLAY_SHOULD_BE_PROVIDED, + level: xapiErrorLevels.MUST_VIOLATION + }); + + } else { + validateLanguageMap(attachment.display, xapiValidationUtils.addPropToTrace(localTrace, properties.DISPLAY), localErrors); + } + + validateLanguageMap(attachment.description, xapiValidationUtils.addPropToTrace(localTrace, properties.DESCRIPTION), localErrors); + validatePropertyIsUri(attachment, properties.USAGE_TYPE, localTrace, localErrors, /*isRequired*/true, xapiErrorLevels.MUST_VIOLATION); + validatePropertyIsUri(attachment, properties.FILE_URL, localTrace, localErrors, /*isRequired*/false, xapiErrorLevels.MUST_VIOLATION); + + // TODO - more complete validation for Internet Media Type via RFC 2046 + validatePropertyIsString(attachment, properties.CONTENT_TYPE, localTrace, localErrors, /*isRequired*/true, xapiErrorLevels.MUST_VIOLATION); + + if (attachment.length === undefined || attachment.length === null || !xapiValidationUtils.isNumber(attachment.length) || (attachment.length % 1 !== 0)) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace, properties.LENGTH), + message: xapiValidationErrors.LENGTH_MUST_BE_INTEGER, + level: xapiErrorLevels.MUST_VIOLATION + }); + } + + if (attachment.sha2 === undefined) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace, properties.SHA2), + message: xapiValidationErrors.SHA2_MUST_BE_PROVIDED_ON_ATTACHMENT_OBJECTS, + level: xapiErrorLevels.MUST_VIOLATION + }); + } else if (attachment.sha2 === null || !xapiValidationUtils.isString(attachment.sha2) || !xapiValidationRegex.BASE_64.test(attachment.sha2)) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace, properties.SHA2), + message: xapiValidationErrors.SHA2_MUST_CONTAIN_BASE_64_STRING, + level: xapiErrorLevels.MUST_VIOLATION + }); + } + + validateAbsenceOfNonWhitelistedProperties(attachment, xapiWhiteListProperties.ATTACHMENT, localTrace, localErrors); + return localErrors; +} + +function validateAttachments(attachments, trace, errors) { + var localErrors, localTrace; + + localErrors = errors || []; + localTrace = trace || properties.ATTACHMENTS; + + if (attachments === undefined) {return localErrors;} + + if (attachments === null || !xapiValidationUtils.isArray(attachments)) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace), + message: xapiValidationErrors.ATTACHMENTS_MUST_BE_NOT_NULL_ARRAY, + level: xapiErrorLevels.MUST_VIOLATION + }); + + return localErrors; + } + + attachments.forEach((attachment, i) => { + validateAttachmentObject(attachment, xapiValidationUtils.addLookupToTrace(localTrace, i), localErrors); + }); + + return localErrors; +} + +function validateAgent(agent, trace, errors) { + var localErrors, localTrace, ifiCount; + + localErrors = errors || []; + localTrace = trace || properties.AGENT; + + if (!xapiValidationUtils.isNonNullMapObject(agent)) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace), + message: xapiValidationErrors.AGENT_MUST_BE_NON_NULL_MAP_OBJECT, + level: xapiErrorLevels.MUST_VIOLATION + }); + return localErrors; + } + + ifiCount = getIFICount(agent); + + if (ifiCount !== xapiGeneral.NUMER_OF_SPECIFIED_IFI_PROPERTIES) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace), + message: xapiValidationErrors.AGENT_IFI_PROPERTIES_MUST_BE_SPECIFIED, + level: xapiErrorLevels.MUST_VIOLATION + }); + } + + if (agent.objectType === objectTypes.GROUP) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace), + message: xapiValidationErrors.AGENT_MUST_NOT_HAVE_GROUP_CHARACTERISTICS, + level: xapiErrorLevels.MUST_VIOLATION + }); + } + + validateIFIProperties(agent, localTrace, localErrors); + validatePropertyIsString(agent, properties.NAME, localTrace, localErrors, /*isRequired*/false); + + validateAbsenceOfNonWhitelistedProperties(agent, xapiWhiteListProperties.AGENT, localTrace, localErrors); + + return localErrors; +} + +function validateGroup(group, trace, errors) { + var localErrors, localTrace, memberTrace, ifiCount; + + localErrors = errors || []; + localTrace = trace || properties.GROUP; + memberTrace = xapiValidationUtils.addPropToTrace(localTrace, properties.MEMBER); + + if (!xapiValidationUtils.isNonNullMapObject(group)) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace), + message: xapiValidationErrors.GROUP_MUST_BE_NON_NULL_MAP_OBJECT, + level: xapiErrorLevels.MUST_VIOLATION + }); + + return localErrors; + } + + ifiCount = getIFICount(group); + + if (ifiCount === 0) { + if (group.member === null || group.member === undefined) { + localErrors.push({ + trace: memberTrace, + message: xapiValidationErrors.MEMBER_MUST_BE_PROVIDED_FOR_ANONYMOUS_GROUPS, + level: xapiErrorLevels.MUST_VIOLATION + }); + } + } else if (ifiCount > xapiGeneral.NUMER_OF_SPECIFIED_IFI_PROPERTIES) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace), + message: xapiValidationErrors.GROUP_IFI_PROPERTIES_MUST_BE_SPECIFIED, + level: xapiErrorLevels.MUST_VIOLATION + }); + } + + validateIFIProperties(group, localTrace, localErrors); + + validatePropertyIsString(group, properties.NAME, localTrace, localErrors, /*isRequired*/false); + + if (group.member !== undefined) { + if (group.member === null || !xapiValidationUtils.isArray(group.member)) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace, properties.MEMBER), + message: xapiValidationErrors.GROUP_MEMBER_MUST_BE_ARRAY, + level: xapiErrorLevels.MUST_VIOLATION + }); + } else { + group.member.forEach((member, i) => { + validateAgent(member, xapiValidationUtils.addLookupToTrace(memberTrace, i), localErrors); + }); + } + } + + validateAbsenceOfNonWhitelistedProperties(group, xapiWhiteListProperties.GROUP, localTrace, localErrors); + + return localErrors; +} + +function validateActor(actor, trace, errors) { + var localErrors, localTrace; + + localErrors = errors || []; + localTrace = trace || properties.ACTOR; + + if (actor === null || actor === undefined) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace), + message: xapiValidationErrors.ACTOR_MUST_BE_PROVIDED, + level: xapiErrorLevels.MUST_VIOLATION + }); + + return localErrors; + } + + if (xapiValidationUtils.isGroup(actor, objectTypes.GROUP)) { + validateGroup(actor, localTrace, localErrors); + } else { + validateAgent(actor, localTrace, localErrors); + } + + return localErrors; +} + +function validateAuthority(authority, trace, errors) { + var localErrors, localTrace; + + localErrors = errors || []; + localTrace = trace || properties.AUTHORITY; + + if (authority === undefined) { + return localErrors; + } + + if (!xapiValidationUtils.isNonNullMapObject(authority)) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace), + message: xapiValidationErrors.AUTHORITY_MUST_BE_NON_NULL_MAP_OBJECT, + level: xapiErrorLevels.MUST_VIOLATION + }); + + return localErrors; + } + if (xapiValidationUtils.isGroup(authority, objectTypes.GROUP)) { + validateGroup(authority, localTrace, localErrors); + if (!authority.member || !authority.member.length || authority.member.length !== xapiGeneral.GROUP_AUTHORITY_AGENT_MEMBERS) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace, properties.MEMBER), + message: xapiValidationErrors.GROUP_AUTHORITY_AGENT_MEMBERS_MUST_BE_TWO, + level: xapiErrorLevels.MUST_VIOLATION + }); + } + } else { + validateAgent(authority, localTrace, localErrors); + } + + return localErrors; +} + +function validateContextActivitySubContext(subContext, trace, errors) { + var localErrors, localTrace; + + localErrors = errors || []; + localTrace = trace || properties.SUB_CONTEXT; + + if (subContext === undefined) {return localErrors;} + + if (subContext === null) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace), + message: xapiValidationErrors.CONTEXT_ACTIVITIES_MUST_NOT_BE_NULL, + level: xapiErrorLevels.MUST_VIOLATION + }); + } else if (xapiValidationUtils.isArray(subContext)) { + subContext.forEach((activity, i) => { + validateActivity(activity, xapiValidationUtils.addLookupToTrace(localTrace, i), localErrors); + }); + } else if (xapiValidationUtils.isObject(subContext)) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace), + message: xapiValidationErrors.CONTEXT_ACTIVITIES_SHOULD_BE_AN_ARRAY, + level: xapiErrorLevels.SHOULD_VIOLATION + }); + + validateActivity(subContext, localTrace, localErrors); + } else { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace), + message: xapiValidationErrors.CONTEXT_ACTIVITIES_MUST_BE_ARRAY_OR_ACTIVITY_OBJ, + level: xapiErrorLevels.MUST_VIOLATION}); + } + return localErrors; +} + +function validateContextActivities(contextActivities, trace, errors) { + var localErrors, localTrace; + + localErrors = errors || []; + localTrace = trace || properties.CONTEXT_ACTIVITIES; + + if (contextActivities === undefined) { + return localErrors; + } + + if (!xapiValidationUtils.isNonNullMapObject(contextActivities)) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace), + message: xapiValidationErrors.CONTEXT_ACTIVITIES_MUST_BE_NON_NULL_MAP_OBJECT, + level: xapiErrorLevels.MUST_VIOLATION + }); + return localErrors; + } + + validateContextActivitySubContext(contextActivities.parent, xapiValidationUtils.addPropToTrace(localTrace, properties.PARENT), localErrors); + validateContextActivitySubContext(contextActivities.grouping, xapiValidationUtils.addPropToTrace(localTrace, properties.GROUPING), localErrors); + validateContextActivitySubContext(contextActivities.category, xapiValidationUtils.addPropToTrace(localTrace, properties.CATEGORY), localErrors); + validateContextActivitySubContext(contextActivities.other, xapiValidationUtils.addPropToTrace(localTrace, properties.OTHER), localErrors); + + validateAbsenceOfNonWhitelistedProperties(contextActivities, xapiWhiteListProperties.CONTEXT_ACTIVITIES, localTrace, localErrors); + + return localErrors; +} + +function validateContext(context, trace, errors, statementObjectObjectType) { + var localErrors, localTrace; + + localErrors = errors || []; + localTrace = trace || properties.CONTEXT; + + if (context === undefined) {return localErrors;} + + if (!xapiValidationUtils.isNonNullMapObject(context)) { + localErrors.push({ + trace: localTrace, + message: xapiValidationErrors.CONTEXT_MUST_BE_NON_NUL_MAP_OBJECT, + level: xapiErrorLevels.MUST_VIOLATION + }); + + return localErrors; + } + + if (context.registration !== undefined && (context.registration === null || !xapiValidationUtils.isString(context.registration) || !xapiValidationRegex.UUID.test(context.registration))) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace, properties.REGISTRATION), + message: xapiValidationErrors.REGISTRATION_MUST_BE_UUID_STRING, + level: xapiErrorLevels.MUST_VIOLATION + }); + } + + if ([objectTypes.GROUP, objectTypes.AGENT].indexOf(statementObjectObjectType) !== xapiGeneral.NO_INDEX_FOUND) { + if (context.revision !== undefined) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace, properties.REVISION), + message: xapiValidationErrors.REVISION_MUST_BE_AGENT_OR_GROUP, + level: xapiErrorLevels.MUST_VIOLATION + }); + } + + if (context.platform !== undefined) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace, properties.PLATFORM), + message: xapiValidationErrors.PLATFORM_MUST_NOT_BE_USED_WITH_REVISION_AGENT_OR_GROUP, + level: xapiErrorLevels.MUST_VIOLATION + }); + } + } + + validatePropertyIsString(context, properties.REVISION, localTrace, localErrors, /*isRequired*/false, xapiErrorLevels.MUST_VIOLATION); + validatePropertyIsString(context, properties.PLATFORM, localTrace, localErrors, /*isRequired*/false, xapiErrorLevels.MUST_VIOLATION); + + if (context.team !== undefined) { + validateGroup(context.team, xapiValidationUtils.addPropToTrace(localTrace, properties.TEAM), localErrors); + } + + if (context.contextActivities !== undefined) { + validateContextActivities(context.contextActivities, xapiValidationUtils.addPropToTrace(localTrace, properties.CONTEXT_ACTIVITIES), localErrors); + } + + if (context.language !== undefined && !xapiValidationUtils.isValidLanguageTag(context.language, xapiValidationRegex.BCP_47)) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace, properties.LANGUAGE), + message: xapiValidationErrors.LANGUAGE_MUST_BE_STRING, + level: xapiErrorLevels.MUST_VIOLATION + }); + } + + if (context.statement !== undefined) { + validateStatementRef(context.statement, xapiValidationUtils.addPropToTrace(localTrace, properties.STATEMENT), localErrors); + } + + if (context.instructor !== undefined) { + if (xapiValidationUtils.isGroup(context.instructor, objectTypes.GROUP)) { + validateGroup(context.instructor, xapiValidationUtils.addPropToTrace(localTrace, properties.INSTRUCTOR), localErrors); + } else { + validateAgent(context.instructor, xapiValidationUtils.addPropToTrace(localTrace, properties.INSTRUCTOR), localErrors); + } + } + + validateExtensions(context.extensions, xapiValidationUtils.addPropToTrace(localTrace, properties.EXTENSIONS), localErrors); + validateAbsenceOfNonWhitelistedProperties(context, xapiWhiteListProperties.EXTENSIONS,localTrace,localErrors); + + return localErrors; +} + +function validateObject(object, trace, errors, isWithinSubStatement) { + var localErrors, localTrace, objectType; + + localErrors = errors || []; + localTrace = trace || properties.OBJECT; + + if (object === undefined) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace), + message: xapiValidationErrors.OBJECT_MUST_BE_DEFINED, + level: xapiErrorLevels.MUST_VIOLATION + }); + + return localErrors; + } + + if (!xapiValidationUtils.isNonNullMapObject(object)) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace), + message: xapiValidationErrors.OBJECT_MUST_BE_NON_NULL_MAP_OBJECT, + level: xapiErrorLevels.MUST_VIOLATION + }); + + return localErrors; + } + + validatePropertyIsString(object, properties.OBJECT_TYPE, localTrace, localErrors, /*isRequired*/true, xapiErrorLevels.SHOULD_VIOLATION); + + objectType = object.objectType || objectTypes.ACTIVITY; + + switch (objectType) { + case objectTypes.ACTIVITY: + validateActivity(object, localTrace, localErrors); + break; + case objectTypes.AGENT: + validateAgent(object, localTrace, localErrors); + break; + case objectTypes.GROUP: + validateGroup(object, localTrace, localErrors); + break; + case objectTypes.STATEMENT_REF: + validateStatementRef(object, localTrace, localErrors); + break; + case objectTypes.SUB_STATEMENT: + if (isWithinSubStatement) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace, properties.OBJECT_TYPE), + message: xapiValidationErrors.SUB_STATEMENT_MUST_NOT_CONTAIN_SUB_STATEMENT, + level: xapiErrorLevels.MUST_VIOLATION + }); + } + validate(object, localTrace, localErrors, /*isSubStatement*/true); + break; + default: + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace, properties.OBJECT_TYPE), + message: `${xapiValidationErrors.OBJECT_TYPE_MUST_BE_VALID_OPTION} ${xApiValidObjectTypes.toString()}`, + level: xapiErrorLevels.MUST_VIOLATION + }); + } + + return localErrors; +} + +function validate(statement, trace, errors, isSubStatement) { + var localErrors, localTrace, statementObjectObjectType, whitelistedProperties; + + localErrors = errors || []; + localTrace = trace || properties.STATEMENT; + + whitelistedProperties = xapiWhiteListProperties.STATEMENT; + + if (!xapiValidationUtils.isNonNullMapObject(statement)) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace), + message: xapiValidationErrors.STATEMENT_REF_MUST_NOT_BE_NULL_MAP_OBJECTS, + level: xapiErrorLevels.MUST_VIOLATION + }); + + return localErrors; + } + + if (!isSubStatement) { + if (statement.id === null || statement.id === undefined || !xapiValidationUtils.isString(statement.id)) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace, properties.ID), + message: xapiValidationErrors.IDS_SHOULD_BE_GENERATED_BY_LRS, + level: xapiErrorLevels.SHOULD_VIOLATION + }); + } else if (!xapiValidationRegex.UUID.test(statement.id)) { + localErrors.push({ + trace: xapiValidationUtils.localTraceToString(localTrace, properties.ID), + message: xapiValidationErrors.ID_MUST_BE_VALID, + level: xapiErrorLevels.MUST_VIOLATION + }); + } + } else { + whitelistedProperties = xapiWhiteListProperties.SUB_STATEMENT; + } + + validateActor(statement.actor, xapiValidationUtils.addPropToTrace(localTrace, properties.ACTOR), localErrors); + validateVerb(statement.verb, xapiValidationUtils.addPropToTrace(localTrace, properties.VERB), localErrors); + validateObject(statement.object, xapiValidationUtils.addPropToTrace(localTrace, properties.OBJECT), localErrors, isSubStatement); + validateResult(statement.result, xapiValidationUtils.addPropToTrace(localTrace, properties.RESULT), localErrors); + + statementObjectObjectType = statement.object && statement.object.objectType ? statement.object.objectType : objectTypes.ACTIVITY; + + validateContext(statement.context, xapiValidationUtils.addPropToTrace(localTrace, properties.CONTEXT), localErrors, statementObjectObjectType); + validatePropertyIsISO8601String(statement, properties.TIMESTAMP, localTrace, localErrors); + validatePropertyIsISO8601String(statement, properties.STORED, localTrace, localErrors); + + validateAuthority(statement.authority, xapiValidationUtils.addPropToTrace(localTrace, properties.AUTHORITY), localErrors); + validateVersion(statement.version, xapiValidationUtils.addPropToTrace(localTrace, properties.VERSION), localErrors); + validateAttachments(statement.attachments, xapiValidationUtils.addPropToTrace(localTrace, properties.ATTACHMENTS), localErrors); + + validateAbsenceOfNonWhitelistedProperties(statement, whitelistedProperties, localTrace, localErrors); + + return localErrors; +} + +function makeStatementReport(statement) { + var localErrors; + + localErrors = []; + validate(statement, properties.STATEMENT, localErrors, /*isRequired*/false); + + return makeV1Report(statement, localErrors); +} + +function validateAmbiguousTypeStatement(statement) { + var statementObject; + + if (statement === undefined) { + return makeV1SingleErrorReport(/*instance*/null, { + trace: properties.STATEMENT, + message: xapiValidationErrors.STATEMENT_ARGUMENT_MUST_BE_PROVIDED, + level: xapiErrorLevels.MUST_VIOLATION + }); + } + + if (statement === null) { + return makeV1SingleErrorReport(/*instance*/null, { + trace: properties.STATEMENT, + message: xapiValidationErrors.STATEMENT_MUST_NOT_BE_NULL, + level: xapiErrorLevels.MUST_VIOLATION + }); + } + + if (xapiValidationUtils.isString(statement)) { + try { + statementObject = JSON.parse(statement); + if (statementObject === null || !xapiValidationUtils.isObject(statementObject) || xapiValidationUtils.isArray(statementObject)) { + return makeV1SingleErrorReport(statementObject, { + trace: properties.STATEMENT, + message: xapiValidationErrors.STATEMENT_MUST_BE_PARSED_CORRECTLY, + level: xapiErrorLevels.MUST_VIOLATION + }); + } + } catch (e) { + return makeV1SingleErrorReport(statementObject, { + trace: properties.STATEMENT, + message: `${xapiValidationErrors.INVALID_JSON}: ${e.message}`, + level: xapiErrorLevels.MUST_VIOLATION + }); + } + + return makeStatementReport(statementObject); + } + + if (xapiValidationUtils.isObject(statement) && !xapiValidationUtils.isArray(statement)) { + return makeStatementReport(statement); + } + + return makeV1SingleErrorReport(/*instance*/null, { + trace: properties.STATEMENT, + message: xapiValidationErrors.STATEMENT_ARGUMENT_IS_NOT_VALID, + level: xapiErrorLevels.MUST_VIOLATION + }); +} + +function dateIncludesZoneInformation(matched) { + return matched[dateFormatRegexPositions.ZONE] || + (matched[dateFormatRegexPositions.RELATIVE_TIME] && matched[dateFormatRegexPositions.TIME_ZONE_HOUR]); +} + +xapiValidation = { + validateStatement: validateAmbiguousTypeStatement +}; + +module.exports = xapiValidation; diff --git a/spec/xapiValidator_spec.js b/test/xapiValidator.test.js similarity index 98% rename from spec/xapiValidator_spec.js rename to test/xapiValidator.test.js index 265532e..cad8730 100644 --- a/spec/xapiValidator_spec.js +++ b/test/xapiValidator.test.js @@ -1,24 +1,28 @@ +import {_} from 'underscore'; +import {expect} from 'chai'; +import xapiValidator from '../src/xapiValidator'; + describe("xapiValidator", function() { describe("#validateStatement", function() { - + function reportHasErrorWithTracePrefix(report, prefix, targetLevel) { - if (report == null || report == undefined || report.errors == null || report.errors == undefined) { + if (report === null || report === undefined || report.errors === null || report.errors === undefined) { return false; } var hasTargetLevel = targetLevel !== null && targetLevel !== undefined; return _.any(report.errors, function(err) { - var foundPrefix = err.trace.indexOf(prefix) == 0; - return hasTargetLevel ? targetLevel == err.level && foundPrefix : foundPrefix; + var foundPrefix = err.trace.indexOf(prefix) === 0; + return hasTargetLevel ? targetLevel === err.level && foundPrefix : foundPrefix; }); } - + describe("when passed no arguments", function() { it("returns non-null report", function() { var result = xapiValidator.validateStatement(); expect(result).to.be.not.null; expect(result).to.be.a("Object"); }); - + it("includes one error", function() { var result = xapiValidator.validateStatement(); var errors = result.errors; @@ -30,14 +34,14 @@ describe("xapiValidator", function() { expect(errors[0]).to.have.property("level") .that.equals("MUST_VIOLATION"); }); - + it("has a null instance property in the report", function() { expect(xapiValidator.validateStatement()) .to.have.property("instance") .that.is.null; }); }); - + describe("when passed a null argument", function() { it("returns non-null report", function() { var result = xapiValidator.validateStatement(null); @@ -47,7 +51,7 @@ describe("xapiValidator", function() { .that.is.a("Array"); expect(result).to.have.property("instance"); }); - + it("includes one error", function() { var result = xapiValidator.validateStatement(null); var errors = result.errors; @@ -59,14 +63,14 @@ describe("xapiValidator", function() { expect(errors[0]).to.have.property("level") .that.equals("MUST_VIOLATION"); }); - + it("has a null instance property in the report", function() { expect(xapiValidator.validateStatement(null)) .to.have.property("instance") .that.is.null; }); }); - + describe("when passed a json string argument", function() { var minimalJsonString = "{\"id\":\"whatever\"}"; it("returns non-null report", function() { @@ -77,7 +81,7 @@ describe("xapiValidator", function() { .that.is.a("Array"); expect(result).to.have.property("instance"); }); - + it("has an instance property with the deserialized JSON in the report", function() { var result = xapiValidator.validateStatement(minimalJsonString); expect(result).to.have.property("instance") @@ -85,7 +89,7 @@ describe("xapiValidator", function() { .that.deep.equals({"id":"whatever"}); }); }); - + describe("when passed a json string argument encoding null", function() { var minimalJsonString = "null"; it("returns non-null report", function() { @@ -96,7 +100,7 @@ describe("xapiValidator", function() { .that.is.a("Array"); expect(result).to.have.property("instance"); }); - + it("includes one error", function() { var result = xapiValidator.validateStatement(minimalJsonString); var errors = result.errors; @@ -106,14 +110,14 @@ describe("xapiValidator", function() { expect(errors[0]).to.have.property("level") .that.equals("MUST_VIOLATION"); }); - + it("has an instance property with null value", function() { var result = xapiValidator.validateStatement(minimalJsonString); expect(result).to.have.property("instance") .that.is.null; }); }); - + describe("when passed an invalid json string argument", function() { var minimalJsonString = "derp"; it("returns non-null report", function() { @@ -124,25 +128,24 @@ describe("xapiValidator", function() { .that.is.a("Array"); expect(result).to.have.property("instance"); }); - + it("includes one error", function() { var result = xapiValidator.validateStatement(minimalJsonString); var errors = result.errors; expect(errors).to.be.instanceOf(Array); expect(errors).to.have.length(1); - expect(errors[0]).to.have.property("message") - .that.equals("Invalid JSON. The statement could not be parsed: Unexpected token d"); + expect(errors[0]).to.have.property("message"); expect(errors[0]).to.have.property("level") .that.equals("MUST_VIOLATION"); }); - + it("has an instance property with null value", function() { var result = xapiValidator.validateStatement(minimalJsonString); expect(result).to.have.property("instance") .that.is.null; }); }); - + describe("when passed a statement object", function() { var inputStatement = {id : "fd41c918-b88b-4b20-a0a5-a4c32391aaa0" , actor : {mbox:"mailto:agent@example.com"}, @@ -156,14 +159,14 @@ describe("xapiValidator", function() { .that.is.a("Array"); expect(result).to.have.property("instance"); }); - + it("has an instance property that matches the input object", function() { var result = xapiValidator.validateStatement(inputStatement); expect(result).to.have.property("instance") .that.deep.equals(inputStatement); }); }); - + describe("when given a null id property", function() { var inputStatement = {id : null , actor : {mbox:"mailto:agent@example.com"}, @@ -174,7 +177,7 @@ describe("xapiValidator", function() { expect(reportHasErrorWithTracePrefix(result, "statement.id")).to.be.true; }); }); - + describe("when given an invalid UUID id property", function() { var inputStatement = {id : "abc123", actor : {mbox:"mailto:agent@example.com"}, @@ -185,7 +188,7 @@ describe("xapiValidator", function() { expect(reportHasErrorWithTracePrefix(result, "statement.id")).to.be.true; }); }); - + describe("when given a valid UUID id property", function() { var inputStatement = {id : "fd41c918-b88b-4b20-a0a5-a4c32391aaa0", actor : {mbox:"mailto:agent@example.com"}, @@ -196,7 +199,7 @@ describe("xapiValidator", function() { expect(reportHasErrorWithTracePrefix(result, "statement.id")).to.be.false; }); }); - + describe("when given a null actor property", function() { var inputStatement = {id : "fd41c918-b88b-4b20-a0a5-a4c32391aaa0" , actor : null, @@ -207,7 +210,7 @@ describe("xapiValidator", function() { expect(reportHasErrorWithTracePrefix(result, "statement.actor")).to.be.true; }); }); - + describe("when given an empty non-null actor property", function() { var inputStatement = {id : "fd41c918-b88b-4b20-a0a5-a4c32391aaa0" , actor : {}, @@ -218,7 +221,7 @@ describe("xapiValidator", function() { expect(reportHasErrorWithTracePrefix(result, "statement.actor")).to.be.true; }); }); - + describe("when given an otherwise valid actor", function() { var inputStatement = {id : "fd41c918-b88b-4b20-a0a5-a4c32391aaa0" , actor : {mbox:"mailto:group@example.com"}, @@ -228,13 +231,13 @@ describe("xapiValidator", function() { var result = xapiValidator.validateStatement(inputStatement); expect(result.errors).to.have.property("length", 0); }); - + it("the name property produces no errors when a simple string", function() { inputStatement.actor.name = "hello"; var result = xapiValidator.validateStatement(inputStatement); expect(result.errors).to.have.property("length", 0); }); - + it("the name property produces no errors when a simple string", function() { inputStatement.actor.name = 1.23; var result = xapiValidator.validateStatement(inputStatement); @@ -242,7 +245,7 @@ describe("xapiValidator", function() { expect(result.errors).to.have.property("length", 1); }); }); - + describe("when given an actor with an objectType of 'Group'", function() { var moreValidStatement = {id : "fd41c918-b88b-4b20-a0a5-a4c32391aaa0" , actor : {objectType:"Group", member:[]}, @@ -252,7 +255,7 @@ describe("xapiValidator", function() { var result = xapiValidator.validateStatement(moreValidStatement); expect(reportHasErrorWithTracePrefix(result, "statement.actor.member")).to.be.false; }); - + it("the member property is required to be present if the actor is unidentified, and produces an error when absent", function() { var inputInvalidStatement = {id : "fd41c918-b88b-4b20-a0a5-a4c32391aaa0" , actor : {objectType:"Group"}, @@ -261,15 +264,15 @@ describe("xapiValidator", function() { var result = xapiValidator.validateStatement(inputInvalidStatement); expect(reportHasErrorWithTracePrefix(result, "statement.actor.member")).to.be.true; }); - + it("the member property is not required to be present if the actor is identified", function() { - var result = xapiValidator.validateStatement({id : "fd41c918-b88b-4b20-a0a5-a4c32391aaa0" , + var result = xapiValidator.validateStatement({id : "fd41c918-b88b-4b20-a0a5-a4c32391aaa0" , actor : {objectType:"Group", mbox:"mailto:group@example.com"}, verb: { "id":"http://adlnet.gov/expapi/verbs/created", "display":{"en-US":"created"}}, object : {id : "http://example.com/myUniqueId", objectType:"Activity"}}); expect(reportHasErrorWithTracePrefix(result, "statement.actor.member")).to.be.false; }); - + it("the member property is allowed to be present if the actor is identified", function() { var result = xapiValidator.validateStatement({id : "fd41c918-b88b-4b20-a0a5-a4c32391aaa0", actor : {objectType:"Group", mbox:"mailto:group@example.com", member:[]}, @@ -278,7 +281,7 @@ describe("xapiValidator", function() { expect(reportHasErrorWithTracePrefix(result, "statement.actor.member")).to.be.false; }); }); - + describe("when given an actor with a members property", function() { var inputStatement = {id : "fd41c918-b88b-4b20-a0a5-a4c32391aaa0" , actor : {member:[]}, @@ -287,28 +290,28 @@ describe("xapiValidator", function() { it("the member property has no errors about it when present but empty", function() { expect(xapiValidator.validateStatement(inputStatement).errors).to.be.empty; }); - + it("the member property has no errors when populated with a simple agent", function() { inputStatement.actor.member = [{mbox:"mailto:group@example.com"}]; expect(xapiValidator.validateStatement(inputStatement).errors).to.be.empty; }); - + it("the member property reports an error when populated with a Group object via objectType", function() { inputStatement.actor.member = [{mbox:"mailto:group@example.com", objectType:"Group"}]; expect(xapiValidator.validateStatement(inputStatement).errors) .to.have.property("length", 1); }); - + it("the member property's agent reports an error when given an account missing its homePage", function() { inputStatement.actor.member = [{account:{name:"bob"}}]; expect(reportHasErrorWithTracePrefix(xapiValidator.validateStatement(inputStatement), "statement.actor.member[0].account.homePage")).to.be.true; }); - + it("the member property's agent reports an error when given an account missing its name", function() { inputStatement.actor.member = [{account:{homePage:"http://example.com"}}]; expect(reportHasErrorWithTracePrefix(xapiValidator.validateStatement(inputStatement), "statement.actor.member[0].account.name")).to.be.true; }); - + it("the member property's agent reports an error when given an account with an all-lowercase homepage", function() { inputStatement.actor.member = [{account:{homepage:"http://example.com", name:"bob"}}]; var report = xapiValidator.validateStatement(inputStatement); @@ -322,28 +325,28 @@ describe("xapiValidator", function() { expect(xapiValidator.validateStatement(inputStatement).errors) .to.have.property("length", 0); }); - + it("the member property's agent reports no error when given a valid mbox", function() { inputStatement.actor.member = [{mbox:"mailto:bob@example.com"}]; expect(xapiValidator.validateStatement(inputStatement).errors) .to.have.property("length", 0); }); - + it("the member property's agent reports an error when given an invalid mbox", function() { inputStatement.actor.member = [{mbox:"SOMETHINGWRONG:bob@example.com"}]; var results = xapiValidator.validateStatement(inputStatement); expect(reportHasErrorWithTracePrefix(results, "statement.actor.member[0].mbox")).to.be.true; expect(results.errors).to.have.property("length", 1); }); - + it("the member property reports an error when populated with a Group object via member", function() { inputStatement.actor.member = [{mbox:"mailto:group@example.com", member:[]}]; expect(xapiValidator.validateStatement(inputStatement).errors) .to.have.property("length", 1); }); - + }); - + describe("when given a statement without a verb property", function() { it("reports an error", function() { var inputStatement = {id : "fd41c918-b88b-4b20-a0a5-a4c32391aaa0" , @@ -354,7 +357,7 @@ describe("xapiValidator", function() { expect(reportHasErrorWithTracePrefix(results, "statement.verb")).to.be.true; }); }); - + describe("when given a verb without an id property", function() { it("reports an error", function() { var inputStatement = {id : "fd41c918-b88b-4b20-a0a5-a4c32391aaa0" , @@ -366,7 +369,7 @@ describe("xapiValidator", function() { expect(reportHasErrorWithTracePrefix(results, "statement.verb.id", "MUST_VIOLATION")).to.be.true; }); }); - + describe("when given a verb with a non-string id property", function() { it("reports an error", function() { var inputStatement = {id : "fd41c918-b88b-4b20-a0a5-a4c32391aaa0" , @@ -378,7 +381,7 @@ describe("xapiValidator", function() { expect(reportHasErrorWithTracePrefix(results, "statement.verb.id", "MUST_VIOLATION")).to.be.true; }); }); - + describe("when given a verb with a relative URI id property", function() { it("reports an SHOULD_VIOLATION error", function() { var inputStatement = {id : "fd41c918-b88b-4b20-a0a5-a4c32391aaa0" , @@ -390,7 +393,7 @@ describe("xapiValidator", function() { expect(reportHasErrorWithTracePrefix(results, "statement.verb.id", "SHOULD_VIOLATION")).to.be.true; }); }); - + describe("when given a verb without a display property", function() { it("reports an error", function() { var inputStatement = {id : "fd41c918-b88b-4b20-a0a5-a4c32391aaa0" , @@ -402,7 +405,7 @@ describe("xapiValidator", function() { expect(reportHasErrorWithTracePrefix(results, "statement.verb.display", "SHOULD_VIOLATION")).to.be.true; }); }); - + describe("when given a verb with an empty display property", function() { it("reports no errors", function() { var inputStatement = {id : "fd41c918-b88b-4b20-a0a5-a4c32391aaa0" , @@ -412,7 +415,7 @@ describe("xapiValidator", function() { expect(xapiValidator.validateStatement(inputStatement).errors).to.have.property("length", 0); }); }); - + describe("when given a verb.display with RFC 5646 key and string value", function() { it("reports no errors", function() { var inputStatement = {id : "fd41c918-b88b-4b20-a0a5-a4c32391aaa0" , @@ -422,7 +425,7 @@ describe("xapiValidator", function() { expect(xapiValidator.validateStatement(inputStatement).errors).to.have.property("length", 0); }); }); - + describe("when given a verb.display with RFC 5646 key and non-string value", function() { it("reports an error", function() { var inputStatement = {id : "fd41c918-b88b-4b20-a0a5-a4c32391aaa0" , @@ -434,7 +437,7 @@ describe("xapiValidator", function() { expect(reportHasErrorWithTracePrefix(results, "statement.verb.display[\"en-US\"]", "MUST_VIOLATION")).to.be.true; }); }); - + describe("when given a verb.display with invalid key and string value", function() { it("reports an error", function() { var inputStatement = {id : "fd41c918-b88b-4b20-a0a5-a4c32391aaa0" , @@ -446,7 +449,7 @@ describe("xapiValidator", function() { expect(reportHasErrorWithTracePrefix(results, "statement.verb.display.123totallyWrong", "MUST_VIOLATION")).to.be.true; }); }); - + describe("when the object property is absent", function() { it("reports a MUST_VIOLATION error", function() { var inputStatement = {id : "fd41c918-b88b-4b20-a0a5-a4c32391aaa0" , @@ -457,7 +460,7 @@ describe("xapiValidator", function() { expect(reportHasErrorWithTracePrefix(results, "statement.object", "MUST_VIOLATION")).to.be.true; }); }); - + describe("when the object property is null", function() { it("reports a MUST_VIOLATION error", function() { var inputStatement = {id : "fd41c918-b88b-4b20-a0a5-a4c32391aaa0" , @@ -469,7 +472,7 @@ describe("xapiValidator", function() { expect(reportHasErrorWithTracePrefix(results, "statement.object", "MUST_VIOLATION")).to.be.true; }); }); - + describe("when the object lacks an objectType property", function() { it("reports a SHOULD_VIOLATION error", function() { var inputStatement = {id : "fd41c918-b88b-4b20-a0a5-a4c32391aaa0" , @@ -487,7 +490,7 @@ describe("xapiValidator", function() { var inputStatement = {id : "fd41c918-b88b-4b20-a0a5-a4c32391aaa0" , actor : {member:[]}, verb: { "id":"http://adlnet.gov/expapi/verbs/created", display : {"en-US":"created"}}, - object : {id : "http://example.com/myUniqueId", objectType:"Activity", + object : {id : "http://example.com/myUniqueId", objectType:"Activity", definition: null}}; var results = xapiValidator.validateStatement(inputStatement); expect(results.errors).to.have.property("length", 1); @@ -500,7 +503,7 @@ describe("xapiValidator", function() { var inputStatement = {id : "fd41c918-b88b-4b20-a0a5-a4c32391aaa0" , actor : {member:[]}, verb: { "id":"http://adlnet.gov/expapi/verbs/created", display : {"en-US":"created"}}, - object : {id : "http://example.com/myUniqueId", objectType:"Activity", + object : {id : "http://example.com/myUniqueId", objectType:"Activity", definition: []}}; var results = xapiValidator.validateStatement(inputStatement); expect(results.errors).to.have.property("length", 1); @@ -524,7 +527,7 @@ describe("xapiValidator", function() { var inputStatement = {id : "fd41c918-b88b-4b20-a0a5-a4c32391aaa0" , actor : {member:[]}, verb: { "id":"http://adlnet.gov/expapi/verbs/created", display : {"en-US":"created"}}, - object : {id : "http://example.com/myUniqueId", objectType:"Activity", + object : {id : "http://example.com/myUniqueId", objectType:"Activity", definition:{name:1.23}}}; var results = xapiValidator.validateStatement(inputStatement); expect(results.errors).to.have.property("length", 1); @@ -535,7 +538,7 @@ describe("xapiValidator", function() { var inputStatement = {id : "fd41c918-b88b-4b20-a0a5-a4c32391aaa0" , actor : {member:[]}, verb: { "id":"http://adlnet.gov/expapi/verbs/created", display : {"en-US":"created"}}, - object : {id : "http://example.com/myUniqueId", objectType:"Activity", + object : {id : "http://example.com/myUniqueId", objectType:"Activity", definition:{name:{"123 totally not a language code" : "created"}}}}; var results = xapiValidator.validateStatement(inputStatement); expect(results.errors).to.have.property("length", 1); @@ -546,20 +549,20 @@ describe("xapiValidator", function() { var inputStatement = {id : "fd41c918-b88b-4b20-a0a5-a4c32391aaa0" , actor : {member:[]}, verb: { "id":"http://adlnet.gov/expapi/verbs/created", display : {"en-US":"created"}}, - object : {id : "http://example.com/myUniqueId", objectType:"Activity", + object : {id : "http://example.com/myUniqueId", objectType:"Activity", definition:{type:"http://adlnet.gov/expapi/activities/cmi.interaction", interactionType:"true-false"}}}; var results = xapiValidator.validateStatement(inputStatement); expect(results.errors).to.have.property("length", 0); expect(reportHasErrorWithTracePrefix(results, "statement.object.definition.name", "MUST_VIOLATION")).to.be.false; }); - + it("a non-CMI interactionType value produces an error", function() { var inputStatement = {id : "fd41c918-b88b-4b20-a0a5-a4c32391aaa0" , actor : {member:[]}, verb: { "id":"http://adlnet.gov/expapi/verbs/created", display : {"en-US":"created"}}, - object : {id : "http://example.com/myUniqueId", objectType:"Activity", + object : {id : "http://example.com/myUniqueId", objectType:"Activity", definition:{type:"http://adlnet.gov/expapi/activities/cmi.interaction", interactionType:"graphicGapMatchInteraction"}}}; var results = xapiValidator.validateStatement(inputStatement); expect(results.errors).to.have.property("length", 1); @@ -570,7 +573,7 @@ describe("xapiValidator", function() { var inputStatement = {id : "fd41c918-b88b-4b20-a0a5-a4c32391aaa0" , actor : {member:[]}, verb: { "id":"http://adlnet.gov/expapi/verbs/created", display : {"en-US":"created"}}, - object : {id : "http://example.com/myUniqueId", objectType:"Activity", + object : {id : "http://example.com/myUniqueId", objectType:"Activity", definition:{correctResponsesPattern: 1.23}}}; var results = xapiValidator.validateStatement(inputStatement); expect(results.errors).to.have.property("length", 1); @@ -581,7 +584,7 @@ describe("xapiValidator", function() { var inputStatement = {id : "fd41c918-b88b-4b20-a0a5-a4c32391aaa0" , actor : {member:[]}, verb: { "id":"http://adlnet.gov/expapi/verbs/created", display : {"en-US":"created"}}, - object : {id : "http://example.com/myUniqueId", objectType:"Activity", + object : {id : "http://example.com/myUniqueId", objectType:"Activity", definition:{correctResponsesPattern: "1.23"}}}; var results = xapiValidator.validateStatement(inputStatement); expect(results.errors).to.have.property("length", 1); @@ -592,7 +595,7 @@ describe("xapiValidator", function() { var inputStatement = {id : "fd41c918-b88b-4b20-a0a5-a4c32391aaa0" , actor : {member:[]}, verb: { "id":"http://adlnet.gov/expapi/verbs/created", display : {"en-US":"created"}}, - object : {id : "http://example.com/myUniqueId", objectType:"Activity", + object : {id : "http://example.com/myUniqueId", objectType:"Activity", definition:{correctResponsesPattern: [1.23]}}}; var results = xapiValidator.validateStatement(inputStatement); expect(results.errors).to.have.property("length", 1); @@ -603,7 +606,7 @@ describe("xapiValidator", function() { var inputStatement = {id : "fd41c918-b88b-4b20-a0a5-a4c32391aaa0" , actor : {member:[]}, verb: { "id":"http://adlnet.gov/expapi/verbs/created", display : {"en-US":"created"}}, - object : {id : "http://example.com/myUniqueId", objectType:"Activity", + object : {id : "http://example.com/myUniqueId", objectType:"Activity", definition:{correctResponsesPattern: ["1.23"]}}}; var results = xapiValidator.validateStatement(inputStatement); expect(results.errors).to.have.property("length", 0); @@ -614,7 +617,7 @@ describe("xapiValidator", function() { var inputStatement = {id : "fd41c918-b88b-4b20-a0a5-a4c32391aaa0" , actor : {member:[]}, verb: { "id":"http://adlnet.gov/expapi/verbs/created", display : {"en-US":"created"}}, - object : {id : "http://example.com/myUniqueId", objectType:"Activity", + object : {id : "http://example.com/myUniqueId", objectType:"Activity", definition:{type:"http://example.com/somethingElse", interactionType:"choice", choices:[]}} }; var results = xapiValidator.validateStatement(inputStatement); @@ -626,7 +629,7 @@ describe("xapiValidator", function() { var inputStatement = {id : "fd41c918-b88b-4b20-a0a5-a4c32391aaa0" , actor : {member:[]}, verb: { "id":"http://adlnet.gov/expapi/verbs/created", display : {"en-US":"created"}}, - object : {id : "http://example.com/myUniqueId", objectType:"Activity", + object : {id : "http://example.com/myUniqueId", objectType:"Activity", definition:{type:"http://adlnet.gov/expapi/activities/cmi.interaction", interactionType:"choice", steps:[]}} }; var results = xapiValidator.validateStatement(inputStatement); @@ -638,8 +641,8 @@ describe("xapiValidator", function() { var inputStatement = {id : "fd41c918-b88b-4b20-a0a5-a4c32391aaa0" , actor : {member:[]}, verb: { "id":"http://adlnet.gov/expapi/verbs/created", display : {"en-US":"created"}}, - object : {id : "http://example.com/myUniqueId", objectType:"Activity", - definition:{type:"http://adlnet.gov/expapi/activities/cmi.interaction", interactionType:"choice", + object : {id : "http://example.com/myUniqueId", objectType:"Activity", + definition:{type:"http://adlnet.gov/expapi/activities/cmi.interaction", interactionType:"choice", choices:[{id:"hello invalid id", description:{}}]}} }; var results = xapiValidator.validateStatement(inputStatement); @@ -651,8 +654,8 @@ describe("xapiValidator", function() { var inputStatement = {id : "fd41c918-b88b-4b20-a0a5-a4c32391aaa0" , actor : {member:[]}, verb: { "id":"http://adlnet.gov/expapi/verbs/created", display : {"en-US":"created"}}, - object : {id : "http://example.com/myUniqueId", objectType:"Activity", - definition:{type:"http://adlnet.gov/expapi/activities/cmi.interaction", interactionType:"choice", + object : {id : "http://example.com/myUniqueId", objectType:"Activity", + definition:{type:"http://adlnet.gov/expapi/activities/cmi.interaction", interactionType:"choice", choices:[{id:"idA", description:{}}, {id:"idA", description:{}}]}} }; var results = xapiValidator.validateStatement(inputStatement); @@ -681,7 +684,7 @@ describe("xapiValidator", function() { expect(reportHasErrorWithTracePrefix(results, "statement.object.id", "MUST_VIOLATION")).to.be.true; }); }); - + describe("given a substatement type object", function() { it("should not report an error when valid", function() { var inputStatement = {id : "fd41c918-b88b-4b20-a0a5-a4c32391aaa0", @@ -695,7 +698,7 @@ describe("xapiValidator", function() { expect(results.errors).to.have.property("length", 0); }); - + it("reports a MUST error when the id property is present", function() { var inputStatement = {id : "fd41c918-b88b-4b20-a0a5-a4c32391aaa0", actor : {mbox:"mailto:agent@example.com"}, @@ -706,11 +709,11 @@ describe("xapiValidator", function() { verb: { "id":"http://adlnet.gov/expapi/verbs/created", "display":{"en-US":"created"}}, object: { id : "http://example.com/myUniqueId", objectType:"Activity"}}}; var results = xapiValidator.validateStatement(inputStatement); - + expect(results.errors).to.have.property("length", 1); expect(reportHasErrorWithTracePrefix(results, "statement.object.id", "MUST_VIOLATION")).to.be.true; }); - + it("reports a MUST error when the version property is present", function() { var inputStatement = {id : "fd41c918-b88b-4b20-a0a5-a4c32391aaa0", actor : {mbox:"mailto:agent@example.com"}, @@ -725,7 +728,7 @@ describe("xapiValidator", function() { expect(results.errors).to.have.property("length", 1); expect(reportHasErrorWithTracePrefix(results, "statement.object.version", "MUST_VIOLATION")).to.be.true; }); - + it("reports a MUST error when the stored property is present", function() { var inputStatement = {id : "fd41c918-b88b-4b20-a0a5-a4c32391aaa0", actor : {mbox:"mailto:agent@example.com"}, @@ -736,11 +739,11 @@ describe("xapiValidator", function() { verb: { "id":"http://adlnet.gov/expapi/verbs/created", "display":{"en-US":"created"}}, object: { id : "http://example.com/myUniqueId", objectType:"Activity"}}}; var results = xapiValidator.validateStatement(inputStatement); - + expect(results.errors).to.have.property("length", 1); expect(reportHasErrorWithTracePrefix(results, "statement.object.stored", "MUST_VIOLATION")).to.be.true; }); - + it("reports a MUST error when the authority property is present", function() { var inputStatement = {id : "fd41c918-b88b-4b20-a0a5-a4c32391aaa0", actor : {mbox:"mailto:agent@example.com"}, @@ -843,7 +846,7 @@ describe("xapiValidator", function() { result : {completion:false}}; var results = xapiValidator.validateStatement(inputStatement); expect(results.errors).to.have.property("length", 0); - + }); it("a non-String response property produces an error", function() { @@ -864,7 +867,7 @@ describe("xapiValidator", function() { object : {id : "http://example.com/myUniqueId", objectType:"Activity"}, result : {response:"idA"}}; var results = xapiValidator.validateStatement(inputStatement); - expect(results.errors).to.have.property("length", 0); + expect(results.errors).to.have.property("length", 0); }); it("a non-String duration property produces an error", function() { @@ -929,7 +932,7 @@ describe("xapiValidator", function() { object : {id : "http://example.com/myUniqueId", objectType:"Activity"}, result : {score:{raw:123}}}; var results = xapiValidator.validateStatement(inputStatement); - expect(results.errors).to.have.property("length", 0); + expect(results.errors).to.have.property("length", 0); }); it("a Number raw property below min produces an error", function() { @@ -961,7 +964,7 @@ describe("xapiValidator", function() { object : {id : "http://example.com/myUniqueId", objectType:"Activity"}, result : {score:{raw:123, min:120, max:125}}}; var results = xapiValidator.validateStatement(inputStatement); - expect(results.errors).to.have.property("length", 0); + expect(results.errors).to.have.property("length", 0); }); it("a non-Number scaled property produces an error", function() { @@ -982,7 +985,7 @@ describe("xapiValidator", function() { object : {id : "http://example.com/myUniqueId", objectType:"Activity"}, result : {score:{scaled:0.5}}}; var results = xapiValidator.validateStatement(inputStatement); - expect(results.errors).to.have.property("length", 0); + expect(results.errors).to.have.property("length", 0); }); it("a Number scaled property below 0 produces an error", function() { @@ -1025,7 +1028,7 @@ describe("xapiValidator", function() { object : {id : "http://example.com/myUniqueId", objectType:"Activity"}, result : {score:{max:123}}}; var results = xapiValidator.validateStatement(inputStatement); - expect(results.errors).to.have.property("length", 0); + expect(results.errors).to.have.property("length", 0); }); it("a Number max property below min produces an error", function() { @@ -1057,7 +1060,7 @@ describe("xapiValidator", function() { object : {id : "http://example.com/myUniqueId", objectType:"Activity"}, result : {score:{min:123}}}; var results = xapiValidator.validateStatement(inputStatement); - expect(results.errors).to.have.property("length", 0); + expect(results.errors).to.have.property("length", 0); }); it("a Number min property above max produces an error", function() { @@ -1080,7 +1083,7 @@ describe("xapiValidator", function() { object : {id : "http://example.com/myUniqueId", objectType:"Activity"}, context: {}}; var results = xapiValidator.validateStatement(inputStatement); - expect(results.errors).to.have.property("length", 0); + expect(results.errors).to.have.property("length", 0); }); it("an non-object context value produces an error", function() { @@ -1791,7 +1794,7 @@ describe("xapiValidator", function() { actor : {mbox:"mailto:agent@example.com"}, verb: { "id":"http://adlnet.gov/expapi/verbs/created", "display":{"en-US":"created"}}, object : {id : "http://example.com/myUniqueId", objectType:"Activity"}, - authority: {objectType:"Group", member:[{objectType:"Agent", mbox:"mailto:bob@example.com"}, + authority: {objectType:"Group", member:[{objectType:"Agent", mbox:"mailto:bob@example.com"}, {objectType:"Agent", mbox:"mailto:tom@example.com"}]}}; var results = xapiValidator.validateStatement(inputStatement); expect(results.errors).to.have.property("length", 0); @@ -1813,7 +1816,7 @@ describe("xapiValidator", function() { actor : {mbox:"mailto:agent@example.com"}, verb: { "id":"http://adlnet.gov/expapi/verbs/created", "display":{"en-US":"created"}}, object : {id : "http://example.com/myUniqueId", objectType:"Activity"}, - authority: {objectType:"Group", member:[{objectType:"Agent", mbox:"mailto:bob@example.com"}, + authority: {objectType:"Group", member:[{objectType:"Agent", mbox:"mailto:bob@example.com"}, {objectType:"Agent", mbox:"mailto:tom@example.com"}, {objectType:"Agent", mbox:"mailto:frank@example.com"}]}}; var results = xapiValidator.validateStatement(inputStatement); @@ -1826,7 +1829,7 @@ describe("xapiValidator", function() { actor : {mbox:"mailto:agent@example.com"}, verb: { "id":"http://adlnet.gov/expapi/verbs/created", "display":{"en-US":"created"}}, object : {id : "http://example.com/myUniqueId", objectType:"Activity"}, - authority: {objectType:"Group", member:[{objectType:"Agent", mbox:"mailto:bob@example.com"}, + authority: {objectType:"Group", member:[{objectType:"Agent", mbox:"mailto:bob@example.com"}, {objectType:"Agent"}]}}; var results = xapiValidator.validateStatement(inputStatement); expect(results.errors).to.have.property("length", 1); @@ -1855,7 +1858,7 @@ describe("xapiValidator", function() { var results = xapiValidator.validateStatement(inputStatement); expect(results.errors).to.have.property("length", 1); expect(reportHasErrorWithTracePrefix(results, "statement.version", "MUST_VIOLATION")).to.be.true; - }); + }); }); describe("for an version property with a string value", function() { @@ -1911,7 +1914,7 @@ describe("xapiValidator", function() { expect(results.errors).to.have.property("length", 1); expect(reportHasErrorWithTracePrefix(results, "statement.version", "MUST_VIOLATION")).to.be.true; }); - + it("a semantic version with SemVer 2.0.0 build release metadata not in SemVer 1.0.0 produces an error", function() { var inputStatement = {id : "fd41c918-b88b-4b20-a0a5-a4c32391aaa0" , actor : {mbox:"mailto:agent@example.com"}, @@ -1921,7 +1924,7 @@ describe("xapiValidator", function() { var results = xapiValidator.validateStatement(inputStatement); expect(results.errors).to.have.property("length", 1); expect(reportHasErrorWithTracePrefix(results, "statement.version", "MUST_VIOLATION")).to.be.true; - }); + }); }); describe("for an attachments property on the statement with a non-Array value", function() { @@ -1946,7 +1949,7 @@ describe("xapiValidator", function() { expect(results.errors).to.have.property("length", 1); expect(reportHasErrorWithTracePrefix(results, "statement.attachments", "MUST_VIOLATION")).to.be.true; }); - + it("an object map value produces an error", function() { var inputStatement = {id : "fd41c918-b88b-4b20-a0a5-a4c32391aaa0" , actor : {mbox:"mailto:agent@example.com"}, @@ -1956,7 +1959,7 @@ describe("xapiValidator", function() { var results = xapiValidator.validateStatement(inputStatement); expect(results.errors).to.have.property("length", 1); expect(reportHasErrorWithTracePrefix(results, "statement.attachments", "MUST_VIOLATION")).to.be.true; - }); + }); }); describe("for an attachments property on the statement with an Array value", function() { @@ -1968,7 +1971,7 @@ describe("xapiValidator", function() { attachments: []}; var results = xapiValidator.validateStatement(inputStatement); expect(results.errors).to.have.property("length", 0); - }); + }); }); describe("for an attachment object within the attachments property's Array on the statement", function() { @@ -2160,4 +2163,4 @@ describe("xapiValidator", function() { }); }); }); -}); \ No newline at end of file +}); diff --git a/xapiValidator.js b/xapiValidator.js index b25fe8e..9a44e08 100644 --- a/xapiValidator.js +++ b/xapiValidator.js @@ -1,874 +1,1620 @@ -// UMD flavor "commonjsStrictGlobal.js" from https://github.com/umdjs/umd -(function (root, factory) { - "use strict"; - if (typeof exports === 'object') { - // CommonJS - factory(exports); - } else if (typeof define === 'function' && define.amd) { - // AMD. Register as an anonymous module. - define(['exports'], function (exports) { - root.xapiValidator = exports; - factory(exports); - }); - } else { - // Browser globals - root.xapiValidator = {}; - factory(root.xapiValidator); - } -} (this, function (exports) { - "use strict"; - var MUST_VIOLATION = "MUST_VIOLATION", - SHOULD_VIOLATION = "SHOULD_VIOLATION", - MAY_VIOLATION = "MAY_VIOLATION", - toString = Object.prototype.toString, - uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i, - iso8601DurationRegex = /^P((\d+([\.,]\d+)?Y)?(\d+([\.,]\d+)?M)?(\d+([\.,]\d+)?W)?(\d+([\.,]\d+)?D)?)?(T(\d+([\.,]\d+)?H)?(\d+([\.,]\d+)?M)?(\d+([\.,]\d+)?S)?)?$/, - iso8601DateTimeRegex, - mailtoUriRegex = /^mailto:/, - semVer1p0p0Regex = /^((\d+)\.(\d+)\.(\d+))(?:-([\dA-Za-z\-]+))?$/, - base64Regex = /^(?:[A-Za-z0-9\+\/]{4})*(?:[A-Za-z0-9\+\/]{2}==|[A-Za-z0-9\+\/]{3}=|[A-Za-z0-9\+\/]{4})$/, - iriRegex, - bcp47Regex, - isArray, - ifiPropertyNames = ["mbox", "mbox_sha1sum", "openID", "account"], - cmiInteractionTypes = ["true-false", "choice", "fill-in", - "long-fill-in", "matching", "performance", - "sequencing", "likert", "numeric", - "other"]; - iriRegex = /^[a-z](?:[\-a-z0-9\+\.])*:(?:\/\/(?:(?:%[0-9a-f][0-9a-f]|[\-a-z0-9\._~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF\u10000-\u1FFFD\u20000-\u2FFFD\u30000-\u3FFFD\u40000-\u4FFFD\u50000-\u5FFFD\u60000-\u6FFFD\u70000-\u7FFFD\u80000-\u8FFFD\u90000-\u9FFFD\uA0000-\uAFFFD\uB0000-\uBFFFD\uC0000-\uCFFFD\uD0000-\uDFFFD\uE1000-\uEFFFD!\$&'\(\)\*\+,;=:])*@)?(?:\[(?:(?:(?:[0-9a-f]{1,4}:){6}(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3})|::(?:[0-9a-f]{1,4}:){5}(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3})|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3})|(?:[0-9a-f]{1,4}:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3})|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3})|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3})|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3})|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|v[0-9a-f]+[\-a-z0-9\._~!\$&'\(\)\*\+,;=:]+)\]|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3}|(?:%[0-9a-f][0-9a-f]|[\-a-z0-9\._~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF\u10000-\u1FFFD\u20000-\u2FFFD\u30000-\u3FFFD\u40000-\u4FFFD\u50000-\u5FFFD\u60000-\u6FFFD\u70000-\u7FFFD\u80000-\u8FFFD\u90000-\u9FFFD\uA0000-\uAFFFD\uB0000-\uBFFFD\uC0000-\uCFFFD\uD0000-\uDFFFD\uE1000-\uEFFFD!\$&'\(\)\*\+,;=@])*)(?::[0-9]*)?(?:\/(?:(?:%[0-9a-f][0-9a-f]|[\-a-z0-9\._~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF\u10000-\u1FFFD\u20000-\u2FFFD\u30000-\u3FFFD\u40000-\u4FFFD\u50000-\u5FFFD\u60000-\u6FFFD\u70000-\u7FFFD\u80000-\u8FFFD\u90000-\u9FFFD\uA0000-\uAFFFD\uB0000-\uBFFFD\uC0000-\uCFFFD\uD0000-\uDFFFD\uE1000-\uEFFFD!\$&'\(\)\*\+,;=:@]))*)*|\/(?:(?:(?:(?:%[0-9a-f][0-9a-f]|[\-a-z0-9\._~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF\u10000-\u1FFFD\u20000-\u2FFFD\u30000-\u3FFFD\u40000-\u4FFFD\u50000-\u5FFFD\u60000-\u6FFFD\u70000-\u7FFFD\u80000-\u8FFFD\u90000-\u9FFFD\uA0000-\uAFFFD\uB0000-\uBFFFD\uC0000-\uCFFFD\uD0000-\uDFFFD\uE1000-\uEFFFD!\$&'\(\)\*\+,;=:@]))+)(?:\/(?:(?:%[0-9a-f][0-9a-f]|[\-a-z0-9\._~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF\u10000-\u1FFFD\u20000-\u2FFFD\u30000-\u3FFFD\u40000-\u4FFFD\u50000-\u5FFFD\u60000-\u6FFFD\u70000-\u7FFFD\u80000-\u8FFFD\u90000-\u9FFFD\uA0000-\uAFFFD\uB0000-\uBFFFD\uC0000-\uCFFFD\uD0000-\uDFFFD\uE1000-\uEFFFD!\$&'\(\)\*\+,;=:@]))*)*)?|(?:(?:(?:%[0-9a-f][0-9a-f]|[\-a-z0-9\._~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF\u10000-\u1FFFD\u20000-\u2FFFD\u30000-\u3FFFD\u40000-\u4FFFD\u50000-\u5FFFD\u60000-\u6FFFD\u70000-\u7FFFD\u80000-\u8FFFD\u90000-\u9FFFD\uA0000-\uAFFFD\uB0000-\uBFFFD\uC0000-\uCFFFD\uD0000-\uDFFFD\uE1000-\uEFFFD!\$&'\(\)\*\+,;=:@]))+)(?:\/(?:(?:%[0-9a-f][0-9a-f]|[\-a-z0-9\._~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF\u10000-\u1FFFD\u20000-\u2FFFD\u30000-\u3FFFD\u40000-\u4FFFD\u50000-\u5FFFD\u60000-\u6FFFD\u70000-\u7FFFD\u80000-\u8FFFD\u90000-\u9FFFD\uA0000-\uAFFFD\uB0000-\uBFFFD\uC0000-\uCFFFD\uD0000-\uDFFFD\uE1000-\uEFFFD!\$&'\(\)\*\+,;=:@]))*)*|(?!(?:%[0-9a-f][0-9a-f]|[\-a-z0-9\._~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF\u10000-\u1FFFD\u20000-\u2FFFD\u30000-\u3FFFD\u40000-\u4FFFD\u50000-\u5FFFD\u60000-\u6FFFD\u70000-\u7FFFD\u80000-\u8FFFD\u90000-\u9FFFD\uA0000-\uAFFFD\uB0000-\uBFFFD\uC0000-\uCFFFD\uD0000-\uDFFFD\uE1000-\uEFFFD!\$&'\(\)\*\+,;=:@])))(?:\?(?:(?:%[0-9a-f][0-9a-f]|[\-a-z0-9\._~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF\u10000-\u1FFFD\u20000-\u2FFFD\u30000-\u3FFFD\u40000-\u4FFFD\u50000-\u5FFFD\u60000-\u6FFFD\u70000-\u7FFFD\u80000-\u8FFFD\u90000-\u9FFFD\uA0000-\uAFFFD\uB0000-\uBFFFD\uC0000-\uCFFFD\uD0000-\uDFFFD\uE1000-\uEFFFD!\$&'\(\)\*\+,;=:@])|[\uE000-\uF8FF\uF0000-\uFFFFD|\u100000-\u10FFFD\/\?])*)?(?:\#(?:(?:%[0-9a-f][0-9a-f]|[\-a-z0-9\._~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF\u10000-\u1FFFD\u20000-\u2FFFD\u30000-\u3FFFD\u40000-\u4FFFD\u50000-\u5FFFD\u60000-\u6FFFD\u70000-\u7FFFD\u80000-\u8FFFD\u90000-\u9FFFD\uA0000-\uAFFFD\uB0000-\uBFFFD\uC0000-\uCFFFD\uD0000-\uDFFFD\uE1000-\uEFFFD!\$&'\(\)\*\+,;=:@])|[\/\?])*)?$/i; - - // 1 YYYY 2 MM 3 DD 4 HH 5 mm 6 ss 7 msec 8 Z 9 ± 10 tzHH 11 tzmm - iso8601DateTimeRegex = /^(\d{4}|[+\-]\d{6})(?:-(\d{2})(?:-(\d{2}))?)?(?:T(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{3}))?)?(?:(Z)|([+\-])(\d{2})(?::(\d{2}))?)?)?$/; - - bcp47Regex = /^(?:(en-GB-oed|i-(?:ami|bnn|default|enochian|hak|klingon|lux|mingo|navajo|pwn|tao|tay|tsu)|sgn-(?:BE-FR|BE-NL|CH-DE))|(art-lojban|cel-gaulish|no-(?:bok|nyn)|zh-(?:guoyu|hakka|min|min-nan|xiang)))$|^(x(?:-[0-9a-z]{1,8})+)$|^(?:((?:[a-z]{2,3}(?:(?:-[a-z]{3}){1,3})?)|[a-z]{4}|[a-z]{5,8})(?:-([a-z]{4}))?(?:-([a-z]{2}|[0-9]{3}))?((?:-(?:[a-z0-9]{5,8}|[0-9][a-z0-9]{3}))*)?((?:-[0-9a-wy-z](?:-[a-z0-9]{2,8}){1,})*)?(-x(?:-[0-9a-z]{1,8})+)?)$/i; - - function isString(obj) { - return toString.call(obj) === '[object String]'; +(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.xapiValidator = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o 1) { - localErrors.push(new ValidationError(addPropToTrace(localTrace, "scaled"), "If present, the scaled property value must be between 0 and 1", MUST_VIOLATION)); - } - } - if (score.min !== undefined) { - validatePropertyIsNumber(score, "min", localTrace, localErrors, false); - if (score.raw !== undefined && score.raw < score.min) { - localErrors.push(new ValidationError(addPropToTrace(localTrace, "raw"), "If both 'raw' and 'min' are present, the raw property value should be greater than min", MUST_VIOLATION)); - } - if (score.max !== undefined && score.max < score.min) { - localErrors.push(new ValidationError(addPropToTrace(localTrace, "max"), "If both 'max' and 'min' are present, the max property value should be greater than min", MUST_VIOLATION)); - } - } - if (score.max !== undefined) { - validatePropertyIsNumber(score, "max", localTrace, localErrors, false); - if (score.raw !== undefined && score.raw > score.max) { - localErrors.push(new ValidationError(addPropToTrace(localTrace, "raw"), "If both 'raw' and 'max' are present, the raw property value should be less than max", MUST_VIOLATION)); - } - } - validatePropertyIsNumber(score, "raw", localTrace, localErrors, false); - validateAbsenceOfNonWhitelistedProperties(score, ["scaled", "raw", "min", "max"], localTrace, localErrors); - return localErrors; - } +function validateStatementRef(statementRef, trace, errors) { + var localErrors, localTrace; - function validateResult(result, trace, errors) { - var localErrors = errors || [], - localTrace = trace || "result"; - if (result === undefined) { - return localErrors; - } - if (!isNonNullMapObject(result)) { - localErrors.push(new ValidationError(addPropToTrace(localTrace), "If present, the result must be a map object", MUST_VIOLATION)); - return localErrors; - } - validateScore(result.score, addPropToTrace(localTrace, "score"), localErrors); - validatePropertyIsBoolean(result, "success", localTrace, localErrors, false); - validatePropertyIsBoolean(result, "completion", localTrace, localErrors, false); - validatePropertyIsString(result, "response", localTrace, localErrors, false); - validateExtensions(result.extensions, addPropToTrace(localTrace, "extensions"), localErrors); - if (result.duration !== undefined && (result.duration === null || !isString(result.duration) || !iso8601DurationRegex.test(result.duration))) { - localErrors.push(new ValidationError(addPropToTrace(localTrace, "duration"), "If present, the duration property value must be an ISO 8601 duration", MUST_VIOLATION)); - } - validateAbsenceOfNonWhitelistedProperties(result, ["score", "success", "completion", "response", "duration", "extensions"], localTrace, localErrors); + localErrors = errors || []; + localTrace = trace || _properties.properties.STATEMENT_REF; - return localErrors; - } + if (!_utils.xapiValidationUtils.isNonNullMapObject(statementRef)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace), + message: _errors.xapiValidationErrors.STATEMENT_REF_MUST_NOT_BE_NULL_MAP_OBJECTS, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + return localErrors; + } - - function validatePropertyIsISO8601String(parent, propertyName, trace, errors) { - var localErrors = errors || [], - localTrace = trace || "datetime", - matched, - datetime = parent[propertyName]; - if (datetime === undefined) { - return localErrors; - } - if (datetime === null || !isString(datetime)) { - localErrors.push(new ValidationError(localTraceToString(localTrace, propertyName), "This property must be a string value, but was null or another value type.", MUST_VIOLATION)); - return localErrors; - } - matched = iso8601DateTimeRegex.exec(datetime); - if (matched) { - if (!(matched[8] || (matched[9] && matched[10]))) { - localErrors.push(new ValidationError(localTraceToString(localTrace, propertyName), "ISO 8601 date time strings used in the xAPI should include time zone information.", SHOULD_VIOLATION)); - } - } else { - localErrors.push(new ValidationError(localTraceToString(localTrace, propertyName), "This property's string value must be conformant to ISO 8601 for Date Times.", MUST_VIOLATION)); - } + if (statementRef.objectType !== _properties.objectTypes.STATEMENT_REF) { + localErrors.push({ + trace: _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.OBJECT_TYPE), + message: _errors.xapiValidationErrors.OBJECT_TYPE_MUST_BE_STATEMENT_REF, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } - return localErrors; - } + if (!statementRef.id || !_regex.xapiValidationRegex.UUID.test(statementRef.id)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.ID), + message: _errors.xapiValidationErrors.ID_MUST_BE_VALID_UUID_REF, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } - + validateAbsenceOfNonWhitelistedProperties(statementRef, _properties.xapiWhiteListProperties.STATEMENT_REF, localTrace, localErrors); - function validateVersion(version, trace, errors) { - var localErrors = errors || [], - localTrace = trace || "version"; - if (version === undefined) { - return localErrors; - } - if (version === null || !isString(version) || !semVer1p0p0Regex.test(version)) { - localErrors.push(new ValidationError(localTraceToString(localTrace), "version must be a non-null string that complies with Semantic Versioning 1.0.0", MUST_VIOLATION)); - } - return localErrors; - } + return localErrors; +} - function validateAttachmentObject(attachment, trace, errors) { - var localErrors = errors || [], - localTrace = trace || "attachment"; - if (!isNonNullMapObject(attachment)) { - localErrors.push(new ValidationError(localTraceToString(localTrace), "attachment instances must be non-null map objects.", MUST_VIOLATION)); - return localErrors; - } - if (attachment.display === undefined) { - localErrors.push(new ValidationError(localTraceToString(localTrace, "display"), "display property must be provided.", MUST_VIOLATION)); - } else { - validateLanguageMap(attachment.display, addPropToTrace(localTrace, "display"), localErrors); - } - validateLanguageMap(attachment.description, addPropToTrace(localTrace, "description"), localErrors); +function validateScore(score, trace, errors) { + var localErrors, localTrace; - validatePropertyIsUri(attachment, "usageType", localTrace, localErrors, true, MUST_VIOLATION); - validatePropertyIsUri(attachment, "fileUrl", localTrace, localErrors, false, MUST_VIOLATION); + localErrors = errors || []; + localTrace = trace || _properties.properties.SCORE; - // TODO - more complete validation for Internet Media Type via RFC 2046 - validatePropertyIsString(attachment, "contentType", localTrace, localErrors, true, MUST_VIOLATION); - if (attachment.length === undefined || attachment.length === null || !isNumber(attachment.length) || !(attachment.length % 1 === 0)) { - localErrors.push(new ValidationError(localTraceToString(localTrace, "length"), "length property must be provided with an integer value", MUST_VIOLATION)); - } + if (score === undefined) { + return localErrors; + } - if (attachment.sha2 === undefined) { - localErrors.push(new ValidationError(localTraceToString(localTrace, "sha2"), "sha2 property must be provided on attachment objects", MUST_VIOLATION)); - } else if (attachment.sha2 === null || !isString(attachment.sha2) || !base64Regex.test(attachment.sha2)) { - localErrors.push(new ValidationError(localTraceToString(localTrace, "sha2"), "sha2 property must contain a string with bas64 contents", MUST_VIOLATION)); - } + validatePropertyIsNumber(score, _properties.properties.SCALED, localTrace, localErrors, /*isRequired*/false); - validateAbsenceOfNonWhitelistedProperties(attachment, ["usageType", "display", "description", "contentType", "length", "sha2", "fileUrl"], localTrace, localErrors); - return localErrors; + if (score.scaled !== undefined) { + if (score.scaled < _general.xapiGeneral.MIN_SCALED_VALUE || score.scaled > _general.xapiGeneral.MAX_SCALED_VALUE) { + localErrors.push({ + trace: _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.SCALED), + message: _errors.xapiValidationErrors.SCALED_MUST_BE_BETWEEN_0_1, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); } + } - function validateAttachments(attachments, trace, errors) { - var localErrors = errors || [], - localTrace = trace || "attachments", - numAttachments, - i; - if (attachments === undefined) { - return localErrors; - } - if (attachments === null || !isArray(attachments)) { - localErrors.push(new ValidationError(localTraceToString(localTrace), "attachments must be a non-null Array.", MUST_VIOLATION)); - return localErrors; - } - numAttachments = attachments.length; - for (i = 0; i < numAttachments; i+=1) { - validateAttachmentObject(attachments[i], addLookupToTrace(localTrace, i), localErrors); - } - return localErrors; - } + if (score.min !== undefined) { + validatePropertyIsNumber(score, _properties.properties.MIN, localTrace, localErrors, /*isRequired*/false); - function isGroup(actorOrGroup) { - return (actorOrGroup.member !== null && actorOrGroup.member !== undefined) || actorOrGroup.objectType === "Group"; + if (score.raw !== undefined && score.raw < score.min) { + localErrors.push({ + trace: _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.RAW), + message: _errors.xapiValidationErrors.RAW_MUST_BE_GREATER_THAN_MIN, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); } - function validateAgent(agent, trace, errors) { - var localErrors = errors || [], - localTrace = trace || "agent", - ifiCount; - if (!isNonNullMapObject(agent)) { - localErrors.push(new ValidationError(localTraceToString(localTrace), "Agent must be a non-null map object", MUST_VIOLATION)); - return localErrors; - } - - ifiCount = getIFICount(agent); - if (ifiCount !== 1) { - localErrors.push(new ValidationError(localTraceToString(localTrace), "Exactly one Inverse Functional Identifier property must be specified.", MUST_VIOLATION)); - } - if (agent.objectType === "Group") { - localErrors.push(new ValidationError(localTraceToString(localTrace), "Invalid object with characteristics of a Group when an Agent was expected.", MUST_VIOLATION)); - } - validateIFIProperties(agent, localTrace, localErrors); - validatePropertyIsString(agent, "name", localTrace, localErrors, false); - - validateAbsenceOfNonWhitelistedProperties(agent, ["objectType", "name"].concat(ifiPropertyNames), localTrace, localErrors); - - return localErrors; + if (score.max !== undefined && score.max < score.min) { + localErrors.push({ + trace: _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.MAX), + message: _errors.xapiValidationErrors.MAX_MUST_BE_GREATER_THAN_MIN, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); } + } - function validateGroup(group, trace, errors) { - var localErrors = errors || [], - localTrace = trace || "group", - memberTrace = addPropToTrace(localTrace, "member"), - ifiCount, - numMembers, - i; - if (!isNonNullMapObject(group)) { - localErrors.push(new ValidationError(localTraceToString(localTrace), "Group must be a non-null map object", MUST_VIOLATION)); - return localErrors; - } - - ifiCount = getIFICount(group); - if (ifiCount === 0) { - if (group.member === null || group.member === undefined) { - localErrors.push(new ValidationError(memberTrace, "member property must be provided for Anonymous Groups.", MUST_VIOLATION)); - } - } else if (ifiCount > 1) { - localErrors.push(new ValidationError(localTraceToString(localTrace), "Only one Inverse Functional Identifier property must be specified.", MUST_VIOLATION)); - } - validateIFIProperties(group, localTrace, localErrors); - validatePropertyIsString(group, "name", localTrace, localErrors, false); - - if (group.member !== undefined) { - if (group.member === null || !isArray(group.member)) { - localErrors.push(new ValidationError(localTraceToString(localTrace, "member"), "If present, the member property of a Group must be an Array", MUST_VIOLATION)); - } else { - numMembers = group.member.length; - for (i = 0; i < numMembers; i+=1) { - validateAgent(group.member[i], addLookupToTrace(memberTrace, i), localErrors); - } - } - } - - validateAbsenceOfNonWhitelistedProperties(group, ["objectType", "name", "member"].concat(ifiPropertyNames), localTrace, localErrors); + if (score.max !== undefined) { + validatePropertyIsNumber(score, _properties.properties.MAX, localTrace, localErrors, /*isRequired*/false); - return localErrors; + if (score.raw !== undefined && score.raw > score.max) { + localErrors.push({ + trace: _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.RAW), + message: _errors.xapiValidationErrors.RAW_MUST_BE_LESS_THAN_MAX, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); } - - function validateActor(actor, trace, errors) { - var localErrors = errors || [], - localTrace = trace || "actor"; - if (actor === null || actor === undefined) { - localErrors.push(new ValidationError(localTraceToString(localTrace), "Actor must be provided.", MUST_VIOLATION)); - return localErrors; - } - if (isGroup(actor)) { - validateGroup(actor, localTrace, localErrors); - } else { - validateAgent(actor, localTrace, localErrors); - } - return localErrors; + } + + validatePropertyIsNumber(score, _properties.properties.RAW, localTrace, localErrors, /*isRequired*/false); + validateAbsenceOfNonWhitelistedProperties(score, _properties.xapiWhiteListProperties.SCORE, localTrace, localErrors); + + return localErrors; +} + +function validateResult(result, trace, errors) { + var localErrors, localTrace; + + localErrors = errors || []; + localTrace = trace || _properties.properties.RESULT; + + if (result === undefined) { + return localErrors; + } + + if (!_utils.xapiValidationUtils.isNonNullMapObject(result)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.addPropToTrace(localTrace), + message: _errors.xapiValidationErrors.RESULT_MUST_BE_MAP_OBJECT, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + + return localErrors; + } + + validateScore(result.score, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.SCORE), localErrors); + validatePropertyIsBoolean(result, _properties.properties.SUCCESS, localTrace, localErrors, /*isRequired*/false); + validatePropertyIsBoolean(result, _properties.properties.COMPLETION, localTrace, localErrors, /*isRequired*/false); + validatePropertyIsString(result, _properties.properties.RESPONSE, localTrace, localErrors, /*isRequired*/false); + validateExtensions(result.extensions, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.EXTENSIONS), localErrors); + + if (result.duration !== undefined && (result.duration === null || !_utils.xapiValidationUtils.isString(result.duration) || !_regex.xapiValidationRegex.ISO_8601_DURATION.test(result.duration))) { + localErrors.push({ + trace: _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.DURATION), + message: _errors.xapiValidationErrors.DURATION_MUST_BE_VALID, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + + validateAbsenceOfNonWhitelistedProperties(result, _properties.xapiWhiteListProperties.RESULT, localTrace, localErrors); + + return localErrors; +} + +function validatePropertyIsISO8601String(parent, propertyName, trace, errors) { + var localErrors, localTrace, matched, datetime; + + localErrors = errors || []; + localTrace = trace || _properties.properties.DATE_TIME; + datetime = parent[propertyName]; + + if (datetime === undefined) { + return localErrors; + } + + if (datetime === null || !_utils.xapiValidationUtils.isString(datetime)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace, propertyName), + message: propertyName + ' ' + _errors.xapiValidationErrors.MUST_BE_STRING, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + + return localErrors; + } + + matched = _regex.xapiValidationRegex.ISO_8601_DATE_TIME.exec(datetime); + + if (matched) { + if (!dateIncludesZoneInformation(matched)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace, propertyName), + message: _errors.xapiValidationErrors.DATE_SHOULD_INCLUDE_ZONE_INFORMATION, + level: _errors.xapiErrorLevels.SHOULD_VIOLATION + }); } - - function validateAuthority(authority, trace, errors) { - var localErrors = errors || [], - localTrace = trace || "authority"; - if (authority === undefined) { - return localErrors; - } - if (!isNonNullMapObject(authority)) { - localErrors.push(new ValidationError(localTraceToString(localTrace), "If present, the authority property must be a non-null map object.", MUST_VIOLATION)); - return localErrors; - } - if (isGroup(authority)) { - validateGroup(authority, localTrace, localErrors); - if (!authority.member || !authority.member.length || authority.member.length !== 2) { - localErrors.push(new ValidationError(localTraceToString(localTrace, "member"), "If used as a Group, the authority property must contain a member property that is an array containing exactly two Agent objects.", MUST_VIOLATION)); - } - } else { - validateAgent(authority, localTrace, localErrors); - } - return localErrors; + } else { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace, propertyName), + message: _errors.xapiValidationErrors.DATE_MUST_BE_VALID, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + + return localErrors; +} + +function validateVersion(version, trace, errors) { + var localErrors, localTrace; + + localErrors = errors || []; + localTrace = trace || _properties.properties.VERSION; + + if (version === undefined) { + return localErrors; + } + + if (version === null || !_utils.xapiValidationUtils.isString(version) || !_regex.xapiValidationRegex.SEMVER_1_P_0_P_0.test(version)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace), + message: _errors.xapiValidationErrors.VERSION_MUST_COMPLY_SEMANTIC_VERSIONING, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + + return localErrors; +} + +function validateAttachmentObject(attachment, trace, errors) { + var localErrors, localTrace; + + localErrors = errors || []; + localTrace = trace || _properties.properties.ATTACHMENT; + + if (!_utils.xapiValidationUtils.isNonNullMapObject(attachment)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace), + message: _errors.xapiValidationErrors.ATTACHMENTS_MUST_NOT_BE_NULL_MAP_OBJECTS, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + + return localErrors; + } + + if (attachment.display === undefined) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace, _properties.properties.DISPLAY), + message: _errors.xapiValidationErrors.DISPLAY_SHOULD_BE_PROVIDED, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } else { + validateLanguageMap(attachment.display, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.DISPLAY), localErrors); + } + + validateLanguageMap(attachment.description, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.DESCRIPTION), localErrors); + validatePropertyIsUri(attachment, _properties.properties.USAGE_TYPE, localTrace, localErrors, /*isRequired*/true, _errors.xapiErrorLevels.MUST_VIOLATION); + validatePropertyIsUri(attachment, _properties.properties.FILE_URL, localTrace, localErrors, /*isRequired*/false, _errors.xapiErrorLevels.MUST_VIOLATION); + + // TODO - more complete validation for Internet Media Type via RFC 2046 + validatePropertyIsString(attachment, _properties.properties.CONTENT_TYPE, localTrace, localErrors, /*isRequired*/true, _errors.xapiErrorLevels.MUST_VIOLATION); + + if (attachment.length === undefined || attachment.length === null || !_utils.xapiValidationUtils.isNumber(attachment.length) || attachment.length % 1 !== 0) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace, _properties.properties.LENGTH), + message: _errors.xapiValidationErrors.LENGTH_MUST_BE_INTEGER, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + + if (attachment.sha2 === undefined) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace, _properties.properties.SHA2), + message: _errors.xapiValidationErrors.SHA2_MUST_BE_PROVIDED_ON_ATTACHMENT_OBJECTS, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } else if (attachment.sha2 === null || !_utils.xapiValidationUtils.isString(attachment.sha2) || !_regex.xapiValidationRegex.BASE_64.test(attachment.sha2)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace, _properties.properties.SHA2), + message: _errors.xapiValidationErrors.SHA2_MUST_CONTAIN_BASE_64_STRING, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + + validateAbsenceOfNonWhitelistedProperties(attachment, _properties.xapiWhiteListProperties.ATTACHMENT, localTrace, localErrors); + return localErrors; +} + +function validateAttachments(attachments, trace, errors) { + var localErrors, localTrace; + + localErrors = errors || []; + localTrace = trace || _properties.properties.ATTACHMENTS; + + if (attachments === undefined) { + return localErrors; + } + + if (attachments === null || !_utils.xapiValidationUtils.isArray(attachments)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace), + message: _errors.xapiValidationErrors.ATTACHMENTS_MUST_BE_NOT_NULL_ARRAY, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + + return localErrors; + } + + attachments.forEach(function (attachment, i) { + validateAttachmentObject(attachment, _utils.xapiValidationUtils.addLookupToTrace(localTrace, i), localErrors); + }); + + return localErrors; +} + +function validateAgent(agent, trace, errors) { + var localErrors, localTrace, ifiCount; + + localErrors = errors || []; + localTrace = trace || _properties.properties.AGENT; + + if (!_utils.xapiValidationUtils.isNonNullMapObject(agent)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace), + message: _errors.xapiValidationErrors.AGENT_MUST_BE_NON_NULL_MAP_OBJECT, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + return localErrors; + } + + ifiCount = getIFICount(agent); + + if (ifiCount !== _general.xapiGeneral.NUMER_OF_SPECIFIED_IFI_PROPERTIES) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace), + message: _errors.xapiValidationErrors.AGENT_IFI_PROPERTIES_MUST_BE_SPECIFIED, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + + if (agent.objectType === _properties.objectTypes.GROUP) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace), + message: _errors.xapiValidationErrors.AGENT_MUST_NOT_HAVE_GROUP_CHARACTERISTICS, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + + validateIFIProperties(agent, localTrace, localErrors); + validatePropertyIsString(agent, _properties.properties.NAME, localTrace, localErrors, /*isRequired*/false); + + validateAbsenceOfNonWhitelistedProperties(agent, _properties.xapiWhiteListProperties.AGENT, localTrace, localErrors); + + return localErrors; +} + +function validateGroup(group, trace, errors) { + var localErrors, localTrace, memberTrace, ifiCount; + + localErrors = errors || []; + localTrace = trace || _properties.properties.GROUP; + memberTrace = _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.MEMBER); + + if (!_utils.xapiValidationUtils.isNonNullMapObject(group)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace), + message: _errors.xapiValidationErrors.GROUP_MUST_BE_NON_NULL_MAP_OBJECT, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + + return localErrors; + } + + ifiCount = getIFICount(group); + + if (ifiCount === 0) { + if (group.member === null || group.member === undefined) { + localErrors.push({ + trace: memberTrace, + message: _errors.xapiValidationErrors.MEMBER_MUST_BE_PROVIDED_FOR_ANONYMOUS_GROUPS, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); } - - function validateContextActivitySubContext(subContext, trace, errors) { - var localErrors = errors || [], - localTrace = trace || "subContext", - numActivities, - i; - if (subContext === undefined) { - return localErrors; - } - if (subContext === null) { - localErrors.push(new ValidationError(localTraceToString(localTrace), "Context Activities property values must not be null.", MUST_VIOLATION)); - } else if (isArray(subContext)) { - numActivities = subContext.length; - for (i = 0; i < numActivities; i+=1) { - validateActivity(subContext[i], addLookupToTrace(localTrace, i), localErrors); - } - } else if (isObject(subContext)) { - localErrors.push(new ValidationError(localTraceToString(localTrace), "Context Activities property values should prefer to be an array of Activities rather than a single Activity object.", SHOULD_VIOLATION)); - validateActivity(subContext, localTrace, localErrors); - } else { - localErrors.push(new ValidationError(localTraceToString(localTrace), "Context Activities property values must be an array of Activity Objects or a single Activity Object.", MUST_VIOLATION)); - } - return localErrors; + } else if (ifiCount > _general.xapiGeneral.NUMER_OF_SPECIFIED_IFI_PROPERTIES) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace), + message: _errors.xapiValidationErrors.GROUP_IFI_PROPERTIES_MUST_BE_SPECIFIED, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + + validateIFIProperties(group, localTrace, localErrors); + + validatePropertyIsString(group, _properties.properties.NAME, localTrace, localErrors, /*isRequired*/false); + + if (group.member !== undefined) { + if (group.member === null || !_utils.xapiValidationUtils.isArray(group.member)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace, _properties.properties.MEMBER), + message: _errors.xapiValidationErrors.GROUP_MEMBER_MUST_BE_ARRAY, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } else { + group.member.forEach(function (member, i) { + validateAgent(member, _utils.xapiValidationUtils.addLookupToTrace(memberTrace, i), localErrors); + }); } - - function validateContextActivities(contextActivities, trace, errors) { - var localErrors = errors || [], - localTrace = trace || "contextActivities"; - if (contextActivities === undefined) { - return localErrors; - } - if (!isNonNullMapObject(contextActivities)) { - localErrors.push(new ValidationError(localTraceToString(localTrace), "The Context Activities instances must be a non-null map object.", MUST_VIOLATION)); - return localErrors; - } - validateContextActivitySubContext(contextActivities.parent, addPropToTrace(localTrace, "parent"), localErrors); - validateContextActivitySubContext(contextActivities.grouping, addPropToTrace(localTrace, "grouping"), localErrors); - validateContextActivitySubContext(contextActivities.category, addPropToTrace(localTrace, "category"), localErrors); - validateContextActivitySubContext(contextActivities.other, addPropToTrace(localTrace, "other"), localErrors); - - validateAbsenceOfNonWhitelistedProperties(contextActivities, ["parent", "grouping", "category", "other"], localTrace, localErrors); - return localErrors; + } + + validateAbsenceOfNonWhitelistedProperties(group, _properties.xapiWhiteListProperties.GROUP, localTrace, localErrors); + + return localErrors; +} + +function validateActor(actor, trace, errors) { + var localErrors, localTrace; + + localErrors = errors || []; + localTrace = trace || _properties.properties.ACTOR; + + if (actor === null || actor === undefined) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace), + message: _errors.xapiValidationErrors.ACTOR_MUST_BE_PROVIDED, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + + return localErrors; + } + + if (_utils.xapiValidationUtils.isGroup(actor, _properties.objectTypes.GROUP)) { + validateGroup(actor, localTrace, localErrors); + } else { + validateAgent(actor, localTrace, localErrors); + } + + return localErrors; +} + +function validateAuthority(authority, trace, errors) { + var localErrors, localTrace; + + localErrors = errors || []; + localTrace = trace || _properties.properties.AUTHORITY; + + if (authority === undefined) { + return localErrors; + } + + if (!_utils.xapiValidationUtils.isNonNullMapObject(authority)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace), + message: _errors.xapiValidationErrors.AUTHORITY_MUST_BE_NON_NULL_MAP_OBJECT, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + + return localErrors; + } + if (_utils.xapiValidationUtils.isGroup(authority, _properties.objectTypes.GROUP)) { + validateGroup(authority, localTrace, localErrors); + if (!authority.member || !authority.member.length || authority.member.length !== _general.xapiGeneral.GROUP_AUTHORITY_AGENT_MEMBERS) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace, _properties.properties.MEMBER), + message: _errors.xapiValidationErrors.GROUP_AUTHORITY_AGENT_MEMBERS_MUST_BE_TWO, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); } - - function validateContext(context, trace, errors, statementObjectObjectType) { - var localErrors = errors || [], - localTrace = trace || "context"; - if (context === undefined) { - return localErrors; - } - if (!isNonNullMapObject(context)) { - localErrors.push(new ValidationError(localTrace, "If present, the context must be a non-null map object.", MUST_VIOLATION)); - return localErrors; - } - if (context.registration !== undefined && (context.registration === null || !isString(context.registration) || !uuidRegex.test(context.registration))) { - localErrors.push(new ValidationError(localTraceToString(localTrace, "registration"), "If present, the registration property must be a UUID string.", MUST_VIOLATION)); - } - if (["Group", "Agent"].indexOf(statementObjectObjectType) !== -1) { - if (context.revision !== undefined) { - localErrors.push(new ValidationError(localTraceToString(localTrace, "revision"), "The revision property must not be used if the Statement's Object is an Agent or Group.", MUST_VIOLATION)); - } - if (context.platform !== undefined) { - localErrors.push(new ValidationError(localTraceToString(localTrace, "platform"), "The platform property must not be used if the Statement's Object is an Agent or Group.", MUST_VIOLATION)); - } - } - - validatePropertyIsString(context, "revision", localTrace, localErrors, false, MUST_VIOLATION); - validatePropertyIsString(context, "platform", localTrace, localErrors, false, MUST_VIOLATION); - if (context.team !== undefined) { - validateGroup(context.team, addPropToTrace(localTrace, "team"), localErrors); - } - if (context.contextActivities !== undefined) { - validateContextActivities(context.contextActivities, addPropToTrace(localTrace, "contextActivities"), localErrors); - } - if (context.language !== undefined && !isValidLanguageTag(context.language)) { - localErrors.push(new ValidationError(localTraceToString(localTrace, "language"), "The language property must be encoded as an RFC 5646 compliant string, but was not.", MUST_VIOLATION)); - } - if (context.statement !== undefined) { - validateStatementRef(context.statement, addPropToTrace(localTrace, "statement"), localErrors); - } - - if (context.instructor !== undefined) { - if (isGroup(context.instructor)) { - validateGroup(context.instructor, addPropToTrace(localTrace, "instructor"), localErrors); - } else { - validateAgent(context.instructor, addPropToTrace(localTrace, "instructor"), localErrors); - } - } - validateExtensions(context.extensions, addPropToTrace(localTrace, "extensions"), localErrors); - validateAbsenceOfNonWhitelistedProperties(context, - ["registration", "instructor", "team", "contextActivities", "revision", "platform", "language", "statement", "extensions"], - localTrace, localErrors); - return localErrors; + } else { + validateAgent(authority, localTrace, localErrors); + } + + return localErrors; +} + +function validateContextActivitySubContext(subContext, trace, errors) { + var localErrors, localTrace; + + localErrors = errors || []; + localTrace = trace || _properties.properties.SUB_CONTEXT; + + if (subContext === undefined) { + return localErrors; + } + + if (subContext === null) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace), + message: _errors.xapiValidationErrors.CONTEXT_ACTIVITIES_MUST_NOT_BE_NULL, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } else if (_utils.xapiValidationUtils.isArray(subContext)) { + subContext.forEach(function (activity, i) { + validateActivity(activity, _utils.xapiValidationUtils.addLookupToTrace(localTrace, i), localErrors); + }); + } else if (_utils.xapiValidationUtils.isObject(subContext)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace), + message: _errors.xapiValidationErrors.CONTEXT_ACTIVITIES_SHOULD_BE_AN_ARRAY, + level: _errors.xapiErrorLevels.SHOULD_VIOLATION + }); + + validateActivity(subContext, localTrace, localErrors); + } else { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace), + message: _errors.xapiValidationErrors.CONTEXT_ACTIVITIES_MUST_BE_ARRAY_OR_ACTIVITY_OBJ, + level: _errors.xapiErrorLevels.MUST_VIOLATION }); + } + return localErrors; +} + +function validateContextActivities(contextActivities, trace, errors) { + var localErrors, localTrace; + + localErrors = errors || []; + localTrace = trace || _properties.properties.CONTEXT_ACTIVITIES; + + if (contextActivities === undefined) { + return localErrors; + } + + if (!_utils.xapiValidationUtils.isNonNullMapObject(contextActivities)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace), + message: _errors.xapiValidationErrors.CONTEXT_ACTIVITIES_MUST_BE_NON_NULL_MAP_OBJECT, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + return localErrors; + } + + validateContextActivitySubContext(contextActivities.parent, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.PARENT), localErrors); + validateContextActivitySubContext(contextActivities.grouping, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.GROUPING), localErrors); + validateContextActivitySubContext(contextActivities.category, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.CATEGORY), localErrors); + validateContextActivitySubContext(contextActivities.other, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.OTHER), localErrors); + + validateAbsenceOfNonWhitelistedProperties(contextActivities, _properties.xapiWhiteListProperties.CONTEXT_ACTIVITIES, localTrace, localErrors); + + return localErrors; +} + +function validateContext(context, trace, errors, statementObjectObjectType) { + var localErrors, localTrace; + + localErrors = errors || []; + localTrace = trace || _properties.properties.CONTEXT; + + if (context === undefined) { + return localErrors; + } + + if (!_utils.xapiValidationUtils.isNonNullMapObject(context)) { + localErrors.push({ + trace: localTrace, + message: _errors.xapiValidationErrors.CONTEXT_MUST_BE_NON_NUL_MAP_OBJECT, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + + return localErrors; + } + + if (context.registration !== undefined && (context.registration === null || !_utils.xapiValidationUtils.isString(context.registration) || !_regex.xapiValidationRegex.UUID.test(context.registration))) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace, _properties.properties.REGISTRATION), + message: _errors.xapiValidationErrors.REGISTRATION_MUST_BE_UUID_STRING, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + + if ([_properties.objectTypes.GROUP, _properties.objectTypes.AGENT].indexOf(statementObjectObjectType) !== _general.xapiGeneral.NO_INDEX_FOUND) { + if (context.revision !== undefined) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace, _properties.properties.REVISION), + message: _errors.xapiValidationErrors.REVISION_MUST_BE_AGENT_OR_GROUP, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); } - function validateObject(object, trace, errors, isWithinSubStatement) { - var localErrors = errors || [], - localTrace = trace || "object", - objectType; - if (object === undefined) { - localErrors.push(new ValidationError(localTraceToString(localTrace), "object property must be provided.", MUST_VIOLATION)); - return localErrors; - } - if (!isNonNullMapObject(object)) { - localErrors.push(new ValidationError(localTraceToString(localTrace), "object property must be a non-null map object.", MUST_VIOLATION)); - return localErrors; - } - validatePropertyIsString(object, "objectType", localTrace, localErrors, true, SHOULD_VIOLATION); - objectType = object.objectType || "Activity"; - if (objectType === "Activity") { - validateActivity(object, localTrace, localErrors); - } else if (objectType === "Agent") { - validateAgent(object, localTrace, localErrors); - } else if (objectType === "Group") { - validateGroup(object, localTrace, localErrors); - } else if (objectType === "StatementRef") { - validateStatementRef(object, localTrace, localErrors); - } else if (objectType === "SubStatement") { - if (isWithinSubStatement) { - localErrors.push(new ValidationError(localTraceToString(localTrace, "objectType"), "A SubStatement must not contain a SubStatement", MUST_VIOLATION)); - } - validateStatement(object, localTrace, localErrors, true); - } else { - localErrors.push(new ValidationError(localTraceToString(localTrace, "objectType"), "object's objectType did not match a valid option ['Activity', 'Agent', 'Group', 'StatementRef', 'SubStatement']", MUST_VIOLATION)); - } - return localErrors; + if (context.platform !== undefined) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace, _properties.properties.PLATFORM), + message: _errors.xapiValidationErrors.PLATFORM_MUST_NOT_BE_USED_WITH_REVISION_AGENT_OR_GROUP, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + } + + validatePropertyIsString(context, _properties.properties.REVISION, localTrace, localErrors, /*isRequired*/false, _errors.xapiErrorLevels.MUST_VIOLATION); + validatePropertyIsString(context, _properties.properties.PLATFORM, localTrace, localErrors, /*isRequired*/false, _errors.xapiErrorLevels.MUST_VIOLATION); + + if (context.team !== undefined) { + validateGroup(context.team, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.TEAM), localErrors); + } + + if (context.contextActivities !== undefined) { + validateContextActivities(context.contextActivities, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.CONTEXT_ACTIVITIES), localErrors); + } + + if (context.language !== undefined && !_utils.xapiValidationUtils.isValidLanguageTag(context.language, _regex.xapiValidationRegex.BCP_47)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace, _properties.properties.LANGUAGE), + message: _errors.xapiValidationErrors.LANGUAGE_MUST_BE_STRING, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + + if (context.statement !== undefined) { + validateStatementRef(context.statement, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.STATEMENT), localErrors); + } + + if (context.instructor !== undefined) { + if (_utils.xapiValidationUtils.isGroup(context.instructor, _properties.objectTypes.GROUP)) { + validateGroup(context.instructor, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.INSTRUCTOR), localErrors); + } else { + validateAgent(context.instructor, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.INSTRUCTOR), localErrors); + } + } + + validateExtensions(context.extensions, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.EXTENSIONS), localErrors); + validateAbsenceOfNonWhitelistedProperties(context, _properties.xapiWhiteListProperties.EXTENSIONS, localTrace, localErrors); + + return localErrors; +} + +function validateObject(object, trace, errors, isWithinSubStatement) { + var localErrors, localTrace, objectType; + + localErrors = errors || []; + localTrace = trace || _properties.properties.OBJECT; + + if (object === undefined) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace), + message: _errors.xapiValidationErrors.OBJECT_MUST_BE_DEFINED, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + + return localErrors; + } + + if (!_utils.xapiValidationUtils.isNonNullMapObject(object)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace), + message: _errors.xapiValidationErrors.OBJECT_MUST_BE_NON_NULL_MAP_OBJECT, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + + return localErrors; + } + + validatePropertyIsString(object, _properties.properties.OBJECT_TYPE, localTrace, localErrors, /*isRequired*/true, _errors.xapiErrorLevels.SHOULD_VIOLATION); + + objectType = object.objectType || _properties.objectTypes.ACTIVITY; + + switch (objectType) { + case _properties.objectTypes.ACTIVITY: + validateActivity(object, localTrace, localErrors); + break; + case _properties.objectTypes.AGENT: + validateAgent(object, localTrace, localErrors); + break; + case _properties.objectTypes.GROUP: + validateGroup(object, localTrace, localErrors); + break; + case _properties.objectTypes.STATEMENT_REF: + validateStatementRef(object, localTrace, localErrors); + break; + case _properties.objectTypes.SUB_STATEMENT: + if (isWithinSubStatement) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace, _properties.properties.OBJECT_TYPE), + message: _errors.xapiValidationErrors.SUB_STATEMENT_MUST_NOT_CONTAIN_SUB_STATEMENT, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + validate(object, localTrace, localErrors, /*isSubStatement*/true); + break; + default: + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace, _properties.properties.OBJECT_TYPE), + message: _errors.xapiValidationErrors.OBJECT_TYPE_MUST_BE_VALID_OPTION + ' ' + _properties.xApiValidObjectTypes.toString(), + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + + return localErrors; +} + +function validate(statement, trace, errors, isSubStatement) { + var localErrors, localTrace, statementObjectObjectType, whitelistedProperties; + + localErrors = errors || []; + localTrace = trace || _properties.properties.STATEMENT; + + whitelistedProperties = _properties.xapiWhiteListProperties.STATEMENT; + + if (!_utils.xapiValidationUtils.isNonNullMapObject(statement)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace), + message: _errors.xapiValidationErrors.STATEMENT_REF_MUST_NOT_BE_NULL_MAP_OBJECTS, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + + return localErrors; + } + + if (!isSubStatement) { + if (statement.id === null || statement.id === undefined || !_utils.xapiValidationUtils.isString(statement.id)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace, _properties.properties.ID), + message: _errors.xapiValidationErrors.IDS_SHOULD_BE_GENERATED_BY_LRS, + level: _errors.xapiErrorLevels.SHOULD_VIOLATION + }); + } else if (!_regex.xapiValidationRegex.UUID.test(statement.id)) { + localErrors.push({ + trace: _utils.xapiValidationUtils.localTraceToString(localTrace, _properties.properties.ID), + message: _errors.xapiValidationErrors.ID_MUST_BE_VALID, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + } else { + whitelistedProperties = _properties.xapiWhiteListProperties.SUB_STATEMENT; + } + + validateActor(statement.actor, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.ACTOR), localErrors); + validateVerb(statement.verb, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.VERB), localErrors); + validateObject(statement.object, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.OBJECT), localErrors, isSubStatement); + validateResult(statement.result, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.RESULT), localErrors); + + statementObjectObjectType = statement.object && statement.object.objectType ? statement.object.objectType : _properties.objectTypes.ACTIVITY; + + validateContext(statement.context, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.CONTEXT), localErrors, statementObjectObjectType); + validatePropertyIsISO8601String(statement, _properties.properties.TIMESTAMP, localTrace, localErrors); + validatePropertyIsISO8601String(statement, _properties.properties.STORED, localTrace, localErrors); + + validateAuthority(statement.authority, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.AUTHORITY), localErrors); + validateVersion(statement.version, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.VERSION), localErrors); + validateAttachments(statement.attachments, _utils.xapiValidationUtils.addPropToTrace(localTrace, _properties.properties.ATTACHMENTS), localErrors); + + validateAbsenceOfNonWhitelistedProperties(statement, whitelistedProperties, localTrace, localErrors); + + return localErrors; +} + +function makeStatementReport(statement) { + var localErrors; + + localErrors = []; + validate(statement, _properties.properties.STATEMENT, localErrors, /*isRequired*/false); + + return makeV1Report(statement, localErrors); +} + +function validateAmbiguousTypeStatement(statement) { + var statementObject; + + if (statement === undefined) { + return makeV1SingleErrorReport( /*instance*/null, { + trace: _properties.properties.STATEMENT, + message: _errors.xapiValidationErrors.STATEMENT_ARGUMENT_MUST_BE_PROVIDED, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + + if (statement === null) { + return makeV1SingleErrorReport( /*instance*/null, { + trace: _properties.properties.STATEMENT, + message: _errors.xapiValidationErrors.STATEMENT_MUST_NOT_BE_NULL, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + + if (_utils.xapiValidationUtils.isString(statement)) { + try { + statementObject = JSON.parse(statement); + if (statementObject === null || !_utils.xapiValidationUtils.isObject(statementObject) || _utils.xapiValidationUtils.isArray(statementObject)) { + return makeV1SingleErrorReport(statementObject, { + trace: _properties.properties.STATEMENT, + message: _errors.xapiValidationErrors.STATEMENT_MUST_BE_PARSED_CORRECTLY, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); + } + } catch (e) { + return makeV1SingleErrorReport(statementObject, { + trace: _properties.properties.STATEMENT, + message: _errors.xapiValidationErrors.INVALID_JSON + ': ' + e.message, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); } - function validateStatement(statement, trace, errors, isSubStatement) { - var localErrors = errors || [], - localTrace = trace || "statement", - statementObjectObjectType, - whitelistedProperties = ["id", "actor", "verb", "object", "result", "context", "timestamp", "stored", "authority", "version", "attachments"]; - - if (!isNonNullMapObject(statement)) { - localErrors.push(new ValidationError(localTraceToString(localTrace), "Statements must be non-null map objects", MUST_VIOLATION)); - return localErrors; - } - - if (!isSubStatement) { - if (statement.id === null || statement.id === undefined || !isString(statement.id)) { - localErrors.push(new ValidationError(localTraceToString(localTrace, "id"), "Ids should be generated by the Activity Provider, and must be generated by the LRS", SHOULD_VIOLATION)); - } else if (!uuidRegex.test(statement.id)) { - localErrors.push(new ValidationError(localTraceToString(localTrace, "id"), "Id was not a valid UUID", MUST_VIOLATION)); - } - } else { - whitelistedProperties = ["actor", "verb", "object", "result", "context", "timestamp", "attachments", "objectType"]; - } - - validateActor(statement.actor, addPropToTrace(localTrace, "actor"), localErrors); - validateVerb(statement.verb, addPropToTrace(localTrace, "verb"), localErrors); - validateObject(statement.object, addPropToTrace(localTrace, "object"), localErrors, isSubStatement); - validateResult(statement.result, addPropToTrace(localTrace, "result"), localErrors); - - statementObjectObjectType = statement.object && statement.object.objectType ? statement.object.objectType : "Activity"; - validateContext(statement.context, addPropToTrace(localTrace, "context"), localErrors, statementObjectObjectType); - validatePropertyIsISO8601String(statement, "timestamp", localTrace, localErrors); - validatePropertyIsISO8601String(statement, "stored", localTrace, localErrors); + return makeStatementReport(statementObject); + } - validateAuthority(statement.authority, addPropToTrace(localTrace, "authority"), localErrors); - validateVersion(statement.version, addPropToTrace(localTrace, "version"), localErrors); - validateAttachments(statement.attachments, addPropToTrace(localTrace, "attachments"), localErrors); + if (_utils.xapiValidationUtils.isObject(statement) && !_utils.xapiValidationUtils.isArray(statement)) { + return makeStatementReport(statement); + } - validateAbsenceOfNonWhitelistedProperties(statement, whitelistedProperties, localTrace, localErrors); + return makeV1SingleErrorReport( /*instance*/null, { + trace: _properties.properties.STATEMENT, + message: _errors.xapiValidationErrors.STATEMENT_ARGUMENT_IS_NOT_VALID, + level: _errors.xapiErrorLevels.MUST_VIOLATION + }); +} - return localErrors; - } +function dateIncludesZoneInformation(matched) { + return matched[_regex.dateFormatRegexPositions.ZONE] || matched[_regex.dateFormatRegexPositions.RELATIVE_TIME] && matched[_regex.dateFormatRegexPositions.TIME_ZONE_HOUR]; +} - function makeStatementReport(statement) { - var localErrors = []; - validateStatement(statement, "statement", localErrors, false); - return makeV1Report(statement, localErrors); - } +xapiValidation = { + validateStatement: validateAmbiguousTypeStatement +}; - function validateAmbiguousTypeStatement(statement) { - var statementObject; - if (statement === undefined) { - return makeV1SingleErrorReport(null, new ValidationError("statement", "No statement argument provided.", MUST_VIOLATION)); - } - if (statement === null) { - return makeV1SingleErrorReport(null, new ValidationError("statement", "Null statement argument provided.", MUST_VIOLATION)); - } - if (isString(statement)) { - try { - statementObject = JSON.parse(statement); - if (statementObject === null || !isObject(statementObject) || isArray(statementObject)) { - return makeV1SingleErrorReport(statementObject, new ValidationError("statement", "Null or non-object statement value parsed from provided statment JSON.", MUST_VIOLATION)); - } - } catch (e) { - return makeV1SingleErrorReport(statementObject, new ValidationError("statement", "Invalid JSON. The statement could not be parsed: " + e.message, MUST_VIOLATION)); - } - return makeStatementReport(statementObject); - } - if (isObject(statement) && !isArray(statement)) { - return makeStatementReport(statement); - } - return makeV1SingleErrorReport(null, new ValidationError("statement", "Statement argument provided was not a valid object or a valid JSON string.", MUST_VIOLATION)); - } +module.exports = xapiValidation; - exports.validateStatement = validateAmbiguousTypeStatement; -})); \ No newline at end of file +},{"./constants/errors":1,"./constants/general":2,"./constants/interaction-types":3,"./constants/properties":4,"./constants/regex":5,"./utils/utils":6}]},{},[7])(7) +}); +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","src/constants/errors.js","src/constants/general.js","src/constants/interaction-types.js","src/constants/properties.js","src/constants/regex.js","src/utils/utils.js","src/xapiValidator.js"],"names":[],"mappings":"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","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","'use strict';\n\nconst xapiErrorLevels = Object.freeze({\n  MAY_VIOLATION:    'MAY_VIOLATION',\n  MUST_VIOLATION:   'MUST_VIOLATION',\n  SHOULD_VIOLATION: 'SHOULD_VIOLATION'\n});\n\nconst xapiValidationErrors = Object.freeze({\n  ACTIVITIES_MUST_NOT_BE_NULL_MAP_OBJECTS:          'Activities must be non-null map objects',\n  ACTOR_MUST_BE_PROVIDED:                           'Actor must be provided.',\n  AGENT_IFI_PROPERTIES_MUST_BE_SPECIFIED:           'Exactly one Inverse Functional Identifier property must be specified for an \"agent\".',\n  AGENT_MUST_BE_NON_NULL_MAP_OBJECT:                '\"agent\" must be a non-null map object',\n  AGENT_MUST_NOT_HAVE_GROUP_CHARACTERISTICS:        'Invalid object with characteristics of a Group when an Agent was expected.',\n  ATTACHMENTS_MUST_BE_NOT_NULL_ARRAY:               '\"attachments\" must be a non-null Array.',\n  ATTACHMENTS_MUST_NOT_BE_NULL_MAP_OBJECTS:         '\"attachment\" instances must be non-null map objects.',\n  AUTHORITY_MUST_BE_NON_NULL_MAP_OBJECT:            'If present, the \"authority\" property must be a non-null map object.',\n  CONTEXT_ACTIVITIES_MUST_BE_ARRAY_OR_ACTIVITY_OBJ: 'Context Activities property values must be an array of Activity Objects or a single Activity Object.',\n  CONTEXT_ACTIVITIES_MUST_BE_NON_NULL_MAP_OBJECT:   'The Context Activities instances must be a non-null map object.',\n  CONTEXT_ACTIVITIES_MUST_NOT_BE_NULL:              '\"Context Activities\" property values must not be null.',\n  CONTEXT_ACTIVITIES_SHOULD_BE_AN_ARRAY:            'Context Activities property values should prefer to be an array of Activities rather than a single Activity object.',\n  CONTEXT_MUST_BE_NON_NUL_MAP_OBJECT:               'If present, the \"context\" property must be a non-null map object.',\n  CORRECT_RESPONSES_PATTERN_MUST_BE_ARRAY:          'If present, the \"correctResponsesPattern\" value must be an Array of strings.',\n  CORRECT_RESPONSES_PATTERN_MUST_BE_STRINGS:        '\"correctResponsesPattern\" items must be strings.',\n  DATE_MUST_BE_VALID:                               'This propertys string value must be conformant to ISO 8601 for Date Times.',\n  DATE_SHOULD_INCLUDE_ZONE_INFORMATION:             'ISO 8601 date time strings used in the xAPI should include time zone information.',\n  DEFINITIONS_MUST_BE_OBJECTS:                      '\"definitions\", when present, must be map objects',\n  DISPLAY_SHOULD_BE_PROVIDED:                       '\"display\" property should be provided.',\n  DURATION_MUST_BE_VALID:                           'If present, the \"duration\" property value must be an ISO 8601 duration',\n  EXTENSIONS_MUST_NOT_BE_NULL:                      'If present, the extensions property must be a non-null map object.',\n  GROUP_AUTHORITY_AGENT_MEMBERS_MUST_BE_TWO:        'If used as a Group, the \"authority\" property must contain a \"member\" property that is an array containing exactly two Agent objects.',\n  GROUP_IFI_PROPERTIES_MUST_BE_SPECIFIED:           'Exactly one Inverse Functional Identifier property must be specified for a \"group\".',\n  GROUP_MEMBER_MUST_BE_ARRAY:                       'If present, the member property of a Group must be an Array',\n  GROUP_MUST_BE_NON_NULL_MAP_OBJECT:                '\"group\" must be a non-null map object',\n  ID_MUST_BE_UNIQUE:                                '\"id\" properties must be unique within each interaction component array',\n  ID_MUST_BE_VALID_UUID_REF:                        '\"id\" property value must be a valid UUID string for statement reference objects.',\n  ID_MUST_BE_VALID:                                 'Id was not a valid UUID',\n  ID_SHOULD_NOT_CONTAIN_WHITESPACES:                '\"id\" properties on interaction components should not contain whitespace',\n  IDS_SHOULD_BE_GENERATED_BY_LRS:                   'Ids should be generated by the Activity Provider, and must be generated by the LRS',\n  IFI_MUST_BE_MBOX_URI:                             '\"mbox\" property was required to be a mailto URI string but was not a string at all.',\n  IFI_MUST_BE_VALID_MBOX_FORMAT:                    '\"mbox\" property was required to be a mailto URI string but did not match the mailto format.',\n  INTERACTION_ACTIVITY_SHOULD_HAVE:                 'Interaction Activity Definitions should have a type property of',\n  INTERACTION_COMPONENT_MUST_NOT_BE_NULL:           'This interaction component collection member must be a non-null map object',\n  INTERACTION_COMPONENT_SHOULD_BE_ARRAY:            'This interaction component collection property should be an array.',\n  INTERACTION_TYPE_MUST_BE_CMI:                     'If present, the \"interactionType\" value must be a CMI interaction type option.',\n  INTERACTION_TYPE_MUST_BE_VALID:                   'This interaction component collection property is not associated with the present interactionType of: ',\n  INVALID_JSON:                                     'Invalid JSON. The statement could not be parsed.',\n  LANGUAGE_MAP_KEY_INVALID:                         'key, Language does not conform to RFC 5646',\n  LANGUAGE_MAP_KEY_MUST_BE_STRING:                  'key: Language Map value should be a String, but was not',\n  LANGUAGE_MAPS_MUST_NOT_BE_NULL:                   'Language Maps, when present, must be non-null map objects',\n  LANGUAGE_MUST_BE_STRING:                          'The language property must be encoded as an RFC 5646 compliant string, but was not.',\n  LENGTH_MUST_BE_INTEGER:                           '\"length\" property must be provided with an integer value',\n  MAX_MUST_BE_GREATER_THAN_MIN:                     'If both \"max\" and \"min\" are present, the max property value should be greater than min',\n  MEMBER_MUST_BE_PROVIDED_FOR_ANONYMOUS_GROUPS:     '\"member\" property must be provided for Anonymous Groups.',\n  MUST_BE_BOOLEAN_PRESENT:                          'property was required to be a Boolean but was absent.',\n  MUST_BE_BOOLEAN:                                  'property, if present, must be a Boolean.',\n  MUST_BE_IRI_STRING:                               'property, if present, should be a IRI-like absolute URI per RFC 3987.',\n  MUST_BE_NUMBER_PRESENT:                           'property was required to be a Number but was absent.',\n  MUST_BE_NUMBER:                                   'property, if present, must be a Number.',\n  MUST_BE_PRESENT:                                  'property was required to be a string but was absent.',\n  MUST_BE_STRING:                                   'property, if present, must be a string.',\n  MUST_BE_URI_PRESENT:                              'property was required to be a URI string but was absent.',\n  MUST_BE_URI_STRING:                               'property, if present, must be a URI string.',\n  OBJECT_MUST_BE_DEFINED:                           '\"object\" property must be provided.',\n  OBJECT_MUST_BE_NON_NULL_MAP_OBJECT:               '\"object\" property must be a non-null map object.',\n  OBJECT_TYPE_MUST_BE_STATEMENT_REF:                '\"objectType\" property value must be \"StatementRef\" for statement reference objects.',\n  OBJECT_TYPE_MUST_BE_VALID_OPTION:                 'object\\'s \"objectType\" did not match a valid option',\n  RAW_MUST_BE_GREATER_THAN_MIN:                     'If both \"raw\" and \"min\" are present, the raw property value should be greater than min',\n  RAW_MUST_BE_LESS_THAN_MAX:                        'If both \"raw\" and \"max\" are present, the raw property value should be less than max',\n  REGISTRATION_MUST_BE_UUID_STRING:                 'If present, the registration property must be a UUID string.',\n  RESULT_MUST_BE_MAP_OBJECT:                        'If present, the result must be a map object',\n  REVISION_MUST_BE_AGENT_OR_GROUP:                  'The revision property must not be used if the Statement\\'s Object is an Agent or Group.',\n  SCALED_MUST_BE_BETWEEN_0_1:                       'If present, the scaled property value must be between 0 and 1',\n  SHA2_MUST_BE_PROVIDED_ON_ATTACHMENT_OBJECTS:      '\"sha2\" property must be provided on attachment objects',\n  SHA2_MUST_CONTAIN_BASE_64_STRING:                 '\"sha2\" property must contain a string with base64 contents',\n  STATEMENT_ARGUMENT_IS_NOT_VALID:                  'Statement argument provided was not a valid object or a valid JSON string.',\n  STATEMENT_ARGUMENT_MUST_BE_PROVIDED:              'No statement argument provided.',\n  STATEMENT_MUST_BE_PARSED_CORRECTLY:               'Null or non-object statement value parsed from provided statment JSON.',\n  STATEMENT_MUST_NOT_BE_NULL:                       'Null statement argument provided.',\n  STATEMENT_REF_MUST_NOT_BE_NULL_MAP_OBJECTS:       'StatementRef instances must be non-null map objects',\n  SUB_STATEMENT_MUST_NOT_CONTAIN_SUB_STATEMENT:     'A SubStatement must not contain a SubStatement',\n  UNEXPECTED:                                       'Unexpected property not permitted',\n  VERB_MUST_BE_PROVIDED:                            'Verb must be provided',\n  VERB_MUST_NOT_BE_NULL:                            'Verb property value must a non-null map object.',\n  VERSION_MUST_COMPLY_SEMANTIC_VERSIONING:          '\"version\" must be a non-null string that complies with Semantic Versioning 1.0.0'\n});\n\nexport {xapiErrorLevels};\nexport {xapiValidationErrors};\n","'use strict';\n\nconst xapiGeneral = Object.freeze({\n  FIRST_REPORT_VERSTION             : '1.0.0',\n  GROUP_AUTHORITY_AGENT_MEMBERS     : 2,\n  INTERACTION_DEFINITION_TYPE       : 'http://adlnet.gov/expapi/activities/cmi.interaction',\n  MAX_SCALED_VALUE                  : 1,\n  MIN_SCALED_VALUE                  : 0,\n  NO_INDEX_FOUND                    : -1,\n  NUMER_OF_SPECIFIED_IFI_PROPERTIES : 1\n});\n\nexport {xapiGeneral};\n","'use strict';\n\nexport const interactionTypes = Object.freeze({\n  CHOICE:       'choice',\n  FILL_IN:      'fill-in',\n  LIKERT:       'likert',\n  LONG_FILL_IN: 'long-fill-in',\n  MATCHING:     'matching',\n  NUMERIC:      'numeric',\n  OTHER:        'other',\n  PERFORMANCE:  'performance',\n  SEQUENCING:   'sequencing',\n  TRUE_FALSE:   'true-false'\n});\n\nexport const xapiValidationInteractionTypes = Object.freeze([\n  interactionTypes.CHOICE,\n  interactionTypes.FILL_IN,\n  interactionTypes.LIKERT,\n  interactionTypes.LONG_FILL_IN,\n  interactionTypes.MATCHING,\n  interactionTypes.NUMERIC,\n  interactionTypes.OTHER,\n  interactionTypes.PERFORMANCE,\n  interactionTypes.SEQUENCING,\n  interactionTypes.TRUE_FALSE\n]);\n","'use strict';\n\nconst properties = Object.freeze({\n  ACCOUNT:                   'account',\n  ACTIVITY:                  'activity',\n  ACTOR:                     'actor',\n  AGENT:                     'agent',\n  ATTACHMENT:                'attachment',\n  ATTACHMENTS:               'attachments',\n  AUTHORITY:                 'authority',\n  CATEGORY:                  'category',\n  CHOICE:                    'choice',\n  CHOICES:                   'choices',\n  COMPLETION:                'completion',\n  CONTENT_TYPE:              'contentType',\n  CONTEXT_ACTIVITIES:        'contextActivities',\n  CONTEXT:                   'context',\n  CORRECT_RESPONSES_PATTERN: 'correctResponsesPattern',\n  DATE_TIME:                 'dateTime',\n  DEFINITION:                'definition',\n  DESCRIPTION:               'description',\n  DISPLAY:                   'display',\n  DURATION:                  'duration',\n  EXTENSIONS:                'extensions',\n  FILE_URL:                  'fileUrl',\n  GROUP:                     'group',\n  GROUPING:                  'grouping',\n  HOME_PAGE:                 'homePage',\n  ID:                        'id',\n  INSTRUCTOR:                'instructor',\n  INTERACTION_COMPONENTS:    'interactionComponents',\n  INTERACTION_TYPE:          'interactionType',\n  LANGUAGE_MAP:              'languageMap',\n  LANGUAGE:                  'language',\n  LENGTH:                    'length',\n  LIKERT:                    'likert',\n  MATCHING:                  'matching',\n  MAX:                       'max',\n  MBOX_SHA_1_SUM:            'mbox_sha1sum',\n  MBOX:                      'mbox',\n  MEMBER:                    'member',\n  MIN:                       'min',\n  MORE_INFO:                 'moreInfo',\n  NAME:                      'name',\n  OBJECT_TYPE:               'objectType',\n  OBJECT:                    'object',\n  OPEN_ID:                   'openID',\n  OTHER:                     'other',\n  PARENT:                    'parent',\n  PERFORMANCE:               'performance',\n  PLATFORM:                  'platform',\n  RAW:                       'raw',\n  REGISTRATION:              'registration',\n  RESPONSE:                  'response',\n  RESULT:                    'result',\n  REVISION:                  'revision',\n  SCALE:                     'scale',\n  SCALED:                    'scaled',\n  SCORE:                     'score',\n  SEQUENCING:                'sequencing',\n  SHA2:                      'sha2',\n  SOURCE:                    'source',\n  STATEMENT_REF:             'statementRef',\n  STATEMENT:                 'statement',\n  STEPS:                     'steps',\n  STORED:                    'stored',\n  SUB_CONTEXT:               'subContext',\n  SUCCESS:                   'success',\n  TARGET:                    'target',\n  TEAM:                      'team',\n  TIMESTAMP:                 'timestamp',\n  TYPE:                      'type',\n  USAGE_TYPE:                'usageType',\n  VERB:                      'verb',\n  VERSION:                   'version'\n});\n\nconst objectTypes = Object.freeze({\n  GROUP:         'Group',\n  AGENT:         'Agent',\n  ACTIVITY:      'Activity',\n  STATEMENT_REF: 'StatementRef',\n  SUB_STATEMENT: 'SubStatement'\n});\n\nconst xapiValidationIfiPropertyNames = Object.freeze([\n  properties.ACCOUNT,\n  properties.MBOX_SHA_1_SUM,\n  properties.MBOX,\n  properties.OPEN_ID\n]);\n\nconst xApiValidObjectTypes = Object.freeze([\n  objectTypes.GROUP,\n  objectTypes.AGENT,\n  objectTypes.ACTIVITY,\n  objectTypes.STATEMENT_REF,\n  objectTypes.SUB_STATEMENT\n]);\n\nconst xapiWhiteListProperties = Object.freeze({\n  IFI: [\n    properties.HOME_PAGE,\n    properties.NAME\n  ],\n  URI: [\n    properties.ID,\n    properties.DISPLAY\n  ],\n  COMPONENT_ARRAY: [\n    properties.ID,\n    properties.DESCRIPTION\n  ],\n  ACTIVITY_DEFINITION: [\n    properties.NAME,\n    properties.DESCRIPTION,\n    properties.TYPE,\n    properties.MORE_INFO,\n    properties.EXTENSIONS,\n    properties.INTERACTION_TYPE,\n    properties.CORRECT_RESPONSES_PATTERN,\n    properties.CHOICES,\n    properties.SCALE,\n    properties.SOURCE,\n    properties.TARGET,\n    properties.STEPS\n  ],\n  ACTIVITY: [\n    properties.OBJECT_TYPE,\n    properties.ID,\n    properties.DEFINITION\n  ],\n  STATEMENT_REF: [\n    properties.ID,\n    properties.OBJECT_TYPE\n  ],\n  SCORE: [\n    properties.SCALED,\n    properties.RAW,\n    properties.MIN,\n    properties.MAX\n  ],\n  RESULT: [\n    properties.SCORE,\n    properties.SUCCESS,\n    properties.COMPLETION,\n    properties.RESPONSE,\n    properties.DURATION,\n    properties.EXTENSIONS\n  ],\n  ATTACHMENT: [\n    properties.USAGE_TYPE,\n    properties.DISPLAY,\n    properties.DESCRIPTION,\n    properties.CONTENT_TYPE,\n    properties.LENGTH,\n    properties.SHA2,\n    properties.FILE_URL\n  ],\n AGENT: [\n   properties.OBJECT_TYPE,\n   properties.NAME,\n   properties.ACCOUNT,\n   properties.MBOX_SHA_1_SUM,\n   properties.MBOX,\n   properties.OPEN_ID\n ],\n GROUP: [\n   properties.OBJECT_TYPE,\n   properties.NAME,\n   properties.MEMBER,\n   properties.ACCOUNT,\n   properties.MBOX_SHA_1_SUM,\n   properties.MBOX,\n   properties.OPEN_ID\n ],\n CONTEXT_ACTIVITIES: [\n   properties.PARENT,\n   properties.GROUPING,\n   properties.CATEGORY,\n   properties.OTHER\n ],\n STATEMENT: [\n   properties.ID,\n   properties.ACTOR,\n   properties.VERB,\n   properties.OBJECT,\n   properties.RESULT,\n   properties.CONTEXT,\n   properties.TIMESTAMP,\n   properties.STORED,\n   properties.AUTHORITY,\n   properties.VERSION,\n   properties.ATTACHMENTS\n ],\n SUB_STATEMENT: [\n   properties.ACTOR,\n   properties.VERB,\n   properties.OBJECT,\n   properties.RESULT,\n   properties.CONTEXT,\n   properties.TIMESTAMP,\n   properties.ATTACHMENTS,\n   properties.OBJECT_TYPE\n ],\n EXTENSIONS: [\n   properties.REGISTRATION,\n   properties.INSTRUCTOR,\n   properties.TEAM,\n   properties.CONTEXT_ACTIVITIES,\n   properties.REVISION,\n   properties.PLATFORM,\n   properties.LANGUAGE,\n   properties.STATEMENT,\n   properties.EXTENSIONS\n ]\n});\n\nexport {properties};\nexport {objectTypes};\nexport {xapiValidationIfiPropertyNames};\nexport {xApiValidObjectTypes};\nexport {xapiWhiteListProperties};\n","'use strict';\n\nconst xapiValidationRegex = Object.freeze({\n  UUID:                /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i,\n  ISO_8601_DURATION:   /^P((\\d+([\\.,]\\d+)?Y)?(\\d+([\\.,]\\d+)?M)?(\\d+([\\.,]\\d+)?W)?(\\d+([\\.,]\\d+)?D)?)?(T(\\d+([\\.,]\\d+)?H)?(\\d+([\\.,]\\d+)?M)?(\\d+([\\.,]\\d+)?S)?)?$/,\n  ISO_8601_DATE_TIME:  /^(\\d{4}|[+\\-]\\d{6})(?:-(\\d{2})(?:-(\\d{2}))?)?(?:T(\\d{2}):(\\d{2})(?::(\\d{2})(?:\\.(\\d{3}))?)?(?:(Z)|([+\\-])(\\d{2})(?::(\\d{2}))?)?)?$/,\n  MAILTO_URI:          /^mailto:/,\n  CONTAINS_WHITESPACE: /\\s/g,\n  SEMVER_1_P_0_P_0:    /^((\\d+)\\.(\\d+)\\.(\\d+))(?:-([\\dA-Za-z\\-]+))?$/,\n  BASE_64:             /^(?:[A-Za-z0-9\\+\\/]{4})*(?:[A-Za-z0-9\\+\\/]{2}==|[A-Za-z0-9\\+\\/]{3}=|[A-Za-z0-9\\+\\/]{4})$/,\n  IRI:                 /^[a-z](?:[\\-a-z0-9\\+\\.])*:(?:\\/\\/(?:(?:%[0-9a-f][0-9a-f]|[\\-a-z0-9\\._~\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF\\u10000-\\u1FFFD\\u20000-\\u2FFFD\\u30000-\\u3FFFD\\u40000-\\u4FFFD\\u50000-\\u5FFFD\\u60000-\\u6FFFD\\u70000-\\u7FFFD\\u80000-\\u8FFFD\\u90000-\\u9FFFD\\uA0000-\\uAFFFD\\uB0000-\\uBFFFD\\uC0000-\\uCFFFD\\uD0000-\\uDFFFD\\uE1000-\\uEFFFD!\\$&'\\(\\)\\*\\+,;=:])*@)?(?:\\[(?:(?:(?:[0-9a-f]{1,4}:){6}(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3})|::(?:[0-9a-f]{1,4}:){5}(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3})|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3})|(?:[0-9a-f]{1,4}:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3})|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3})|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3})|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3})|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|v[0-9a-f]+[\\-a-z0-9\\._~!\\$&'\\(\\)\\*\\+,;=:]+)\\]|(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(?:\\.(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3}|(?:%[0-9a-f][0-9a-f]|[\\-a-z0-9\\._~\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF\\u10000-\\u1FFFD\\u20000-\\u2FFFD\\u30000-\\u3FFFD\\u40000-\\u4FFFD\\u50000-\\u5FFFD\\u60000-\\u6FFFD\\u70000-\\u7FFFD\\u80000-\\u8FFFD\\u90000-\\u9FFFD\\uA0000-\\uAFFFD\\uB0000-\\uBFFFD\\uC0000-\\uCFFFD\\uD0000-\\uDFFFD\\uE1000-\\uEFFFD!\\$&'\\(\\)\\*\\+,;=@])*)(?::[0-9]*)?(?:\\/(?:(?:%[0-9a-f][0-9a-f]|[\\-a-z0-9\\._~\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF\\u10000-\\u1FFFD\\u20000-\\u2FFFD\\u30000-\\u3FFFD\\u40000-\\u4FFFD\\u50000-\\u5FFFD\\u60000-\\u6FFFD\\u70000-\\u7FFFD\\u80000-\\u8FFFD\\u90000-\\u9FFFD\\uA0000-\\uAFFFD\\uB0000-\\uBFFFD\\uC0000-\\uCFFFD\\uD0000-\\uDFFFD\\uE1000-\\uEFFFD!\\$&'\\(\\)\\*\\+,;=:@]))*)*|\\/(?:(?:(?:(?:%[0-9a-f][0-9a-f]|[\\-a-z0-9\\._~\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF\\u10000-\\u1FFFD\\u20000-\\u2FFFD\\u30000-\\u3FFFD\\u40000-\\u4FFFD\\u50000-\\u5FFFD\\u60000-\\u6FFFD\\u70000-\\u7FFFD\\u80000-\\u8FFFD\\u90000-\\u9FFFD\\uA0000-\\uAFFFD\\uB0000-\\uBFFFD\\uC0000-\\uCFFFD\\uD0000-\\uDFFFD\\uE1000-\\uEFFFD!\\$&'\\(\\)\\*\\+,;=:@]))+)(?:\\/(?:(?:%[0-9a-f][0-9a-f]|[\\-a-z0-9\\._~\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF\\u10000-\\u1FFFD\\u20000-\\u2FFFD\\u30000-\\u3FFFD\\u40000-\\u4FFFD\\u50000-\\u5FFFD\\u60000-\\u6FFFD\\u70000-\\u7FFFD\\u80000-\\u8FFFD\\u90000-\\u9FFFD\\uA0000-\\uAFFFD\\uB0000-\\uBFFFD\\uC0000-\\uCFFFD\\uD0000-\\uDFFFD\\uE1000-\\uEFFFD!\\$&'\\(\\)\\*\\+,;=:@]))*)*)?|(?:(?:(?:%[0-9a-f][0-9a-f]|[\\-a-z0-9\\._~\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF\\u10000-\\u1FFFD\\u20000-\\u2FFFD\\u30000-\\u3FFFD\\u40000-\\u4FFFD\\u50000-\\u5FFFD\\u60000-\\u6FFFD\\u70000-\\u7FFFD\\u80000-\\u8FFFD\\u90000-\\u9FFFD\\uA0000-\\uAFFFD\\uB0000-\\uBFFFD\\uC0000-\\uCFFFD\\uD0000-\\uDFFFD\\uE1000-\\uEFFFD!\\$&'\\(\\)\\*\\+,;=:@]))+)(?:\\/(?:(?:%[0-9a-f][0-9a-f]|[\\-a-z0-9\\._~\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF\\u10000-\\u1FFFD\\u20000-\\u2FFFD\\u30000-\\u3FFFD\\u40000-\\u4FFFD\\u50000-\\u5FFFD\\u60000-\\u6FFFD\\u70000-\\u7FFFD\\u80000-\\u8FFFD\\u90000-\\u9FFFD\\uA0000-\\uAFFFD\\uB0000-\\uBFFFD\\uC0000-\\uCFFFD\\uD0000-\\uDFFFD\\uE1000-\\uEFFFD!\\$&'\\(\\)\\*\\+,;=:@]))*)*|(?!(?:%[0-9a-f][0-9a-f]|[\\-a-z0-9\\._~\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF\\u10000-\\u1FFFD\\u20000-\\u2FFFD\\u30000-\\u3FFFD\\u40000-\\u4FFFD\\u50000-\\u5FFFD\\u60000-\\u6FFFD\\u70000-\\u7FFFD\\u80000-\\u8FFFD\\u90000-\\u9FFFD\\uA0000-\\uAFFFD\\uB0000-\\uBFFFD\\uC0000-\\uCFFFD\\uD0000-\\uDFFFD\\uE1000-\\uEFFFD!\\$&'\\(\\)\\*\\+,;=:@])))(?:\\?(?:(?:%[0-9a-f][0-9a-f]|[\\-a-z0-9\\._~\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF\\u10000-\\u1FFFD\\u20000-\\u2FFFD\\u30000-\\u3FFFD\\u40000-\\u4FFFD\\u50000-\\u5FFFD\\u60000-\\u6FFFD\\u70000-\\u7FFFD\\u80000-\\u8FFFD\\u90000-\\u9FFFD\\uA0000-\\uAFFFD\\uB0000-\\uBFFFD\\uC0000-\\uCFFFD\\uD0000-\\uDFFFD\\uE1000-\\uEFFFD!\\$&'\\(\\)\\*\\+,;=:@])|[\\uE000-\\uF8FF\\uF0000-\\uFFFFD|\\u100000-\\u10FFFD\\/\\?])*)?(?:\\#(?:(?:%[0-9a-f][0-9a-f]|[\\-a-z0-9\\._~\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF\\u10000-\\u1FFFD\\u20000-\\u2FFFD\\u30000-\\u3FFFD\\u40000-\\u4FFFD\\u50000-\\u5FFFD\\u60000-\\u6FFFD\\u70000-\\u7FFFD\\u80000-\\u8FFFD\\u90000-\\u9FFFD\\uA0000-\\uAFFFD\\uB0000-\\uBFFFD\\uC0000-\\uCFFFD\\uD0000-\\uDFFFD\\uE1000-\\uEFFFD!\\$&'\\(\\)\\*\\+,;=:@])|[\\/\\?])*)?$/i,\n  BCP_47:              /^(?:(en-GB-oed|i-(?:ami|bnn|default|enochian|hak|klingon|lux|mingo|navajo|pwn|tao|tay|tsu)|sgn-(?:BE-FR|BE-NL|CH-DE))|(art-lojban|cel-gaulish|no-(?:bok|nyn)|zh-(?:guoyu|hakka|min|min-nan|xiang)))$|^(x(?:-[0-9a-z]{1,8})+)$|^(?:((?:[a-z]{2,3}(?:(?:-[a-z]{3}){1,3})?)|[a-z]{4}|[a-z]{5,8})(?:-([a-z]{4}))?(?:-([a-z]{2}|[0-9]{3}))?((?:-(?:[a-z0-9]{5,8}|[0-9][a-z0-9]{3}))*)?((?:-[0-9a-wy-z](?:-[a-z0-9]{2,8}){1,})*)?(-x(?:-[0-9a-z]{1,8})+)?)$/i\n});\n\nconst dateFormatRegexPositions = Object.freeze({\n  YEAR:             1,\n  MONTH:            2,\n  DAY:              3,\n  HOUR:             4,\n  MINUTE:           5,\n  SECOND:           6,\n  MSECOND:          7,\n  ZONE:             8,\n  RELATIVE_TIME:    9,\n  TIME_ZONE_HOUR:   10,\n  TIME_ZONE_MINUTE: 11\n});\n\nexport {xapiValidationRegex};\nexport {dateFormatRegexPositions};\n","'use strict';\n\nconst\n  IS_STRING  = '[object String]',\n  IS_ARRAY   = '[object Array]',\n  IS_BOOLEAN = '[object Boolean]',\n  IS_NUMBER  = '[object Number]'\n;\n\nvar toString = Object.prototype.toString;\nvar xapiValidationUtils;\n\nxapiValidationUtils = {\n  isString(obj) {\n    return toString.call(obj) === IS_STRING;\n  },\n\n  isObject(obj) {\n    return obj === Object(obj);\n  },\n\n  isArray: Array.isArray || function(obj) {\n    return toString.call(obj) === IS_ARRAY;\n  },\n\n  isBoolean(obj) {\n    return obj === true || obj === false || toString.call(obj) === IS_BOOLEAN;\n  },\n\n  isNumber(obj) {\n    return toString.call(obj) === IS_NUMBER;\n  },\n\n  isDefined(obj) {\n    return (obj !== null || obj !== undefined);\n  },\n\n  isNonNullMapObject(target) {\n      return this.isDefined(target) && this.isObject(target) && !this.isArray(target);\n  },\n\n  isValidLanguageTag(target, validLanguageRegex) {\n    // TODO - use more precise 5646 handling, rather than this simplified BCP 47 regex, which combines RFC 5646 and RFC 4647.\n    // return this.isDefined(target) && this.isString(target) && xapiValidationRegex.BCP_47.test(target);\n    return this.isDefined(target) && this.isString(target) && validLanguageRegex.test(target);\n  },\n\n  addPropToTrace(trace, addendum) {\n    return this.isDefined(addendum) ? `${trace}.${addendum}` : trace;\n  },\n\n  addLookupToTrace(trace, key) {\n    return (!this.isDefined(key)) ? trace : (this.isNumber(key) ? `${trace}[${key}]` : `${trace}[\"${key}\"]`);\n  },\n\n  localTraceToString(trace, addendum) {\n    return this.addPropToTrace(trace, addendum);\n  },\n\n  isGroup(actorOrGroup, groupType) {\n    // return (actorOrGroup.member !== null && actorOrGroup.member !== undefined) || actorOrGroup.objectType === objectTypes.GROUP;\n    return (actorOrGroup.member !== null && actorOrGroup.member !== undefined) || actorOrGroup.objectType === groupType;\n  }\n};\n\nexport {xapiValidationUtils};\n","'use strict';\n\nimport {properties, objectTypes, xapiValidationIfiPropertyNames, xApiValidObjectTypes, xapiWhiteListProperties} from './constants/properties';\nimport {xapiErrorLevels, xapiValidationErrors} from './constants/errors';\nimport {xapiValidationInteractionTypes} from './constants/interaction-types';\nimport {xapiValidationRegex, dateFormatRegexPositions} from './constants/regex';\nimport {xapiGeneral} from './constants/general';\nimport {xapiValidationUtils} from './utils/utils';\n\nvar xapiValidation;\n\nfunction makeV1Report(instance, errors) {\n  var version;\n\n  instance = instance || null;\n  errors   = errors   || null;\n  version  = xapiGeneral.FIRST_REPORT_VERSTION;\n  return {instance, errors, version};\n}\n\nfunction makeV1SingleErrorReport(instance, error) {\n  return makeV1Report(instance, error === null || error === undefined ? [] : [error]);\n}\n\nfunction validateAbsenceOfNonWhitelistedProperties(target, allowedProperties, trace, errors) {\n  var localErrors, localTrace, propertyName;\n\n  localErrors = errors || [];\n  localTrace  = trace  || '';\n\n  for (propertyName in target) {\n    if (target.hasOwnProperty(propertyName) && allowedProperties.indexOf(propertyName) === xapiGeneral.NO_INDEX_FOUND) {\n      localErrors.push({\n        trace:   xapiValidationUtils.addPropToTrace(localTrace, propertyName),\n        message: xapiValidationErrors.UNEXPECTED,\n        level:   xapiErrorLevels.MUST_VIOLATION\n      });\n    }\n  }\n\n  return localErrors;\n}\n\nfunction validatePropertyIsString(parent, propertyName, trace, errors, isRequired, violationType) {\n  var localErrors, localTrace, propValue, localViolationType;\n\n  localErrors        = errors || [];\n  localTrace         = trace  || '';\n  propValue          = parent[propertyName],\n  localViolationType = violationType || xapiErrorLevels.MUST_VIOLATION;\n\n  if (propValue !== undefined) {\n    if (propValue === null || !xapiValidationUtils.isString(propValue)) {\n      localErrors.push({\n        trace:   xapiValidationUtils.localTraceToString(localTrace, propertyName),\n        message: `${propertyName} ${xapiValidationErrors.MUST_BE_STRING}`,\n        level:   localViolationType\n      });\n    }\n  } else if (isRequired) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace, propertyName),\n      message: `${propertyName} ${xapiValidationErrors.MUST_BE_PRESENT}`,\n      level:   localViolationType\n    });\n  }\n\n  return localErrors;\n}\n\nfunction validatePropertyIsUri(target, propertyName, trace, errors, isRequired) {\n  var localErrors, localTrace, propValue;\n\n  localErrors = errors || [];\n  localTrace  = trace  || '';\n  propValue   = target[propertyName];\n\n  if (propValue !== undefined) {\n    if (propValue === null || !xapiValidationUtils.isString(propValue)) {\n      localErrors.push({\n        trace:   xapiValidationUtils.localTraceToString(localTrace, propertyName),\n        message: `${propertyName} ${xapiValidationErrors.MUST_BE_URI_STRING}`,\n        level:   xapiErrorLevels.MUST_VIOLATION\n      });\n    } else if (!xapiValidationRegex.IRI.test(propValue)) {\n      localErrors.push({\n        trace:  xapiValidationUtils.localTraceToString(localTrace, propertyName),\n        message: `${propertyName} ${xapiValidationErrors.MUST_BE_IRI_STRING}`,\n        level:   xapiErrorLevels.SHOULD_VIOLATION\n      });\n    }\n  } else if (isRequired) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace, propertyName),\n      message: `${propertyName} ${xapiValidationErrors.MUST_BE_URI_PRESENT}`,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n  }\n  return localErrors;\n}\n\nfunction validatePropertyIsUrl(target, propertyName, trace, errors, isRequired) {\n  // TODO - check whether a formal URL format definition is recommended/enforced for xAPI\n  return validatePropertyIsString(target, propertyName, trace, errors, isRequired);\n}\n\nfunction validatePropertyIsBoolean(parent, propertyName, trace, errors, isRequired) {\n  var localErrors, localTrace, propValue;\n\n  localErrors = errors || [];\n  localTrace  = trace  || '';\n  propValue   = parent[propertyName];\n\n  if (propValue !== undefined) {\n    if (propValue === null || !xapiValidationUtils.isBoolean(propValue)) {\n      localErrors.push({\n        trace:   xapiValidationUtils.localTraceToString(localTrace, propertyName),\n        message: `${propertyName} ${xapiValidationErrors.MUST_BE_BOOLEAN}`,\n        level:   xapiErrorLevels.MUST_VIOLATION\n      });\n    }\n  } else if (isRequired) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace, propertyName),\n      message: `${propertyName} ${xapiValidationErrors.MUST_BE_BOOLEAN_PRESENT}`,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n  }\n  return localErrors;\n}\n\nfunction validatePropertyIsNumber(parent, propertyName, trace, errors, isRequired) {\n  var localErrors, localTrace, propValue;\n\n  localErrors = errors || [];\n  localTrace  = trace  || '';\n  propValue   = parent[propertyName];\n\n    if (propValue !== undefined) {\n      if (propValue === null || !xapiValidationUtils.isNumber(propValue)) {\n        localErrors.push({\n          trace:   xapiValidationUtils.localTraceToString(localTrace, propertyName),\n          message: `${propertyName} ${xapiValidationErrors.MUST_BE_NUMBER}`,\n          level:   xapiErrorLevels.MUST_VIOLATION\n        });\n      }\n    } else if (isRequired) {\n      localErrors.push({\n        trace:   xapiValidationUtils.localTraceToString(localTrace, propertyName),\n        message: `${propertyName} ${xapiValidationErrors.MUST_BE_NUMBER_PRESENT}`,\n        level:   xapiErrorLevels.MUST_VIOLATION\n      });\n    }\n    return localErrors;\n}\n\nfunction validateIFIProperties(target, trace, errors) {\n  var localErrors, localTrace, accountTrace;\n\n  localErrors = errors || [];\n  localTrace  = trace  || '';\n\n  if (target.mbox !== undefined && target.mbox !== null) {\n    if (!xapiValidationUtils.isString(target.mbox)) {\n      localErrors.push({\n        trace: xapiValidationUtils.localTraceToString(localTrace, properties.MBOX),\n        message: xapiValidationErrors.IFI_MUST_BE_MBOX_URI,\n        level: xapiErrorLevels.MUST_VIOLATION\n      });\n    } else if (!xapiValidationRegex.MAILTO_URI.test(target.mbox)) {\n      localErrors.push({\n        trace:   xapiValidationUtils.localTraceToString(localTrace, properties.MBOX),\n        message: xapiValidationErrors.IFI_MUST_BE_VALID_MBOX_FORMAT,\n        level:   xapiErrorLevels.MUST_VIOLATION\n      });\n    }\n  }\n\n  validatePropertyIsString(target, properties.MBOX_SHA_1_SUM, localTrace, localErrors,  /*isRequired*/false);\n  validatePropertyIsUri(target, properties.OPEN_ID, localTrace, localErrors, /*isRequired*/false);\n\n  if (target.account !== undefined && target.account !== null) {\n    accountTrace = xapiValidationUtils.addPropToTrace(localTrace, properties.ACCOUNT);\n    validatePropertyIsUri(target.account, properties.HOME_PAGE,accountTrace, localErrors, /*isRequired*/true);\n    validatePropertyIsString(target.account, properties.NAME, accountTrace, localErrors, /*isRequired*/true);\n    validateAbsenceOfNonWhitelistedProperties(target.account, xapiWhiteListProperties.IFI, accountTrace, localErrors);\n  }\n\n  return localErrors;\n}\n\nfunction getIFIs(target) {\n  var ifis;\n\n  if (target === null || target === undefined) {return [];}\n\n  ifis = xapiValidationIfiPropertyNames.filter((name) => {\n    if (target[name] !== undefined && target[name] !== null) {\n      return {key: name, value: target[name]};\n    }\n  });\n\n  return ifis;\n}\n\nfunction getIFICount(target) {\n  return getIFIs(target).length;\n}\n\nfunction validateExtensions(extensions, trace, errors) {\n  var localErrors, localTrace;\n\n  localErrors = errors || [],\n  localTrace  = trace  || properties.EXTENSIONS;\n\n  if (extensions === undefined) {return localErrors;}\n\n  if (!xapiValidationUtils.isNonNullMapObject(extensions)) {\n    localErrors.push({\n      trace:   localTrace,\n      message: xapiValidationErrors.EXTENSIONS_MUST_NOT_BE_NULL,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n  }\n  // TODO - double-check what further enforceable constraints exist on extension object properties\n  return localErrors;\n}\n\nfunction validateLanguageMap(languageMap, trace, errors) {\n  var localErrors, localTrace, propName, mappedValue;\n\n  localErrors = errors || [];\n  localTrace  = trace  || properties.LANGUAGE_MAP;\n\n  if (languageMap === undefined) {return localErrors;}\n\n  if (!xapiValidationUtils.isNonNullMapObject(languageMap)) {\n    localErrors.push({\n      trace:   xapiValidationUtils.addPropToTrace(localTrace),\n      message: xapiValidationErrors.LANGUAGE_MAPS_MUST_NOT_BE_NULL,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n\n    return localErrors;\n  }\n\n  for (propName in languageMap) {\n\n    if (languageMap.hasOwnProperty(propName)) {\n      if (!xapiValidationUtils.isValidLanguageTag(propName, xapiValidationRegex.BCP_47)) {\n        localErrors.push({\n          trace:   xapiValidationUtils.addPropToTrace(localTrace, propName),\n          message: `${propName} ${xapiValidationErrors.LANGUAGE_MAP_KEY_INVALID}`,\n          level:   xapiErrorLevels.MUST_VIOLATION\n        });\n      }\n\n      mappedValue = languageMap[propName];\n\n      if (mappedValue === null || mappedValue === undefined || !xapiValidationUtils.isString(mappedValue)) {\n        localErrors.push({\n          trace:   xapiValidationUtils.addLookupToTrace(localTrace, propName),\n          message: `${propName} ${xapiValidationErrors.LANGUAGE_MAP_KEY_MUST_BE_STRING}`,\n          level:   xapiErrorLevels.MUST_VIOLATION\n        });\n      }\n    }\n  }\n\n  return localErrors;\n}\n\nfunction validateVerb(verb, trace, errors) {\n  var localErrors, localTrace;\n\n  localErrors = errors || [];\n  localTrace  = trace  || properties.VERB;\n\n  if (verb === undefined) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace),\n      message: xapiValidationErrors.VERB_MUST_BE_PROVIDED,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n\n    return localErrors;\n  }\n\n  if (!xapiValidationUtils.isNonNullMapObject(verb)) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace),\n      message: xapiValidationErrors.VERB_MUST_NOT_BE_NULL,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n\n    return localErrors;\n  }\n\n  validatePropertyIsUri(verb, properties.ID, localTrace, localErrors,  /*isRequired*/true);\n\n  if (verb.display === undefined) {\n    localErrors.push({\n      trace:   xapiValidationUtils.addPropToTrace(localTrace, properties.DISPLAY),\n      message: xapiValidationErrors.DISPLAY_SHOULD_BE_PROVIDED,\n      level:   xapiErrorLevels.SHOULD_VIOLATION\n    });\n  } else {\n    validateLanguageMap(verb.display, xapiValidationUtils.addPropToTrace(localTrace, properties.DISPLAY), localErrors);\n  }\n\n  validateAbsenceOfNonWhitelistedProperties(verb, xapiWhiteListProperties.URI, localTrace, localErrors);\n\n  return localErrors;\n}\n\nfunction validateInteractionComponentArray(components, interactionType, allowedInteractionTypes, trace, errors) {\n  var localErrors, localTrace, isAllowedComponentType, ids, perComponentTrace;\n\n  localErrors            = errors || [];\n  localTrace             = trace  || properties.INTERACTION_COMPONENTS;\n  isAllowedComponentType = allowedInteractionTypes.indexOf(interactionType) !== xapiGeneral.NO_INDEX_FOUND;\n  ids                    = [];\n\n  if (isAllowedComponentType && components !== undefined) {\n    if (components === null || !xapiValidationUtils.isArray(components)) {\n      localErrors.push({\n        trace:   localTrace,\n        message: xapiValidationErrors.INTERACTION_COMPONENT_SHOULD_BE_ARRAY,\n        level:   xapiErrorLevels.SHOULD_VIOLATION\n      });\n    } else {\n      components.forEach((interactionComponent, i) => {\n        perComponentTrace = xapiValidationUtils.addLookupToTrace(localTrace, i);\n\n        if (!xapiValidationUtils.isNonNullMapObject(interactionComponent)) {\n          localErrors.push({\n            trace:   perComponentTrace,\n            message: xapiValidationErrors.INTERACTION_COMPONENT_MUST_NOT_BE_NULL,\n            level:   xapiErrorLevels.MUST_VIOLATION\n          });\n        } else {\n          validatePropertyIsString(interactionComponent, properties.ID, perComponentTrace, localErrors, /*isRequired*/true, xapiErrorLevels.MUST_VIOLATION);\n          if (ids.indexOf(interactionComponent.id) !== xapiGeneral.NO_INDEX_FOUND) {\n            localErrors.push({\n              trace:   xapiValidationUtils.addPropToTrace(perComponentTrace, properties.ID),\n              message: xapiValidationErrors.ID_MUST_BE_UNIQUE,\n              level:   xapiErrorLevels.MUST_VIOLATION\n            });\n          } else {\n            ids.push(interactionComponent.id);\n          }\n\n          if (interactionComponent.id && xapiValidationRegex.CONTAINS_WHITESPACE.test(interactionComponent.id)) {\n            localErrors.push({\n              trace:   xapiValidationUtils.addPropToTrace(perComponentTrace, properties.ID),\n              message: xapiValidationErrors.ID_SHOULD_NOT_CONTAIN_WHITESPACES,\n              level:   xapiErrorLevels.SHOULD_VIOLATION\n            });\n          }\n\n          validateLanguageMap(interactionComponent.description, xapiValidationUtils.addPropToTrace(perComponentTrace, properties.DESCRIPTION), localErrors);\n          validateAbsenceOfNonWhitelistedProperties(interactionComponent, xapiWhiteListProperties.COMPONENT_ARRAY, perComponentTrace, localErrors);\n        }\n      });\n\n    }\n  } else if (interactionType && components) {\n    localErrors.push({\n      trace:   localTrace,\n      message: `${xapiValidationErrors.INTERACTION_TYPE_MUST_BE_VALID} ${interactionType}`,\n      level:   xapiErrorLevels.SHOULD_VIOLATION\n    });\n  }\n\n  return localErrors;\n}\n\nfunction validateActivityDefintion(definition, trace, errors) {\n  var localErrors, localTrace, correctResponsesPatternTrace;\n\n  localErrors                  = errors || [];\n  localTrace                   = trace  || properties.DEFINITION;\n  correctResponsesPatternTrace = xapiValidationUtils.addPropToTrace(localTrace, properties.CORRECT_RESPONSES_PATTERN);\n\n  if (!xapiValidationUtils.isNonNullMapObject(definition)) {\n    localErrors.push({\n      trace:   xapiValidationUtils.addPropToTrace(localTrace),\n      message: xapiValidationErrors.DEFINITIONS_MUST_BE_OBJECTS,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n\n    return localErrors;\n  }\n\n  validateLanguageMap(definition.name, xapiValidationUtils.addPropToTrace(localTrace, properties.NAME), localErrors);\n  validateLanguageMap(definition.description, xapiValidationUtils.addPropToTrace(localTrace, properties.DESCRIPTION), localErrors);\n\n  validatePropertyIsUri(definition, properties.TYPE, localTrace, localErrors,  /*isRequired*/false);\n  validatePropertyIsUrl(definition, properties.MORE_INFO, localTrace, localErrors,  /*isRequired*/false);\n  validateExtensions(definition.extensions, xapiValidationUtils.addPropToTrace(localTrace, properties.EXTENSIONS), localErrors);\n\n  if (definition.interactionType !== undefined) {\n    if (definition.type !== xapiGeneral.INTERACTION_DEFINITION_TYPE) {\n      localErrors.push({\n        trace:   xapiValidationUtils.localTraceToString(localTrace, properties.TYPE),\n        message: `${xapiValidationErrors.INTERACTION_ACTIVITY_SHOULD_HAVE} \"${xapiGeneral.INTERACTION_DEFINITION_TYPE}\"`,\n        level:   xapiErrorLevels.SHOULD_VIOLATION\n      });\n    }\n\n    if (xapiValidationInteractionTypes.indexOf(definition.interactionType) === xapiGeneral.NO_INDEX_FOUND) {\n      localErrors.push({\n        trace:   xapiValidationUtils.localTraceToString(localTrace, properties.INTERACTION_TYPE),\n        message: xapiValidationErrors.INTERACTION_TYPE_MUST_BE_CMI,\n        level:   xapiErrorLevels.MUST_VIOLATION\n      });\n    }\n  }\n\n  if (definition.correctResponsesPattern !== undefined) {\n    if (!xapiValidationUtils.isArray(definition.correctResponsesPattern)) {\n      localErrors.push({\n        trace:   correctResponsesPatternTrace,\n        message: xapiValidationErrors.CORRECT_RESPONSES_PATTERN_MUST_BE_ARRAY,\n        level:   xapiErrorLevels.MUST_VIOLATION\n      });\n    } else {\n      definition.correctResponsesPattern.forEach((response, i) => {\n        if (response === null || response === undefined || !xapiValidationUtils.isString(response)) {\n          localErrors.push({\n            trace:   xapiValidationUtils.addLookupToTrace(correctResponsesPatternTrace, i),\n            message: xapiValidationErrors.CORRECT_RESPONSES_PATTERN_MUST_BE_STRINGS,\n            level:   xapiErrorLevels.MUST_VIOLATION\n          });\n        }\n      });\n    }\n  }\n\n  validateInteractionComponentArray(\n    definition.choices,\n    definition.interactionType,\n    [properties.CHOICE, properties.SEQUENCING],\n    xapiValidationUtils.addPropToTrace(localTrace, properties.CHOICES),\n    localErrors\n  );\n\n  validateInteractionComponentArray(\n    definition.scale,\n    definition.interactionType,\n    [properties.LIKERT],\n    xapiValidationUtils.addPropToTrace(localTrace, properties.SCALE),\n    localErrors\n  );\n\n  validateInteractionComponentArray(\n    definition.source,\n    definition.interactionType,\n    [properties.MATCHING],\n    xapiValidationUtils.addPropToTrace(localTrace, properties.SOURCE),\n    localErrors\n  );\n\n  validateInteractionComponentArray(\n    definition.target,\n    definition.interactionType,\n    [properties.MATCHING],\n    xapiValidationUtils.addPropToTrace(localTrace, properties.TARGET),\n    localErrors\n  );\n\n  validateInteractionComponentArray(\n    definition.steps,\n    definition.interactionType,\n    [properties.PERFORMANCE],\n    xapiValidationUtils.addPropToTrace(localTrace, properties.STEPS),\n    localErrors\n  );\n\n  validateAbsenceOfNonWhitelistedProperties(definition, xapiWhiteListProperties.ACTIVITY_DEFINITION, localTrace, localErrors);\n  return localErrors;\n}\n\nfunction validateActivity(activity, trace, errors) {\n  var localErrors, localTrace;\n\n  localErrors = errors || [];\n  localTrace  = trace  || properties.ACTIVITY;\n\n  if (!xapiValidationUtils.isNonNullMapObject(activity)) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace),\n      message: xapiValidationErrors.ACTIVITIES_MUST_NOT_BE_NULL,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n\n    return localErrors;\n  }\n\n  validatePropertyIsUri(activity, properties.ID, localTrace, localErrors,  /*isRequired*/true);\n\n  if (activity.definition !== undefined) {\n    validateActivityDefintion(\n      activity.definition,\n      xapiValidationUtils.addPropToTrace(localTrace, properties.DEFINITION),\n      localErrors\n    );\n  }\n\n  validateAbsenceOfNonWhitelistedProperties(activity, xapiWhiteListProperties.ACTIVITY, localTrace, localErrors);\n\n  return localErrors;\n}\n\nfunction validateStatementRef(statementRef, trace, errors) {\n  var localErrors, localTrace;\n\n  localErrors = errors || [];\n  localTrace  = trace  || properties.STATEMENT_REF;\n\n  if (!xapiValidationUtils.isNonNullMapObject(statementRef)) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace),\n      message: xapiValidationErrors.STATEMENT_REF_MUST_NOT_BE_NULL_MAP_OBJECTS,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n    return localErrors;\n  }\n\n\n  if (statementRef.objectType !== objectTypes.STATEMENT_REF) {\n    localErrors.push({\n      trace:   xapiValidationUtils.addPropToTrace(localTrace, properties.OBJECT_TYPE),\n      message: xapiValidationErrors.OBJECT_TYPE_MUST_BE_STATEMENT_REF,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n  }\n\n  if (!statementRef.id || !xapiValidationRegex.UUID.test(statementRef.id)) {\n    localErrors.push({\n      trace:   xapiValidationUtils.addPropToTrace(localTrace, properties.ID),\n      message: xapiValidationErrors.ID_MUST_BE_VALID_UUID_REF,\n      level:  xapiErrorLevels.MUST_VIOLATION\n    });\n  }\n\n  validateAbsenceOfNonWhitelistedProperties(statementRef, xapiWhiteListProperties.STATEMENT_REF, localTrace, localErrors);\n\n  return localErrors;\n}\n\nfunction validateScore(score, trace, errors) {\n  var localErrors, localTrace;\n\n  localErrors = errors || [];\n  localTrace  = trace  || properties.SCORE;\n\n  if (score === undefined) {\n      return localErrors;\n  }\n\n  validatePropertyIsNumber(score, properties.SCALED, localTrace, localErrors,  /*isRequired*/false);\n\n  if (score.scaled !== undefined) {\n    if (score.scaled < xapiGeneral.MIN_SCALED_VALUE || score.scaled > xapiGeneral.MAX_SCALED_VALUE) {\n      localErrors.push({\n        trace:   xapiValidationUtils.addPropToTrace(localTrace, properties.SCALED),\n        message: xapiValidationErrors.SCALED_MUST_BE_BETWEEN_0_1,\n        level:   xapiErrorLevels.MUST_VIOLATION\n      });\n    }\n  }\n\n  if (score.min !== undefined) {\n    validatePropertyIsNumber(score, properties.MIN, localTrace, localErrors,  /*isRequired*/false);\n\n      if (score.raw !== undefined && score.raw < score.min) {\n        localErrors.push({\n          trace:   xapiValidationUtils.addPropToTrace(localTrace, properties.RAW),\n          message: xapiValidationErrors.RAW_MUST_BE_GREATER_THAN_MIN,\n          level:   xapiErrorLevels.MUST_VIOLATION\n        });\n      }\n\n      if (score.max !== undefined && score.max < score.min) {\n        localErrors.push({\n          trace:   xapiValidationUtils.addPropToTrace(localTrace, properties.MAX),\n          message: xapiValidationErrors.MAX_MUST_BE_GREATER_THAN_MIN,\n          level:   xapiErrorLevels.MUST_VIOLATION\n        });\n      }\n  }\n\n  if (score.max !== undefined) {\n    validatePropertyIsNumber(score, properties.MAX, localTrace, localErrors,  /*isRequired*/false);\n\n    if (score.raw !== undefined && score.raw > score.max) {\n      localErrors.push({\n        trace:   xapiValidationUtils.addPropToTrace(localTrace, properties.RAW),\n        message: xapiValidationErrors.RAW_MUST_BE_LESS_THAN_MAX,\n        level:   xapiErrorLevels.MUST_VIOLATION\n      });\n    }\n  }\n\n  validatePropertyIsNumber(score, properties.RAW, localTrace, localErrors,  /*isRequired*/false);\n  validateAbsenceOfNonWhitelistedProperties(score, xapiWhiteListProperties.SCORE, localTrace, localErrors);\n\n  return localErrors;\n}\n\nfunction validateResult(result, trace, errors) {\n  var localErrors, localTrace;\n\n  localErrors = errors || [];\n  localTrace  = trace  || properties.RESULT;\n\n  if (result === undefined) {return localErrors;}\n\n  if (!xapiValidationUtils.isNonNullMapObject(result)) {\n    localErrors.push({\n      trace:   xapiValidationUtils.addPropToTrace(localTrace),\n      message: xapiValidationErrors.RESULT_MUST_BE_MAP_OBJECT,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n\n    return localErrors;\n  }\n\n  validateScore(result.score, xapiValidationUtils.addPropToTrace(localTrace, properties.SCORE), localErrors);\n  validatePropertyIsBoolean(result, properties.SUCCESS, localTrace, localErrors,  /*isRequired*/false);\n  validatePropertyIsBoolean(result, properties.COMPLETION, localTrace, localErrors,  /*isRequired*/false);\n  validatePropertyIsString(result, properties.RESPONSE, localTrace, localErrors,  /*isRequired*/false);\n  validateExtensions(result.extensions, xapiValidationUtils.addPropToTrace(localTrace, properties.EXTENSIONS), localErrors);\n\n  if (result.duration !== undefined && (result.duration === null || !xapiValidationUtils.isString(result.duration) || !xapiValidationRegex.ISO_8601_DURATION.test(result.duration))) {\n    localErrors.push({\n      trace:   xapiValidationUtils.addPropToTrace(localTrace, properties.DURATION),\n      message: xapiValidationErrors.DURATION_MUST_BE_VALID,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n  }\n\n  validateAbsenceOfNonWhitelistedProperties(result, xapiWhiteListProperties.RESULT, localTrace, localErrors);\n\n  return localErrors;\n}\n\nfunction validatePropertyIsISO8601String(parent, propertyName, trace, errors) {\n  var localErrors, localTrace, matched, datetime;\n\n  localErrors = errors || [];\n  localTrace  = trace  || properties.DATE_TIME;\n  datetime    = parent[propertyName];\n\n  if (datetime === undefined) {return localErrors;}\n\n  if (datetime === null || !xapiValidationUtils.isString(datetime)) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace, propertyName),\n      message: `${propertyName} ${xapiValidationErrors.MUST_BE_STRING}`,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n\n    return localErrors;\n  }\n\n  matched = xapiValidationRegex.ISO_8601_DATE_TIME.exec(datetime);\n\n  if (matched) {\n    if (!dateIncludesZoneInformation(matched)) {\n      localErrors.push({\n        trace:   xapiValidationUtils.localTraceToString(localTrace, propertyName),\n        message: xapiValidationErrors.DATE_SHOULD_INCLUDE_ZONE_INFORMATION,\n        level:   xapiErrorLevels.SHOULD_VIOLATION\n      });\n    }\n  } else {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace, propertyName),\n      message: xapiValidationErrors.DATE_MUST_BE_VALID,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n  }\n\n  return localErrors;\n}\n\nfunction validateVersion(version, trace, errors) {\n  var localErrors, localTrace;\n\n  localErrors = errors || [];\n  localTrace  = trace  || properties.VERSION;\n\n  if (version === undefined) {return localErrors;}\n\n  if (version === null || !xapiValidationUtils.isString(version) || !xapiValidationRegex.SEMVER_1_P_0_P_0.test(version)) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace),\n      message: xapiValidationErrors.VERSION_MUST_COMPLY_SEMANTIC_VERSIONING,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n  }\n\n  return localErrors;\n}\n\nfunction validateAttachmentObject(attachment, trace, errors) {\n  var localErrors, localTrace;\n\n  localErrors = errors || [];\n  localTrace  = trace || properties.ATTACHMENT;\n\n  if (!xapiValidationUtils.isNonNullMapObject(attachment)) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace),\n      message: xapiValidationErrors.ATTACHMENTS_MUST_NOT_BE_NULL_MAP_OBJECTS,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n\n    return localErrors;\n  }\n\n  if (attachment.display === undefined) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace, properties.DISPLAY),\n      message: xapiValidationErrors.DISPLAY_SHOULD_BE_PROVIDED,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n\n  } else {\n    validateLanguageMap(attachment.display, xapiValidationUtils.addPropToTrace(localTrace, properties.DISPLAY), localErrors);\n  }\n\n  validateLanguageMap(attachment.description, xapiValidationUtils.addPropToTrace(localTrace, properties.DESCRIPTION), localErrors);\n  validatePropertyIsUri(attachment, properties.USAGE_TYPE, localTrace, localErrors, /*isRequired*/true, xapiErrorLevels.MUST_VIOLATION);\n  validatePropertyIsUri(attachment, properties.FILE_URL, localTrace, localErrors,  /*isRequired*/false, xapiErrorLevels.MUST_VIOLATION);\n\n  // TODO - more complete validation for Internet Media Type via RFC 2046\n  validatePropertyIsString(attachment, properties.CONTENT_TYPE, localTrace, localErrors, /*isRequired*/true, xapiErrorLevels.MUST_VIOLATION);\n\n  if (attachment.length === undefined || attachment.length === null || !xapiValidationUtils.isNumber(attachment.length) || (attachment.length % 1 !== 0)) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace, properties.LENGTH),\n      message: xapiValidationErrors.LENGTH_MUST_BE_INTEGER,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n  }\n\n  if (attachment.sha2 === undefined) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace, properties.SHA2),\n      message: xapiValidationErrors.SHA2_MUST_BE_PROVIDED_ON_ATTACHMENT_OBJECTS,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n  } else if (attachment.sha2 === null || !xapiValidationUtils.isString(attachment.sha2) || !xapiValidationRegex.BASE_64.test(attachment.sha2)) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace, properties.SHA2),\n      message: xapiValidationErrors.SHA2_MUST_CONTAIN_BASE_64_STRING,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n  }\n\n  validateAbsenceOfNonWhitelistedProperties(attachment, xapiWhiteListProperties.ATTACHMENT, localTrace, localErrors);\n  return localErrors;\n}\n\nfunction validateAttachments(attachments, trace, errors) {\n  var localErrors, localTrace;\n\n  localErrors = errors || [];\n  localTrace  = trace  || properties.ATTACHMENTS;\n\n  if (attachments === undefined) {return localErrors;}\n\n  if (attachments === null || !xapiValidationUtils.isArray(attachments)) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace),\n      message: xapiValidationErrors.ATTACHMENTS_MUST_BE_NOT_NULL_ARRAY,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n\n    return localErrors;\n  }\n\n  attachments.forEach((attachment, i) => {\n    validateAttachmentObject(attachment, xapiValidationUtils.addLookupToTrace(localTrace, i), localErrors);\n  });\n\n  return localErrors;\n}\n\nfunction validateAgent(agent, trace, errors) {\n  var localErrors, localTrace, ifiCount;\n\n  localErrors = errors || [];\n  localTrace  = trace  || properties.AGENT;\n\n  if (!xapiValidationUtils.isNonNullMapObject(agent)) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace),\n      message: xapiValidationErrors.AGENT_MUST_BE_NON_NULL_MAP_OBJECT,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n    return localErrors;\n  }\n\n  ifiCount = getIFICount(agent);\n\n  if (ifiCount !== xapiGeneral.NUMER_OF_SPECIFIED_IFI_PROPERTIES) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace),\n      message: xapiValidationErrors.AGENT_IFI_PROPERTIES_MUST_BE_SPECIFIED,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n  }\n\n  if (agent.objectType === objectTypes.GROUP) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace),\n      message: xapiValidationErrors.AGENT_MUST_NOT_HAVE_GROUP_CHARACTERISTICS,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n  }\n\n  validateIFIProperties(agent, localTrace, localErrors);\n  validatePropertyIsString(agent, properties.NAME, localTrace, localErrors,  /*isRequired*/false);\n\n  validateAbsenceOfNonWhitelistedProperties(agent, xapiWhiteListProperties.AGENT, localTrace, localErrors);\n\n  return localErrors;\n}\n\nfunction validateGroup(group, trace, errors) {\n  var localErrors, localTrace, memberTrace, ifiCount;\n\n  localErrors = errors || [];\n  localTrace  = trace  || properties.GROUP;\n  memberTrace = xapiValidationUtils.addPropToTrace(localTrace, properties.MEMBER);\n\n  if (!xapiValidationUtils.isNonNullMapObject(group)) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace),\n      message: xapiValidationErrors.GROUP_MUST_BE_NON_NULL_MAP_OBJECT,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n\n    return localErrors;\n  }\n\n  ifiCount = getIFICount(group);\n\n  if (ifiCount === 0) {\n    if (group.member === null || group.member === undefined) {\n      localErrors.push({\n        trace:   memberTrace,\n        message: xapiValidationErrors.MEMBER_MUST_BE_PROVIDED_FOR_ANONYMOUS_GROUPS,\n        level:   xapiErrorLevels.MUST_VIOLATION\n      });\n    }\n  } else if (ifiCount > xapiGeneral.NUMER_OF_SPECIFIED_IFI_PROPERTIES) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace),\n      message: xapiValidationErrors.GROUP_IFI_PROPERTIES_MUST_BE_SPECIFIED,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n  }\n\n  validateIFIProperties(group, localTrace, localErrors);\n\n  validatePropertyIsString(group, properties.NAME, localTrace, localErrors,  /*isRequired*/false);\n\n  if (group.member !== undefined) {\n    if (group.member === null || !xapiValidationUtils.isArray(group.member)) {\n      localErrors.push({\n        trace:   xapiValidationUtils.localTraceToString(localTrace, properties.MEMBER),\n        message: xapiValidationErrors.GROUP_MEMBER_MUST_BE_ARRAY,\n        level:   xapiErrorLevels.MUST_VIOLATION\n      });\n    } else {\n      group.member.forEach((member, i) => {\n        validateAgent(member, xapiValidationUtils.addLookupToTrace(memberTrace, i), localErrors);\n      });\n    }\n  }\n\n  validateAbsenceOfNonWhitelistedProperties(group, xapiWhiteListProperties.GROUP, localTrace, localErrors);\n\n  return localErrors;\n}\n\nfunction validateActor(actor, trace, errors) {\n  var localErrors, localTrace;\n\n  localErrors = errors || [];\n  localTrace  = trace  || properties.ACTOR;\n\n  if (actor === null || actor === undefined) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace),\n      message: xapiValidationErrors.ACTOR_MUST_BE_PROVIDED,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n\n    return localErrors;\n  }\n\n  if (xapiValidationUtils.isGroup(actor, objectTypes.GROUP)) {\n    validateGroup(actor, localTrace, localErrors);\n  } else {\n    validateAgent(actor, localTrace, localErrors);\n  }\n\n  return localErrors;\n}\n\nfunction validateAuthority(authority, trace, errors) {\n  var localErrors, localTrace;\n\n  localErrors = errors || [];\n  localTrace  = trace  || properties.AUTHORITY;\n\n  if (authority === undefined) {\n    return localErrors;\n  }\n\n  if (!xapiValidationUtils.isNonNullMapObject(authority)) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace),\n      message: xapiValidationErrors.AUTHORITY_MUST_BE_NON_NULL_MAP_OBJECT,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n\n    return localErrors;\n  }\n  if (xapiValidationUtils.isGroup(authority, objectTypes.GROUP)) {\n    validateGroup(authority, localTrace, localErrors);\n    if (!authority.member || !authority.member.length || authority.member.length !== xapiGeneral.GROUP_AUTHORITY_AGENT_MEMBERS) {\n      localErrors.push({\n        trace:   xapiValidationUtils.localTraceToString(localTrace, properties.MEMBER),\n        message: xapiValidationErrors.GROUP_AUTHORITY_AGENT_MEMBERS_MUST_BE_TWO,\n        level:   xapiErrorLevels.MUST_VIOLATION\n      });\n    }\n  } else {\n    validateAgent(authority, localTrace, localErrors);\n  }\n\n  return localErrors;\n}\n\nfunction validateContextActivitySubContext(subContext, trace, errors) {\n  var localErrors, localTrace;\n\n  localErrors = errors || [];\n  localTrace  = trace  || properties.SUB_CONTEXT;\n\n  if (subContext === undefined) {return localErrors;}\n\n  if (subContext === null) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace),\n      message: xapiValidationErrors.CONTEXT_ACTIVITIES_MUST_NOT_BE_NULL,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n  } else if (xapiValidationUtils.isArray(subContext)) {\n    subContext.forEach((activity, i) => {\n      validateActivity(activity, xapiValidationUtils.addLookupToTrace(localTrace, i), localErrors);\n    });\n  } else if (xapiValidationUtils.isObject(subContext)) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace),\n      message: xapiValidationErrors.CONTEXT_ACTIVITIES_SHOULD_BE_AN_ARRAY,\n      level:   xapiErrorLevels.SHOULD_VIOLATION\n    });\n\n    validateActivity(subContext, localTrace, localErrors);\n  } else {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace),\n      message: xapiValidationErrors.CONTEXT_ACTIVITIES_MUST_BE_ARRAY_OR_ACTIVITY_OBJ,\n      level:   xapiErrorLevels.MUST_VIOLATION});\n  }\n  return localErrors;\n}\n\nfunction validateContextActivities(contextActivities, trace, errors) {\n  var localErrors, localTrace;\n\n  localErrors = errors || [];\n  localTrace  = trace  || properties.CONTEXT_ACTIVITIES;\n\n  if (contextActivities === undefined) {\n    return localErrors;\n  }\n\n  if (!xapiValidationUtils.isNonNullMapObject(contextActivities)) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace),\n      message: xapiValidationErrors.CONTEXT_ACTIVITIES_MUST_BE_NON_NULL_MAP_OBJECT,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n    return localErrors;\n  }\n\n  validateContextActivitySubContext(contextActivities.parent, xapiValidationUtils.addPropToTrace(localTrace, properties.PARENT), localErrors);\n  validateContextActivitySubContext(contextActivities.grouping, xapiValidationUtils.addPropToTrace(localTrace, properties.GROUPING), localErrors);\n  validateContextActivitySubContext(contextActivities.category, xapiValidationUtils.addPropToTrace(localTrace, properties.CATEGORY), localErrors);\n  validateContextActivitySubContext(contextActivities.other, xapiValidationUtils.addPropToTrace(localTrace, properties.OTHER), localErrors);\n\n  validateAbsenceOfNonWhitelistedProperties(contextActivities, xapiWhiteListProperties.CONTEXT_ACTIVITIES, localTrace, localErrors);\n\n  return localErrors;\n}\n\nfunction validateContext(context, trace, errors, statementObjectObjectType) {\n  var localErrors, localTrace;\n\n  localErrors = errors || [];\n  localTrace = trace || properties.CONTEXT;\n\n  if (context === undefined) {return localErrors;}\n\n  if (!xapiValidationUtils.isNonNullMapObject(context)) {\n    localErrors.push({\n      trace:   localTrace,\n      message: xapiValidationErrors.CONTEXT_MUST_BE_NON_NUL_MAP_OBJECT,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n\n    return localErrors;\n  }\n\n  if (context.registration !== undefined && (context.registration === null || !xapiValidationUtils.isString(context.registration) || !xapiValidationRegex.UUID.test(context.registration))) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace, properties.REGISTRATION),\n      message: xapiValidationErrors.REGISTRATION_MUST_BE_UUID_STRING,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n  }\n\n  if ([objectTypes.GROUP, objectTypes.AGENT].indexOf(statementObjectObjectType) !== xapiGeneral.NO_INDEX_FOUND) {\n    if (context.revision !== undefined) {\n      localErrors.push({\n        trace:   xapiValidationUtils.localTraceToString(localTrace, properties.REVISION),\n        message: xapiValidationErrors.REVISION_MUST_BE_AGENT_OR_GROUP,\n        level:   xapiErrorLevels.MUST_VIOLATION\n      });\n    }\n\n    if (context.platform !== undefined) {\n      localErrors.push({\n        trace:   xapiValidationUtils.localTraceToString(localTrace, properties.PLATFORM),\n        message: xapiValidationErrors.PLATFORM_MUST_NOT_BE_USED_WITH_REVISION_AGENT_OR_GROUP,\n        level:   xapiErrorLevels.MUST_VIOLATION\n      });\n    }\n  }\n\n  validatePropertyIsString(context, properties.REVISION, localTrace, localErrors, /*isRequired*/false, xapiErrorLevels.MUST_VIOLATION);\n  validatePropertyIsString(context, properties.PLATFORM, localTrace, localErrors, /*isRequired*/false, xapiErrorLevels.MUST_VIOLATION);\n\n  if (context.team !== undefined) {\n      validateGroup(context.team, xapiValidationUtils.addPropToTrace(localTrace, properties.TEAM), localErrors);\n  }\n\n  if (context.contextActivities !== undefined) {\n    validateContextActivities(context.contextActivities, xapiValidationUtils.addPropToTrace(localTrace, properties.CONTEXT_ACTIVITIES), localErrors);\n  }\n\n  if (context.language !== undefined && !xapiValidationUtils.isValidLanguageTag(context.language, xapiValidationRegex.BCP_47)) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace, properties.LANGUAGE),\n      message: xapiValidationErrors.LANGUAGE_MUST_BE_STRING,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n  }\n\n  if (context.statement !== undefined) {\n    validateStatementRef(context.statement, xapiValidationUtils.addPropToTrace(localTrace, properties.STATEMENT), localErrors);\n  }\n\n  if (context.instructor !== undefined) {\n    if (xapiValidationUtils.isGroup(context.instructor, objectTypes.GROUP)) {\n      validateGroup(context.instructor, xapiValidationUtils.addPropToTrace(localTrace, properties.INSTRUCTOR), localErrors);\n    } else {\n      validateAgent(context.instructor, xapiValidationUtils.addPropToTrace(localTrace, properties.INSTRUCTOR), localErrors);\n    }\n  }\n\n  validateExtensions(context.extensions, xapiValidationUtils.addPropToTrace(localTrace, properties.EXTENSIONS), localErrors);\n  validateAbsenceOfNonWhitelistedProperties(context, xapiWhiteListProperties.EXTENSIONS,localTrace,localErrors);\n\n  return localErrors;\n}\n\nfunction validateObject(object, trace, errors, isWithinSubStatement) {\n  var localErrors, localTrace, objectType;\n\n  localErrors = errors || [];\n  localTrace  = trace  || properties.OBJECT;\n\n  if (object === undefined) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace),\n      message: xapiValidationErrors.OBJECT_MUST_BE_DEFINED,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n\n    return localErrors;\n  }\n\n  if (!xapiValidationUtils.isNonNullMapObject(object)) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace),\n      message: xapiValidationErrors.OBJECT_MUST_BE_NON_NULL_MAP_OBJECT,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n\n    return localErrors;\n  }\n\n  validatePropertyIsString(object, properties.OBJECT_TYPE, localTrace, localErrors, /*isRequired*/true, xapiErrorLevels.SHOULD_VIOLATION);\n\n  objectType = object.objectType || objectTypes.ACTIVITY;\n\n  switch (objectType) {\n    case objectTypes.ACTIVITY:\n      validateActivity(object, localTrace, localErrors);\n      break;\n    case objectTypes.AGENT:\n      validateAgent(object, localTrace, localErrors);\n      break;\n    case objectTypes.GROUP:\n      validateGroup(object, localTrace, localErrors);\n      break;\n    case objectTypes.STATEMENT_REF:\n      validateStatementRef(object, localTrace, localErrors);\n      break;\n    case objectTypes.SUB_STATEMENT:\n      if (isWithinSubStatement) {\n        localErrors.push({\n          trace:   xapiValidationUtils.localTraceToString(localTrace, properties.OBJECT_TYPE),\n          message: xapiValidationErrors.SUB_STATEMENT_MUST_NOT_CONTAIN_SUB_STATEMENT,\n          level:   xapiErrorLevels.MUST_VIOLATION\n        });\n      }\n      validate(object, localTrace, localErrors,  /*isSubStatement*/true);\n      break;\n    default:\n      localErrors.push({\n        trace:   xapiValidationUtils.localTraceToString(localTrace, properties.OBJECT_TYPE),\n        message: `${xapiValidationErrors.OBJECT_TYPE_MUST_BE_VALID_OPTION} ${xApiValidObjectTypes.toString()}`,\n        level:   xapiErrorLevels.MUST_VIOLATION\n      });\n  }\n\n  return localErrors;\n}\n\nfunction validate(statement, trace, errors, isSubStatement) {\n  var localErrors, localTrace, statementObjectObjectType, whitelistedProperties;\n\n  localErrors = errors || [];\n  localTrace  = trace  || properties.STATEMENT;\n\n  whitelistedProperties = xapiWhiteListProperties.STATEMENT;\n\n  if (!xapiValidationUtils.isNonNullMapObject(statement)) {\n    localErrors.push({\n      trace:   xapiValidationUtils.localTraceToString(localTrace),\n      message: xapiValidationErrors.STATEMENT_REF_MUST_NOT_BE_NULL_MAP_OBJECTS,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n\n    return localErrors;\n  }\n\n  if (!isSubStatement) {\n    if (statement.id === null || statement.id === undefined || !xapiValidationUtils.isString(statement.id)) {\n      localErrors.push({\n        trace:   xapiValidationUtils.localTraceToString(localTrace, properties.ID),\n        message: xapiValidationErrors.IDS_SHOULD_BE_GENERATED_BY_LRS,\n        level:   xapiErrorLevels.SHOULD_VIOLATION\n      });\n    } else if (!xapiValidationRegex.UUID.test(statement.id)) {\n      localErrors.push({\n        trace:   xapiValidationUtils.localTraceToString(localTrace, properties.ID),\n        message: xapiValidationErrors.ID_MUST_BE_VALID,\n        level:   xapiErrorLevels.MUST_VIOLATION\n      });\n    }\n  } else {\n    whitelistedProperties = xapiWhiteListProperties.SUB_STATEMENT;\n  }\n\n  validateActor(statement.actor, xapiValidationUtils.addPropToTrace(localTrace, properties.ACTOR), localErrors);\n  validateVerb(statement.verb, xapiValidationUtils.addPropToTrace(localTrace, properties.VERB), localErrors);\n  validateObject(statement.object, xapiValidationUtils.addPropToTrace(localTrace, properties.OBJECT), localErrors, isSubStatement);\n  validateResult(statement.result, xapiValidationUtils.addPropToTrace(localTrace, properties.RESULT), localErrors);\n\n  statementObjectObjectType = statement.object && statement.object.objectType ? statement.object.objectType : objectTypes.ACTIVITY;\n\n  validateContext(statement.context, xapiValidationUtils.addPropToTrace(localTrace, properties.CONTEXT), localErrors, statementObjectObjectType);\n  validatePropertyIsISO8601String(statement, properties.TIMESTAMP, localTrace, localErrors);\n  validatePropertyIsISO8601String(statement, properties.STORED, localTrace, localErrors);\n\n  validateAuthority(statement.authority, xapiValidationUtils.addPropToTrace(localTrace, properties.AUTHORITY), localErrors);\n  validateVersion(statement.version, xapiValidationUtils.addPropToTrace(localTrace, properties.VERSION), localErrors);\n  validateAttachments(statement.attachments, xapiValidationUtils.addPropToTrace(localTrace, properties.ATTACHMENTS), localErrors);\n\n  validateAbsenceOfNonWhitelistedProperties(statement, whitelistedProperties, localTrace, localErrors);\n\n  return localErrors;\n}\n\nfunction makeStatementReport(statement) {\n  var localErrors;\n\n  localErrors = [];\n  validate(statement, properties.STATEMENT, localErrors,  /*isRequired*/false);\n\n  return makeV1Report(statement, localErrors);\n}\n\nfunction validateAmbiguousTypeStatement(statement) {\n  var statementObject;\n\n  if (statement === undefined) {\n    return makeV1SingleErrorReport(/*instance*/null, {\n      trace:   properties.STATEMENT,\n      message: xapiValidationErrors.STATEMENT_ARGUMENT_MUST_BE_PROVIDED,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n  }\n\n  if (statement === null) {\n    return makeV1SingleErrorReport(/*instance*/null, {\n      trace:   properties.STATEMENT,\n      message: xapiValidationErrors.STATEMENT_MUST_NOT_BE_NULL,\n      level:   xapiErrorLevels.MUST_VIOLATION\n    });\n  }\n\n  if (xapiValidationUtils.isString(statement)) {\n    try {\n      statementObject = JSON.parse(statement);\n      if (statementObject === null || !xapiValidationUtils.isObject(statementObject) || xapiValidationUtils.isArray(statementObject)) {\n        return makeV1SingleErrorReport(statementObject, {\n          trace:   properties.STATEMENT,\n          message: xapiValidationErrors.STATEMENT_MUST_BE_PARSED_CORRECTLY,\n          level:   xapiErrorLevels.MUST_VIOLATION\n        });\n      }\n    } catch (e) {\n      return makeV1SingleErrorReport(statementObject, {\n        trace:   properties.STATEMENT,\n        message: `${xapiValidationErrors.INVALID_JSON}: ${e.message}`,\n        level:   xapiErrorLevels.MUST_VIOLATION\n      });\n    }\n\n    return makeStatementReport(statementObject);\n  }\n\n  if (xapiValidationUtils.isObject(statement) && !xapiValidationUtils.isArray(statement)) {\n    return makeStatementReport(statement);\n  }\n\n  return makeV1SingleErrorReport(/*instance*/null, {\n    trace:   properties.STATEMENT,\n    message: xapiValidationErrors.STATEMENT_ARGUMENT_IS_NOT_VALID,\n    level:   xapiErrorLevels.MUST_VIOLATION\n  });\n}\n\nfunction dateIncludesZoneInformation(matched) {\n  return matched[dateFormatRegexPositions.ZONE] ||\n          (matched[dateFormatRegexPositions.RELATIVE_TIME] && matched[dateFormatRegexPositions.TIME_ZONE_HOUR]);\n}\n\nxapiValidation = {\n  validateStatement: validateAmbiguousTypeStatement\n};\n\nmodule.exports = xapiValidation;\n"]}