@adminforth/rich-editor 1.0.17 → 1.0.18

package/custom/node_modules/lodash-es/union.js

@@ -0,0 +1,26 @@
+import baseFlatten from './_baseFlatten.js';
+import baseRest from './_baseRest.js';
+import baseUniq from './_baseUniq.js';
+import isArrayLikeObject from './isArrayLikeObject.js';
+
+/**
+ * Creates an array of unique values, in order, from all given arrays using
+ * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+ * for equality comparisons.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Array
+ * @param {...Array} [arrays] The arrays to inspect.
+ * @returns {Array} Returns the new array of combined values.
+ * @example
+ *
+ * _.union([2], [1, 2]);
+ * // => [2, 1]
+ */
+var union = baseRest(function(arrays) {
+  return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true));
+});
+
+export default union;

package/custom/node_modules/lodash-es/unionBy.js

@@ -0,0 +1,39 @@
+import baseFlatten from './_baseFlatten.js';
+import baseIteratee from './_baseIteratee.js';
+import baseRest from './_baseRest.js';
+import baseUniq from './_baseUniq.js';
+import isArrayLikeObject from './isArrayLikeObject.js';
+import last from './last.js';
+
+/**
+ * This method is like `_.union` except that it accepts `iteratee` which is
+ * invoked for each element of each `arrays` to generate the criterion by
+ * which uniqueness is computed. Result values are chosen from the first
+ * array in which the value occurs. The iteratee is invoked with one argument:
+ * (value).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Array
+ * @param {...Array} [arrays] The arrays to inspect.
+ * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
+ * @returns {Array} Returns the new array of combined values.
+ * @example
+ *
+ * _.unionBy([2.1], [1.2, 2.3], Math.floor);
+ * // => [2.1, 1.2]
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.unionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
+ * // => [{ 'x': 1 }, { 'x': 2 }]
+ */
+var unionBy = baseRest(function(arrays) {
+  var iteratee = last(arrays);
+  if (isArrayLikeObject(iteratee)) {
+    iteratee = undefined;
+  }
+  return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), baseIteratee(iteratee, 2));
+});
+
+export default unionBy;

package/custom/node_modules/lodash-es/unionWith.js

@@ -0,0 +1,34 @@
+import baseFlatten from './_baseFlatten.js';
+import baseRest from './_baseRest.js';
+import baseUniq from './_baseUniq.js';
+import isArrayLikeObject from './isArrayLikeObject.js';
+import last from './last.js';
+
+/**
+ * This method is like `_.union` except that it accepts `comparator` which
+ * is invoked to compare elements of `arrays`. Result values are chosen from
+ * the first array in which the value occurs. The comparator is invoked
+ * with two arguments: (arrVal, othVal).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Array
+ * @param {...Array} [arrays] The arrays to inspect.
+ * @param {Function} [comparator] The comparator invoked per element.
+ * @returns {Array} Returns the new array of combined values.
+ * @example
+ *
+ * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
+ * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
+ *
+ * _.unionWith(objects, others, _.isEqual);
+ * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]
+ */
+var unionWith = baseRest(function(arrays) {
+  var comparator = last(arrays);
+  comparator = typeof comparator == 'function' ? comparator : undefined;
+  return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), undefined, comparator);
+});
+
+export default unionWith;

package/custom/node_modules/lodash-es/uniq.js

@@ -0,0 +1,25 @@
+import baseUniq from './_baseUniq.js';
+
+/**
+ * Creates a duplicate-free version of an array, using
+ * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+ * for equality comparisons, in which only the first occurrence of each element
+ * is kept. The order of result values is determined by the order they occur
+ * in the array.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Array
+ * @param {Array} array The array to inspect.
+ * @returns {Array} Returns the new duplicate free array.
+ * @example
+ *
+ * _.uniq([2, 1, 2]);
+ * // => [2, 1]
+ */
+function uniq(array) {
+  return (array && array.length) ? baseUniq(array) : [];
+}
+
+export default uniq;

package/custom/node_modules/lodash-es/uniqBy.js

