This app provides monitoring and information features for the common freifunk user and the technical stuff of a freifunk community.
Code base is taken from a TUM Practical Course project and added here to see if Freifunk Altdorf can use it.
https://www.freifunk-altdorf.de
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4893 lines
128 KiB
4893 lines
128 KiB
(function webpackUniversalModuleDefinition(root, factory) { |
|
if(typeof exports === 'object' && typeof module === 'object') |
|
module.exports = factory(); |
|
else if(typeof define === 'function' && define.amd) |
|
define(factory); |
|
else if(typeof exports === 'object') |
|
exports["ReactProxy"] = factory(); |
|
else |
|
root["ReactProxy"] = factory(); |
|
})(this, function() { |
|
return /******/ (function(modules) { // webpackBootstrap |
|
/******/ // The module cache |
|
/******/ var installedModules = {}; |
|
/******/ |
|
/******/ // The require function |
|
/******/ function __webpack_require__(moduleId) { |
|
/******/ |
|
/******/ // Check if module is in cache |
|
/******/ if(installedModules[moduleId]) |
|
/******/ return installedModules[moduleId].exports; |
|
/******/ |
|
/******/ // Create a new module (and put it into the cache) |
|
/******/ var module = installedModules[moduleId] = { |
|
/******/ exports: {}, |
|
/******/ id: moduleId, |
|
/******/ loaded: false |
|
/******/ }; |
|
/******/ |
|
/******/ // Execute the module function |
|
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); |
|
/******/ |
|
/******/ // Flag the module as loaded |
|
/******/ module.loaded = true; |
|
/******/ |
|
/******/ // Return the exports of the module |
|
/******/ return module.exports; |
|
/******/ } |
|
/******/ |
|
/******/ |
|
/******/ // expose the modules object (__webpack_modules__) |
|
/******/ __webpack_require__.m = modules; |
|
/******/ |
|
/******/ // expose the module cache |
|
/******/ __webpack_require__.c = installedModules; |
|
/******/ |
|
/******/ // __webpack_public_path__ |
|
/******/ __webpack_require__.p = ""; |
|
/******/ |
|
/******/ // Load entry module and return exports |
|
/******/ return __webpack_require__(0); |
|
/******/ }) |
|
/************************************************************************/ |
|
/******/ ([ |
|
/* 0 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
'use strict'; |
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports.getForceUpdate = exports.createProxy = undefined; |
|
|
|
var _supportsProtoAssignment = __webpack_require__(19); |
|
|
|
var _supportsProtoAssignment2 = _interopRequireDefault(_supportsProtoAssignment); |
|
|
|
var _createClassProxy = __webpack_require__(42); |
|
|
|
var _createClassProxy2 = _interopRequireDefault(_createClassProxy); |
|
|
|
var _reactDeepForceUpdate = __webpack_require__(124); |
|
|
|
var _reactDeepForceUpdate2 = _interopRequireDefault(_reactDeepForceUpdate); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } |
|
|
|
if (!(0, _supportsProtoAssignment2.default)()) { |
|
console.warn('This JavaScript environment does not support __proto__. ' + 'This means that react-proxy is unable to proxy React components. ' + 'Features that rely on react-proxy, such as react-transform-hmr, ' + 'will not function as expected.'); |
|
} |
|
|
|
exports.createProxy = _createClassProxy2.default; |
|
exports.getForceUpdate = _reactDeepForceUpdate2.default; |
|
|
|
/***/ }, |
|
/* 1 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
/** |
|
* Checks if `value` is classified as an `Array` object. |
|
* |
|
* @static |
|
* @memberOf _ |
|
* @type {Function} |
|
* @category Lang |
|
* @param {*} value The value to check. |
|
* @returns {boolean} Returns `true` if `value` is correctly classified, else `false`. |
|
* @example |
|
* |
|
* _.isArray([1, 2, 3]); |
|
* // => true |
|
* |
|
* _.isArray(document.body.children); |
|
* // => false |
|
* |
|
* _.isArray('abc'); |
|
* // => false |
|
* |
|
* _.isArray(_.noop); |
|
* // => false |
|
*/ |
|
var isArray = Array.isArray; |
|
|
|
module.exports = isArray; |
|
|
|
|
|
/***/ }, |
|
/* 2 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var getNative = __webpack_require__(9), |
|
root = __webpack_require__(5); |
|
|
|
/* Built-in method references that are verified to be native. */ |
|
var Map = getNative(root, 'Map'); |
|
|
|
module.exports = Map; |
|
|
|
|
|
/***/ }, |
|
/* 3 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
/** |
|
* Checks if `value` is suitable for use as unique object key. |
|
* |
|
* @private |
|
* @param {*} value The value to check. |
|
* @returns {boolean} Returns `true` if `value` is suitable, else `false`. |
|
*/ |
|
function isKeyable(value) { |
|
var type = typeof value; |
|
return type == 'number' || type == 'boolean' || |
|
(type == 'string' && value != '__proto__') || value == null; |
|
} |
|
|
|
module.exports = isKeyable; |
|
|
|
|
|
/***/ }, |
|
/* 4 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
/** |
|
* Checks if `value` is object-like. A value is object-like if it's not `null` |
|
* and has a `typeof` result of "object". |
|
* |
|
* @static |
|
* @memberOf _ |
|
* @category Lang |
|
* @param {*} value The value to check. |
|
* @returns {boolean} Returns `true` if `value` is object-like, else `false`. |
|
* @example |
|
* |
|
* _.isObjectLike({}); |
|
* // => true |
|
* |
|
* _.isObjectLike([1, 2, 3]); |
|
* // => true |
|
* |
|
* _.isObjectLike(_.noop); |
|
* // => false |
|
* |
|
* _.isObjectLike(null); |
|
* // => false |
|
*/ |
|
function isObjectLike(value) { |
|
return !!value && typeof value == 'object'; |
|
} |
|
|
|
module.exports = isObjectLike; |
|
|
|
|
|
/***/ }, |
|
/* 5 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
/* WEBPACK VAR INJECTION */(function(module, global) {var checkGlobal = __webpack_require__(77); |
|
|
|
/** Used to determine if values are of the language type `Object`. */ |
|
var objectTypes = { |
|
'function': true, |
|
'object': true |
|
}; |
|
|
|
/** Detect free variable `exports`. */ |
|
var freeExports = (objectTypes[typeof exports] && exports && !exports.nodeType) |
|
? exports |
|
: undefined; |
|
|
|
/** Detect free variable `module`. */ |
|
var freeModule = (objectTypes[typeof module] && module && !module.nodeType) |
|
? module |
|
: undefined; |
|
|
|
/** Detect free variable `global` from Node.js. */ |
|
var freeGlobal = checkGlobal(freeExports && freeModule && typeof global == 'object' && global); |
|
|
|
/** Detect free variable `self`. */ |
|
var freeSelf = checkGlobal(objectTypes[typeof self] && self); |
|
|
|
/** Detect free variable `window`. */ |
|
var freeWindow = checkGlobal(objectTypes[typeof window] && window); |
|
|
|
/** Detect `this` as the global object. */ |
|
var thisGlobal = checkGlobal(objectTypes[typeof this] && this); |
|
|
|
/** |
|
* Used as a reference to the global object. |
|
* |
|
* The `this` value is used if it's the global object to avoid Greasemonkey's |
|
* restricted `window` object, otherwise the `window` object is used. |
|
*/ |
|
var root = freeGlobal || |
|
((freeWindow !== (thisGlobal && thisGlobal.window)) && freeWindow) || |
|
freeSelf || thisGlobal || Function('return this')(); |
|
|
|
module.exports = root; |
|
|
|
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(125)(module), (function() { return this; }()))) |
|
|
|
/***/ }, |
|
/* 6 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var getLength = __webpack_require__(85), |
|
isFunction = __webpack_require__(18), |
|
isLength = __webpack_require__(11); |
|
|
|
/** |
|
* Checks if `value` is array-like. A value is considered array-like if it's |
|
* not a function and has a `value.length` that's an integer greater than or |
|
* equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`. |
|
* |
|
* @static |
|
* @memberOf _ |
|
* @category Lang |
|
* @param {*} value The value to check. |
|
* @returns {boolean} Returns `true` if `value` is array-like, else `false`. |
|
* @example |
|
* |
|
* _.isArrayLike([1, 2, 3]); |
|
* // => true |
|
* |
|
* _.isArrayLike(document.body.children); |
|
* // => true |
|
* |
|
* _.isArrayLike('abc'); |
|
* // => true |
|
* |
|
* _.isArrayLike(_.noop); |
|
* // => false |
|
*/ |
|
function isArrayLike(value) { |
|
return value != null && isLength(getLength(value)) && !isFunction(value); |
|
} |
|
|
|
module.exports = isArrayLike; |
|
|
|
|
|
/***/ }, |
|
/* 7 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
/** |
|
* Checks if `value` is the [language type](https://es5.github.io/#x8) of `Object`. |
|
* (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) |
|
* |
|
* @static |
|
* @memberOf _ |
|
* @category Lang |
|
* @param {*} value The value to check. |
|
* @returns {boolean} Returns `true` if `value` is an object, else `false`. |
|
* @example |
|
* |
|
* _.isObject({}); |
|
* // => true |
|
* |
|
* _.isObject([1, 2, 3]); |
|
* // => true |
|
* |
|
* _.isObject(_.noop); |
|
* // => true |
|
* |
|
* _.isObject(null); |
|
* // => false |
|
*/ |
|
function isObject(value) { |
|
var type = typeof value; |
|
return !!value && (type == 'object' || type == 'function'); |
|
} |
|
|
|
module.exports = isObject; |
|
|
|
|
|
/***/ }, |
|
/* 8 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var eq = __webpack_require__(15); |
|
|
|
/** |
|
* Gets the index at which the first occurrence of `key` is found in `array` |
|
* of key-value pairs. |
|
* |
|
* @private |
|
* @param {Array} array The array to search. |
|
* @param {*} key The key to search for. |
|
* @returns {number} Returns the index of the matched value, else `-1`. |
|
*/ |
|
function assocIndexOf(array, key) { |
|
var length = array.length; |
|
while (length--) { |
|
if (eq(array[length][0], key)) { |
|
return length; |
|
} |
|
} |
|
return -1; |
|
} |
|
|
|
module.exports = assocIndexOf; |
|
|
|
|
|
/***/ }, |
|
/* 9 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var isNative = __webpack_require__(115); |
|
|
|
/** |
|
* Gets the native function at `key` of `object`. |
|
* |
|
* @private |
|
* @param {Object} object The object to query. |
|
* @param {string} key The key of the method to get. |
|
* @returns {*} Returns the function if it's native, else `undefined`. |
|
*/ |
|
function getNative(object, key) { |
|
var value = object[key]; |
|
return isNative(value) ? value : undefined; |
|
} |
|
|
|
module.exports = getNative; |
|
|
|
|
|
/***/ }, |
|
/* 10 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var getNative = __webpack_require__(9); |
|
|
|
/* Built-in method references that are verified to be native. */ |
|
var nativeCreate = getNative(Object, 'create'); |
|
|
|
module.exports = nativeCreate; |
|
|
|
|
|
/***/ }, |
|
/* 11 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
/** Used as references for various `Number` constants. */ |
|
var MAX_SAFE_INTEGER = 9007199254740991; |
|
|
|
/** |
|
* Checks if `value` is a valid array-like length. |
|
* |
|
* **Note:** This function is loosely based on [`ToLength`](http://ecma-international.org/ecma-262/6.0/#sec-tolength). |
|
* |
|
* @static |
|
* @memberOf _ |
|
* @category Lang |
|
* @param {*} value The value to check. |
|
* @returns {boolean} Returns `true` if `value` is a valid length, else `false`. |
|
* @example |
|
* |
|
* _.isLength(3); |
|
* // => true |
|
* |
|
* _.isLength(Number.MIN_VALUE); |
|
* // => false |
|
* |
|
* _.isLength(Infinity); |
|
* // => false |
|
* |
|
* _.isLength('3'); |
|
* // => false |
|
*/ |
|
function isLength(value) { |
|
return typeof value == 'number' && |
|
value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER; |
|
} |
|
|
|
module.exports = isLength; |
|
|
|
|
|
/***/ }, |
|
/* 12 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var baseHas = __webpack_require__(31), |
|
baseKeys = __webpack_require__(67), |
|
indexKeys = __webpack_require__(92), |
|
isArrayLike = __webpack_require__(6), |
|
isIndex = __webpack_require__(13), |
|
isPrototype = __webpack_require__(37); |
|
|
|
/** |
|
* Creates an array of the own enumerable property names of `object`. |
|
* |
|
* **Note:** Non-object values are coerced to objects. See the |
|
* [ES spec](http://ecma-international.org/ecma-262/6.0/#sec-object.keys) |
|
* for more details. |
|
* |
|
* @static |
|
* @memberOf _ |
|
* @category Object |
|
* @param {Object} object The object to query. |
|
* @returns {Array} Returns the array of property names. |
|
* @example |
|
* |
|
* function Foo() { |
|
* this.a = 1; |
|
* this.b = 2; |
|
* } |
|
* |
|
* Foo.prototype.c = 3; |
|
* |
|
* _.keys(new Foo); |
|
* // => ['a', 'b'] (iteration order is not guaranteed) |
|
* |
|
* _.keys('hi'); |
|
* // => ['0', '1'] |
|
*/ |
|
function keys(object) { |
|
var isProto = isPrototype(object); |
|
if (!(isProto || isArrayLike(object))) { |
|
return baseKeys(object); |
|
} |
|
var indexes = indexKeys(object), |
|
skipIndexes = !!indexes, |
|
result = indexes || [], |
|
length = result.length; |
|
|
|
for (var key in object) { |
|
if (baseHas(object, key) && |
|
!(skipIndexes && (key == 'length' || isIndex(key, length))) && |
|
!(isProto && key == 'constructor')) { |
|
result.push(key); |
|
} |
|
} |
|
return result; |
|
} |
|
|
|
module.exports = keys; |
|
|
|
|
|
/***/ }, |
|
/* 13 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
/** Used as references for various `Number` constants. */ |
|
var MAX_SAFE_INTEGER = 9007199254740991; |
|
|
|
/** Used to detect unsigned integer values. */ |
|
var reIsUint = /^(?:0|[1-9]\d*)$/; |
|
|
|
/** |
|
* Checks if `value` is a valid array-like index. |
|
* |
|
* @private |
|
* @param {*} value The value to check. |
|
* @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index. |
|
* @returns {boolean} Returns `true` if `value` is a valid index, else `false`. |
|
*/ |
|
function isIndex(value, length) { |
|
value = (typeof value == 'number' || reIsUint.test(value)) ? +value : -1; |
|
length = length == null ? MAX_SAFE_INTEGER : length; |
|
return value > -1 && value % 1 == 0 && value < length; |
|
} |
|
|
|
module.exports = isIndex; |
|
|
|
|
|
/***/ }, |
|
/* 14 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var isArray = __webpack_require__(1); |
|
|
|
/** Used to match property names within property paths. */ |
|
var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, |
|
reIsPlainProp = /^\w*$/; |
|
|
|
/** |
|
* Checks if `value` is a property name and not a property path. |
|
* |
|
* @private |
|
* @param {*} value The value to check. |
|
* @param {Object} [object] The object to query keys on. |
|
* @returns {boolean} Returns `true` if `value` is a property name, else `false`. |
|
*/ |
|
function isKey(value, object) { |
|
if (typeof value == 'number') { |
|
return true; |
|
} |
|
return !isArray(value) && |
|
(reIsPlainProp.test(value) || !reIsDeepProp.test(value) || |
|
(object != null && value in Object(object))); |
|
} |
|
|
|
module.exports = isKey; |
|
|
|
|
|
/***/ }, |
|
/* 15 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
/** |
|
* Performs a [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero) |
|
* comparison between two values to determine if they are equivalent. |
|
* |
|
* @static |
|
* @memberOf _ |
|
* @category Lang |
|
* @param {*} value The value to compare. |
|
* @param {*} other The other value to compare. |
|
* @returns {boolean} Returns `true` if the values are equivalent, else `false`. |
|
* @example |
|
* |
|
* var object = { 'user': 'fred' }; |
|
* var other = { 'user': 'fred' }; |
|
* |
|
* _.eq(object, object); |
|
* // => true |
|
* |
|
* _.eq(object, other); |
|
* // => false |
|
* |
|
* _.eq('a', 'a'); |
|
* // => true |
|
* |
|
* _.eq('a', Object('a')); |
|
* // => false |
|
* |
|
* _.eq(NaN, NaN); |
|
* // => true |
|
*/ |
|
function eq(value, other) { |
|
return value === other || (value !== value && other !== other); |
|
} |
|
|
|
module.exports = eq; |
|
|
|
|
|
/***/ }, |
|
/* 16 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var isArrayLikeObject = __webpack_require__(17); |
|
|
|
/** `Object#toString` result references. */ |
|
var argsTag = '[object Arguments]'; |
|
|
|
/** Used for built-in method references. */ |
|
var objectProto = Object.prototype; |
|
|
|
/** Used to check objects for own properties. */ |
|
var hasOwnProperty = objectProto.hasOwnProperty; |
|
|
|
/** |
|
* Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring) |
|
* of values. |
|
*/ |
|
var objectToString = objectProto.toString; |
|
|
|
/** Built-in value references. */ |
|
var propertyIsEnumerable = objectProto.propertyIsEnumerable; |
|
|
|
/** |
|
* Checks if `value` is likely an `arguments` object. |
|
* |
|
* @static |
|
* @memberOf _ |
|
* @category Lang |
|
* @param {*} value The value to check. |
|
* @returns {boolean} Returns `true` if `value` is correctly classified, else `false`. |
|
* @example |
|
* |
|
* _.isArguments(function() { return arguments; }()); |
|
* // => true |
|
* |
|
* _.isArguments([1, 2, 3]); |
|
* // => false |
|
*/ |
|
function isArguments(value) { |
|
// Safari 8.1 incorrectly makes `arguments.callee` enumerable in strict mode. |
|
return isArrayLikeObject(value) && hasOwnProperty.call(value, 'callee') && |
|
(!propertyIsEnumerable.call(value, 'callee') || objectToString.call(value) == argsTag); |
|
} |
|
|
|
module.exports = isArguments; |
|
|
|
|
|
/***/ }, |
|
/* 17 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var isArrayLike = __webpack_require__(6), |
|
isObjectLike = __webpack_require__(4); |
|
|
|
/** |
|
* This method is like `_.isArrayLike` except that it also checks if `value` |
|
* is an object. |
|
* |
|
* @static |
|
* @memberOf _ |
|
* @category Lang |
|
* @param {*} value The value to check. |
|
* @returns {boolean} Returns `true` if `value` is an array-like object, else `false`. |
|
* @example |
|
* |
|
* _.isArrayLikeObject([1, 2, 3]); |
|
* // => true |
|
* |
|
* _.isArrayLikeObject(document.body.children); |
|
* // => true |
|
* |
|
* _.isArrayLikeObject('abc'); |
|
* // => false |
|
* |
|
* _.isArrayLikeObject(_.noop); |
|
* // => false |
|
*/ |
|
function isArrayLikeObject(value) { |
|
return isObjectLike(value) && isArrayLike(value); |
|
} |
|
|
|
module.exports = isArrayLikeObject; |
|
|
|
|
|
/***/ }, |
|
/* 18 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var isObject = __webpack_require__(7); |
|
|
|
/** `Object#toString` result references. */ |
|
var funcTag = '[object Function]', |
|
genTag = '[object GeneratorFunction]'; |
|
|
|
/** Used for built-in method references. */ |
|
var objectProto = Object.prototype; |
|
|
|
/** |
|
* Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring) |
|
* of values. |
|
*/ |
|
var objectToString = objectProto.toString; |
|
|
|
/** |
|
* Checks if `value` is classified as a `Function` object. |
|
* |
|
* @static |
|
* @memberOf _ |
|
* @category Lang |
|
* @param {*} value The value to check. |
|
* @returns {boolean} Returns `true` if `value` is correctly classified, else `false`. |
|
* @example |
|
* |
|
* _.isFunction(_); |
|
* // => true |
|
* |
|
* _.isFunction(/abc/); |
|
* // => false |
|
*/ |
|
function isFunction(value) { |
|
// The use of `Object#toString` avoids issues with the `typeof` operator |
|
// in Safari 8 which returns 'object' for typed array and weak map constructors, |
|
// and PhantomJS 1.9 which returns 'function' for `NodeList` instances. |
|
var tag = isObject(value) ? objectToString.call(value) : ''; |
|
return tag == funcTag || tag == genTag; |
|
} |
|
|
|
module.exports = isFunction; |
|
|
|
|
|
/***/ }, |
|
/* 19 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports.default = supportsProtoAssignment; |
|
var x = {}; |
|
var y = { supports: true }; |
|
try { |
|
x.__proto__ = y; |
|
} catch (err) {} |
|
|
|
function supportsProtoAssignment() { |
|
return x.supports || false; |
|
}; |
|
|
|
/***/ }, |
|
/* 20 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var mapClear = __webpack_require__(96), |
|
mapDelete = __webpack_require__(97), |
|
mapGet = __webpack_require__(98), |
|
mapHas = __webpack_require__(99), |
|
mapSet = __webpack_require__(100); |
|
|
|
/** |
|
* Creates a map cache object to store key-value pairs. |
|
* |
|
* @private |
|
* @constructor |
|
* @param {Array} [values] The values to cache. |
|
*/ |
|
function MapCache(values) { |
|
var index = -1, |
|
length = values ? values.length : 0; |
|
|
|
this.clear(); |
|
while (++index < length) { |
|
var entry = values[index]; |
|
this.set(entry[0], entry[1]); |
|
} |
|
} |
|
|
|
// Add functions to the `MapCache`. |
|
MapCache.prototype.clear = mapClear; |
|
MapCache.prototype['delete'] = mapDelete; |
|
MapCache.prototype.get = mapGet; |
|
MapCache.prototype.has = mapHas; |
|
MapCache.prototype.set = mapSet; |
|
|
|
module.exports = MapCache; |
|
|
|
|
|
/***/ }, |
|
/* 21 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var stackClear = __webpack_require__(104), |
|
stackDelete = __webpack_require__(105), |
|
stackGet = __webpack_require__(106), |
|
stackHas = __webpack_require__(107), |
|
stackSet = __webpack_require__(108); |
|
|
|
/** |
|
* Creates a stack cache object to store key-value pairs. |
|
* |
|
* @private |
|
* @constructor |
|
* @param {Array} [values] The values to cache. |
|
*/ |
|
function Stack(values) { |
|
var index = -1, |
|
length = values ? values.length : 0; |
|
|
|
this.clear(); |
|
while (++index < length) { |
|
var entry = values[index]; |
|
this.set(entry[0], entry[1]); |
|
} |
|
} |
|
|
|
// Add functions to the `Stack` cache. |
|
Stack.prototype.clear = stackClear; |
|
Stack.prototype['delete'] = stackDelete; |
|
Stack.prototype.get = stackGet; |
|
Stack.prototype.has = stackHas; |
|
Stack.prototype.set = stackSet; |
|
|
|
module.exports = Stack; |
|
|
|
|
|
/***/ }, |
|
/* 22 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var root = __webpack_require__(5); |
|
|
|
/** Built-in value references. */ |
|
var Symbol = root.Symbol; |
|
|
|
module.exports = Symbol; |
|
|
|
|
|
/***/ }, |
|
/* 23 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
/** |
|
* A specialized version of `_.map` for arrays without support for iteratee |
|
* shorthands. |
|
* |
|
* @private |
|
* @param {Array} array The array to iterate over. |
|
* @param {Function} iteratee The function invoked per iteration. |
|
* @returns {Array} Returns the new mapped array. |
|
*/ |
|
function arrayMap(array, iteratee) { |
|
var index = -1, |
|
length = array.length, |
|
result = Array(length); |
|
|
|
while (++index < length) { |
|
result[index] = iteratee(array[index], index, array); |
|
} |
|
return result; |
|
} |
|
|
|
module.exports = arrayMap; |
|
|
|
|
|
/***/ }, |
|
/* 24 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var eq = __webpack_require__(15); |
|
|
|
/** Used for built-in method references. */ |
|
var objectProto = Object.prototype; |
|
|
|
/** Used to check objects for own properties. */ |
|
var hasOwnProperty = objectProto.hasOwnProperty; |
|
|
|
/** |
|
* Assigns `value` to `key` of `object` if the existing value is not equivalent |
|
* using [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero) |
|
* for equality comparisons. |
|
* |
|
* @private |
|
* @param {Object} object The object to modify. |
|
* @param {string} key The key of the property to assign. |
|
* @param {*} value The value to assign. |
|
*/ |
|
function assignValue(object, key, value) { |
|
var objValue = object[key]; |
|
if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) || |
|
(value === undefined && !(key in object))) { |
|
object[key] = value; |
|
} |
|
} |
|
|
|
module.exports = assignValue; |
|
|
|
|
|
/***/ }, |
|
/* 25 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var assocIndexOf = __webpack_require__(8); |
|
|
|
/** Used for built-in method references. */ |
|
var arrayProto = Array.prototype; |
|
|
|
/** Built-in value references. */ |
|
var splice = arrayProto.splice; |
|
|
|
/** |
|
* Removes `key` and its value from the associative array. |
|
* |
|
* @private |
|
* @param {Array} array The array to query. |
|
* @param {string} key The key of the value to remove. |
|
* @returns {boolean} Returns `true` if the entry was removed, else `false`. |
|
*/ |
|
function assocDelete(array, key) { |
|
var index = assocIndexOf(array, key); |
|
if (index < 0) { |
|
return false; |
|
} |
|
var lastIndex = array.length - 1; |
|
if (index == lastIndex) { |
|
array.pop(); |
|
} else { |
|
splice.call(array, index, 1); |
|
} |
|
return true; |
|
} |
|
|
|
module.exports = assocDelete; |
|
|
|
|
|
/***/ }, |
|
/* 26 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var assocIndexOf = __webpack_require__(8); |
|
|
|
/** |
|
* Gets the associative array value for `key`. |
|
* |
|
* @private |
|
* @param {Array} array The array to query. |
|
* @param {string} key The key of the value to get. |
|
* @returns {*} Returns the entry value. |
|
*/ |
|
function assocGet(array, key) { |
|
var index = assocIndexOf(array, key); |
|
return index < 0 ? undefined : array[index][1]; |
|
} |
|
|
|
module.exports = assocGet; |
|
|
|
|
|
/***/ }, |
|
/* 27 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var assocIndexOf = __webpack_require__(8); |
|
|
|
/** |
|
* Checks if an associative array value for `key` exists. |
|
* |
|
* @private |
|
* @param {Array} array The array to query. |
|
* @param {string} key The key of the entry to check. |
|
* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. |
|
*/ |
|
function assocHas(array, key) { |
|
return assocIndexOf(array, key) > -1; |
|
} |
|
|
|
module.exports = assocHas; |
|
|
|
|
|
/***/ }, |
|
/* 28 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var assocIndexOf = __webpack_require__(8); |
|
|
|
/** |
|
* Sets the associative array `key` to `value`. |
|
* |
|
* @private |
|
* @param {Array} array The array to modify. |
|
* @param {string} key The key of the value to set. |
|
* @param {*} value The value to set. |
|
*/ |
|
function assocSet(array, key, value) { |
|
var index = assocIndexOf(array, key); |
|
if (index < 0) { |
|
array.push([key, value]); |
|
} else { |
|
array[index][1] = value; |
|
} |
|
} |
|
|
|
module.exports = assocSet; |
|
|
|
|
|
/***/ }, |
|
/* 29 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var isArray = __webpack_require__(1), |
|
stringToPath = __webpack_require__(109); |
|
|
|
/** |
|
* Casts `value` to a path array if it's not one. |
|
* |
|
* @private |
|
* @param {*} value The value to inspect. |
|
* @returns {Array} Returns the cast property path array. |
|
*/ |
|
function baseCastPath(value) { |
|
return isArray(value) ? value : stringToPath(value); |
|
} |
|
|
|
module.exports = baseCastPath; |
|
|
|
|
|
/***/ }, |
|
/* 30 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var baseCastPath = __webpack_require__(29), |
|
isKey = __webpack_require__(14); |
|
|
|
/** |
|
* The base implementation of `_.get` without support for default values. |
|
* |
|
* @private |
|
* @param {Object} object The object to query. |
|
* @param {Array|string} path The path of the property to get. |
|
* @returns {*} Returns the resolved value. |
|
*/ |
|
function baseGet(object, path) { |
|
path = isKey(path, object) ? [path + ''] : baseCastPath(path); |
|
|
|
var index = 0, |
|
length = path.length; |
|
|
|
while (object != null && index < length) { |
|
object = object[path[index++]]; |
|
} |
|
return (index && index == length) ? object : undefined; |
|
} |
|
|
|
module.exports = baseGet; |
|
|
|
|
|
/***/ }, |
|
/* 31 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
/** Used for built-in method references. */ |
|
var objectProto = Object.prototype; |
|
|
|
/** Used to check objects for own properties. */ |
|
var hasOwnProperty = objectProto.hasOwnProperty; |
|
|
|
/** Built-in value references. */ |
|
var getPrototypeOf = Object.getPrototypeOf; |
|
|
|
/** |
|
* The base implementation of `_.has` without support for deep paths. |
|
* |
|
* @private |
|
* @param {Object} object The object to query. |
|
* @param {Array|string} key The key to check. |
|
* @returns {boolean} Returns `true` if `key` exists, else `false`. |
|
*/ |
|
function baseHas(object, key) { |
|
// Avoid a bug in IE 10-11 where objects with a [[Prototype]] of `null`, |
|
// that are composed entirely of index properties, return `false` for |
|
// `hasOwnProperty` checks of them. |
|
return hasOwnProperty.call(object, key) || |
|
(typeof object == 'object' && key in object && getPrototypeOf(object) === null); |
|
} |
|
|
|
module.exports = baseHas; |
|
|
|
|
|
/***/ }, |
|
/* 32 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var baseIsEqualDeep = __webpack_require__(64), |
|
isObject = __webpack_require__(7), |
|
isObjectLike = __webpack_require__(4); |
|
|
|
/** |
|
* The base implementation of `_.isEqual` which supports partial comparisons |
|
* and tracks traversed objects. |
|
* |
|
* @private |
|
* @param {*} value The value to compare. |
|
* @param {*} other The other value to compare. |
|
* @param {Function} [customizer] The function to customize comparisons. |
|
* @param {boolean} [bitmask] The bitmask of comparison flags. |
|
* The bitmask may be composed of the following flags: |
|
* 1 - Unordered comparison |
|
* 2 - Partial comparison |
|
* @param {Object} [stack] Tracks traversed `value` and `other` objects. |
|
* @returns {boolean} Returns `true` if the values are equivalent, else `false`. |
|
*/ |
|
function baseIsEqual(value, other, customizer, bitmask, stack) { |
|
if (value === other) { |
|
return true; |
|
} |
|
if (value == null || other == null || (!isObject(value) && !isObjectLike(other))) { |
|
return value !== value && other !== other; |
|
} |
|
return baseIsEqualDeep(value, other, baseIsEqual, customizer, bitmask, stack); |
|
} |
|
|
|
module.exports = baseIsEqual; |
|
|
|
|
|
/***/ }, |
|
/* 33 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
/** |
|
* The base implementation of `_.property` without support for deep paths. |
|
* |
|
* @private |
|
* @param {string} key The key of the property to get. |
|
* @returns {Function} Returns the new function. |
|
*/ |
|
function baseProperty(key) { |
|
return function(object) { |
|
return object == null ? undefined : object[key]; |
|
}; |
|
} |
|
|
|
module.exports = baseProperty; |
|
|
|
|
|
/***/ }, |
|
/* 34 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var arraySome = __webpack_require__(54); |
|
|
|
/** Used to compose bitmasks for comparison styles. */ |
|
var UNORDERED_COMPARE_FLAG = 1, |
|
PARTIAL_COMPARE_FLAG = 2; |
|
|
|
/** |
|
* A specialized version of `baseIsEqualDeep` for arrays with support for |
|
* partial deep comparisons. |
|
* |
|
* @private |
|
* @param {Array} array The array to compare. |
|
* @param {Array} other The other array to compare. |
|
* @param {Function} equalFunc The function to determine equivalents of values. |
|
* @param {Function} customizer The function to customize comparisons. |
|
* @param {number} bitmask The bitmask of comparison flags. See `baseIsEqual` for more details. |
|
* @param {Object} stack Tracks traversed `array` and `other` objects. |
|
* @returns {boolean} Returns `true` if the arrays are equivalent, else `false`. |
|
*/ |
|
function equalArrays(array, other, equalFunc, customizer, bitmask, stack) { |
|
var index = -1, |
|
isPartial = bitmask & PARTIAL_COMPARE_FLAG, |
|
isUnordered = bitmask & UNORDERED_COMPARE_FLAG, |
|
arrLength = array.length, |
|
othLength = other.length; |
|
|
|
if (arrLength != othLength && !(isPartial && othLength > arrLength)) { |
|
return false; |
|
} |
|
// Assume cyclic values are equal. |
|
var stacked = stack.get(array); |
|
if (stacked) { |
|
return stacked == other; |
|
} |
|
var result = true; |
|
stack.set(array, other); |
|
|
|
// Ignore non-index properties. |
|
while (++index < arrLength) { |
|
var arrValue = array[index], |
|
othValue = other[index]; |
|
|
|
if (customizer) { |
|
var compared = isPartial |
|
? customizer(othValue, arrValue, index, other, array, stack) |
|
: customizer(arrValue, othValue, index, array, other, stack); |
|
} |
|
if (compared !== undefined) { |
|
if (compared) { |
|
continue; |
|
} |
|
result = false; |
|
break; |
|
} |
|
// Recursively compare arrays (susceptible to call stack limits). |
|
if (isUnordered) { |
|
if (!arraySome(other, function(othValue) { |
|
return arrValue === othValue || equalFunc(arrValue, othValue, customizer, bitmask, stack); |
|
})) { |
|
result = false; |
|
break; |
|
} |
|
} else if (!(arrValue === othValue || equalFunc(arrValue, othValue, customizer, bitmask, stack))) { |
|
result = false; |
|
break; |
|
} |
|
} |
|
stack['delete'](array); |
|
return result; |
|
} |
|
|
|
module.exports = equalArrays; |
|
|
|
|
|
/***/ }, |
|
/* 35 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var nativeCreate = __webpack_require__(10); |
|
|
|
/** Used for built-in method references. */ |
|
var objectProto = Object.prototype; |
|
|
|
/** Used to check objects for own properties. */ |
|
var hasOwnProperty = objectProto.hasOwnProperty; |
|
|
|
/** |
|
* Checks if a hash value for `key` exists. |
|
* |
|
* @private |
|
* @param {Object} hash The hash to query. |
|
* @param {string} key The key of the entry to check. |
|
* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. |
|
*/ |
|
function hashHas(hash, key) { |
|
return nativeCreate ? hash[key] !== undefined : hasOwnProperty.call(hash, key); |
|
} |
|
|
|
module.exports = hashHas; |
|
|
|
|
|
/***/ }, |
|
/* 36 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
/** |
|
* Checks if `value` is a host object in IE < 9. |
|
* |
|
* @private |
|
* @param {*} value The value to check. |
|
* @returns {boolean} Returns `true` if `value` is a host object, else `false`. |
|
*/ |
|
function isHostObject(value) { |
|
// Many host objects are `Object` objects that can coerce to strings |
|
// despite having improperly defined `toString` methods. |
|
var result = false; |
|
if (value != null && typeof value.toString != 'function') { |
|
try { |
|
result = !!(value + ''); |
|
} catch (e) {} |
|
} |
|
return result; |
|
} |
|
|
|
module.exports = isHostObject; |
|
|
|
|
|
/***/ }, |
|
/* 37 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
/** Used for built-in method references. */ |
|
var objectProto = Object.prototype; |
|
|
|
/** |
|
* Checks if `value` is likely a prototype object. |
|
* |
|
* @private |
|
* @param {*} value The value to check. |
|
* @returns {boolean} Returns `true` if `value` is a prototype, else `false`. |
|
*/ |
|
function isPrototype(value) { |
|
var Ctor = value && value.constructor, |
|
proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto; |
|
|
|
return value === proto; |
|
} |
|
|
|
module.exports = isPrototype; |
|
|
|
|
|
/***/ }, |
|
/* 38 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var baseGet = __webpack_require__(30); |
|
|
|
/** |
|
* Gets the value at `path` of `object`. If the resolved value is |
|
* `undefined` the `defaultValue` is used in its place. |
|
* |
|
* @static |
|
* @memberOf _ |
|
* @category Object |
|
* @param {Object} object The object to query. |
|
* @param {Array|string} path The path of the property to get. |
|
* @param {*} [defaultValue] The value returned if the resolved value is `undefined`. |
|
* @returns {*} Returns the resolved value. |
|
* @example |
|
* |
|
* var object = { 'a': [{ 'b': { 'c': 3 } }] }; |
|
* |
|
* _.get(object, 'a[0].b.c'); |
|
* // => 3 |
|
* |
|
* _.get(object, ['a', '0', 'b', 'c']); |
|
* // => 3 |
|
* |
|
* _.get(object, 'a.b.c', 'default'); |
|
* // => 'default' |
|
*/ |
|
function get(object, path, defaultValue) { |
|
var result = object == null ? undefined : baseGet(object, path); |
|
return result === undefined ? defaultValue : result; |
|
} |
|
|
|
module.exports = get; |
|
|
|
|
|
/***/ }, |
|
/* 39 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var isArray = __webpack_require__(1), |
|
isObjectLike = __webpack_require__(4); |
|
|
|
/** `Object#toString` result references. */ |
|
var stringTag = '[object String]'; |
|
|
|
/** Used for built-in method references. */ |
|
var objectProto = Object.prototype; |
|
|
|
/** |
|
* Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring) |
|
* of values. |
|
*/ |
|
var objectToString = objectProto.toString; |
|
|
|
/** |
|
* Checks if `value` is classified as a `String` primitive or object. |
|
* |
|
* @static |
|
* @memberOf _ |
|
* @category Lang |
|
* @param {*} value The value to check. |
|
* @returns {boolean} Returns `true` if `value` is correctly classified, else `false`. |
|
* @example |
|
* |
|
* _.isString('abc'); |
|
* // => true |
|
* |
|
* _.isString(1); |
|
* // => false |
|
*/ |
|
function isString(value) { |
|
return typeof value == 'string' || |
|
(!isArray(value) && isObjectLike(value) && objectToString.call(value) == stringTag); |
|
} |
|
|
|
module.exports = isString; |
|
|
|
|
|
/***/ }, |
|
/* 40 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var apply = __webpack_require__(50), |
|
toInteger = __webpack_require__(120); |
|
|
|
/** Used as the `TypeError` message for "Functions" methods. */ |
|
var FUNC_ERROR_TEXT = 'Expected a function'; |
|
|
|
/* Built-in method references for those with the same name as other `lodash` methods. */ |
|
var nativeMax = Math.max; |
|
|
|
/** |
|
* Creates a function that invokes `func` with the `this` binding of the |
|
* created function and arguments from `start` and beyond provided as an array. |
|
* |
|
* **Note:** This method is based on the [rest parameter](https://mdn.io/rest_parameters). |
|
* |
|
* @static |
|
* @memberOf _ |
|
* @category Function |
|
* @param {Function} func The function to apply a rest parameter to. |
|
* @param {number} [start=func.length-1] The start position of the rest parameter. |
|
* @returns {Function} Returns the new function. |
|
* @example |
|
* |
|
* var say = _.rest(function(what, names) { |
|
* return what + ' ' + _.initial(names).join(', ') + |
|
* (_.size(names) > 1 ? ', & ' : '') + _.last(names); |
|
* }); |
|
* |
|
* say('hello', 'fred', 'barney', 'pebbles'); |
|
* // => 'hello fred, barney, & pebbles' |
|
*/ |
|
function rest(func, start) { |
|
if (typeof func != 'function') { |
|
throw new TypeError(FUNC_ERROR_TEXT); |
|
} |
|
start = nativeMax(start === undefined ? (func.length - 1) : toInteger(start), 0); |
|
return function() { |
|
var args = arguments, |
|
index = -1, |
|
length = nativeMax(args.length - start, 0), |
|
array = Array(length); |
|
|
|
while (++index < length) { |
|
array[index] = args[start + index]; |
|
} |
|
switch (start) { |
|
case 0: return func.call(this, array); |
|
case 1: return func.call(this, args[0], array); |
|
case 2: return func.call(this, args[0], args[1], array); |
|
} |
|
var otherArgs = Array(start + 1); |
|
index = -1; |
|
while (++index < start) { |
|
otherArgs[index] = args[index]; |
|
} |
|
otherArgs[start] = array; |
|
return apply(func, this, otherArgs); |
|
}; |
|
} |
|
|
|
module.exports = rest; |
|
|
|
|
|
/***/ }, |
|
/* 41 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
'use strict'; |
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports.default = bindAutoBindMethods; |
|
/** |
|
* Copyright 2013-2015, Facebook, Inc. |
|
* All rights reserved. |
|
* |
|
* This source code is licensed under the BSD-style license found in the |
|
* LICENSE file in the root directory of React source tree. An additional grant |
|
* of patent rights can be found in the PATENTS file in the same directory. |
|
* |
|
* Original: |
|
* https://github.com/facebook/react/blob/6508b1ad273a6f371e8d90ae676e5390199461b4/src/isomorphic/classic/class/ReactClass.js#L650-L713 |
|
*/ |
|
|
|
function bindAutoBindMethod(component, method) { |
|
var boundMethod = method.bind(component); |
|
|
|
boundMethod.__reactBoundContext = component; |
|
boundMethod.__reactBoundMethod = method; |
|
boundMethod.__reactBoundArguments = null; |
|
|
|
var componentName = component.constructor.displayName, |
|
_bind = boundMethod.bind; |
|
|
|
boundMethod.bind = function (newThis) { |
|
var args = Array.prototype.slice.call(arguments, 1); |
|
if (newThis !== component && newThis !== null) { |
|
console.warn('bind(): React component methods may only be bound to the ' + 'component instance. See ' + componentName); |
|
} else if (!args.length) { |
|
console.warn('bind(): You are binding a component method to the component. ' + 'React does this for you automatically in a high-performance ' + 'way, so you can safely remove this call. See ' + componentName); |
|
return boundMethod; |
|
} |
|
|
|
var reboundMethod = _bind.apply(boundMethod, arguments); |
|
reboundMethod.__reactBoundContext = component; |
|
reboundMethod.__reactBoundMethod = method; |
|
reboundMethod.__reactBoundArguments = args; |
|
|
|
return reboundMethod; |
|
}; |
|
|
|
return boundMethod; |
|
} |
|
|
|
function bindAutoBindMethodsFromMap(component) { |
|
for (var autoBindKey in component.__reactAutoBindMap) { |
|
if (!component.__reactAutoBindMap.hasOwnProperty(autoBindKey)) { |
|
return; |
|
} |
|
|
|
// Tweak: skip methods that are already bound. |
|
// This is to preserve method reference in case it is used |
|
// as a subscription handler that needs to be detached later. |
|
if (component.hasOwnProperty(autoBindKey) && component[autoBindKey].__reactBoundContext === component) { |
|
continue; |
|
} |
|
|
|
var method = component.__reactAutoBindMap[autoBindKey]; |
|
component[autoBindKey] = bindAutoBindMethod(component, method); |
|
} |
|
} |
|
|
|
function bindAutoBindMethods(component) { |
|
if (component.__reactAutoBindPairs) { |
|
bindAutoBindMethodsFromArray(component); |
|
} else if (component.__reactAutoBindMap) { |
|
bindAutoBindMethodsFromMap(component); |
|
} |
|
} |
|
|
|
function bindAutoBindMethodsFromArray(component) { |
|
var pairs = component.__reactAutoBindPairs; |
|
|
|
if (!pairs) { |
|
return; |
|
} |
|
|
|
for (var i = 0; i < pairs.length; i += 2) { |
|
var autoBindKey = pairs[i]; |
|
|
|
if (component.hasOwnProperty(autoBindKey) && component[autoBindKey].__reactBoundContext === component) { |
|
continue; |
|
} |
|
|
|
var method = pairs[i + 1]; |
|
|
|
component[autoBindKey] = bindAutoBindMethod(component, method); |
|
} |
|
} |
|
|
|
/***/ }, |
|
/* 42 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
'use strict'; |
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
|
|
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; |
|
|
|
var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }(); |
|
|
|
exports.default = proxyClass; |
|
exports.default = createClassProxy; |
|
|
|
var _find = __webpack_require__(112); |
|
|
|
var _find2 = _interopRequireDefault(_find); |
|
|
|
var _createPrototypeProxy = __webpack_require__(43); |
|
|
|
var _createPrototypeProxy2 = _interopRequireDefault(_createPrototypeProxy); |
|
|
|
var _bindAutoBindMethods = __webpack_require__(41); |
|
|
|
var _bindAutoBindMethods2 = _interopRequireDefault(_bindAutoBindMethods); |
|
|
|
var _deleteUnknownAutoBindMethods = __webpack_require__(44); |
|
|
|
var _deleteUnknownAutoBindMethods2 = _interopRequireDefault(_deleteUnknownAutoBindMethods); |
|
|
|
var _supportsProtoAssignment = __webpack_require__(19); |
|
|
|
var _supportsProtoAssignment2 = _interopRequireDefault(_supportsProtoAssignment); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } |
|
|
|
function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } } |
|
|
|
var RESERVED_STATICS = ['length', 'name', 'arguments', 'caller', 'prototype', 'toString']; |
|
|
|
function isEqualDescriptor(a, b) { |
|
if (!a && !b) { |
|
return true; |
|
} |
|
if (!a || !b) { |
|
return false; |
|
} |
|
for (var key in a) { |
|
if (a[key] !== b[key]) { |
|
return false; |
|
} |
|
} |
|
return true; |
|
} |
|
|
|
// This was originally a WeakMap but we had issues with React Native: |
|
// https://github.com/gaearon/react-proxy/issues/50#issuecomment-192928066 |
|
var allProxies = []; |
|
function findProxy(Component) { |
|
var pair = (0, _find2.default)(allProxies, function (_ref) { |
|
var _ref2 = _slicedToArray(_ref, 1); |
|
|
|
var key = _ref2[0]; |
|
return key === Component; |
|
}); |
|
return pair ? pair[1] : null; |
|
} |
|
function addProxy(Component, proxy) { |
|
allProxies.push([Component, proxy]); |
|
} |
|
|
|
function proxyClass(InitialComponent) { |
|
// Prevent double wrapping. |
|
// Given a proxy class, return the existing proxy managing it. |
|
var existingProxy = findProxy(InitialComponent); |
|
if (existingProxy) { |
|
return existingProxy; |
|
} |
|
|
|
var prototypeProxy = (0, _createPrototypeProxy2.default)(); |
|
var CurrentComponent = undefined; |
|
var ProxyComponent = undefined; |
|
|
|
var staticDescriptors = {}; |
|
function wasStaticModifiedByUser(key) { |
|
// Compare the descriptor with the one we previously set ourselves. |
|
var currentDescriptor = Object.getOwnPropertyDescriptor(ProxyComponent, key); |
|
return !isEqualDescriptor(staticDescriptors[key], currentDescriptor); |
|
} |
|
|
|
function instantiate(factory, context, params) { |
|
var component = factory(); |
|
|
|
try { |
|
return component.apply(context, params); |
|
} catch (err) { |
|
(function () { |
|
// Native ES6 class instantiation |
|
var instance = new (Function.prototype.bind.apply(component, [null].concat(_toConsumableArray(params))))(); |
|
|
|
Object.keys(instance).forEach(function (key) { |
|
if (RESERVED_STATICS.indexOf(key) > -1) { |
|
return; |
|
} |
|
context[key] = instance[key]; |
|
}); |
|
})(); |
|
} |
|
} |
|
|
|
try { |
|
// Create a proxy constructor with matching name |
|
ProxyComponent = new Function('factory', 'instantiate', 'return function ' + (InitialComponent.name || 'ProxyComponent') + '() {\n return instantiate(factory, this, arguments);\n }')(function () { |
|
return CurrentComponent; |
|
}, instantiate); |
|
} catch (err) { |
|
// Some environments may forbid dynamic evaluation |
|
ProxyComponent = function ProxyComponent() { |
|
return instantiate(function () { |
|
return CurrentComponent; |
|
}, this, arguments); |
|
}; |
|
} |
|
|
|
// Point proxy constructor to the proxy prototype |
|
ProxyComponent.prototype = prototypeProxy.get(); |
|
|
|
// Proxy toString() to the current constructor |
|
ProxyComponent.toString = function toString() { |
|
return CurrentComponent.toString(); |
|
}; |
|
|
|
function update(NextComponent) { |
|
if (typeof NextComponent !== 'function') { |
|
throw new Error('Expected a constructor.'); |
|
} |
|
|
|
// Prevent proxy cycles |
|
var existingProxy = findProxy(NextComponent); |
|
if (existingProxy) { |
|
return update(existingProxy.__getCurrent()); |
|
} |
|
|
|
// Save the next constructor so we call it |
|
CurrentComponent = NextComponent; |
|
|
|
// Update the prototype proxy with new methods |
|
var mountedInstances = prototypeProxy.update(NextComponent.prototype); |
|
|
|
// Set up the constructor property so accessing the statics work |
|
ProxyComponent.prototype.constructor = ProxyComponent; |
|
|
|
// Set up the same prototype for inherited statics |
|
ProxyComponent.__proto__ = NextComponent.__proto__; |
|
|
|
// Copy static methods and properties |
|
Object.getOwnPropertyNames(NextComponent).forEach(function (key) { |
|
if (RESERVED_STATICS.indexOf(key) > -1) { |
|
return; |
|
} |
|
|
|
var staticDescriptor = _extends({}, Object.getOwnPropertyDescriptor(NextComponent, key), { |
|
configurable: true |
|
}); |
|
|
|
// Copy static unless user has redefined it at runtime |
|
if (!wasStaticModifiedByUser(key)) { |
|
Object.defineProperty(ProxyComponent, key, staticDescriptor); |
|
staticDescriptors[key] = staticDescriptor; |
|
} |
|
}); |
|
|
|
// Remove old static methods and properties |
|
Object.getOwnPropertyNames(ProxyComponent).forEach(function (key) { |
|
if (RESERVED_STATICS.indexOf(key) > -1) { |
|
return; |
|
} |
|
|
|
// Skip statics that exist on the next class |
|
if (NextComponent.hasOwnProperty(key)) { |
|
return; |
|
} |
|
|
|
// Skip non-configurable statics |
|
var descriptor = Object.getOwnPropertyDescriptor(ProxyComponent, key); |
|
if (descriptor && !descriptor.configurable) { |
|
return; |
|
} |
|
|
|
// Delete static unless user has redefined it at runtime |
|
if (!wasStaticModifiedByUser(key)) { |
|
delete ProxyComponent[key]; |
|
delete staticDescriptors[key]; |
|
} |
|
}); |
|
|
|
// Try to infer displayName |
|
ProxyComponent.displayName = NextComponent.displayName || NextComponent.name; |
|
|
|
// We might have added new methods that need to be auto-bound |
|
mountedInstances.forEach(_bindAutoBindMethods2.default); |
|
mountedInstances.forEach(_deleteUnknownAutoBindMethods2.default); |
|
|
|
// Let the user take care of redrawing |
|
return mountedInstances; |
|
}; |
|
|
|
function get() { |
|
return ProxyComponent; |
|
} |
|
|
|
function getCurrent() { |
|
return CurrentComponent; |
|
} |
|
|
|
update(InitialComponent); |
|
|
|
var proxy = { get: get, update: update }; |
|
addProxy(ProxyComponent, proxy); |
|
|
|
Object.defineProperty(proxy, '__getCurrent', { |
|
configurable: false, |
|
writable: false, |
|
enumerable: false, |
|
value: getCurrent |
|
}); |
|
|
|
return proxy; |
|
} |
|
|
|
function createFallback(Component) { |
|
var CurrentComponent = Component; |
|
|
|
return { |
|
get: function get() { |
|
return CurrentComponent; |
|
}, |
|
update: function update(NextComponent) { |
|
CurrentComponent = NextComponent; |
|
} |
|
}; |
|
} |
|
|
|
function createClassProxy(Component) { |
|
return Component.__proto__ && (0, _supportsProtoAssignment2.default)() ? proxyClass(Component) : createFallback(Component); |
|
} |
|
|
|
/***/ }, |
|
/* 43 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
'use strict'; |
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports.default = createPrototypeProxy; |
|
|
|
var _assign = __webpack_require__(110); |
|
|
|
var _assign2 = _interopRequireDefault(_assign); |
|
|
|
var _difference = __webpack_require__(111); |
|
|
|
var _difference2 = _interopRequireDefault(_difference); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } |
|
|
|
function createPrototypeProxy() { |
|
var proxy = {}; |
|
var current = null; |
|
var mountedInstances = []; |
|
|
|
/** |
|
* Creates a proxied toString() method pointing to the current version's toString(). |
|
*/ |
|
function proxyToString(name) { |
|
// Wrap to always call the current version |
|
return function toString() { |
|
if (typeof current[name] === 'function') { |
|
return current[name].toString(); |
|
} else { |
|
return '<method was deleted>'; |
|
} |
|
}; |
|
} |
|
|
|
/** |
|
* Creates a proxied method that calls the current version, whenever available. |
|
*/ |
|
function proxyMethod(name) { |
|
// Wrap to always call the current version |
|
var proxiedMethod = function proxiedMethod() { |
|
if (typeof current[name] === 'function') { |
|
return current[name].apply(this, arguments); |
|
} |
|
}; |
|
|
|
// Copy properties of the original function, if any |
|
(0, _assign2.default)(proxiedMethod, current[name]); |
|
proxiedMethod.toString = proxyToString(name); |
|
|
|
return proxiedMethod; |
|
} |
|
|
|
/** |
|
* Augments the original componentDidMount with instance tracking. |
|
*/ |
|
function proxiedComponentDidMount() { |
|
mountedInstances.push(this); |
|
if (typeof current.componentDidMount === 'function') { |
|
return current.componentDidMount.apply(this, arguments); |
|
} |
|
} |
|
proxiedComponentDidMount.toString = proxyToString('componentDidMount'); |
|
|
|
/** |
|
* Augments the original componentWillUnmount with instance tracking. |
|
*/ |
|
function proxiedComponentWillUnmount() { |
|
var index = mountedInstances.indexOf(this); |
|
// Unless we're in a weird environment without componentDidMount |
|
if (index !== -1) { |
|
mountedInstances.splice(index, 1); |
|
} |
|
if (typeof current.componentWillUnmount === 'function') { |
|
return current.componentWillUnmount.apply(this, arguments); |
|
} |
|
} |
|
proxiedComponentWillUnmount.toString = proxyToString('componentWillUnmount'); |
|
|
|
/** |
|
* Defines a property on the proxy. |
|
*/ |
|
function defineProxyProperty(name, descriptor) { |
|
Object.defineProperty(proxy, name, descriptor); |
|
} |
|
|
|
/** |
|
* Defines a property, attempting to keep the original descriptor configuration. |
|
*/ |
|
function defineProxyPropertyWithValue(name, value) { |
|
var _ref = Object.getOwnPropertyDescriptor(current, name) || {}; |
|
|
|
var _ref$enumerable = _ref.enumerable; |
|
var enumerable = _ref$enumerable === undefined ? false : _ref$enumerable; |
|
var _ref$writable = _ref.writable; |
|
var writable = _ref$writable === undefined ? true : _ref$writable; |
|
|
|
|
|
defineProxyProperty(name, { |
|
configurable: true, |
|
enumerable: enumerable, |
|
writable: writable, |
|
value: value |
|
}); |
|
} |
|
|
|
/** |
|
* Creates an auto-bind map mimicking the original map, but directed at proxy. |
|
*/ |
|
function createAutoBindMap() { |
|
if (!current.__reactAutoBindMap) { |
|
return; |
|
} |
|
|
|
var __reactAutoBindMap = {}; |
|
for (var name in current.__reactAutoBindMap) { |
|
if (typeof proxy[name] === 'function' && current.__reactAutoBindMap.hasOwnProperty(name)) { |
|
__reactAutoBindMap[name] = proxy[name]; |
|
} |
|
} |
|
|
|
return __reactAutoBindMap; |
|
} |
|
|
|
/** |
|
* Creates an auto-bind map mimicking the original map, but directed at proxy. |
|
*/ |
|
function createAutoBindPairs() { |
|
var __reactAutoBindPairs = []; |
|
|
|
for (var i = 0; i < current.__reactAutoBindPairs.length; i += 2) { |
|
var name = current.__reactAutoBindPairs[i]; |
|
var method = proxy[name]; |
|
|
|
if (typeof method === 'function') { |
|
__reactAutoBindPairs.push(name, method); |
|
} |
|
} |
|
|
|
return __reactAutoBindPairs; |
|
} |
|
|
|
/** |
|
* Applies the updated prototype. |
|
*/ |
|
function update(next) { |
|
// Save current source of truth |
|
current = next; |
|
|
|
// Find changed property names |
|
var currentNames = Object.getOwnPropertyNames(current); |
|
var previousName = Object.getOwnPropertyNames(proxy); |
|
var removedNames = (0, _difference2.default)(previousName, currentNames); |
|
|
|
// Remove properties and methods that are no longer there |
|
removedNames.forEach(function (name) { |
|
delete proxy[name]; |
|
}); |
|
|
|
// Copy every descriptor |
|
currentNames.forEach(function (name) { |
|
var descriptor = Object.getOwnPropertyDescriptor(current, name); |
|
if (typeof descriptor.value === 'function') { |
|
// Functions require additional wrapping so they can be bound later |
|
defineProxyPropertyWithValue(name, proxyMethod(name)); |
|
} else { |
|
// Other values can be copied directly |
|
defineProxyProperty(name, descriptor); |
|
} |
|
}); |
|
|
|
// Track mounting and unmounting |
|
defineProxyPropertyWithValue('componentDidMount', proxiedComponentDidMount); |
|
defineProxyPropertyWithValue('componentWillUnmount', proxiedComponentWillUnmount); |
|
|
|
if (current.hasOwnProperty('__reactAutoBindMap')) { |
|
defineProxyPropertyWithValue('__reactAutoBindMap', createAutoBindMap()); |
|
} |
|
|
|
if (current.hasOwnProperty('__reactAutoBindPairs')) { |
|
defineProxyPropertyWithValue('__reactAutoBindPairs', createAutoBindPairs()); |
|
} |
|
|
|
// Set up the prototype chain |
|
proxy.__proto__ = next; |
|
|
|
return mountedInstances; |
|
} |
|
|
|
/** |
|
* Returns the up-to-date proxy prototype. |
|
*/ |
|
function get() { |
|
return proxy; |
|
} |
|
|
|
return { |
|
update: update, |
|
get: get |
|
}; |
|
}; |
|
|
|
/***/ }, |
|
/* 44 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
'use strict'; |
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports.default = deleteUnknownAutoBindMethods; |
|
function shouldDeleteClassicInstanceMethod(component, name) { |
|
if (component.__reactAutoBindMap && component.__reactAutoBindMap.hasOwnProperty(name)) { |
|
// It's a known autobound function, keep it |
|
return false; |
|
} |
|
|
|
if (component.__reactAutoBindPairs && component.__reactAutoBindPairs.indexOf(name) >= 0) { |
|
// It's a known autobound function, keep it |
|
return false; |
|
} |
|
|
|
if (component[name].__reactBoundArguments !== null) { |
|
// It's a function bound to specific args, keep it |
|
return false; |
|
} |
|
|
|
// It's a cached bound method for a function |
|
// that was deleted by user, so we delete it from component. |
|
return true; |
|
} |
|
|
|
function shouldDeleteModernInstanceMethod(component, name) { |
|
var prototype = component.constructor.prototype; |
|
|
|
var prototypeDescriptor = Object.getOwnPropertyDescriptor(prototype, name); |
|
|
|
if (!prototypeDescriptor || !prototypeDescriptor.get) { |
|
// This is definitely not an autobinding getter |
|
return false; |
|
} |
|
|
|
if (prototypeDescriptor.get().length !== component[name].length) { |
|
// The length doesn't match, bail out |
|
return false; |
|
} |
|
|
|
// This seems like a method bound using an autobinding getter on the prototype |
|
// Hopefully we won't run into too many false positives. |
|
return true; |
|
} |
|
|
|
function shouldDeleteInstanceMethod(component, name) { |
|
var descriptor = Object.getOwnPropertyDescriptor(component, name); |
|
if (typeof descriptor.value !== 'function') { |
|
// Not a function, or something fancy: bail out |
|
return; |
|
} |
|
|
|
if (component.__reactAutoBindMap || component.__reactAutoBindPairs) { |
|
// Classic |
|
return shouldDeleteClassicInstanceMethod(component, name); |
|
} else { |
|
// Modern |
|
return shouldDeleteModernInstanceMethod(component, name); |
|
} |
|
} |
|
|
|
/** |
|
* Deletes autobound methods from the instance. |
|
* |
|
* For classic React classes, we only delete the methods that no longer exist in map. |
|
* This means the user actually deleted them in code. |
|
* |
|
* For modern classes, we delete methods that exist on prototype with the same length, |
|
* and which have getters on prototype, but are normal values on the instance. |
|
* This is usually an indication that an autobinding decorator is being used, |
|
* and the getter will re-generate the memoized handler on next access. |
|
*/ |
|
function deleteUnknownAutoBindMethods(component) { |
|
var names = Object.getOwnPropertyNames(component); |
|
|
|
names.forEach(function (name) { |
|
if (shouldDeleteInstanceMethod(component, name)) { |
|
delete component[name]; |
|
} |
|
}); |
|
} |
|
|
|
/***/ }, |
|
/* 45 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var nativeCreate = __webpack_require__(10); |
|
|
|
/** Used for built-in method references. */ |
|
var objectProto = Object.prototype; |
|
|
|
/** |
|
* Creates an hash object. |
|
* |
|
* @private |
|
* @constructor |
|
* @returns {Object} Returns the new hash object. |
|
*/ |
|
function Hash() {} |
|
|
|
// Avoid inheriting from `Object.prototype` when possible. |
|
Hash.prototype = nativeCreate ? nativeCreate(null) : objectProto; |
|
|
|
module.exports = Hash; |
|
|
|
|
|
/***/ }, |
|
/* 46 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var getNative = __webpack_require__(9), |
|
root = __webpack_require__(5); |
|
|
|
/* Built-in method references that are verified to be native. */ |
|
var Set = getNative(root, 'Set'); |
|
|
|
module.exports = Set; |
|
|
|
|
|
/***/ }, |
|
/* 47 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var MapCache = __webpack_require__(20), |
|
cachePush = __webpack_require__(76); |
|
|
|
/** |
|
* |
|
* Creates a set cache object to store unique values. |
|
* |
|
* @private |
|
* @constructor |
|
* @param {Array} [values] The values to cache. |
|
*/ |
|
function SetCache(values) { |
|
var index = -1, |
|
length = values ? values.length : 0; |
|
|
|
this.__data__ = new MapCache; |
|
while (++index < length) { |
|
this.push(values[index]); |
|
} |
|
} |
|
|
|
// Add functions to the `SetCache`. |
|
SetCache.prototype.push = cachePush; |
|
|
|
module.exports = SetCache; |
|
|
|
|
|
/***/ }, |
|
/* 48 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var root = __webpack_require__(5); |
|
|
|
/** Built-in value references. */ |
|
var Uint8Array = root.Uint8Array; |
|
|
|
module.exports = Uint8Array; |
|
|
|
|
|
/***/ }, |
|
/* 49 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var getNative = __webpack_require__(9), |
|
root = __webpack_require__(5); |
|
|
|
/* Built-in method references that are verified to be native. */ |
|
var WeakMap = getNative(root, 'WeakMap'); |
|
|
|
module.exports = WeakMap; |
|
|
|
|
|
/***/ }, |
|
/* 50 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
/** |
|
* A faster alternative to `Function#apply`, this function invokes `func` |
|
* with the `this` binding of `thisArg` and the arguments of `args`. |
|
* |
|
* @private |
|
* @param {Function} func The function to invoke. |
|
* @param {*} thisArg The `this` binding of `func`. |
|
* @param {...*} args The arguments to invoke `func` with. |
|
* @returns {*} Returns the result of `func`. |
|
*/ |
|
function apply(func, thisArg, args) { |
|
var length = args.length; |
|
switch (length) { |
|
case 0: return func.call(thisArg); |
|
case 1: return func.call(thisArg, args[0]); |
|
case 2: return func.call(thisArg, args[0], args[1]); |
|
case 3: return func.call(thisArg, args[0], args[1], args[2]); |
|
} |
|
return func.apply(thisArg, args); |
|
} |
|
|
|
module.exports = apply; |
|
|
|
|
|
/***/ }, |
|
/* 51 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var baseIndexOf = __webpack_require__(63); |
|
|
|
/** |
|
* A specialized version of `_.includes` for arrays without support for |
|
* specifying an index to search from. |
|
* |
|
* @private |
|
* @param {Array} array The array to search. |
|
* @param {*} target The value to search for. |
|
* @returns {boolean} Returns `true` if `target` is found, else `false`. |
|
*/ |
|
function arrayIncludes(array, value) { |
|
return !!array.length && baseIndexOf(array, value, 0) > -1; |
|
} |
|
|
|
module.exports = arrayIncludes; |
|
|
|
|
|
/***/ }, |
|
/* 52 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
/** |
|
* This function is like `arrayIncludes` except that it accepts a comparator. |
|
* |
|
* @private |
|
* @param {Array} array The array to search. |
|
* @param {*} target The value to search for. |
|
* @param {Function} comparator The comparator invoked per element. |
|
* @returns {boolean} Returns `true` if `target` is found, else `false`. |
|
*/ |
|
function arrayIncludesWith(array, value, comparator) { |
|
var index = -1, |
|
length = array.length; |
|
|
|
while (++index < length) { |
|
if (comparator(value, array[index])) { |
|
return true; |
|
} |
|
} |
|
return false; |
|
} |
|
|
|
module.exports = arrayIncludesWith; |
|
|
|
|
|
/***/ }, |
|
/* 53 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
/** |
|
* Appends the elements of `values` to `array`. |
|
* |
|
* @private |
|
* @param {Array} array The array to modify. |
|
* @param {Array} values The values to append. |
|
* @returns {Array} Returns `array`. |
|
*/ |
|
function arrayPush(array, values) { |
|
var index = -1, |
|
length = values.length, |
|
offset = array.length; |
|
|
|
while (++index < length) { |
|
array[offset + index] = values[index]; |
|
} |
|
return array; |
|
} |
|
|
|
module.exports = arrayPush; |
|
|
|
|
|
/***/ }, |
|
/* 54 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
/** |
|
* A specialized version of `_.some` for arrays without support for iteratee |
|
* shorthands. |
|
* |
|
* @private |
|
* @param {Array} array The array to iterate over. |
|
* @param {Function} predicate The function invoked per iteration. |
|
* @returns {boolean} Returns `true` if any element passes the predicate check, else `false`. |
|
*/ |
|
function arraySome(array, predicate) { |
|
var index = -1, |
|
length = array.length; |
|
|
|
while (++index < length) { |
|
if (predicate(array[index], index, array)) { |
|
return true; |
|
} |
|
} |
|
return false; |
|
} |
|
|
|
module.exports = arraySome; |
|
|
|
|
|
/***/ }, |
|
/* 55 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var SetCache = __webpack_require__(47), |
|
arrayIncludes = __webpack_require__(51), |
|
arrayIncludesWith = __webpack_require__(52), |
|
arrayMap = __webpack_require__(23), |
|
baseUnary = __webpack_require__(74), |
|
cacheHas = __webpack_require__(75); |
|
|
|
/** Used as the size to enable large array optimizations. */ |
|
var LARGE_ARRAY_SIZE = 200; |
|
|
|
/** |
|
* The base implementation of methods like `_.difference` without support for |
|
* excluding multiple arrays or iteratee shorthands. |
|
* |
|
* @private |
|
* @param {Array} array The array to inspect. |
|
* @param {Array} values The values to exclude. |
|
* @param {Function} [iteratee] The iteratee invoked per element. |
|
* @param {Function} [comparator] The comparator invoked per element. |
|
* @returns {Array} Returns the new array of filtered values. |
|
*/ |
|
function baseDifference(array, values, iteratee, comparator) { |
|
var index = -1, |
|
includes = arrayIncludes, |
|
isCommon = true, |
|
length = array.length, |
|
result = [], |
|
valuesLength = values.length; |
|
|
|
if (!length) { |
|
return result; |
|
} |
|
if (iteratee) { |
|
values = arrayMap(values, baseUnary(iteratee)); |
|
} |
|
if (comparator) { |
|
includes = arrayIncludesWith; |
|
isCommon = false; |
|
} |
|
else if (values.length >= LARGE_ARRAY_SIZE) { |
|
includes = cacheHas; |
|
isCommon = false; |
|
values = new SetCache(values); |
|
} |
|
outer: |
|
while (++index < length) { |
|
var value = array[index], |
|
computed = iteratee ? iteratee(value) : value; |
|
|
|
if (isCommon && computed === computed) { |
|
var valuesIndex = valuesLength; |
|
while (valuesIndex--) { |
|
if (values[valuesIndex] === computed) { |
|
continue outer; |
|
} |
|
} |
|
result.push(value); |
|
} |
|
else if (!includes(values, computed, comparator)) { |
|
result.push(value); |
|
} |
|
} |
|
return result; |
|
} |
|
|
|
module.exports = baseDifference; |
|
|
|
|
|
/***/ }, |
|
/* 56 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var baseForOwn = __webpack_require__(61), |
|
createBaseEach = __webpack_require__(81); |
|
|
|
/** |
|
* The base implementation of `_.forEach` without support for iteratee shorthands. |
|
* |
|
* @private |
|
* @param {Array|Object} collection The collection to iterate over. |
|
* @param {Function} iteratee The function invoked per iteration. |
|
* @returns {Array|Object} Returns `collection`. |
|
*/ |
|
var baseEach = createBaseEach(baseForOwn); |
|
|
|
module.exports = baseEach; |
|
|
|
|
|
/***/ }, |
|
/* 57 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
/** |
|
* The base implementation of methods like `_.find` and `_.findKey`, without |
|
* support for iteratee shorthands, which iterates over `collection` using |
|
* `eachFunc`. |
|
* |
|
* @private |
|
* @param {Array|Object} collection The collection to search. |
|
* @param {Function} predicate The function invoked per iteration. |
|
* @param {Function} eachFunc The function to iterate over `collection`. |
|
* @param {boolean} [retKey] Specify returning the key of the found element instead of the element itself. |
|
* @returns {*} Returns the found element or its key, else `undefined`. |
|
*/ |
|
function baseFind(collection, predicate, eachFunc, retKey) { |
|
var result; |
|
eachFunc(collection, function(value, key, collection) { |
|
if (predicate(value, key, collection)) { |
|
result = retKey ? key : value; |
|
return false; |
|
} |
|
}); |
|
return result; |
|
} |
|
|
|
module.exports = baseFind; |
|
|
|
|
|
/***/ }, |
|
/* 58 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
/** |
|
* The base implementation of `_.findIndex` and `_.findLastIndex` without |
|
* support for iteratee shorthands. |
|
* |
|
* @private |
|
* @param {Array} array The array to search. |
|
* @param {Function} predicate The function invoked per iteration. |
|
* @param {boolean} [fromRight] Specify iterating from right to left. |
|
* @returns {number} Returns the index of the matched value, else `-1`. |
|
*/ |
|
function baseFindIndex(array, predicate, fromRight) { |
|
var length = array.length, |
|
index = fromRight ? length : -1; |
|
|
|
while ((fromRight ? index-- : ++index < length)) { |
|
if (predicate(array[index], index, array)) { |
|
return index; |
|
} |
|
} |
|
return -1; |
|
} |
|
|
|
module.exports = baseFindIndex; |
|
|
|
|
|
/***/ }, |
|
/* 59 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var arrayPush = __webpack_require__(53), |
|
isArguments = __webpack_require__(16), |
|
isArray = __webpack_require__(1), |
|
isArrayLikeObject = __webpack_require__(17); |
|
|
|
/** |
|
* The base implementation of `_.flatten` with support for restricting flattening. |
|
* |
|
* @private |
|
* @param {Array} array The array to flatten. |
|
* @param {number} depth The maximum recursion depth. |
|
* @param {boolean} [isStrict] Restrict flattening to arrays-like objects. |
|
* @param {Array} [result=[]] The initial result value. |
|
* @returns {Array} Returns the new flattened array. |
|
*/ |
|
function baseFlatten(array, depth, isStrict, result) { |
|
result || (result = []); |
|
|
|
var index = -1, |
|
length = array.length; |
|
|
|
while (++index < length) { |
|
var value = array[index]; |
|
if (depth > 0 && isArrayLikeObject(value) && |
|
(isStrict || isArray(value) || isArguments(value))) { |
|
if (depth > 1) { |
|
// Recursively flatten arrays (susceptible to call stack limits). |
|
baseFlatten(value, depth - 1, isStrict, result); |
|
} else { |
|
arrayPush(result, value); |
|
} |
|
} else if (!isStrict) { |
|
result[result.length] = value; |
|
} |
|
} |
|
return result; |
|
} |
|
|
|
module.exports = baseFlatten; |
|
|
|
|
|
/***/ }, |
|
/* 60 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var createBaseFor = __webpack_require__(82); |
|
|
|
/** |
|
* The base implementation of `baseForIn` and `baseForOwn` which iterates |
|
* over `object` properties returned by `keysFunc` invoking `iteratee` for |
|
* each property. Iteratee functions may exit iteration early by explicitly |
|
* returning `false`. |
|
* |
|
* @private |
|
* @param {Object} object The object to iterate over. |
|
* @param {Function} iteratee The function invoked per iteration. |
|
* @param {Function} keysFunc The function to get the keys of `object`. |
|
* @returns {Object} Returns `object`. |
|
*/ |
|
var baseFor = createBaseFor(); |
|
|
|
module.exports = baseFor; |
|
|
|
|
|
/***/ }, |
|
/* 61 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var baseFor = __webpack_require__(60), |
|
keys = __webpack_require__(12); |
|
|
|
/** |
|
* The base implementation of `_.forOwn` without support for iteratee shorthands. |
|
* |
|
* @private |
|
* @param {Object} object The object to iterate over. |
|
* @param {Function} iteratee The function invoked per iteration. |
|
* @returns {Object} Returns `object`. |
|
*/ |
|
function baseForOwn(object, iteratee) { |
|
return object && baseFor(object, iteratee, keys); |
|
} |
|
|
|
module.exports = baseForOwn; |
|
|
|
|
|
/***/ }, |
|
/* 62 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
/** |
|
* The base implementation of `_.hasIn` without support for deep paths. |
|
* |
|
* @private |
|
* @param {Object} object The object to query. |
|
* @param {Array|string} key The key to check. |
|
* @returns {boolean} Returns `true` if `key` exists, else `false`. |
|
*/ |
|
function baseHasIn(object, key) { |
|
return key in Object(object); |
|
} |
|
|
|
module.exports = baseHasIn; |
|
|
|
|
|
/***/ }, |
|
/* 63 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var indexOfNaN = __webpack_require__(93); |
|
|
|
/** |
|
* The base implementation of `_.indexOf` without `fromIndex` bounds checks. |
|
* |
|
* @private |
|
* @param {Array} array The array to search. |
|
* @param {*} value The value to search for. |
|
* @param {number} fromIndex The index to search from. |
|
* @returns {number} Returns the index of the matched value, else `-1`. |
|
*/ |
|
function baseIndexOf(array, value, fromIndex) { |
|
if (value !== value) { |
|
return indexOfNaN(array, fromIndex); |
|
} |
|
var index = fromIndex - 1, |
|
length = array.length; |
|
|
|
while (++index < length) { |
|
if (array[index] === value) { |
|
return index; |
|
} |
|
} |
|
return -1; |
|
} |
|
|
|
module.exports = baseIndexOf; |
|
|
|
|
|
/***/ }, |
|
/* 64 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var Stack = __webpack_require__(21), |
|
equalArrays = __webpack_require__(34), |
|
equalByTag = __webpack_require__(83), |
|
equalObjects = __webpack_require__(84), |
|
getTag = __webpack_require__(87), |
|
isArray = __webpack_require__(1), |
|
isHostObject = __webpack_require__(36), |
|
isTypedArray = __webpack_require__(117); |
|
|
|
/** Used to compose bitmasks for comparison styles. */ |
|
var PARTIAL_COMPARE_FLAG = 2; |
|
|
|
/** `Object#toString` result references. */ |
|
var argsTag = '[object Arguments]', |
|
arrayTag = '[object Array]', |
|
objectTag = '[object Object]'; |
|
|
|
/** Used for built-in method references. */ |
|
var objectProto = Object.prototype; |
|
|
|
/** Used to check objects for own properties. */ |
|
var hasOwnProperty = objectProto.hasOwnProperty; |
|
|
|
/** |
|
* A specialized version of `baseIsEqual` for arrays and objects which performs |
|
* deep comparisons and tracks traversed objects enabling objects with circular |
|
* references to be compared. |
|
* |
|
* @private |
|
* @param {Object} object The object to compare. |
|
* @param {Object} other The other object to compare. |
|
* @param {Function} equalFunc The function to determine equivalents of values. |
|
* @param {Function} [customizer] The function to customize comparisons. |
|
* @param {number} [bitmask] The bitmask of comparison flags. See `baseIsEqual` for more details. |
|
* @param {Object} [stack] Tracks traversed `object` and `other` objects. |
|
* @returns {boolean} Returns `true` if the objects are equivalent, else `false`. |
|
*/ |
|
function baseIsEqualDeep(object, other, equalFunc, customizer, bitmask, stack) { |
|
var objIsArr = isArray(object), |
|
othIsArr = isArray(other), |
|
objTag = arrayTag, |
|
othTag = arrayTag; |
|
|
|
if (!objIsArr) { |
|
objTag = getTag(object); |
|
objTag = objTag == argsTag ? objectTag : objTag; |
|
} |
|
if (!othIsArr) { |
|
othTag = getTag(other); |
|
othTag = othTag == argsTag ? objectTag : othTag; |
|
} |
|
var objIsObj = objTag == objectTag && !isHostObject(object), |
|
othIsObj = othTag == objectTag && !isHostObject(other), |
|
isSameTag = objTag == othTag; |
|
|
|
if (isSameTag && !objIsObj) { |
|
stack || (stack = new Stack); |
|
return (objIsArr || isTypedArray(object)) |
|
? equalArrays(object, other, equalFunc, customizer, bitmask, stack) |
|
: equalByTag(object, other, objTag, equalFunc, customizer, bitmask, stack); |
|
} |
|
if (!(bitmask & PARTIAL_COMPARE_FLAG)) { |
|
var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'), |
|
othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__'); |
|
|
|
if (objIsWrapped || othIsWrapped) { |
|
stack || (stack = new Stack); |
|
return equalFunc(objIsWrapped ? object.value() : object, othIsWrapped ? other.value() : other, customizer, bitmask, stack); |
|
} |
|
} |
|
if (!isSameTag) { |
|
return false; |
|
} |
|
stack || (stack = new Stack); |
|
return equalObjects(object, other, equalFunc, customizer, bitmask, stack); |
|
} |
|
|
|
module.exports = baseIsEqualDeep; |
|
|
|
|
|
/***/ }, |
|
/* 65 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var Stack = __webpack_require__(21), |
|
baseIsEqual = __webpack_require__(32); |
|
|
|
/** Used to compose bitmasks for comparison styles. */ |
|
var UNORDERED_COMPARE_FLAG = 1, |
|
PARTIAL_COMPARE_FLAG = 2; |
|
|
|
/** |
|
* The base implementation of `_.isMatch` without support for iteratee shorthands. |
|
* |
|
* @private |
|
* @param {Object} object The object to inspect. |
|
* @param {Object} source The object of property values to match. |
|
* @param {Array} matchData The property names, values, and compare flags to match. |
|
* @param {Function} [customizer] The function to customize comparisons. |
|
* @returns {boolean} Returns `true` if `object` is a match, else `false`. |
|
*/ |
|
function baseIsMatch(object, source, matchData, customizer) { |
|
var index = matchData.length, |
|
length = index, |
|
noCustomizer = !customizer; |
|
|
|
if (object == null) { |
|
return !length; |
|
} |
|
object = Object(object); |
|
while (index--) { |
|
var data = matchData[index]; |
|
if ((noCustomizer && data[2]) |
|
? data[1] !== object[data[0]] |
|
: !(data[0] in object) |
|
) { |
|
return false; |
|
} |
|
} |
|
while (++index < length) { |
|
data = matchData[index]; |
|
var key = data[0], |
|
objValue = object[key], |
|
srcValue = data[1]; |
|
|
|
if (noCustomizer && data[2]) { |
|
if (objValue === undefined && !(key in object)) { |
|
return false; |
|
} |
|
} else { |
|
var stack = new Stack, |
|
result = customizer ? customizer(objValue, srcValue, key, object, source, stack) : undefined; |
|
|
|
if (!(result === undefined |
|
? baseIsEqual(srcValue, objValue, customizer, UNORDERED_COMPARE_FLAG | PARTIAL_COMPARE_FLAG, stack) |
|
: result |
|
)) { |
|
return false; |
|
} |
|
} |
|
} |
|
return true; |
|
} |
|
|
|
module.exports = baseIsMatch; |
|
|
|
|
|
/***/ }, |
|
/* 66 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var baseMatches = __webpack_require__(68), |
|
baseMatchesProperty = __webpack_require__(69), |
|
identity = __webpack_require__(114), |
|
isArray = __webpack_require__(1), |
|
property = __webpack_require__(119); |
|
|
|
/** |
|
* The base implementation of `_.iteratee`. |
|
* |
|
* @private |
|
* @param {*} [value=_.identity] The value to convert to an iteratee. |
|
* @returns {Function} Returns the iteratee. |
|
*/ |
|
function baseIteratee(value) { |
|
var type = typeof value; |
|
if (type == 'function') { |
|
return value; |
|
} |
|
if (value == null) { |
|
return identity; |
|
} |
|
if (type == 'object') { |
|
return isArray(value) |
|
? baseMatchesProperty(value[0], value[1]) |
|
: baseMatches(value); |
|
} |
|
return property(value); |
|
} |
|
|
|
module.exports = baseIteratee; |
|
|
|
|
|
/***/ }, |
|
/* 67 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
/* Built-in method references for those with the same name as other `lodash` methods. */ |
|
var nativeKeys = Object.keys; |
|
|
|
/** |
|
* The base implementation of `_.keys` which doesn't skip the constructor |
|
* property of prototypes or treat sparse arrays as dense. |
|
* |
|
* @private |
|
* @param {Object} object The object to query. |
|
* @returns {Array} Returns the array of property names. |
|
*/ |
|
function baseKeys(object) { |
|
return nativeKeys(Object(object)); |
|
} |
|
|
|
module.exports = baseKeys; |
|
|
|
|
|
/***/ }, |
|
/* 68 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var baseIsMatch = __webpack_require__(65), |
|
getMatchData = __webpack_require__(86); |
|
|
|
/** |
|
* The base implementation of `_.matches` which doesn't clone `source`. |
|
* |
|
* @private |
|
* @param {Object} source The object of property values to match. |
|
* @returns {Function} Returns the new function. |
|
*/ |
|
function baseMatches(source) { |
|
var matchData = getMatchData(source); |
|
if (matchData.length == 1 && matchData[0][2]) { |
|
var key = matchData[0][0], |
|
value = matchData[0][1]; |
|
|
|
return function(object) { |
|
if (object == null) { |
|
return false; |
|
} |
|
return object[key] === value && |
|
(value !== undefined || (key in Object(object))); |
|
}; |
|
} |
|
return function(object) { |
|
return object === source || baseIsMatch(object, source, matchData); |
|
}; |
|
} |
|
|
|
module.exports = baseMatches; |
|
|
|
|
|
/***/ }, |
|
/* 69 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var baseIsEqual = __webpack_require__(32), |
|
get = __webpack_require__(38), |
|
hasIn = __webpack_require__(113); |
|
|
|
/** Used to compose bitmasks for comparison styles. */ |
|
var UNORDERED_COMPARE_FLAG = 1, |
|
PARTIAL_COMPARE_FLAG = 2; |
|
|
|
/** |
|
* The base implementation of `_.matchesProperty` which doesn't clone `srcValue`. |
|
* |
|
* @private |
|
* @param {string} path The path of the property to get. |
|
* @param {*} srcValue The value to match. |
|
* @returns {Function} Returns the new function. |
|
*/ |
|
function baseMatchesProperty(path, srcValue) { |
|
return function(object) { |
|
var objValue = get(object, path); |
|
return (objValue === undefined && objValue === srcValue) |
|
? hasIn(object, path) |
|
: baseIsEqual(srcValue, objValue, undefined, UNORDERED_COMPARE_FLAG | PARTIAL_COMPARE_FLAG); |
|
}; |
|
} |
|
|
|
module.exports = baseMatchesProperty; |
|
|
|
|
|
/***/ }, |
|
/* 70 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var baseGet = __webpack_require__(30); |
|
|
|
/** |
|
* A specialized version of `baseProperty` which supports deep paths. |
|
* |
|
* @private |
|
* @param {Array|string} path The path of the property to get. |
|
* @returns {Function} Returns the new function. |
|
*/ |
|
function basePropertyDeep(path) { |
|
return function(object) { |
|
return baseGet(object, path); |
|
}; |
|
} |
|
|
|
module.exports = basePropertyDeep; |
|
|
|
|
|
/***/ }, |
|
/* 71 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
/** |
|
* The base implementation of `_.slice` without an iteratee call guard. |
|
* |
|
* @private |
|
* @param {Array} array The array to slice. |
|
* @param {number} [start=0] The start position. |
|
* @param {number} [end=array.length] The end position. |
|
* @returns {Array} Returns the slice of `array`. |
|
*/ |
|
function baseSlice(array, start, end) { |
|
var index = -1, |
|
length = array.length; |
|
|
|
if (start < 0) { |
|
start = -start > length ? 0 : (length + start); |
|
} |
|
end = end > length ? length : end; |
|
if (end < 0) { |
|
end += length; |
|
} |
|
length = start > end ? 0 : ((end - start) >>> 0); |
|
start >>>= 0; |
|
|
|
var result = Array(length); |
|
while (++index < length) { |
|
result[index] = array[index + start]; |
|
} |
|
return result; |
|
} |
|
|
|
module.exports = baseSlice; |
|
|
|
|
|
/***/ }, |
|
/* 72 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
/** |
|
* The base implementation of `_.times` without support for iteratee shorthands |
|
* or max array length checks. |
|
* |
|
* @private |
|
* @param {number} n The number of times to invoke `iteratee`. |
|
* @param {Function} iteratee The function invoked per iteration. |
|
* @returns {Array} Returns the array of results. |
|
*/ |
|
function baseTimes(n, iteratee) { |
|
var index = -1, |
|
result = Array(n); |
|
|
|
while (++index < n) { |
|
result[index] = iteratee(index); |
|
} |
|
return result; |
|
} |
|
|
|
module.exports = baseTimes; |
|
|
|
|
|
/***/ }, |
|
/* 73 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var arrayMap = __webpack_require__(23); |
|
|
|
/** |
|
* The base implementation of `_.toPairs` and `_.toPairsIn` which creates an array |
|
* of key-value pairs for `object` corresponding to the property names of `props`. |
|
* |
|
* @private |
|
* @param {Object} object The object to query. |
|
* @param {Array} props The property names to get values for. |
|
* @returns {Object} Returns the new array of key-value pairs. |
|
*/ |
|
function baseToPairs(object, props) { |
|
return arrayMap(props, function(key) { |
|
return [key, object[key]]; |
|
}); |
|
} |
|
|
|
module.exports = baseToPairs; |
|
|
|
|
|
/***/ }, |
|
/* 74 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
/** |
|
* The base implementation of `_.unary` without support for storing wrapper metadata. |
|
* |
|
* @private |
|
* @param {Function} func The function to cap arguments for. |
|
* @returns {Function} Returns the new function. |
|
*/ |
|
function baseUnary(func) { |
|
return function(value) { |
|
return func(value); |
|
}; |
|
} |
|
|
|
module.exports = baseUnary; |
|
|
|
|
|
/***/ }, |
|
/* 75 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var isKeyable = __webpack_require__(3); |
|
|
|
/** Used to stand-in for `undefined` hash values. */ |
|
var HASH_UNDEFINED = '__lodash_hash_undefined__'; |
|
|
|
/** |
|
* Checks if `value` is in `cache`. |
|
* |
|
* @private |
|
* @param {Object} cache The set cache to search. |
|
* @param {*} value The value to search for. |
|
* @returns {number} Returns `true` if `value` is found, else `false`. |
|
*/ |
|
function cacheHas(cache, value) { |
|
var map = cache.__data__; |
|
if (isKeyable(value)) { |
|
var data = map.__data__, |
|
hash = typeof value == 'string' ? data.string : data.hash; |
|
|
|
return hash[value] === HASH_UNDEFINED; |
|
} |
|
return map.has(value); |
|
} |
|
|
|
module.exports = cacheHas; |
|
|
|
|
|
/***/ }, |
|
/* 76 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var isKeyable = __webpack_require__(3); |
|
|
|
/** Used to stand-in for `undefined` hash values. */ |
|
var HASH_UNDEFINED = '__lodash_hash_undefined__'; |
|
|
|
/** |
|
* Adds `value` to the set cache. |
|
* |
|
* @private |
|
* @name push |
|
* @memberOf SetCache |
|
* @param {*} value The value to cache. |
|
*/ |
|
function cachePush(value) { |
|
var map = this.__data__; |
|
if (isKeyable(value)) { |
|
var data = map.__data__, |
|
hash = typeof value == 'string' ? data.string : data.hash; |
|
|
|
hash[value] = HASH_UNDEFINED; |
|
} |
|
else { |
|
map.set(value, HASH_UNDEFINED); |
|
} |
|
} |
|
|
|
module.exports = cachePush; |
|
|
|
|
|
/***/ }, |
|
/* 77 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
/** |
|
* Checks if `value` is a global object. |
|
* |
|
* @private |
|
* @param {*} value The value to check. |
|
* @returns {null|Object} Returns `value` if it's a global object, else `null`. |
|
*/ |
|
function checkGlobal(value) { |
|
return (value && value.Object === Object) ? value : null; |
|
} |
|
|
|
module.exports = checkGlobal; |
|
|
|
|
|
/***/ }, |
|
/* 78 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var copyObjectWith = __webpack_require__(79); |
|
|
|
/** |
|
* Copies properties of `source` to `object`. |
|
* |
|
* @private |
|
* @param {Object} source The object to copy properties from. |
|
* @param {Array} props The property names to copy. |
|
* @param {Object} [object={}] The object to copy properties to. |
|
* @returns {Object} Returns `object`. |
|
*/ |
|
function copyObject(source, props, object) { |
|
return copyObjectWith(source, props, object); |
|
} |
|
|
|
module.exports = copyObject; |
|
|
|
|
|
/***/ }, |
|
/* 79 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var assignValue = __webpack_require__(24); |
|
|
|
/** |
|
* This function is like `copyObject` except that it accepts a function to |
|
* customize copied values. |
|
* |
|
* @private |
|
* @param {Object} source The object to copy properties from. |
|
* @param {Array} props The property names to copy. |
|
* @param {Object} [object={}] The object to copy properties to. |
|
* @param {Function} [customizer] The function to customize copied values. |
|
* @returns {Object} Returns `object`. |
|
*/ |
|
function copyObjectWith(source, props, object, customizer) { |
|
object || (object = {}); |
|
|
|
var index = -1, |
|
length = props.length; |
|
|
|
while (++index < length) { |
|
var key = props[index]; |
|
|
|
var newValue = customizer |
|
? customizer(object[key], source[key], key, object, source) |
|
: source[key]; |
|
|
|
assignValue(object, key, newValue); |
|
} |
|
return object; |
|
} |
|
|
|
module.exports = copyObjectWith; |
|
|
|
|
|
/***/ }, |
|
/* 80 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var isIterateeCall = __webpack_require__(94), |
|
rest = __webpack_require__(40); |
|
|
|
/** |
|
* Creates a function like `_.assign`. |
|
* |
|
* @private |
|
* @param {Function} assigner The function to assign values. |
|
* @returns {Function} Returns the new assigner function. |
|
*/ |
|
function createAssigner(assigner) { |
|
return rest(function(object, sources) { |
|
var index = -1, |
|
length = sources.length, |
|
customizer = length > 1 ? sources[length - 1] : undefined, |
|
guard = length > 2 ? sources[2] : undefined; |
|
|
|
customizer = typeof customizer == 'function' |
|
? (length--, customizer) |
|
: undefined; |
|
|
|
if (guard && isIterateeCall(sources[0], sources[1], guard)) { |
|
customizer = length < 3 ? undefined : customizer; |
|
length = 1; |
|
} |
|
object = Object(object); |
|
while (++index < length) { |
|
var source = sources[index]; |
|
if (source) { |
|
assigner(object, source, index, customizer); |
|
} |
|
} |
|
return object; |
|
}); |
|
} |
|
|
|
module.exports = createAssigner; |
|
|
|
|
|
/***/ }, |
|
/* 81 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var isArrayLike = __webpack_require__(6); |
|
|
|
/** |
|
* Creates a `baseEach` or `baseEachRight` function. |
|
* |
|
* @private |
|
* @param {Function} eachFunc The function to iterate over a collection. |
|
* @param {boolean} [fromRight] Specify iterating from right to left. |
|
* @returns {Function} Returns the new base function. |
|
*/ |
|
function createBaseEach(eachFunc, fromRight) { |
|
return function(collection, iteratee) { |
|
if (collection == null) { |
|
return collection; |
|
} |
|
if (!isArrayLike(collection)) { |
|
return eachFunc(collection, iteratee); |
|
} |
|
var length = collection.length, |
|
index = fromRight ? length : -1, |
|
iterable = Object(collection); |
|
|
|
while ((fromRight ? index-- : ++index < length)) { |
|
if (iteratee(iterable[index], index, iterable) === false) { |
|
break; |
|
} |
|
} |
|
return collection; |
|
}; |
|
} |
|
|
|
module.exports = createBaseEach; |
|
|
|
|
|
/***/ }, |
|
/* 82 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
/** |
|
* Creates a base function for methods like `_.forIn`. |
|
* |
|
* @private |
|
* @param {boolean} [fromRight] Specify iterating from right to left. |
|
* @returns {Function} Returns the new base function. |
|
*/ |
|
function createBaseFor(fromRight) { |
|
return function(object, iteratee, keysFunc) { |
|
var index = -1, |
|
iterable = Object(object), |
|
props = keysFunc(object), |
|
length = props.length; |
|
|
|
while (length--) { |
|
var key = props[fromRight ? length : ++index]; |
|
if (iteratee(iterable[key], key, iterable) === false) { |
|
break; |
|
} |
|
} |
|
return object; |
|
}; |
|
} |
|
|
|
module.exports = createBaseFor; |
|
|
|
|
|
/***/ }, |
|
/* 83 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var Symbol = __webpack_require__(22), |
|
Uint8Array = __webpack_require__(48), |
|
equalArrays = __webpack_require__(34), |
|
mapToArray = __webpack_require__(101), |
|
setToArray = __webpack_require__(103); |
|
|
|
/** Used to compose bitmasks for comparison styles. */ |
|
var UNORDERED_COMPARE_FLAG = 1, |
|
PARTIAL_COMPARE_FLAG = 2; |
|
|
|
/** `Object#toString` result references. */ |
|
var boolTag = '[object Boolean]', |
|
dateTag = '[object Date]', |
|
errorTag = '[object Error]', |
|
mapTag = '[object Map]', |
|
numberTag = '[object Number]', |
|
regexpTag = '[object RegExp]', |
|
setTag = '[object Set]', |
|
stringTag = '[object String]', |
|
symbolTag = '[object Symbol]'; |
|
|
|
var arrayBufferTag = '[object ArrayBuffer]'; |
|
|
|
/** Used to convert symbols to primitives and strings. */ |
|
var symbolProto = Symbol ? Symbol.prototype : undefined, |
|
symbolValueOf = symbolProto ? symbolProto.valueOf : undefined; |
|
|
|
/** |
|
* A specialized version of `baseIsEqualDeep` for comparing objects of |
|
* the same `toStringTag`. |
|
* |
|
* **Note:** This function only supports comparing values with tags of |
|
* `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`. |
|
* |
|
* @private |
|
* @param {Object} object The object to compare. |
|
* @param {Object} other The other object to compare. |
|
* @param {string} tag The `toStringTag` of the objects to compare. |
|
* @param {Function} equalFunc The function to determine equivalents of values. |
|
* @param {Function} customizer The function to customize comparisons. |
|
* @param {number} bitmask The bitmask of comparison flags. See `baseIsEqual` for more details. |
|
* @param {Object} stack Tracks traversed `object` and `other` objects. |
|
* @returns {boolean} Returns `true` if the objects are equivalent, else `false`. |
|
*/ |
|
function equalByTag(object, other, tag, equalFunc, customizer, bitmask, stack) { |
|
switch (tag) { |
|
case arrayBufferTag: |
|
if ((object.byteLength != other.byteLength) || |
|
!equalFunc(new Uint8Array(object), new Uint8Array(other))) { |
|
return false; |
|
} |
|
return true; |
|
|
|
case boolTag: |
|
case dateTag: |
|
// Coerce dates and booleans to numbers, dates to milliseconds and booleans |
|
// to `1` or `0` treating invalid dates coerced to `NaN` as not equal. |
|
return +object == +other; |
|
|
|
case errorTag: |
|
return object.name == other.name && object.message == other.message; |
|
|
|
case numberTag: |
|
// Treat `NaN` vs. `NaN` as equal. |
|
return (object != +object) ? other != +other : object == +other; |
|
|
|
case regexpTag: |
|
case stringTag: |
|
// Coerce regexes to strings and treat strings primitives and string |
|
// objects as equal. See https://es5.github.io/#x15.10.6.4 for more details. |
|
return object == (other + ''); |
|
|
|
case mapTag: |
|
var convert = mapToArray; |
|
|
|
case setTag: |
|
var isPartial = bitmask & PARTIAL_COMPARE_FLAG; |
|
convert || (convert = setToArray); |
|
|
|
if (object.size != other.size && !isPartial) { |
|
return false; |
|
} |
|
// Assume cyclic values are equal. |
|
var stacked = stack.get(object); |
|
if (stacked) { |
|
return stacked == other; |
|
} |
|
// Recursively compare objects (susceptible to call stack limits). |
|
return equalArrays(convert(object), convert(other), equalFunc, customizer, bitmask | UNORDERED_COMPARE_FLAG, stack.set(object, other)); |
|
|
|
case symbolTag: |
|
if (symbolValueOf) { |
|
return symbolValueOf.call(object) == symbolValueOf.call(other); |
|
} |
|
} |
|
return false; |
|
} |
|
|
|
module.exports = equalByTag; |
|
|
|
|
|
/***/ }, |
|
/* 84 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var baseHas = __webpack_require__(31), |
|
keys = __webpack_require__(12); |
|
|
|
/** Used to compose bitmasks for comparison styles. */ |
|
var PARTIAL_COMPARE_FLAG = 2; |
|
|
|
/** |
|
* A specialized version of `baseIsEqualDeep` for objects with support for |
|
* partial deep comparisons. |
|
* |
|
* @private |
|
* @param {Object} object The object to compare. |
|
* @param {Object} other The other object to compare. |
|
* @param {Function} equalFunc The function to determine equivalents of values. |
|
* @param {Function} customizer The function to customize comparisons. |
|
* @param {number} bitmask The bitmask of comparison flags. See `baseIsEqual` for more details. |
|
* @param {Object} stack Tracks traversed `object` and `other` objects. |
|
* @returns {boolean} Returns `true` if the objects are equivalent, else `false`. |
|
*/ |
|
function equalObjects(object, other, equalFunc, customizer, bitmask, stack) { |
|
var isPartial = bitmask & PARTIAL_COMPARE_FLAG, |
|
objProps = keys(object), |
|
objLength = objProps.length, |
|
othProps = keys(other), |
|
othLength = othProps.length; |
|
|
|
if (objLength != othLength && !isPartial) { |
|
return false; |
|
} |
|
var index = objLength; |
|
while (index--) { |
|
var key = objProps[index]; |
|
if (!(isPartial ? key in other : baseHas(other, key))) { |
|
return false; |
|
} |
|
} |
|
// Assume cyclic values are equal. |
|
var stacked = stack.get(object); |
|
if (stacked) { |
|
return stacked == other; |
|
} |
|
var result = true; |
|
stack.set(object, other); |
|
|
|
var skipCtor = isPartial; |
|
while (++index < objLength) { |
|
key = objProps[index]; |
|
var objValue = object[key], |
|
othValue = other[key]; |
|
|
|
if (customizer) { |
|
var compared = isPartial |
|
? customizer(othValue, objValue, key, other, object, stack) |
|
: customizer(objValue, othValue, key, object, other, stack); |
|
} |
|
// Recursively compare objects (susceptible to call stack limits). |
|
if (!(compared === undefined |
|
? (objValue === othValue || equalFunc(objValue, othValue, customizer, bitmask, stack)) |
|
: compared |
|
)) { |
|
result = false; |
|
break; |
|
} |
|
skipCtor || (skipCtor = key == 'constructor'); |
|
} |
|
if (result && !skipCtor) { |
|
var objCtor = object.constructor, |
|
othCtor = other.constructor; |
|
|
|
// Non `Object` object instances with different constructors are not equal. |
|
if (objCtor != othCtor && |
|
('constructor' in object && 'constructor' in other) && |
|
!(typeof objCtor == 'function' && objCtor instanceof objCtor && |
|
typeof othCtor == 'function' && othCtor instanceof othCtor)) { |
|
result = false; |
|
} |
|
} |
|
stack['delete'](object); |
|
return result; |
|
} |
|
|
|
module.exports = equalObjects; |
|
|
|
|
|
/***/ }, |
|
/* 85 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var baseProperty = __webpack_require__(33); |
|
|
|
/** |
|
* Gets the "length" property value of `object`. |
|
* |
|
* **Note:** This function is used to avoid a [JIT bug](https://bugs.webkit.org/show_bug.cgi?id=142792) |
|
* that affects Safari on at least iOS 8.1-8.3 ARM64. |
|
* |
|
* @private |
|
* @param {Object} object The object to query. |
|
* @returns {*} Returns the "length" value. |
|
*/ |
|
var getLength = baseProperty('length'); |
|
|
|
module.exports = getLength; |
|
|
|
|
|
/***/ }, |
|
/* 86 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var isStrictComparable = __webpack_require__(95), |
|
toPairs = __webpack_require__(122); |
|
|
|
/** |
|
* Gets the property names, values, and compare flags of `object`. |
|
* |
|
* @private |
|
* @param {Object} object The object to query. |
|
* @returns {Array} Returns the match data of `object`. |
|
*/ |
|
function getMatchData(object) { |
|
var result = toPairs(object), |
|
length = result.length; |
|
|
|
while (length--) { |
|
result[length][2] = isStrictComparable(result[length][1]); |
|
} |
|
return result; |
|
} |
|
|
|
module.exports = getMatchData; |
|
|
|
|
|
/***/ }, |
|
/* 87 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var Map = __webpack_require__(2), |
|
Set = __webpack_require__(46), |
|
WeakMap = __webpack_require__(49); |
|
|
|
/** `Object#toString` result references. */ |
|
var mapTag = '[object Map]', |
|
objectTag = '[object Object]', |
|
setTag = '[object Set]', |
|
weakMapTag = '[object WeakMap]'; |
|
|
|
/** Used for built-in method references. */ |
|
var objectProto = Object.prototype; |
|
|
|
/** Used to resolve the decompiled source of functions. */ |
|
var funcToString = Function.prototype.toString; |
|
|
|
/** |
|
* Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring) |
|
* of values. |
|
*/ |
|
var objectToString = objectProto.toString; |
|
|
|
/** Used to detect maps, sets, and weakmaps. */ |
|
var mapCtorString = Map ? funcToString.call(Map) : '', |
|
setCtorString = Set ? funcToString.call(Set) : '', |
|
weakMapCtorString = WeakMap ? funcToString.call(WeakMap) : ''; |
|
|
|
/** |
|
* Gets the `toStringTag` of `value`. |
|
* |
|
* @private |
|
* @param {*} value The value to query. |
|
* @returns {string} Returns the `toStringTag`. |
|
*/ |
|
function getTag(value) { |
|
return objectToString.call(value); |
|
} |
|
|
|
// Fallback for IE 11 providing `toStringTag` values for maps, sets, and weakmaps. |
|
if ((Map && getTag(new Map) != mapTag) || |
|
(Set && getTag(new Set) != setTag) || |
|
(WeakMap && getTag(new WeakMap) != weakMapTag)) { |
|
getTag = function(value) { |
|
var result = objectToString.call(value), |
|
Ctor = result == objectTag ? value.constructor : null, |
|
ctorString = typeof Ctor == 'function' ? funcToString.call(Ctor) : ''; |
|
|
|
if (ctorString) { |
|
switch (ctorString) { |
|
case mapCtorString: return mapTag; |
|
case setCtorString: return setTag; |
|
case weakMapCtorString: return weakMapTag; |
|
} |
|
} |
|
return result; |
|
}; |
|
} |
|
|
|
module.exports = getTag; |
|
|
|
|
|
/***/ }, |
|
/* 88 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var baseCastPath = __webpack_require__(29), |
|
isArguments = __webpack_require__(16), |
|
isArray = __webpack_require__(1), |
|
isIndex = __webpack_require__(13), |
|
isKey = __webpack_require__(14), |
|
isLength = __webpack_require__(11), |
|
isString = __webpack_require__(39), |
|
last = __webpack_require__(118), |
|
parent = __webpack_require__(102); |
|
|
|
/** |
|
* Checks if `path` exists on `object`. |
|
* |
|
* @private |
|
* @param {Object} object The object to query. |
|
* @param {Array|string} path The path to check. |
|
* @param {Function} hasFunc The function to check properties. |
|
* @returns {boolean} Returns `true` if `path` exists, else `false`. |
|
*/ |
|
function hasPath(object, path, hasFunc) { |
|
if (object == null) { |
|
return false; |
|
} |
|
var result = hasFunc(object, path); |
|
if (!result && !isKey(path)) { |
|
path = baseCastPath(path); |
|
object = parent(object, path); |
|
if (object != null) { |
|
path = last(path); |
|
result = hasFunc(object, path); |
|
} |
|
} |
|
var length = object ? object.length : undefined; |
|
return result || ( |
|
!!length && isLength(length) && isIndex(path, length) && |
|
(isArray(object) || isString(object) || isArguments(object)) |
|
); |
|
} |
|
|
|
module.exports = hasPath; |
|
|
|
|
|
/***/ }, |
|
/* 89 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var hashHas = __webpack_require__(35); |
|
|
|
/** |
|
* Removes `key` and its value from the hash. |
|
* |
|
* @private |
|
* @param {Object} hash The hash to modify. |
|
* @param {string} key The key of the value to remove. |
|
* @returns {boolean} Returns `true` if the entry was removed, else `false`. |
|
*/ |
|
function hashDelete(hash, key) { |
|
return hashHas(hash, key) && delete hash[key]; |
|
} |
|
|
|
module.exports = hashDelete; |
|
|
|
|
|
/***/ }, |
|
/* 90 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var nativeCreate = __webpack_require__(10); |
|
|
|
/** Used to stand-in for `undefined` hash values. */ |
|
var HASH_UNDEFINED = '__lodash_hash_undefined__'; |
|
|
|
/** Used for built-in method references. */ |
|
var objectProto = Object.prototype; |
|
|
|
/** Used to check objects for own properties. */ |
|
var hasOwnProperty = objectProto.hasOwnProperty; |
|
|
|
/** |
|
* Gets the hash value for `key`. |
|
* |
|
* @private |
|
* @param {Object} hash The hash to query. |
|
* @param {string} key The key of the value to get. |
|
* @returns {*} Returns the entry value. |
|
*/ |
|
function hashGet(hash, key) { |
|
if (nativeCreate) { |
|
var result = hash[key]; |
|
return result === HASH_UNDEFINED ? undefined : result; |
|
} |
|
return hasOwnProperty.call(hash, key) ? hash[key] : undefined; |
|
} |
|
|
|
module.exports = hashGet; |
|
|
|
|
|
/***/ }, |
|
/* 91 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var nativeCreate = __webpack_require__(10); |
|
|
|
/** Used to stand-in for `undefined` hash values. */ |
|
var HASH_UNDEFINED = '__lodash_hash_undefined__'; |
|
|
|
/** |
|
* Sets the hash `key` to `value`. |
|
* |
|
* @private |
|
* @param {Object} hash The hash to modify. |
|
* @param {string} key The key of the value to set. |
|
* @param {*} value The value to set. |
|
*/ |
|
function hashSet(hash, key, value) { |
|
hash[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value; |
|
} |
|
|
|
module.exports = hashSet; |
|
|
|
|
|
/***/ }, |
|
/* 92 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var baseTimes = __webpack_require__(72), |
|
isArguments = __webpack_require__(16), |
|
isArray = __webpack_require__(1), |
|
isLength = __webpack_require__(11), |
|
isString = __webpack_require__(39); |
|
|
|
/** |
|
* Creates an array of index keys for `object` values of arrays, |
|
* `arguments` objects, and strings, otherwise `null` is returned. |
|
* |
|
* @private |
|
* @param {Object} object The object to query. |
|
* @returns {Array|null} Returns index keys, else `null`. |
|
*/ |
|
function indexKeys(object) { |
|
var length = object ? object.length : undefined; |
|
if (isLength(length) && |
|
(isArray(object) || isString(object) || isArguments(object))) { |
|
return baseTimes(length, String); |
|
} |
|
return null; |
|
} |
|
|
|
module.exports = indexKeys; |
|
|
|
|
|
/***/ }, |
|
/* 93 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
/** |
|
* Gets the index at which the first occurrence of `NaN` is found in `array`. |
|
* |
|
* @private |
|
* @param {Array} array The array to search. |
|
* @param {number} fromIndex The index to search from. |
|
* @param {boolean} [fromRight] Specify iterating from right to left. |
|
* @returns {number} Returns the index of the matched `NaN`, else `-1`. |
|
*/ |
|
function indexOfNaN(array, fromIndex, fromRight) { |
|
var length = array.length, |
|
index = fromIndex + (fromRight ? 0 : -1); |
|
|
|
while ((fromRight ? index-- : ++index < length)) { |
|
var other = array[index]; |
|
if (other !== other) { |
|
return index; |
|
} |
|
} |
|
return -1; |
|
} |
|
|
|
module.exports = indexOfNaN; |
|
|
|
|
|
/***/ }, |
|
/* 94 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var eq = __webpack_require__(15), |
|
isArrayLike = __webpack_require__(6), |
|
isIndex = __webpack_require__(13), |
|
isObject = __webpack_require__(7); |
|
|
|
/** |
|
* Checks if the given arguments are from an iteratee call. |
|
* |
|
* @private |
|
* @param {*} value The potential iteratee value argument. |
|
* @param {*} index The potential iteratee index or key argument. |
|
* @param {*} object The potential iteratee object argument. |
|
* @returns {boolean} Returns `true` if the arguments are from an iteratee call, else `false`. |
|
*/ |
|
function isIterateeCall(value, index, object) { |
|
if (!isObject(object)) { |
|
return false; |
|
} |
|
var type = typeof index; |
|
if (type == 'number' |
|
? (isArrayLike(object) && isIndex(index, object.length)) |
|
: (type == 'string' && index in object)) { |
|
return eq(object[index], value); |
|
} |
|
return false; |
|
} |
|
|
|
module.exports = isIterateeCall; |
|
|
|
|
|
/***/ }, |
|
/* 95 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var isObject = __webpack_require__(7); |
|
|
|
/** |
|
* Checks if `value` is suitable for strict equality comparisons, i.e. `===`. |
|
* |
|
* @private |
|
* @param {*} value The value to check. |
|
* @returns {boolean} Returns `true` if `value` if suitable for strict |
|
* equality comparisons, else `false`. |
|
*/ |
|
function isStrictComparable(value) { |
|
return value === value && !isObject(value); |
|
} |
|
|
|
module.exports = isStrictComparable; |
|
|
|
|
|
/***/ }, |
|
/* 96 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var Hash = __webpack_require__(45), |
|
Map = __webpack_require__(2); |
|
|
|
/** |
|
* Removes all key-value entries from the map. |
|
* |
|
* @private |
|
* @name clear |
|
* @memberOf MapCache |
|
*/ |
|
function mapClear() { |
|
this.__data__ = { |
|
'hash': new Hash, |
|
'map': Map ? new Map : [], |
|
'string': new Hash |
|
}; |
|
} |
|
|
|
module.exports = mapClear; |
|
|
|
|
|
/***/ }, |
|
/* 97 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var Map = __webpack_require__(2), |
|
assocDelete = __webpack_require__(25), |
|
hashDelete = __webpack_require__(89), |
|
isKeyable = __webpack_require__(3); |
|
|
|
/** |
|
* Removes `key` and its value from the map. |
|
* |
|
* @private |
|
* @name delete |
|
* @memberOf MapCache |
|
* @param {string} key The key of the value to remove. |
|
* @returns {boolean} Returns `true` if the entry was removed, else `false`. |
|
*/ |
|
function mapDelete(key) { |
|
var data = this.__data__; |
|
if (isKeyable(key)) { |
|
return hashDelete(typeof key == 'string' ? data.string : data.hash, key); |
|
} |
|
return Map ? data.map['delete'](key) : assocDelete(data.map, key); |
|
} |
|
|
|
module.exports = mapDelete; |
|
|
|
|
|
/***/ }, |
|
/* 98 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var Map = __webpack_require__(2), |
|
assocGet = __webpack_require__(26), |
|
hashGet = __webpack_require__(90), |
|
isKeyable = __webpack_require__(3); |
|
|
|
/** |
|
* Gets the map value for `key`. |
|
* |
|
* @private |
|
* @name get |
|
* @memberOf MapCache |
|
* @param {string} key The key of the value to get. |
|
* @returns {*} Returns the entry value. |
|
*/ |
|
function mapGet(key) { |
|
var data = this.__data__; |
|
if (isKeyable(key)) { |
|
return hashGet(typeof key == 'string' ? data.string : data.hash, key); |
|
} |
|
return Map ? data.map.get(key) : assocGet(data.map, key); |
|
} |
|
|
|
module.exports = mapGet; |
|
|
|
|
|
/***/ }, |
|
/* 99 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var Map = __webpack_require__(2), |
|
assocHas = __webpack_require__(27), |
|
hashHas = __webpack_require__(35), |
|
isKeyable = __webpack_require__(3); |
|
|
|
/** |
|
* Checks if a map value for `key` exists. |
|
* |
|
* @private |
|
* @name has |
|
* @memberOf MapCache |
|
* @param {string} key The key of the entry to check. |
|
* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. |
|
*/ |
|
function mapHas(key) { |
|
var data = this.__data__; |
|
if (isKeyable(key)) { |
|
return hashHas(typeof key == 'string' ? data.string : data.hash, key); |
|
} |
|
return Map ? data.map.has(key) : assocHas(data.map, key); |
|
} |
|
|
|
module.exports = mapHas; |
|
|
|
|
|
/***/ }, |
|
/* 100 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var Map = __webpack_require__(2), |
|
assocSet = __webpack_require__(28), |
|
hashSet = __webpack_require__(91), |
|
isKeyable = __webpack_require__(3); |
|
|
|
/** |
|
* Sets the map `key` to `value`. |
|
* |
|
* @private |
|
* @name set |
|
* @memberOf MapCache |
|
* @param {string} key The key of the value to set. |
|
* @param {*} value The value to set. |
|
* @returns {Object} Returns the map cache object. |
|
*/ |
|
function mapSet(key, value) { |
|
var data = this.__data__; |
|
if (isKeyable(key)) { |
|
hashSet(typeof key == 'string' ? data.string : data.hash, key, value); |
|
} else if (Map) { |
|
data.map.set(key, value); |
|
} else { |
|
assocSet(data.map, key, value); |
|
} |
|
return this; |
|
} |
|
|
|
module.exports = mapSet; |
|
|
|
|
|
/***/ }, |
|
/* 101 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
/** |
|
* Converts `map` to an array. |
|
* |
|
* @private |
|
* @param {Object} map The map to convert. |
|
* @returns {Array} Returns the converted array. |
|
*/ |
|
function mapToArray(map) { |
|
var index = -1, |
|
result = Array(map.size); |
|
|
|
map.forEach(function(value, key) { |
|
result[++index] = [key, value]; |
|
}); |
|
return result; |
|
} |
|
|
|
module.exports = mapToArray; |
|
|
|
|
|
/***/ }, |
|
/* 102 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var baseSlice = __webpack_require__(71), |
|
get = __webpack_require__(38); |
|
|
|
/** |
|
* Gets the parent value at `path` of `object`. |
|
* |
|
* @private |
|
* @param {Object} object The object to query. |
|
* @param {Array} path The path to get the parent value of. |
|
* @returns {*} Returns the parent value. |
|
*/ |
|
function parent(object, path) { |
|
return path.length == 1 ? object : get(object, baseSlice(path, 0, -1)); |
|
} |
|
|
|
module.exports = parent; |
|
|
|
|
|
/***/ }, |
|
/* 103 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
/** |
|
* Converts `set` to an array. |
|
* |
|
* @private |
|
* @param {Object} set The set to convert. |
|
* @returns {Array} Returns the converted array. |
|
*/ |
|
function setToArray(set) { |
|
var index = -1, |
|
result = Array(set.size); |
|
|
|
set.forEach(function(value) { |
|
result[++index] = value; |
|
}); |
|
return result; |
|
} |
|
|
|
module.exports = setToArray; |
|
|
|
|
|
/***/ }, |
|
/* 104 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
/** |
|
* Removes all key-value entries from the stack. |
|
* |
|
* @private |
|
* @name clear |
|
* @memberOf Stack |
|
*/ |
|
function stackClear() { |
|
this.__data__ = { 'array': [], 'map': null }; |
|
} |
|
|
|
module.exports = stackClear; |
|
|
|
|
|
/***/ }, |
|
/* 105 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var assocDelete = __webpack_require__(25); |
|
|
|
/** |
|
* Removes `key` and its value from the stack. |
|
* |
|
* @private |
|
* @name delete |
|
* @memberOf Stack |
|
* @param {string} key The key of the value to remove. |
|
* @returns {boolean} Returns `true` if the entry was removed, else `false`. |
|
*/ |
|
function stackDelete(key) { |
|
var data = this.__data__, |
|
array = data.array; |
|
|
|
return array ? assocDelete(array, key) : data.map['delete'](key); |
|
} |
|
|
|
module.exports = stackDelete; |
|
|
|
|
|
/***/ }, |
|
/* 106 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var assocGet = __webpack_require__(26); |
|
|
|
/** |
|
* Gets the stack value for `key`. |
|
* |
|
* @private |
|
* @name get |
|
* @memberOf Stack |
|
* @param {string} key The key of the value to get. |
|
* @returns {*} Returns the entry value. |
|
*/ |
|
function stackGet(key) { |
|
var data = this.__data__, |
|
array = data.array; |
|
|
|
return array ? assocGet(array, key) : data.map.get(key); |
|
} |
|
|
|
module.exports = stackGet; |
|
|
|
|
|
/***/ }, |
|
/* 107 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var assocHas = __webpack_require__(27); |
|
|
|
/** |
|
* Checks if a stack value for `key` exists. |
|
* |
|
* @private |
|
* @name has |
|
* @memberOf Stack |
|
* @param {string} key The key of the entry to check. |
|
* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. |
|
*/ |
|
function stackHas(key) { |
|
var data = this.__data__, |
|
array = data.array; |
|
|
|
return array ? assocHas(array, key) : data.map.has(key); |
|
} |
|
|
|
module.exports = stackHas; |
|
|
|
|
|
/***/ }, |
|
/* 108 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var MapCache = __webpack_require__(20), |
|
assocSet = __webpack_require__(28); |
|
|
|
/** Used as the size to enable large array optimizations. */ |
|
var LARGE_ARRAY_SIZE = 200; |
|
|
|
/** |
|
* Sets the stack `key` to `value`. |
|
* |
|
* @private |
|
* @name set |
|
* @memberOf Stack |
|
* @param {string} key The key of the value to set. |
|
* @param {*} value The value to set. |
|
* @returns {Object} Returns the stack cache object. |
|
*/ |
|
function stackSet(key, value) { |
|
var data = this.__data__, |
|
array = data.array; |
|
|
|
if (array) { |
|
if (array.length < (LARGE_ARRAY_SIZE - 1)) { |
|
assocSet(array, key, value); |
|
} else { |
|
data.array = null; |
|
data.map = new MapCache(array); |
|
} |
|
} |
|
var map = data.map; |
|
if (map) { |
|
map.set(key, value); |
|
} |
|
return this; |
|
} |
|
|
|
module.exports = stackSet; |
|
|
|
|
|
/***/ }, |
|
/* 109 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var toString = __webpack_require__(123); |
|
|
|
/** Used to match property names within property paths. */ |
|
var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]/g; |
|
|
|
/** Used to match backslashes in property paths. */ |
|
var reEscapeChar = /\\(\\)?/g; |
|
|
|
/** |
|
* Converts `string` to a property path array. |
|
* |
|
* @private |
|
* @param {string} string The string to convert. |
|
* @returns {Array} Returns the property path array. |
|
*/ |
|
function stringToPath(string) { |
|
var result = []; |
|
toString(string).replace(rePropName, function(match, number, quote, string) { |
|
result.push(quote ? string.replace(reEscapeChar, '$1') : (number || match)); |
|
}); |
|
return result; |
|
} |
|
|
|
module.exports = stringToPath; |
|
|
|
|
|
/***/ }, |
|
/* 110 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var assignValue = __webpack_require__(24), |
|
copyObject = __webpack_require__(78), |
|
createAssigner = __webpack_require__(80), |
|
isArrayLike = __webpack_require__(6), |
|
isPrototype = __webpack_require__(37), |
|
keys = __webpack_require__(12); |
|
|
|
/** Used for built-in method references. */ |
|
var objectProto = Object.prototype; |
|
|
|
/** Used to check objects for own properties. */ |
|
var hasOwnProperty = objectProto.hasOwnProperty; |
|
|
|
/** Built-in value references. */ |
|
var propertyIsEnumerable = objectProto.propertyIsEnumerable; |
|
|
|
/** Detect if properties shadowing those on `Object.prototype` are non-enumerable. */ |
|
var nonEnumShadows = !propertyIsEnumerable.call({ 'valueOf': 1 }, 'valueOf'); |
|
|
|
/** |
|
* Assigns own enumerable properties of source objects to the destination |
|
* object. Source objects are applied from left to right. Subsequent sources |
|
* overwrite property assignments of previous sources. |
|
* |
|
* **Note:** This method mutates `object` and is loosely based on |
|
* [`Object.assign`](https://mdn.io/Object/assign). |
|
* |
|
* @static |
|
* @memberOf _ |
|
* @category Object |
|
* @param {Object} object The destination object. |
|
* @param {...Object} [sources] The source objects. |
|
* @returns {Object} Returns `object`. |
|
* @example |
|
* |
|
* function Foo() { |
|
* this.c = 3; |
|
* } |
|
* |
|
* function Bar() { |
|
* this.e = 5; |
|
* } |
|
* |
|
* Foo.prototype.d = 4; |
|
* Bar.prototype.f = 6; |
|
* |
|
* _.assign({ 'a': 1 }, new Foo, new Bar); |
|
* // => { 'a': 1, 'c': 3, 'e': 5 } |
|
*/ |
|
var assign = createAssigner(function(object, source) { |
|
if (nonEnumShadows || isPrototype(source) || isArrayLike(source)) { |
|
copyObject(source, keys(source), object); |
|
return; |
|
} |
|
for (var key in source) { |
|
if (hasOwnProperty.call(source, key)) { |
|
assignValue(object, key, source[key]); |
|
} |
|
} |
|
}); |
|
|
|
module.exports = assign; |
|
|
|
|
|
/***/ }, |
|
/* 111 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var baseDifference = __webpack_require__(55), |
|
baseFlatten = __webpack_require__(59), |
|
isArrayLikeObject = __webpack_require__(17), |
|
rest = __webpack_require__(40); |
|
|
|
/** |
|
* Creates an array of unique `array` values not included in the other |
|
* given arrays using [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero) |
|
* for equality comparisons. The order of result values is determined by the |
|
* order they occur in the first array. |
|
* |
|
* @static |
|
* @memberOf _ |
|
* @category Array |
|
* @param {Array} array The array to inspect. |
|
* @param {...Array} [values] The values to exclude. |
|
* @returns {Array} Returns the new array of filtered values. |
|
* @example |
|
* |
|
* _.difference([3, 2, 1], [4, 2]); |
|
* // => [3, 1] |
|
*/ |
|
var difference = rest(function(array, values) { |
|
return isArrayLikeObject(array) |
|
? baseDifference(array, baseFlatten(values, 1, true)) |
|
: []; |
|
}); |
|
|
|
module.exports = difference; |
|
|
|
|
|
/***/ }, |
|
/* 112 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var baseEach = __webpack_require__(56), |
|
baseFind = __webpack_require__(57), |
|
baseFindIndex = __webpack_require__(58), |
|
baseIteratee = __webpack_require__(66), |
|
isArray = __webpack_require__(1); |
|
|
|
/** |
|
* Iterates over elements of `collection`, returning the first element |
|
* `predicate` returns truthy for. The predicate is invoked with three arguments: |
|
* (value, index|key, collection). |
|
* |
|
* @static |
|
* @memberOf _ |
|
* @category Collection |
|
* @param {Array|Object} collection The collection to search. |
|
* @param {Function|Object|string} [predicate=_.identity] The function invoked per iteration. |
|
* @returns {*} Returns the matched element, else `undefined`. |
|
* @example |
|
* |
|
* var users = [ |
|
* { 'user': 'barney', 'age': 36, 'active': true }, |
|
* { 'user': 'fred', 'age': 40, 'active': false }, |
|
* { 'user': 'pebbles', 'age': 1, 'active': true } |
|
* ]; |
|
* |
|
* _.find(users, function(o) { return o.age < 40; }); |
|
* // => object for 'barney' |
|
* |
|
* // The `_.matches` iteratee shorthand. |
|
* _.find(users, { 'age': 1, 'active': true }); |
|
* // => object for 'pebbles' |
|
* |
|
* // The `_.matchesProperty` iteratee shorthand. |
|
* _.find(users, ['active', false]); |
|
* // => object for 'fred' |
|
* |
|
* // The `_.property` iteratee shorthand. |
|
* _.find(users, 'active'); |
|
* // => object for 'barney' |
|
*/ |
|
function find(collection, predicate) { |
|
predicate = baseIteratee(predicate, 3); |
|
if (isArray(collection)) { |
|
var index = baseFindIndex(collection, predicate); |
|
return index > -1 ? collection[index] : undefined; |
|
} |
|
return baseFind(collection, predicate, baseEach); |
|
} |
|
|
|
module.exports = find; |
|
|
|
|
|
/***/ }, |
|
/* 113 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var baseHasIn = __webpack_require__(62), |
|
hasPath = __webpack_require__(88); |
|
|
|
/** |
|
* Checks if `path` is a direct or inherited property of `object`. |
|
* |
|
* @static |
|
* @memberOf _ |
|
* @category Object |
|
* @param {Object} object The object to query. |
|
* @param {Array|string} path The path to check. |
|
* @returns {boolean} Returns `true` if `path` exists, else `false`. |
|
* @example |
|
* |
|
* var object = _.create({ 'a': _.create({ 'b': _.create({ 'c': 3 }) }) }); |
|
* |
|
* _.hasIn(object, 'a'); |
|
* // => true |
|
* |
|
* _.hasIn(object, 'a.b.c'); |
|
* // => true |
|
* |
|
* _.hasIn(object, ['a', 'b', 'c']); |
|
* // => true |
|
* |
|
* _.hasIn(object, 'b'); |
|
* // => false |
|
*/ |
|
function hasIn(object, path) { |
|
return hasPath(object, path, baseHasIn); |
|
} |
|
|
|
module.exports = hasIn; |
|
|
|
|
|
/***/ }, |
|
/* 114 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
/** |
|
* This method returns the first argument given to it. |
|
* |
|
* @static |
|
* @memberOf _ |
|
* @category Util |
|
* @param {*} value Any value. |
|
* @returns {*} Returns `value`. |
|
* @example |
|
* |
|
* var object = { 'user': 'fred' }; |
|
* |
|
* _.identity(object) === object; |
|
* // => true |
|
*/ |
|
function identity(value) { |
|
return value; |
|
} |
|
|
|
module.exports = identity; |
|
|
|
|
|
/***/ }, |
|
/* 115 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var isFunction = __webpack_require__(18), |
|
isHostObject = __webpack_require__(36), |
|
isObjectLike = __webpack_require__(4); |
|
|
|
/** Used to match `RegExp` [syntax characters](http://ecma-international.org/ecma-262/6.0/#sec-patterns). */ |
|
var reRegExpChar = /[\\^$.*+?()[\]{}|]/g; |
|
|
|
/** Used to detect host constructors (Safari > 5). */ |
|
var reIsHostCtor = /^\[object .+?Constructor\]$/; |
|
|
|
/** Used for built-in method references. */ |
|
var objectProto = Object.prototype; |
|
|
|
/** Used to resolve the decompiled source of functions. */ |
|
var funcToString = Function.prototype.toString; |
|
|
|
/** Used to check objects for own properties. */ |
|
var hasOwnProperty = objectProto.hasOwnProperty; |
|
|
|
/** Used to detect if a method is native. */ |
|
var reIsNative = RegExp('^' + |
|
funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&') |
|
.replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$' |
|
); |
|
|
|
/** |
|
* Checks if `value` is a native function. |
|
* |
|
* @static |
|
* @memberOf _ |
|
* @category Lang |
|
* @param {*} value The value to check. |
|
* @returns {boolean} Returns `true` if `value` is a native function, else `false`. |
|
* @example |
|
* |
|
* _.isNative(Array.prototype.push); |
|
* // => true |
|
* |
|
* _.isNative(_); |
|
* // => false |
|
*/ |
|
function isNative(value) { |
|
if (value == null) { |
|
return false; |
|
} |
|
if (isFunction(value)) { |
|
return reIsNative.test(funcToString.call(value)); |
|
} |
|
return isObjectLike(value) && |
|
(isHostObject(value) ? reIsNative : reIsHostCtor).test(value); |
|
} |
|
|
|
module.exports = isNative; |
|
|
|
|
|
/***/ }, |
|
/* 116 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var isObjectLike = __webpack_require__(4); |
|
|
|
/** `Object#toString` result references. */ |
|
var symbolTag = '[object Symbol]'; |
|
|
|
/** Used for built-in method references. */ |
|
var objectProto = Object.prototype; |
|
|
|
/** |
|
* Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring) |
|
* of values. |
|
*/ |
|
var objectToString = objectProto.toString; |
|
|
|
/** |
|
* Checks if `value` is classified as a `Symbol` primitive or object. |
|
* |
|
* @static |
|
* @memberOf _ |
|
* @category Lang |
|
* @param {*} value The value to check. |
|
* @returns {boolean} Returns `true` if `value` is correctly classified, else `false`. |
|
* @example |
|
* |
|
* _.isSymbol(Symbol.iterator); |
|
* // => true |
|
* |
|
* _.isSymbol('abc'); |
|
* // => false |
|
*/ |
|
function isSymbol(value) { |
|
return typeof value == 'symbol' || |
|
(isObjectLike(value) && objectToString.call(value) == symbolTag); |
|
} |
|
|
|
module.exports = isSymbol; |
|
|
|
|
|
/***/ }, |
|
/* 117 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var isLength = __webpack_require__(11), |
|
isObjectLike = __webpack_require__(4); |
|
|
|
/** `Object#toString` result references. */ |
|
var argsTag = '[object Arguments]', |
|
arrayTag = '[object Array]', |
|
boolTag = '[object Boolean]', |
|
dateTag = '[object Date]', |
|
errorTag = '[object Error]', |
|
funcTag = '[object Function]', |
|
mapTag = '[object Map]', |
|
numberTag = '[object Number]', |
|
objectTag = '[object Object]', |
|
regexpTag = '[object RegExp]', |
|
setTag = '[object Set]', |
|
stringTag = '[object String]', |
|
weakMapTag = '[object WeakMap]'; |
|
|
|
var arrayBufferTag = '[object ArrayBuffer]', |
|
float32Tag = '[object Float32Array]', |
|
float64Tag = '[object Float64Array]', |
|
int8Tag = '[object Int8Array]', |
|
int16Tag = '[object Int16Array]', |
|
int32Tag = '[object Int32Array]', |
|
uint8Tag = '[object Uint8Array]', |
|
uint8ClampedTag = '[object Uint8ClampedArray]', |
|
uint16Tag = '[object Uint16Array]', |
|
uint32Tag = '[object Uint32Array]'; |
|
|
|
/** Used to identify `toStringTag` values of typed arrays. */ |
|
var typedArrayTags = {}; |
|
typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = |
|
typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = |
|
typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = |
|
typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = |
|
typedArrayTags[uint32Tag] = true; |
|
typedArrayTags[argsTag] = typedArrayTags[arrayTag] = |
|
typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = |
|
typedArrayTags[dateTag] = typedArrayTags[errorTag] = |
|
typedArrayTags[funcTag] = typedArrayTags[mapTag] = |
|
typedArrayTags[numberTag] = typedArrayTags[objectTag] = |
|
typedArrayTags[regexpTag] = typedArrayTags[setTag] = |
|
typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false; |
|
|
|
/** Used for built-in method references. */ |
|
var objectProto = Object.prototype; |
|
|
|
/** |
|
* Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring) |
|
* of values. |
|
*/ |
|
var objectToString = objectProto.toString; |
|
|
|
/** |
|
* Checks if `value` is classified as a typed array. |
|
* |
|
* @static |
|
* @memberOf _ |
|
* @category Lang |
|
* @param {*} value The value to check. |
|
* @returns {boolean} Returns `true` if `value` is correctly classified, else `false`. |
|
* @example |
|
* |
|
* _.isTypedArray(new Uint8Array); |
|
* // => true |
|
* |
|
* _.isTypedArray([]); |
|
* // => false |
|
*/ |
|
function isTypedArray(value) { |
|
return isObjectLike(value) && |
|
isLength(value.length) && !!typedArrayTags[objectToString.call(value)]; |
|
} |
|
|
|
module.exports = isTypedArray; |
|
|
|
|
|
/***/ }, |
|
/* 118 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
/** |
|
* Gets the last element of `array`. |
|
* |
|
* @static |
|
* @memberOf _ |
|
* @category Array |
|
* @param {Array} array The array to query. |
|
* @returns {*} Returns the last element of `array`. |
|
* @example |
|
* |
|
* _.last([1, 2, 3]); |
|
* // => 3 |
|
*/ |
|
function last(array) { |
|
var length = array ? array.length : 0; |
|
return length ? array[length - 1] : undefined; |
|
} |
|
|
|
module.exports = last; |
|
|
|
|
|
/***/ }, |
|
/* 119 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var baseProperty = __webpack_require__(33), |
|
basePropertyDeep = __webpack_require__(70), |
|
isKey = __webpack_require__(14); |
|
|
|
/** |
|
* Creates a function that returns the value at `path` of a given object. |
|
* |
|
* @static |
|
* @memberOf _ |
|
* @category Util |
|
* @param {Array|string} path The path of the property to get. |
|
* @returns {Function} Returns the new function. |
|
* @example |
|
* |
|
* var objects = [ |
|
* { 'a': { 'b': { 'c': 2 } } }, |
|
* { 'a': { 'b': { 'c': 1 } } } |
|
* ]; |
|
* |
|
* _.map(objects, _.property('a.b.c')); |
|
* // => [2, 1] |
|
* |
|
* _.map(_.sortBy(objects, _.property(['a', 'b', 'c'])), 'a.b.c'); |
|
* // => [1, 2] |
|
*/ |
|
function property(path) { |
|
return isKey(path) ? baseProperty(path) : basePropertyDeep(path); |
|
} |
|
|
|
module.exports = property; |
|
|
|
|
|
/***/ }, |
|
/* 120 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var toNumber = __webpack_require__(121); |
|
|
|
/** Used as references for various `Number` constants. */ |
|
var INFINITY = 1 / 0, |
|
MAX_INTEGER = 1.7976931348623157e+308; |
|
|
|
/** |
|
* Converts `value` to an integer. |
|
* |
|
* **Note:** This function is loosely based on [`ToInteger`](http://www.ecma-international.org/ecma-262/6.0/#sec-tointeger). |
|
* |
|
* @static |
|
* @memberOf _ |
|
* @category Lang |
|
* @param {*} value The value to convert. |
|
* @returns {number} Returns the converted integer. |
|
* @example |
|
* |
|
* _.toInteger(3); |
|
* // => 3 |
|
* |
|
* _.toInteger(Number.MIN_VALUE); |
|
* // => 0 |
|
* |
|
* _.toInteger(Infinity); |
|
* // => 1.7976931348623157e+308 |
|
* |
|
* _.toInteger('3'); |
|
* // => 3 |
|
*/ |
|
function toInteger(value) { |
|
if (!value) { |
|
return value === 0 ? value : 0; |
|
} |
|
value = toNumber(value); |
|
if (value === INFINITY || value === -INFINITY) { |
|
var sign = (value < 0 ? -1 : 1); |
|
return sign * MAX_INTEGER; |
|
} |
|
var remainder = value % 1; |
|
return value === value ? (remainder ? value - remainder : value) : 0; |
|
} |
|
|
|
module.exports = toInteger; |
|
|
|
|
|
/***/ }, |
|
/* 121 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var isFunction = __webpack_require__(18), |
|
isObject = __webpack_require__(7); |
|
|
|
/** Used as references for various `Number` constants. */ |
|
var NAN = 0 / 0; |
|
|
|
/** Used to match leading and trailing whitespace. */ |
|
var reTrim = /^\s+|\s+$/g; |
|
|
|
/** Used to detect bad signed hexadecimal string values. */ |
|
var reIsBadHex = /^[-+]0x[0-9a-f]+$/i; |
|
|
|
/** Used to detect binary string values. */ |
|
var reIsBinary = /^0b[01]+$/i; |
|
|
|
/** Used to detect octal string values. */ |
|
var reIsOctal = /^0o[0-7]+$/i; |
|
|
|
/** Built-in method references without a dependency on `root`. */ |
|
var freeParseInt = parseInt; |
|
|
|
/** |
|
* Converts `value` to a number. |
|
* |
|
* @static |
|
* @memberOf _ |
|
* @category Lang |
|
* @param {*} value The value to process. |
|
* @returns {number} Returns the number. |
|
* @example |
|
* |
|
* _.toNumber(3); |
|
* // => 3 |
|
* |
|
* _.toNumber(Number.MIN_VALUE); |
|
* // => 5e-324 |
|
* |
|
* _.toNumber(Infinity); |
|
* // => Infinity |
|
* |
|
* _.toNumber('3'); |
|
* // => 3 |
|
*/ |
|
function toNumber(value) { |
|
if (isObject(value)) { |
|
var other = isFunction(value.valueOf) ? value.valueOf() : value; |
|
value = isObject(other) ? (other + '') : other; |
|
} |
|
if (typeof value != 'string') { |
|
return value === 0 ? value : +value; |
|
} |
|
value = value.replace(reTrim, ''); |
|
var isBinary = reIsBinary.test(value); |
|
return (isBinary || reIsOctal.test(value)) |
|
? freeParseInt(value.slice(2), isBinary ? 2 : 8) |
|
: (reIsBadHex.test(value) ? NAN : +value); |
|
} |
|
|
|
module.exports = toNumber; |
|
|
|
|
|
/***/ }, |
|
/* 122 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var baseToPairs = __webpack_require__(73), |
|
keys = __webpack_require__(12); |
|
|
|
/** |
|
* Creates an array of own enumerable key-value pairs for `object` which |
|
* can be consumed by `_.fromPairs`. |
|
* |
|
* @static |
|
* @memberOf _ |
|
* @category Object |
|
* @param {Object} object The object to query. |
|
* @returns {Array} Returns the new array of key-value pairs. |
|
* @example |
|
* |
|
* function Foo() { |
|
* this.a = 1; |
|
* this.b = 2; |
|
* } |
|
* |
|
* Foo.prototype.c = 3; |
|
* |
|
* _.toPairs(new Foo); |
|
* // => [['a', 1], ['b', 2]] (iteration order is not guaranteed) |
|
*/ |
|
function toPairs(object) { |
|
return baseToPairs(object, keys(object)); |
|
} |
|
|
|
module.exports = toPairs; |
|
|
|
|
|
/***/ }, |
|
/* 123 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
var Symbol = __webpack_require__(22), |
|
isSymbol = __webpack_require__(116); |
|
|
|
/** Used as references for various `Number` constants. */ |
|
var INFINITY = 1 / 0; |
|
|
|
/** Used to convert symbols to primitives and strings. */ |
|
var symbolProto = Symbol ? Symbol.prototype : undefined, |
|
symbolToString = symbolProto ? symbolProto.toString : undefined; |
|
|
|
/** |
|
* Converts `value` to a string if it's not one. An empty string is returned |
|
* for `null` and `undefined` values. The sign of `-0` is preserved. |
|
* |
|
* @static |
|
* @memberOf _ |
|
* @category Lang |
|
* @param {*} value The value to process. |
|
* @returns {string} Returns the string. |
|
* @example |
|
* |
|
* _.toString(null); |
|
* // => '' |
|
* |
|
* _.toString(-0); |
|
* // => '-0' |
|
* |
|
* _.toString([1, 2, 3]); |
|
* // => '1,2,3' |
|
*/ |
|
function toString(value) { |
|
// Exit early for strings to avoid a performance hit in some environments. |
|
if (typeof value == 'string') { |
|
return value; |
|
} |
|
if (value == null) { |
|
return ''; |
|
} |
|
if (isSymbol(value)) { |
|
return symbolToString ? symbolToString.call(value) : ''; |
|
} |
|
var result = (value + ''); |
|
return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; |
|
} |
|
|
|
module.exports = toString; |
|
|
|
|
|
/***/ }, |
|
/* 124 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
"use strict"; |
|
|
|
exports.__esModule = true; |
|
exports["default"] = getForceUpdate; |
|
function traverseRenderedChildren(internalInstance, callback, argument) { |
|
callback(internalInstance, argument); |
|
|
|
if (internalInstance._renderedComponent) { |
|
traverseRenderedChildren(internalInstance._renderedComponent, callback, argument); |
|
} else { |
|
for (var key in internalInstance._renderedChildren) { |
|
if (internalInstance._renderedChildren.hasOwnProperty(key)) { |
|
traverseRenderedChildren(internalInstance._renderedChildren[key], callback, argument); |
|
} |
|
} |
|
} |
|
} |
|
|
|
function setPendingForceUpdate(internalInstance) { |
|
if (internalInstance._pendingForceUpdate === false) { |
|
internalInstance._pendingForceUpdate = true; |
|
} |
|
} |
|
|
|
function forceUpdateIfPending(internalInstance, React) { |
|
if (internalInstance._pendingForceUpdate === true) { |
|
var publicInstance = internalInstance._instance; |
|
React.Component.prototype.forceUpdate.call(publicInstance); |
|
} |
|
} |
|
|
|
function getForceUpdate(React) { |
|
return function (instance) { |
|
var internalInstance = instance._reactInternalInstance; |
|
traverseRenderedChildren(internalInstance, setPendingForceUpdate); |
|
traverseRenderedChildren(internalInstance, forceUpdateIfPending, React); |
|
}; |
|
} |
|
|
|
module.exports = exports["default"]; |
|
|
|
/***/ }, |
|
/* 125 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
module.exports = function(module) { |
|
if(!module.webpackPolyfill) { |
|
module.deprecate = function() {}; |
|
module.paths = []; |
|
// module.parent = undefined by default |
|
module.children = []; |
|
module.webpackPolyfill = 1; |
|
} |
|
return module; |
|
} |
|
|
|
|
|
/***/ } |
|
/******/ ]) |
|
});
|
|
|