{"version":3,"sources":["webpack:///./node_modules/assert-plus/assert.js","webpack:///./node_modules/assert/assert.js"],"names":["assert","Stream","util","UUID_REGEXP","_capitalize","str","charAt","toUpperCase","slice","_toss","name","expected","oper","arg","actual","AssertionError","message","format","undefined","operator","stackStartFunction","caller","_getClass","Object","prototype","toString","call","noop","types","bool","check","func","string","object","number","isNaN","finite","isFinite","buffer","Buffer","isBuffer","array","Array","isArray","stream","date","Date","regexp","RegExp","uuid","test","_setExports","ndebug","out","keys","NODE_NDEBUG","msg","forEach","k","type","i","length","module","exports","objectAssign","compare","a","b","x","y","len","Math","min","global","_isBuffer","hasOwn","hasOwnProperty","pSlice","functionsHaveNames","pToString","obj","isView","arrbuf","ArrayBuffer","DataView","ok","regex","getName","isFunction","match","truncate","s","n","inspect","something","rawname","getMessage","self","fail","value","_deepEqual","strict","memos","isDate","getTime","isRegExp","source","multiline","lastIndex","ignoreCase","Float32Array","Float64Array","Uint8Array","actualIndex","indexOf","push","objEquiv","isArguments","actualVisitedObjects","isPrimitive","getPrototypeOf","aIsArgs","bIsArgs","key","ka","objectKeys","kb","sort","notDeepStrictEqual","expectedException","e","Error","isPrototypeOf","_tryBlock","block","error","_throws","shouldThrow","TypeError","userProvidedMessage","isUnwantedException","isError","isUnexpectedException","options","this","generatedMessage","captureStackTrace","err","stack","fn_name","idx","next_line","substring","inherits","equal","notEqual","deepEqual","deepStrictEqual","notDeepEqual","strictEqual","notStrictEqual","throws","doesNotThrow","ifError"],"mappings":"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","file":"js/chunk-vendors~1e8f79e4.7bdbb44f.js","sourcesContent":["// Copyright (c) 2012, Mark Cavage. All rights reserved.\n// Copyright 2015 Joyent, Inc.\n\nvar assert = require('assert');\nvar Stream = require('stream').Stream;\nvar util = require('util');\n\n\n///--- Globals\n\n/* JSSTYLED */\nvar UUID_REGEXP = /^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$/;\n\n\n///--- Internal\n\nfunction _capitalize(str) {\n    return (str.charAt(0).toUpperCase() + str.slice(1));\n}\n\nfunction _toss(name, expected, oper, arg, actual) {\n    throw new assert.AssertionError({\n        message: util.format('%s (%s) is required', name, expected),\n        actual: (actual === undefined) ? typeof (arg) : actual(arg),\n        expected: expected,\n        operator: oper || '===',\n        stackStartFunction: _toss.caller\n    });\n}\n\nfunction _getClass(arg) {\n    return (Object.prototype.toString.call(arg).slice(8, -1));\n}\n\nfunction noop() {\n    // Why even bother with asserts?\n}\n\n\n///--- Exports\n\nvar types = {\n    bool: {\n        check: function (arg) { return typeof (arg) === 'boolean'; }\n    },\n    func: {\n        check: function (arg) { return typeof (arg) === 'function'; }\n    },\n    string: {\n        check: function (arg) { return typeof (arg) === 'string'; }\n    },\n    object: {\n        check: function (arg) {\n            return typeof (arg) === 'object' && arg !== null;\n        }\n    },\n    number: {\n        check: function (arg) {\n            return typeof (arg) === 'number' && !isNaN(arg);\n        }\n    },\n    finite: {\n        check: function (arg) {\n            return typeof (arg) === 'number' && !isNaN(arg) && isFinite(arg);\n        }\n    },\n    buffer: {\n        check: function (arg) { return Buffer.isBuffer(arg); },\n        operator: 'Buffer.isBuffer'\n    },\n    array: {\n        check: function (arg) { return Array.isArray(arg); },\n        operator: 'Array.isArray'\n    },\n    stream: {\n        check: function (arg) { return arg instanceof Stream; },\n        operator: 'instanceof',\n        actual: _getClass\n    },\n    date: {\n        check: function (arg) { return arg instanceof Date; },\n        operator: 'instanceof',\n        actual: _getClass\n    },\n    regexp: {\n        check: function (arg) { return arg instanceof RegExp; },\n        operator: 'instanceof',\n        actual: _getClass\n    },\n    uuid: {\n        check: function (arg) {\n            return typeof (arg) === 'string' && UUID_REGEXP.test(arg);\n        },\n        operator: 'isUUID'\n    }\n};\n\nfunction _setExports(ndebug) {\n    var keys = Object.keys(types);\n    var out;\n\n    /* re-export standard assert */\n    if (process.env.NODE_NDEBUG) {\n        out = noop;\n    } else {\n        out = function (arg, msg) {\n            if (!arg) {\n                _toss(msg, 'true', arg);\n            }\n        };\n    }\n\n    /* standard checks */\n    keys.forEach(function (k) {\n        if (ndebug) {\n            out[k] = noop;\n            return;\n        }\n        var type = types[k];\n        out[k] = function (arg, msg) {\n            if (!type.check(arg)) {\n                _toss(msg, k, type.operator, arg, type.actual);\n            }\n        };\n    });\n\n    /* optional checks */\n    keys.forEach(function (k) {\n        var name = 'optional' + _capitalize(k);\n        if (ndebug) {\n            out[name] = noop;\n            return;\n        }\n        var type = types[k];\n        out[name] = function (arg, msg) {\n            if (arg === undefined || arg === null) {\n                return;\n            }\n            if (!type.check(arg)) {\n                _toss(msg, k, type.operator, arg, type.actual);\n            }\n        };\n    });\n\n    /* arrayOf checks */\n    keys.forEach(function (k) {\n        var name = 'arrayOf' + _capitalize(k);\n        if (ndebug) {\n            out[name] = noop;\n            return;\n        }\n        var type = types[k];\n        var expected = '[' + k + ']';\n        out[name] = function (arg, msg) {\n            if (!Array.isArray(arg)) {\n                _toss(msg, expected, type.operator, arg, type.actual);\n            }\n            var i;\n            for (i = 0; i < arg.length; i++) {\n                if (!type.check(arg[i])) {\n                    _toss(msg, expected, type.operator, arg, type.actual);\n                }\n            }\n        };\n    });\n\n    /* optionalArrayOf checks */\n    keys.forEach(function (k) {\n        var name = 'optionalArrayOf' + _capitalize(k);\n        if (ndebug) {\n            out[name] = noop;\n            return;\n        }\n        var type = types[k];\n        var expected = '[' + k + ']';\n        out[name] = function (arg, msg) {\n            if (arg === undefined || arg === null) {\n                return;\n            }\n            if (!Array.isArray(arg)) {\n                _toss(msg, expected, type.operator, arg, type.actual);\n            }\n            var i;\n            for (i = 0; i < arg.length; i++) {\n                if (!type.check(arg[i])) {\n                    _toss(msg, expected, type.operator, arg, type.actual);\n                }\n            }\n        };\n    });\n\n    /* re-export built-in assertions */\n    Object.keys(assert).forEach(function (k) {\n        if (k === 'AssertionError') {\n            out[k] = assert[k];\n            return;\n        }\n        if (ndebug) {\n            out[k] = noop;\n            return;\n        }\n        out[k] = assert[k];\n    });\n\n    /* export ourselves (for unit tests _only_) */\n    out._setExports = _setExports;\n\n    return out;\n}\n\nmodule.exports = _setExports(process.env.NODE_NDEBUG);\n","'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 <feross@feross.org> <http://feross.org>\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":""}