@@ -0,0 +1,31 @@
+import baseIteratee from './_baseIteratee.js';
+import baseUniq from './_baseUniq.js';
+
+/**
+ * This method is like `_.uniq` except that it accepts `iteratee` which is
+ * invoked for each element in `array` to generate the criterion by which
+ * uniqueness is computed. The order of result values is determined by the
+ * order they occur in the array. The iteratee is invoked with one argument:
+ * (value).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Array
+ * @param {Array} array The array to inspect.
+ * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
+ * @returns {Array} Returns the new duplicate free array.
+ * @example
+ *
+ * _.uniqBy([2.1, 1.2, 2.3], Math.floor);
+ * // => [2.1, 1.2]
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
+ * // => [{ 'x': 1 }, { 'x': 2 }]
+ */
+function uniqBy(array, iteratee) {
+  return (array && array.length) ? baseUniq(array, baseIteratee(iteratee, 2)) : [];
+}
+
+export default uniqBy;

package/custom/node_modules/lodash-es/uniqWith.js

@@ -0,0 +1,28 @@
+import baseUniq from './_baseUniq.js';
+
+/**
+ * This method is like `_.uniq` except that it accepts `comparator` which
+ * is invoked to compare elements of `array`. The order of result values is
+ * determined by the order they occur in the array.The comparator is invoked
+ * with two arguments: (arrVal, othVal).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Array
+ * @param {Array} array The array to inspect.
+ * @param {Function} [comparator] The comparator invoked per element.
+ * @returns {Array} Returns the new duplicate free array.
+ * @example
+ *
+ * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }];
+ *
+ * _.uniqWith(objects, _.isEqual);
+ * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]
+ */
+function uniqWith(array, comparator) {
+  comparator = typeof comparator == 'function' ? comparator : undefined;
+  return (array && array.length) ? baseUniq(array, undefined, comparator) : [];
+}
+
+export default uniqWith;

package/custom/node_modules/lodash-es/uniqueId.js

@@ -0,0 +1,28 @@
+import toString from './toString.js';
+
+/** Used to generate unique IDs. */
+var idCounter = 0;
+
+/**
+ * Generates a unique ID. If `prefix` is given, the ID is appended to it.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Util
+ * @param {string} [prefix=''] The value to prefix the ID with.
+ * @returns {string} Returns the unique ID.
+ * @example
+ *
+ * _.uniqueId('contact_');
+ * // => 'contact_104'
+ *
+ * _.uniqueId();
+ * // => '105'
+ */
+function uniqueId(prefix) {
+  var id = ++idCounter;
+  return toString(prefix) + id;
+}
+
+export default uniqueId;

package/custom/node_modules/lodash-es/unset.js

@@ -0,0 +1,34 @@
+import baseUnset from './_baseUnset.js';
+
+/**
+ * Removes the property at `path` of `object`.
+ *
+ * **Note:** This method mutates `object`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Object
+ * @param {Object} object The object to modify.
+ * @param {Array|string} path The path of the property to unset.
+ * @returns {boolean} Returns `true` if the property is deleted, else `false`.
+ * @example
+ *
+ * var object = { 'a': [{ 'b': { 'c': 7 } }] };
+ * _.unset(object, 'a[0].b.c');
+ * // => true
+ *
+ * console.log(object);
+ * // => { 'a': [{ 'b': {} }] };
+ *
+ * _.unset(object, ['a', '0', 'b', 'c']);
+ * // => true
+ *
+ * console.log(object);
+ * // => { 'a': [{ 'b': {} }] };
+ */
+function unset(object, path) {
+  return object == null ? true : baseUnset(object, path);
+}
+
+export default unset;

package/custom/node_modules/lodash-es/unzip.js

