{"version":3,"sources":["webpack:///./node_modules/assert/assert.js"],"names":["objectAssign","compare","a","b","x","length","y","i","len","Math","min","isBuffer","global","Buffer","_isBuffer","util","hasOwn","Object","prototype","hasOwnProperty","pSlice","Array","slice","functionsHaveNames","name","pToString","obj","toString","call","isView","arrbuf","ArrayBuffer","DataView","buffer","assert","module","exports","ok","regex","getName","func","isFunction","match","truncate","s","n","inspect","something","rawname","fail","actual","expected","message","operator","stackStartFunction","AssertionError","value","_deepEqual","strict","memos","isDate","getTime","isRegExp","source","multiline","lastIndex","ignoreCase","Float32Array","Float64Array","Uint8Array","actualIndex","indexOf","push","actualVisitedObjects","isPrimitive","getPrototypeOf","aIsArgs","isArguments","bIsArgs","key","ka","objectKeys","kb","sort","objEquiv","object","expectedException","test","e","Error","isPrototypeOf","_throws","shouldThrow","block","TypeError","error","_tryBlock","userProvidedMessage","isUnexpectedException","isError","options","self","this","generatedMessage","captureStackTrace","err","stack","out","fn_name","idx","next_line","substring","inherits","equal","notEqual","deepEqual","deepStrictEqual","notDeepEqual","notDeepStrictEqual","strictEqual","notStrictEqual","throws","doesNotThrow","ifError","keys"],"mappings":"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","file":"vendor.assert~53c24337.540b3c832f1632161554.chunk.js","sourcesContent":["'use strict';\n\nvar objectAssign = require('object-assign');\n\n// compare and isBuffer taken from https://github.com/feross/buffer/blob/680e9e5e488f22aac27599a57dc844a6315928dd/index.js\n// original notice:\n\n/*!\n * The buffer module from node.js, for the browser.\n *\n * @author Feross Aboukhadijeh \n * @license MIT\n */\nfunction compare(a, b) {\n if (a === b) {\n return 0;\n }\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) {\n return -1;\n }\n if (y < x) {\n return 1;\n }\n return 0;\n}\nfunction isBuffer(b) {\n if (global.Buffer && typeof global.Buffer.isBuffer === 'function') {\n return global.Buffer.isBuffer(b);\n }\n return !!(b != null && b._isBuffer);\n}\n\n// based on node assert, original notice:\n// NB: The URL to the CommonJS spec is kept just for tradition.\n// node-assert has evolved a lot since then, both in API and behavior.\n\n// http://wiki.commonjs.org/wiki/Unit_Testing/1.0\n//\n// THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8!\n//\n// Originally from narwhal.js (http://narwhaljs.org)\n// Copyright (c) 2009 Thomas Robinson <280north.com>\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the 'Software'), to\n// deal in the Software without restriction, including without limitation the\n// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n// sell copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\n// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\n// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar util = require('util/');\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar pSlice = Array.prototype.slice;\nvar functionsHaveNames = (function () {\n return function foo() {}.name === 'foo';\n}());\nfunction pToString (obj) {\n return Object.prototype.toString.call(obj);\n}\nfunction isView(arrbuf) {\n if (isBuffer(arrbuf)) {\n return false;\n }\n if (typeof global.ArrayBuffer !== 'function') {\n return false;\n }\n if (typeof ArrayBuffer.isView === 'function') {\n return ArrayBuffer.isView(arrbuf);\n }\n if (!arrbuf) {\n return false;\n }\n if (arrbuf instanceof DataView) {\n return true;\n }\n if (arrbuf.buffer && arrbuf.buffer instanceof ArrayBuffer) {\n return true;\n }\n return false;\n}\n// 1. The assert module provides functions that throw\n// AssertionError's when particular conditions are not met. The\n// assert module must conform to the following interface.\n\nvar assert = module.exports = ok;\n\n// 2. The AssertionError is defined in assert.\n// new assert.AssertionError({ message: message,\n// actual: actual,\n// expected: expected })\n\nvar regex = /\\s*function\\s+([^\\(\\s]*)\\s*/;\n// based on https://github.com/ljharb/function.prototype.name/blob/adeeeec8bfcc6068b187d7d9fb3d5bb1d3a30899/implementation.js\nfunction getName(func) {\n if (!util.isFunction(func)) {\n return;\n }\n if (functionsHaveNames) {\n return func.name;\n }\n var str = func.toString();\n var match = str.match(regex);\n return match && match[1];\n}\nassert.AssertionError = function AssertionError(options) {\n this.name = 'AssertionError';\n this.actual = options.actual;\n this.expected = options.expected;\n this.operator = options.operator;\n if (options.message) {\n this.message = options.message;\n this.generatedMessage = false;\n } else {\n this.message = getMessage(this);\n this.generatedMessage = true;\n }\n var stackStartFunction = options.stackStartFunction || fail;\n if (Error.captureStackTrace) {\n Error.captureStackTrace(this, stackStartFunction);\n } else {\n // non v8 browsers so we can have a stacktrace\n var err = new Error();\n if (err.stack) {\n var out = err.stack;\n\n // try to strip useless frames\n var fn_name = getName(stackStartFunction);\n var idx = out.indexOf('\\n' + fn_name);\n if (idx >= 0) {\n // once we have located the function frame\n // we need to strip out everything before it (and its line)\n var next_line = out.indexOf('\\n', idx + 1);\n out = out.substring(next_line + 1);\n }\n\n this.stack = out;\n }\n }\n};\n\n// assert.AssertionError instanceof Error\nutil.inherits(assert.AssertionError, Error);\n\nfunction truncate(s, n) {\n if (typeof s === 'string') {\n return s.length < n ? s : s.slice(0, n);\n } else {\n return s;\n }\n}\nfunction inspect(something) {\n if (functionsHaveNames || !util.isFunction(something)) {\n return util.inspect(something);\n }\n var rawname = getName(something);\n var name = rawname ? ': ' + rawname : '';\n return '[Function' + name + ']';\n}\nfunction getMessage(self) {\n return truncate(inspect(self.actual), 128) + ' ' +\n self.operator + ' ' +\n truncate(inspect(self.expected), 128);\n}\n\n// At present only the three keys mentioned above are used and\n// understood by the spec. Implementations or sub modules can pass\n// other keys to the AssertionError's constructor - they will be\n// ignored.\n\n// 3. All of the following functions must throw an AssertionError\n// when a corresponding condition is not met, with a message that\n// may be undefined if not provided. All assertion methods provide\n// both the actual and expected values to the assertion error for\n// display purposes.\n\nfunction fail(actual, expected, message, operator, stackStartFunction) {\n throw new assert.AssertionError({\n message: message,\n actual: actual,\n expected: expected,\n operator: operator,\n stackStartFunction: stackStartFunction\n });\n}\n\n// EXTENSION! allows for well behaved errors defined elsewhere.\nassert.fail = fail;\n\n// 4. Pure assertion tests whether a value is truthy, as determined\n// by !!guard.\n// assert.ok(guard, message_opt);\n// This statement is equivalent to assert.equal(true, !!guard,\n// message_opt);. To test strictly for the value true, use\n// assert.strictEqual(true, guard, message_opt);.\n\nfunction ok(value, message) {\n if (!value) fail(value, true, message, '==', assert.ok);\n}\nassert.ok = ok;\n\n// 5. The equality assertion tests shallow, coercive equality with\n// ==.\n// assert.equal(actual, expected, message_opt);\n\nassert.equal = function equal(actual, expected, message) {\n if (actual != expected) fail(actual, expected, message, '==', assert.equal);\n};\n\n// 6. The non-equality assertion tests for whether two objects are not equal\n// with != assert.notEqual(actual, expected, message_opt);\n\nassert.notEqual = function notEqual(actual, expected, message) {\n if (actual == expected) {\n fail(actual, expected, message, '!=', assert.notEqual);\n }\n};\n\n// 7. The equivalence assertion tests a deep equality relation.\n// assert.deepEqual(actual, expected, message_opt);\n\nassert.deepEqual = function deepEqual(actual, expected, message) {\n if (!_deepEqual(actual, expected, false)) {\n fail(actual, expected, message, 'deepEqual', assert.deepEqual);\n }\n};\n\nassert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {\n if (!_deepEqual(actual, expected, true)) {\n fail(actual, expected, message, 'deepStrictEqual', assert.deepStrictEqual);\n }\n};\n\nfunction _deepEqual(actual, expected, strict, memos) {\n // 7.1. All identical values are equivalent, as determined by ===.\n if (actual === expected) {\n return true;\n } else if (isBuffer(actual) && isBuffer(expected)) {\n return compare(actual, expected) === 0;\n\n // 7.2. If the expected value is a Date object, the actual value is\n // equivalent if it is also a Date object that refers to the same time.\n } else if (util.isDate(actual) && util.isDate(expected)) {\n return actual.getTime() === expected.getTime();\n\n // 7.3 If the expected value is a RegExp object, the actual value is\n // equivalent if it is also a RegExp object with the same source and\n // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).\n } else if (util.isRegExp(actual) && util.isRegExp(expected)) {\n return actual.source === expected.source &&\n actual.global === expected.global &&\n actual.multiline === expected.multiline &&\n actual.lastIndex === expected.lastIndex &&\n actual.ignoreCase === expected.ignoreCase;\n\n // 7.4. Other pairs that do not both pass typeof value == 'object',\n // equivalence is determined by ==.\n } else if ((actual === null || typeof actual !== 'object') &&\n (expected === null || typeof expected !== 'object')) {\n return strict ? actual === expected : actual == expected;\n\n // If both values are instances of typed arrays, wrap their underlying\n // ArrayBuffers in a Buffer each to increase performance\n // This optimization requires the arrays to have the same type as checked by\n // Object.prototype.toString (aka pToString). Never perform binary\n // comparisons for Float*Arrays, though, since e.g. +0 === -0 but their\n // bit patterns are not identical.\n } else if (isView(actual) && isView(expected) &&\n pToString(actual) === pToString(expected) &&\n !(actual instanceof Float32Array ||\n actual instanceof Float64Array)) {\n return compare(new Uint8Array(actual.buffer),\n new Uint8Array(expected.buffer)) === 0;\n\n // 7.5 For all other Object pairs, including Array objects, equivalence is\n // determined by having the same number of owned properties (as verified\n // with Object.prototype.hasOwnProperty.call), the same set of keys\n // (although not necessarily the same order), equivalent values for every\n // corresponding key, and an identical 'prototype' property. Note: this\n // accounts for both named and indexed properties on Arrays.\n } else if (isBuffer(actual) !== isBuffer(expected)) {\n return false;\n } else {\n memos = memos || {actual: [], expected: []};\n\n var actualIndex = memos.actual.indexOf(actual);\n if (actualIndex !== -1) {\n if (actualIndex === memos.expected.indexOf(expected)) {\n return true;\n }\n }\n\n memos.actual.push(actual);\n memos.expected.push(expected);\n\n return objEquiv(actual, expected, strict, memos);\n }\n}\n\nfunction isArguments(object) {\n return Object.prototype.toString.call(object) == '[object Arguments]';\n}\n\nfunction objEquiv(a, b, strict, actualVisitedObjects) {\n if (a === null || a === undefined || b === null || b === undefined)\n return false;\n // if one is a primitive, the other must be same\n if (util.isPrimitive(a) || util.isPrimitive(b))\n return a === b;\n if (strict && Object.getPrototypeOf(a) !== Object.getPrototypeOf(b))\n return false;\n var aIsArgs = isArguments(a);\n var bIsArgs = isArguments(b);\n if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs))\n return false;\n if (aIsArgs) {\n a = pSlice.call(a);\n b = pSlice.call(b);\n return _deepEqual(a, b, strict);\n }\n var ka = objectKeys(a);\n var kb = objectKeys(b);\n var key, i;\n // having the same number of owned properties (keys incorporates\n // hasOwnProperty)\n if (ka.length !== kb.length)\n return false;\n //the same set of keys (although not necessarily the same order),\n ka.sort();\n kb.sort();\n //~~~cheap key test\n for (i = ka.length - 1; i >= 0; i--) {\n if (ka[i] !== kb[i])\n return false;\n }\n //equivalent values for every corresponding key, and\n //~~~possibly expensive deep test\n for (i = ka.length - 1; i >= 0; i--) {\n key = ka[i];\n if (!_deepEqual(a[key], b[key], strict, actualVisitedObjects))\n return false;\n }\n return true;\n}\n\n// 8. The non-equivalence assertion tests for any deep inequality.\n// assert.notDeepEqual(actual, expected, message_opt);\n\nassert.notDeepEqual = function notDeepEqual(actual, expected, message) {\n if (_deepEqual(actual, expected, false)) {\n fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);\n }\n};\n\nassert.notDeepStrictEqual = notDeepStrictEqual;\nfunction notDeepStrictEqual(actual, expected, message) {\n if (_deepEqual(actual, expected, true)) {\n fail(actual, expected, message, 'notDeepStrictEqual', notDeepStrictEqual);\n }\n}\n\n\n// 9. The strict equality assertion tests strict equality, as determined by ===.\n// assert.strictEqual(actual, expected, message_opt);\n\nassert.strictEqual = function strictEqual(actual, expected, message) {\n if (actual !== expected) {\n fail(actual, expected, message, '===', assert.strictEqual);\n }\n};\n\n// 10. The strict non-equality assertion tests for strict inequality, as\n// determined by !==. assert.notStrictEqual(actual, expected, message_opt);\n\nassert.notStrictEqual = function notStrictEqual(actual, expected, message) {\n if (actual === expected) {\n fail(actual, expected, message, '!==', assert.notStrictEqual);\n }\n};\n\nfunction expectedException(actual, expected) {\n if (!actual || !expected) {\n return false;\n }\n\n if (Object.prototype.toString.call(expected) == '[object RegExp]') {\n return expected.test(actual);\n }\n\n try {\n if (actual instanceof expected) {\n return true;\n }\n } catch (e) {\n // Ignore. The instanceof check doesn't work for arrow functions.\n }\n\n if (Error.isPrototypeOf(expected)) {\n return false;\n }\n\n return expected.call({}, actual) === true;\n}\n\nfunction _tryBlock(block) {\n var error;\n try {\n block();\n } catch (e) {\n error = e;\n }\n return error;\n}\n\nfunction _throws(shouldThrow, block, expected, message) {\n var actual;\n\n if (typeof block !== 'function') {\n throw new TypeError('\"block\" argument must be a function');\n }\n\n if (typeof expected === 'string') {\n message = expected;\n expected = null;\n }\n\n actual = _tryBlock(block);\n\n message = (expected && expected.name ? ' (' + expected.name + ').' : '.') +\n (message ? ' ' + message : '.');\n\n if (shouldThrow && !actual) {\n fail(actual, expected, 'Missing expected exception' + message);\n }\n\n var userProvidedMessage = typeof message === 'string';\n var isUnwantedException = !shouldThrow && util.isError(actual);\n var isUnexpectedException = !shouldThrow && actual && !expected;\n\n if ((isUnwantedException &&\n userProvidedMessage &&\n expectedException(actual, expected)) ||\n isUnexpectedException) {\n fail(actual, expected, 'Got unwanted exception' + message);\n }\n\n if ((shouldThrow && actual && expected &&\n !expectedException(actual, expected)) || (!shouldThrow && actual)) {\n throw actual;\n }\n}\n\n// 11. Expected to throw an error:\n// assert.throws(block, Error_opt, message_opt);\n\nassert.throws = function(block, /*optional*/error, /*optional*/message) {\n _throws(true, block, error, message);\n};\n\n// EXTENSION! This is annoying to write outside this module.\nassert.doesNotThrow = function(block, /*optional*/error, /*optional*/message) {\n _throws(false, block, error, message);\n};\n\nassert.ifError = function(err) { if (err) throw err; };\n\n// Expose a strict only variant of assert\nfunction strict(value, message) {\n if (!value) fail(value, true, message, '==', strict);\n}\nassert.strict = objectAssign(strict, assert, {\n equal: assert.strictEqual,\n deepEqual: assert.deepStrictEqual,\n notEqual: assert.notStrictEqual,\n notDeepEqual: assert.notDeepStrictEqual\n});\nassert.strict.strict = assert.strict;\n\nvar objectKeys = Object.keys || function (obj) {\n var keys = [];\n for (var key in obj) {\n if (hasOwn.call(obj, key)) keys.push(key);\n }\n return keys;\n};\n"],"sourceRoot":""}