|
|
@@ -1,7 +1,7 @@
|
|
|
/**
|
|
|
* @license
|
|
|
* lodash 3.10.1 (Custom Build) <https://lodash.com/>
|
|
|
- * Build: `lodash modern exports="amd" include="clone,extend,isPlainObject,isObject,isArray" --development --output src/lib/lodash/lodash-ckeditor.js`
|
|
|
+ * Build: `lodash modern exports="amd" include="clone,extend,isPlainObject,isObject,isArray,last,isEqual" --development --output src/lib/lodash/lodash-ckeditor.js`
|
|
|
* Copyright 2012-2015 The Dojo Foundation <http://dojofoundation.org/>
|
|
|
* Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
|
|
|
* Copyright 2009-2015 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
|
|
|
@@ -53,6 +53,21 @@
|
|
|
/** Used to detect unsigned integer values. */
|
|
|
var reIsUint = /^\d+$/;
|
|
|
|
|
|
+ /** 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 to identify `toStringTag` values supported by `_.clone`. */
|
|
|
var cloneableTags = {};
|
|
|
cloneableTags[argsTag] = cloneableTags[arrayTag] =
|
|
|
@@ -293,6 +308,28 @@
|
|
|
return array;
|
|
|
}
|
|
|
|
|
|
+ /**
|
|
|
+ * A specialized version of `_.some` for arrays without support for callback
|
|
|
+ * shorthands and `this` binding.
|
|
|
+ *
|
|
|
+ * @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;
|
|
|
+ }
|
|
|
+
|
|
|
/**
|
|
|
* A specialized version of `_.assign` for customizing assigned values without
|
|
|
* support for argument juggling, multiple sources, and `this` binding `customizer`
|
|
|
@@ -466,6 +503,107 @@
|
|
|
return baseFor(object, iteratee, keys);
|
|
|
}
|
|
|
|
|
|
+ /**
|
|
|
+ * The base implementation of `_.isEqual` without support for `this` binding
|
|
|
+ * `customizer` functions.
|
|
|
+ *
|
|
|
+ * @private
|
|
|
+ * @param {*} value The value to compare.
|
|
|
+ * @param {*} other The other value to compare.
|
|
|
+ * @param {Function} [customizer] The function to customize comparing values.
|
|
|
+ * @param {boolean} [isLoose] Specify performing partial comparisons.
|
|
|
+ * @param {Array} [stackA] Tracks traversed `value` objects.
|
|
|
+ * @param {Array} [stackB] Tracks traversed `other` objects.
|
|
|
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
|
|
|
+ */
|
|
|
+ function baseIsEqual(value, other, customizer, isLoose, stackA, stackB) {
|
|
|
+ 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, isLoose, stackA, stackB);
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * 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 comparing objects.
|
|
|
+ * @param {boolean} [isLoose] Specify performing partial comparisons.
|
|
|
+ * @param {Array} [stackA=[]] Tracks traversed `value` objects.
|
|
|
+ * @param {Array} [stackB=[]] Tracks traversed `other` objects.
|
|
|
+ * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
|
|
|
+ */
|
|
|
+ function baseIsEqualDeep(object, other, equalFunc, customizer, isLoose, stackA, stackB) {
|
|
|
+ var objIsArr = isArray(object),
|
|
|
+ othIsArr = isArray(other),
|
|
|
+ objTag = arrayTag,
|
|
|
+ othTag = arrayTag;
|
|
|
+
|
|
|
+ if (!objIsArr) {
|
|
|
+ objTag = objToString.call(object);
|
|
|
+ if (objTag == argsTag) {
|
|
|
+ objTag = objectTag;
|
|
|
+ } else if (objTag != objectTag) {
|
|
|
+ objIsArr = isTypedArray(object);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (!othIsArr) {
|
|
|
+ othTag = objToString.call(other);
|
|
|
+ if (othTag == argsTag) {
|
|
|
+ othTag = objectTag;
|
|
|
+ } else if (othTag != objectTag) {
|
|
|
+ othIsArr = isTypedArray(other);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ var objIsObj = objTag == objectTag,
|
|
|
+ othIsObj = othTag == objectTag,
|
|
|
+ isSameTag = objTag == othTag;
|
|
|
+
|
|
|
+ if (isSameTag && !(objIsArr || objIsObj)) {
|
|
|
+ return equalByTag(object, other, objTag);
|
|
|
+ }
|
|
|
+ if (!isLoose) {
|
|
|
+ var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),
|
|
|
+ othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');
|
|
|
+
|
|
|
+ if (objIsWrapped || othIsWrapped) {
|
|
|
+ return equalFunc(objIsWrapped ? object.value() : object, othIsWrapped ? other.value() : other, customizer, isLoose, stackA, stackB);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (!isSameTag) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ // Assume cyclic values are equal.
|
|
|
+ // For more information on detecting circular references see https://es5.github.io/#JO.
|
|
|
+ stackA || (stackA = []);
|
|
|
+ stackB || (stackB = []);
|
|
|
+
|
|
|
+ var length = stackA.length;
|
|
|
+ while (length--) {
|
|
|
+ if (stackA[length] == object) {
|
|
|
+ return stackB[length] == other;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // Add `object` and `other` to the stack of traversed objects.
|
|
|
+ stackA.push(object);
|
|
|
+ stackB.push(other);
|
|
|
+
|
|
|
+ var result = (objIsArr ? equalArrays : equalObjects)(object, other, equalFunc, customizer, isLoose, stackA, stackB);
|
|
|
+
|
|
|
+ stackA.pop();
|
|
|
+ stackB.pop();
|
|
|
+
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+
|
|
|
/**
|
|
|
* The base implementation of `_.property` without support for deep paths.
|
|
|
*
|
|
|
@@ -590,6 +728,151 @@
|
|
|
};
|
|
|
}
|
|
|
|
|
|
+ /**
|
|
|
+ * 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 comparing arrays.
|
|
|
+ * @param {boolean} [isLoose] Specify performing partial comparisons.
|
|
|
+ * @param {Array} [stackA] Tracks traversed `value` objects.
|
|
|
+ * @param {Array} [stackB] Tracks traversed `other` objects.
|
|
|
+ * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.
|
|
|
+ */
|
|
|
+ function equalArrays(array, other, equalFunc, customizer, isLoose, stackA, stackB) {
|
|
|
+ var index = -1,
|
|
|
+ arrLength = array.length,
|
|
|
+ othLength = other.length;
|
|
|
+
|
|
|
+ if (arrLength != othLength && !(isLoose && othLength > arrLength)) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ // Ignore non-index properties.
|
|
|
+ while (++index < arrLength) {
|
|
|
+ var arrValue = array[index],
|
|
|
+ othValue = other[index],
|
|
|
+ result = customizer ? customizer(isLoose ? othValue : arrValue, isLoose ? arrValue : othValue, index) : undefined;
|
|
|
+
|
|
|
+ if (result !== undefined) {
|
|
|
+ if (result) {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ // Recursively compare arrays (susceptible to call stack limits).
|
|
|
+ if (isLoose) {
|
|
|
+ if (!arraySome(other, function(othValue) {
|
|
|
+ return arrValue === othValue || equalFunc(arrValue, othValue, customizer, isLoose, stackA, stackB);
|
|
|
+ })) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, customizer, isLoose, stackA, stackB))) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * 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.
|
|
|
+ * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
|
|
|
+ */
|
|
|
+ function equalByTag(object, other, tag) {
|
|
|
+ switch (tag) {
|
|
|
+ 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 + '');
|
|
|
+ }
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * 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 comparing values.
|
|
|
+ * @param {boolean} [isLoose] Specify performing partial comparisons.
|
|
|
+ * @param {Array} [stackA] Tracks traversed `value` objects.
|
|
|
+ * @param {Array} [stackB] Tracks traversed `other` objects.
|
|
|
+ * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
|
|
|
+ */
|
|
|
+ function equalObjects(object, other, equalFunc, customizer, isLoose, stackA, stackB) {
|
|
|
+ var objProps = keys(object),
|
|
|
+ objLength = objProps.length,
|
|
|
+ othProps = keys(other),
|
|
|
+ othLength = othProps.length;
|
|
|
+
|
|
|
+ if (objLength != othLength && !isLoose) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ var index = objLength;
|
|
|
+ while (index--) {
|
|
|
+ var key = objProps[index];
|
|
|
+ if (!(isLoose ? key in other : hasOwnProperty.call(other, key))) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ var skipCtor = isLoose;
|
|
|
+ while (++index < objLength) {
|
|
|
+ key = objProps[index];
|
|
|
+ var objValue = object[key],
|
|
|
+ othValue = other[key],
|
|
|
+ result = customizer ? customizer(isLoose ? othValue : objValue, isLoose? objValue : othValue, key) : undefined;
|
|
|
+
|
|
|
+ // Recursively compare objects (susceptible to call stack limits).
|
|
|
+ if (!(result === undefined ? equalFunc(objValue, othValue, customizer, isLoose, stackA, stackB) : result)) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ skipCtor || (skipCtor = key == 'constructor');
|
|
|
+ }
|
|
|
+ if (!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)) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
/**
|
|
|
* Gets the "length" property value of `object`.
|
|
|
*
|
|
|
@@ -790,6 +1073,26 @@
|
|
|
|
|
|
/*------------------------------------------------------------------------*/
|
|
|
|
|
|
+ /**
|
|
|
+ * 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;
|
|
|
+ }
|
|
|
+
|
|
|
+ /*------------------------------------------------------------------------*/
|
|
|
+
|
|
|
/**
|
|
|
* Creates a function that invokes `func` with the `this` binding of the
|
|
|
* created function and arguments from `start` and beyond provided as an array.
|
|
|
@@ -949,6 +1252,56 @@
|
|
|
return isObjectLike(value) && isLength(value.length) && objToString.call(value) == arrayTag;
|
|
|
};
|
|
|
|
|
|
+ /**
|
|
|
+ * Performs a deep comparison between two values to determine if they are
|
|
|
+ * equivalent. If `customizer` is provided it's invoked to compare values.
|
|
|
+ * If `customizer` returns `undefined` comparisons are handled by the method
|
|
|
+ * instead. The `customizer` is bound to `thisArg` and invoked with up to
|
|
|
+ * three arguments: (value, other [, index|key]).
|
|
|
+ *
|
|
|
+ * **Note:** This method supports comparing arrays, booleans, `Date` objects,
|
|
|
+ * numbers, `Object` objects, regexes, and strings. Objects are compared by
|
|
|
+ * their own, not inherited, enumerable properties. Functions and DOM nodes
|
|
|
+ * are **not** supported. Provide a customizer function to extend support
|
|
|
+ * for comparing other values.
|
|
|
+ *
|
|
|
+ * @static
|
|
|
+ * @memberOf _
|
|
|
+ * @alias eq
|
|
|
+ * @category Lang
|
|
|
+ * @param {*} value The value to compare.
|
|
|
+ * @param {*} other The other value to compare.
|
|
|
+ * @param {Function} [customizer] The function to customize value comparisons.
|
|
|
+ * @param {*} [thisArg] The `this` binding of `customizer`.
|
|
|
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
|
|
|
+ * @example
|
|
|
+ *
|
|
|
+ * var object = { 'user': 'fred' };
|
|
|
+ * var other = { 'user': 'fred' };
|
|
|
+ *
|
|
|
+ * object == other;
|
|
|
+ * // => false
|
|
|
+ *
|
|
|
+ * _.isEqual(object, other);
|
|
|
+ * // => true
|
|
|
+ *
|
|
|
+ * // using a customizer callback
|
|
|
+ * var array = ['hello', 'goodbye'];
|
|
|
+ * var other = ['hi', 'goodbye'];
|
|
|
+ *
|
|
|
+ * _.isEqual(array, other, function(value, other) {
|
|
|
+ * if (_.every([value, other], RegExp.prototype.test, /^h(?:i|ello)$/)) {
|
|
|
+ * return true;
|
|
|
+ * }
|
|
|
+ * });
|
|
|
+ * // => true
|
|
|
+ */
|
|
|
+ function isEqual(value, other, customizer, thisArg) {
|
|
|
+ customizer = typeof customizer == 'function' ? bindCallback(customizer, thisArg, 3) : undefined;
|
|
|
+ var result = customizer ? customizer(value, other) : undefined;
|
|
|
+ return result === undefined ? baseIsEqual(value, other, customizer) : !!result;
|
|
|
+ }
|
|
|
+
|
|
|
/**
|
|
|
* Checks if `value` is classified as a `Function` object.
|
|
|
*
|
|
|
@@ -1076,6 +1429,26 @@
|
|
|
return result === undefined || hasOwnProperty.call(value, result);
|
|
|
}
|
|
|
|
|
|
+ /**
|
|
|
+ * 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[objToString.call(value)];
|
|
|
+ }
|
|
|
+
|
|
|
/*------------------------------------------------------------------------*/
|
|
|
|
|
|
/**
|
|
|
@@ -1242,10 +1615,16 @@
|
|
|
lodash.identity = identity;
|
|
|
lodash.isArguments = isArguments;
|
|
|
lodash.isArray = isArray;
|
|
|
+ lodash.isEqual = isEqual;
|
|
|
lodash.isFunction = isFunction;
|
|
|
lodash.isNative = isNative;
|
|
|
lodash.isObject = isObject;
|
|
|
lodash.isPlainObject = isPlainObject;
|
|
|
+ lodash.isTypedArray = isTypedArray;
|
|
|
+ lodash.last = last;
|
|
|
+
|
|
|
+ // Add aliases.
|
|
|
+ lodash.eq = isEqual;
|
|
|
|
|
|
/*------------------------------------------------------------------------*/
|
|
|
|