@@ -0,0 +1,45 @@
+import arrayFilter from './_arrayFilter.js';
+import arrayMap from './_arrayMap.js';
+import baseProperty from './_baseProperty.js';
+import baseTimes from './_baseTimes.js';
+import isArrayLikeObject from './isArrayLikeObject.js';
+
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeMax = Math.max;
+
+/**
+ * This method is like `_.zip` except that it accepts an array of grouped
+ * elements and creates an array regrouping the elements to their pre-zip
+ * configuration.
+ *
+ * @static
+ * @memberOf _
+ * @since 1.2.0
+ * @category Array
+ * @param {Array} array The array of grouped elements to process.
+ * @returns {Array} Returns the new array of regrouped elements.
+ * @example
+ *
+ * var zipped = _.zip(['a', 'b'], [1, 2], [true, false]);
+ * // => [['a', 1, true], ['b', 2, false]]
+ *
+ * _.unzip(zipped);
+ * // => [['a', 'b'], [1, 2], [true, false]]
+ */
+function unzip(array) {
+  if (!(array && array.length)) {
+    return [];
+  }
+  var length = 0;
+  array = arrayFilter(array, function(group) {
+    if (isArrayLikeObject(group)) {
+      length = nativeMax(group.length, length);
+      return true;
+    }
+  });
+  return baseTimes(length, function(index) {
+    return arrayMap(array, baseProperty(index));
+  });
+}
+
+export default unzip;

package/custom/node_modules/lodash-es/unzipWith.js

@@ -0,0 +1,39 @@
+import apply from './_apply.js';
+import arrayMap from './_arrayMap.js';
+import unzip from './unzip.js';
+
+/**
+ * This method is like `_.unzip` except that it accepts `iteratee` to specify
+ * how regrouped values should be combined. The iteratee is invoked with the
+ * elements of each group: (...group).
+ *
+ * @static
+ * @memberOf _
+ * @since 3.8.0
+ * @category Array
+ * @param {Array} array The array of grouped elements to process.
+ * @param {Function} [iteratee=_.identity] The function to combine
+ *  regrouped values.
+ * @returns {Array} Returns the new array of regrouped elements.
+ * @example
+ *
+ * var zipped = _.zip([1, 2], [10, 20], [100, 200]);
+ * // => [[1, 10, 100], [2, 20, 200]]
+ *
+ * _.unzipWith(zipped, _.add);
+ * // => [3, 30, 300]
+ */
+function unzipWith(array, iteratee) {
+  if (!(array && array.length)) {
+    return [];
+  }
+  var result = unzip(array);
+  if (iteratee == null) {
+    return result;
+  }
+  return arrayMap(result, function(group) {
+    return apply(iteratee, undefined, group);
+  });
+}
+
+export default unzipWith;

package/custom/node_modules/lodash-es/update.js

@@ -0,0 +1,35 @@
+import baseUpdate from './_baseUpdate.js';
+import castFunction from './_castFunction.js';
+
+/**
+ * This method is like `_.set` except that accepts `updater` to produce the
+ * value to set. Use `_.updateWith` to customize `path` creation. The `updater`
+ * is invoked with one argument: (value).
+ *
+ * **Note:** This method mutates `object`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.6.0
+ * @category Object
+ * @param {Object} object The object to modify.
+ * @param {Array|string} path The path of the property to set.
+ * @param {Function} updater The function to produce the updated value.
+ * @returns {Object} Returns `object`.
+ * @example
+ *
+ * var object = { 'a': [{ 'b': { 'c': 3 } }] };
+ *
+ * _.update(object, 'a[0].b.c', function(n) { return n * n; });
+ * console.log(object.a[0].b.c);
+ * // => 9
+ *
+ * _.update(object, 'x[0].y.z', function(n) { return n ? n + 1 : 0; });
+ * console.log(object.x[0].y.z);
+ * // => 0
+ */
+function update(object, path, updater) {
+  return object == null ? object : baseUpdate(object, path, castFunction(updater));
+}
+
+export default update;

package/custom/node_modules/lodash-es/updateWith.js

@@ -0,0 +1,33 @@
+import baseUpdate from './_baseUpdate.js';
+import castFunction from './_castFunction.js';
+
+/**
+ * This method is like `_.update` except that it accepts `customizer` which is
+ * invoked to produce the objects of `path`.  If `customizer` returns `undefined`
+ * path creation is handled by the method instead. The `customizer` is invoked
+ * with three arguments: (nsValue, key, nsObject).
+ *
+ * **Note:** This method mutates `object`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.6.0
+ * @category Object
+ * @param {Object} object The object to modify.
+ * @param {Array|string} path The path of the property to set.
+ * @param {Function} updater The function to produce the updated value.
+ * @param {Function} [customizer] The function to customize assigned values.
+ * @returns {Object} Returns `object`.
+ * @example
+ *
+ * var object = {};
+ *
+ * _.updateWith(object, '[0][1]', _.constant('a'), Object);
+ * // => { '0': { '1': 'a' } }
+ */
+function updateWith(object, path, updater, customizer) {
+  customizer = typeof customizer == 'function' ? customizer : undefined;
+  return object == null ? object : baseUpdate(object, path, castFunction(updater), customizer);
+}
+
+export default updateWith;

package/custom/node_modules/lodash-es/upperCase.js

@@ -0,0 +1,27 @@
+import createCompounder from './_createCompounder.js';
+
+/**
+ * Converts `string`, as space separated words, to upper case.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category String
+ * @param {string} [string=''] The string to convert.
+ * @returns {string} Returns the upper cased string.
+ * @example
+ *
+ * _.upperCase('--foo-bar');
+ * // => 'FOO BAR'
+ *
+ * _.upperCase('fooBar');
+ * // => 'FOO BAR'
+ *
+ * _.upperCase('__foo_bar__');
+ * // => 'FOO BAR'
+ */
+var upperCase = createCompounder(function(result, word, index) {
+  return result + (index ? ' ' : '') + word.toUpperCase();
+});
+
+export default upperCase;

package/custom/node_modules/lodash-es/upperFirst.js

@@ -0,0 +1,22 @@
+import createCaseFirst from './_createCaseFirst.js';
+
+/**
+ * Converts the first character of `string` to upper case.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category String
+ * @param {string} [string=''] The string to convert.
+ * @returns {string} Returns the converted string.
+ * @example
+ *
+ * _.upperFirst('fred');
+ * // => 'Fred'
+ *
+ * _.upperFirst('FRED');
+ * // => 'FRED'
+ */
+var upperFirst = createCaseFirst('toUpperCase');
+
+export default upperFirst;

package/custom/node_modules/lodash-es/util.default.js

@@ -0,0 +1,42 @@
+import attempt from './attempt.js';
+import bindAll from './bindAll.js';
+import cond from './cond.js';
+import conforms from './conforms.js';
+import constant from './constant.js';
+import defaultTo from './defaultTo.js';
+import flow from './flow.js';
+import flowRight from './flowRight.js';
+import identity from './identity.js';
+import iteratee from './iteratee.js';
+import matches from './matches.js';
+import matchesProperty from './matchesProperty.js';
+import method from './method.js';
+import methodOf from './methodOf.js';
+import mixin from './mixin.js';
+import noop from './noop.js';
+import nthArg from './nthArg.js';
+import over from './over.js';
+import overEvery from './overEvery.js';
+import overSome from './overSome.js';
+import property from './property.js';
+import propertyOf from './propertyOf.js';
+import range from './range.js';
+import rangeRight from './rangeRight.js';
+import stubArray from './stubArray.js';
+import stubFalse from './stubFalse.js';
+import stubObject from './stubObject.js';
+import stubString from './stubString.js';
+import stubTrue from './stubTrue.js';
+import times from './times.js';
+import toPath from './toPath.js';
+import uniqueId from './uniqueId.js';
+
+export default {
+  attempt, bindAll, cond, conforms, constant,
+  defaultTo, flow, flowRight, identity, iteratee,
+  matches, matchesProperty, method, methodOf, mixin,
+  noop, nthArg, over, overEvery, overSome,
+  property, propertyOf, range, rangeRight, stubArray,
+  stubFalse, stubObject, stubString, stubTrue, times,
+  toPath, uniqueId
+};

package/custom/node_modules/lodash-es/util.js

@@ -0,0 +1,33 @@
+export { default as attempt } from './attempt.js';
+export { default as bindAll } from './bindAll.js';
+export { default as cond } from './cond.js';
+export { default as conforms } from './conforms.js';
+export { default as constant } from './constant.js';
+export { default as defaultTo } from './defaultTo.js';
+export { default as flow } from './flow.js';
+export { default as flowRight } from './flowRight.js';
+export { default as identity } from './identity.js';
+export { default as iteratee } from './iteratee.js';
+export { default as matches } from './matches.js';
+export { default as matchesProperty } from './matchesProperty.js';
+export { default as method } from './method.js';
+export { default as methodOf } from './methodOf.js';
+export { default as mixin } from './mixin.js';
+export { default as noop } from './noop.js';
+export { default as nthArg } from './nthArg.js';
+export { default as over } from './over.js';
+export { default as overEvery } from './overEvery.js';
+export { default as overSome } from './overSome.js';
+export { default as property } from './property.js';
+export { default as propertyOf } from './propertyOf.js';
+export { default as range } from './range.js';
+export { default as rangeRight } from './rangeRight.js';
+export { default as stubArray } from './stubArray.js';
+export { default as stubFalse } from './stubFalse.js';
+export { default as stubObject } from './stubObject.js';
+export { default as stubString } from './stubString.js';
+export { default as stubTrue } from './stubTrue.js';
+export { default as times } from './times.js';
+export { default as toPath } from './toPath.js';
+export { default as uniqueId } from './uniqueId.js';
+export { default } from './util.default.js';

package/custom/node_modules/lodash-es/value.js

@@ -0,0 +1 @@
+export { default } from './wrapperValue.js'

package/custom/node_modules/lodash-es/valueOf.js

@@ -0,0 +1 @@
+export { default } from './wrapperValue.js'

package/custom/node_modules/lodash-es/values.js

@@ -0,0 +1,34 @@
+import baseValues from './_baseValues.js';
+import keys from './keys.js';
+
+/**
+ * Creates an array of the own enumerable string keyed property values of `object`.
+ *
+ * **Note:** Non-object values are coerced to objects.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property values.
+ * @example
+ *
+ * function Foo() {
+ *   this.a = 1;
+ *   this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.values(new Foo);
+ * // => [1, 2] (iteration order is not guaranteed)
+ *
+ * _.values('hi');
+ * // => ['h', 'i']
+ */
+function values(object) {
+  return object == null ? [] : baseValues(object, keys(object));
+}
+
+export default values;

package/custom/node_modules/lodash-es/valuesIn.js

@@ -0,0 +1,32 @@
+import baseValues from './_baseValues.js';
+import keysIn from './keysIn.js';
+
+/**
+ * Creates an array of the own and inherited enumerable string keyed property
+ * values of `object`.
+ *
+ * **Note:** Non-object values are coerced to objects.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Object
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property values.
+ * @example
+ *
+ * function Foo() {
+ *   this.a = 1;
+ *   this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.valuesIn(new Foo);
+ * // => [1, 2, 3] (iteration order is not guaranteed)
+ */
+function valuesIn(object) {
+  return object == null ? [] : baseValues(object, keysIn(object));
+}
+
+export default valuesIn;

package/custom/node_modules/lodash-es/without.js

@@ -0,0 +1,31 @@
+import baseDifference from './_baseDifference.js';
+import baseRest from './_baseRest.js';
+import isArrayLikeObject from './isArrayLikeObject.js';
+
+/**
+ * Creates an array excluding all given values using
+ * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+ * for equality comparisons.
+ *
+ * **Note:** Unlike `_.pull`, this method returns a new array.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Array
+ * @param {Array} array The array to inspect.
+ * @param {...*} [values] The values to exclude.
+ * @returns {Array} Returns the new array of filtered values.
+ * @see _.difference, _.xor
+ * @example
+ *
+ * _.without([2, 1, 2, 3], 1, 2);
+ * // => [3]
+ */
+var without = baseRest(function(array, values) {
+  return isArrayLikeObject(array)
+    ? baseDifference(array, values)
+    : [];
+});
+
+export default without;