@adminforth/rich-editor 1.0.2

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

@@ -0,0 +1,62 @@
+import baseGetTag from './_baseGetTag.js';
+import getPrototype from './_getPrototype.js';
+import isObjectLike from './isObjectLike.js';
+
+/** `Object#toString` result references. */
+var objectTag = '[object Object]';
+
+/** Used for built-in method references. */
+var funcProto = Function.prototype,
+    objectProto = Object.prototype;
+
+/** Used to resolve the decompiled source of functions. */
+var funcToString = funcProto.toString;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/** Used to infer the `Object` constructor. */
+var objectCtorString = funcToString.call(Object);
+
+/**
+ * Checks if `value` is a plain object, that is, an object created by the
+ * `Object` constructor or one with a `[[Prototype]]` of `null`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.8.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
+ * @example
+ *
+ * function Foo() {
+ *   this.a = 1;
+ * }
+ *
+ * _.isPlainObject(new Foo);
+ * // => false
+ *
+ * _.isPlainObject([1, 2, 3]);
+ * // => false
+ *
+ * _.isPlainObject({ 'x': 0, 'y': 0 });
+ * // => true
+ *
+ * _.isPlainObject(Object.create(null));
+ * // => true
+ */
+function isPlainObject(value) {
+  if (!isObjectLike(value) || baseGetTag(value) != objectTag) {
+    return false;
+  }
+  var proto = getPrototype(value);
+  if (proto === null) {
+    return true;
+  }
+  var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;
+  return typeof Ctor == 'function' && Ctor instanceof Ctor &&
+    funcToString.call(Ctor) == objectCtorString;
+}
+
+export default isPlainObject;

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

@@ -0,0 +1,27 @@
+import baseIsRegExp from './_baseIsRegExp.js';
+import baseUnary from './_baseUnary.js';
+import nodeUtil from './_nodeUtil.js';
+
+/* Node.js helper references. */
+var nodeIsRegExp = nodeUtil && nodeUtil.isRegExp;
+
+/**
+ * Checks if `value` is classified as a `RegExp` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.
+ * @example
+ *
+ * _.isRegExp(/abc/);
+ * // => true
+ *
+ * _.isRegExp('/abc/');
+ * // => false
+ */
+var isRegExp = nodeIsRegExp ? baseUnary(nodeIsRegExp) : baseIsRegExp;
+
+export default isRegExp;

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

@@ -0,0 +1,37 @@
+import isInteger from './isInteger.js';
+
+/** Used as references for various `Number` constants. */
+var MAX_SAFE_INTEGER = 9007199254740991;
+
+/**
+ * Checks if `value` is a safe integer. An integer is safe if it's an IEEE-754
+ * double precision number which isn't the result of a rounded unsafe integer.
+ *
+ * **Note:** This method is based on
+ * [`Number.isSafeInteger`](https://mdn.io/Number/isSafeInteger).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a safe integer, else `false`.
+ * @example
+ *
+ * _.isSafeInteger(3);
+ * // => true
+ *
+ * _.isSafeInteger(Number.MIN_VALUE);
+ * // => false
+ *
+ * _.isSafeInteger(Infinity);
+ * // => false
+ *
+ * _.isSafeInteger('3');
+ * // => false
+ */
+function isSafeInteger(value) {
+  return isInteger(value) && value >= -MAX_SAFE_INTEGER && value <= MAX_SAFE_INTEGER;
+}
+
+export default isSafeInteger;

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

@@ -0,0 +1,27 @@
+import baseIsSet from './_baseIsSet.js';
+import baseUnary from './_baseUnary.js';
+import nodeUtil from './_nodeUtil.js';
+
+/* Node.js helper references. */
+var nodeIsSet = nodeUtil && nodeUtil.isSet;
+
+/**
+ * Checks if `value` is classified as a `Set` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.3.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a set, else `false`.
+ * @example
+ *
+ * _.isSet(new Set);
+ * // => true
+ *
+ * _.isSet(new WeakSet);
+ * // => false
+ */
+var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;
+
+export default isSet;

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

@@ -0,0 +1,30 @@
+import baseGetTag from './_baseGetTag.js';
+import isArray from './isArray.js';
+import isObjectLike from './isObjectLike.js';
+
+/** `Object#toString` result references. */
+var stringTag = '[object String]';
+
+/**
+ * Checks if `value` is classified as a `String` primitive or object.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a string, else `false`.
+ * @example
+ *
+ * _.isString('abc');
+ * // => true
+ *
+ * _.isString(1);
+ * // => false
+ */
+function isString(value) {
+  return typeof value == 'string' ||
+    (!isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag);
+}
+
+export default isString;

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

@@ -0,0 +1,29 @@
+import baseGetTag from './_baseGetTag.js';
+import isObjectLike from './isObjectLike.js';
+
+/** `Object#toString` result references. */
+var symbolTag = '[object Symbol]';
+
+/**
+ * Checks if `value` is classified as a `Symbol` primitive or object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
+ * @example
+ *
+ * _.isSymbol(Symbol.iterator);
+ * // => true
+ *
+ * _.isSymbol('abc');
+ * // => false
+ */
+function isSymbol(value) {
+  return typeof value == 'symbol' ||
+    (isObjectLike(value) && baseGetTag(value) == symbolTag);
+}
+
+export default isSymbol;

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

@@ -0,0 +1,27 @@
+import baseIsTypedArray from './_baseIsTypedArray.js';
+import baseUnary from './_baseUnary.js';
+import nodeUtil from './_nodeUtil.js';
+
+/* Node.js helper references. */
+var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
+
+/**
+ * Checks if `value` is classified as a typed array.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
+ * @example
+ *
+ * _.isTypedArray(new Uint8Array);
+ * // => true
+ *
+ * _.isTypedArray([]);
+ * // => false
+ */
+var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
+
+export default isTypedArray;

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

@@ -0,0 +1,22 @@
+/**
+ * Checks if `value` is `undefined`.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is `undefined`, else `false`.
+ * @example
+ *
+ * _.isUndefined(void 0);
+ * // => true
+ *
+ * _.isUndefined(null);
+ * // => false
+ */
+function isUndefined(value) {
+  return value === undefined;
+}
+
+export default isUndefined;

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

@@ -0,0 +1,28 @@
+import getTag from './_getTag.js';
+import isObjectLike from './isObjectLike.js';
+
+/** `Object#toString` result references. */
+var weakMapTag = '[object WeakMap]';
+
+/**
+ * Checks if `value` is classified as a `WeakMap` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.3.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a weak map, else `false`.
+ * @example
+ *
+ * _.isWeakMap(new WeakMap);
+ * // => true
+ *
+ * _.isWeakMap(new Map);
+ * // => false
+ */
+function isWeakMap(value) {
+  return isObjectLike(value) && getTag(value) == weakMapTag;
+}
+
+export default isWeakMap;

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

@@ -0,0 +1,28 @@
+import baseGetTag from './_baseGetTag.js';
+import isObjectLike from './isObjectLike.js';
+
+/** `Object#toString` result references. */
+var weakSetTag = '[object WeakSet]';
+
+/**
+ * Checks if `value` is classified as a `WeakSet` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.3.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a weak set, else `false`.
+ * @example
+ *
+ * _.isWeakSet(new WeakSet);
+ * // => true
+ *
+ * _.isWeakSet(new Set);
+ * // => false
+ */
+function isWeakSet(value) {
+  return isObjectLike(value) && baseGetTag(value) == weakSetTag;
+}
+
+export default isWeakSet;

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

@@ -0,0 +1,53 @@
+import baseClone from './_baseClone.js';
+import baseIteratee from './_baseIteratee.js';
+
+/** Used to compose bitmasks for cloning. */
+var CLONE_DEEP_FLAG = 1;
+
+/**
+ * Creates a function that invokes `func` with the arguments of the created
+ * function. If `func` is a property name, the created function returns the
+ * property value for a given element. If `func` is an array or object, the
+ * created function returns `true` for elements that contain the equivalent
+ * source properties, otherwise it returns `false`.
+ *
+ * @static
+ * @since 4.0.0
+ * @memberOf _
+ * @category Util
+ * @param {*} [func=_.identity] The value to convert to a callback.
+ * @returns {Function} Returns the callback.
+ * @example
+ *
+ * var users = [
+ *   { 'user': 'barney', 'age': 36, 'active': true },
+ *   { 'user': 'fred',   'age': 40, 'active': false }
+ * ];
+ *
+ * // The `_.matches` iteratee shorthand.
+ * _.filter(users, _.iteratee({ 'user': 'barney', 'active': true }));
+ * // => [{ 'user': 'barney', 'age': 36, 'active': true }]
+ *
+ * // The `_.matchesProperty` iteratee shorthand.
+ * _.filter(users, _.iteratee(['user', 'fred']));
+ * // => [{ 'user': 'fred', 'age': 40 }]
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.map(users, _.iteratee('user'));
+ * // => ['barney', 'fred']
+ *
+ * // Create custom iteratee shorthands.
+ * _.iteratee = _.wrap(_.iteratee, function(iteratee, func) {
+ *   return !_.isRegExp(func) ? iteratee(func) : function(string) {
+ *     return func.test(string);
+ *   };
+ * });
+ *
+ * _.filter(['abc', 'def'], /ef/);
+ * // => ['def']
+ */
+function iteratee(func) {
+  return baseIteratee(typeof func == 'function' ? func : baseClone(func, CLONE_DEEP_FLAG));
+}
+
+export default iteratee;

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

@@ -0,0 +1,26 @@
+/** Used for built-in method references. */
+var arrayProto = Array.prototype;
+
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeJoin = arrayProto.join;
+
+/**
+ * Converts all elements in `array` into a string separated by `separator`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Array
+ * @param {Array} array The array to convert.
+ * @param {string} [separator=','] The element separator.
+ * @returns {string} Returns the joined string.
+ * @example
+ *
+ * _.join(['a', 'b', 'c'], '~');
+ * // => 'a~b~c'
+ */
+function join(array, separator) {
+  return array == null ? '' : nativeJoin.call(array, separator);
+}
+
+export default join;

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

@@ -0,0 +1,28 @@
+import createCompounder from './_createCompounder.js';
+
+/**
+ * Converts `string` to
+ * [kebab case](https://en.wikipedia.org/wiki/Letter_case#Special_case_styles).
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category String
+ * @param {string} [string=''] The string to convert.
+ * @returns {string} Returns the kebab cased string.
+ * @example
+ *
+ * _.kebabCase('Foo Bar');
+ * // => 'foo-bar'
+ *
+ * _.kebabCase('fooBar');
+ * // => 'foo-bar'
+ *
+ * _.kebabCase('__FOO_BAR__');
+ * // => 'foo-bar'
+ */
+var kebabCase = createCompounder(function(result, word, index) {
+  return result + (index ? '-' : '') + word.toLowerCase();
+});
+
+export default kebabCase;

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

@@ -0,0 +1,36 @@
+import baseAssignValue from './_baseAssignValue.js';
+import createAggregator from './_createAggregator.js';
+
+/**
+ * Creates an object composed of keys generated from the results of running
+ * each element of `collection` thru `iteratee`. The corresponding value of
+ * each key is the last element responsible for generating the key. The
+ * iteratee is invoked with one argument: (value).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} [iteratee=_.identity] The iteratee to transform keys.
+ * @returns {Object} Returns the composed aggregate object.
+ * @example
+ *
+ * var array = [
+ *   { 'dir': 'left', 'code': 97 },
+ *   { 'dir': 'right', 'code': 100 }
+ * ];
+ *
+ * _.keyBy(array, function(o) {
+ *   return String.fromCharCode(o.code);
+ * });
+ * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }
+ *
+ * _.keyBy(array, 'dir');
+ * // => { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } }
+ */
+var keyBy = createAggregator(function(result, value, key) {
+  baseAssignValue(result, key, value);
+});
+
+export default keyBy;

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

@@ -0,0 +1,37 @@
+import arrayLikeKeys from './_arrayLikeKeys.js';
+import baseKeys from './_baseKeys.js';
+import isArrayLike from './isArrayLike.js';
+
+/**
+ * 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/7.0/#sec-object.keys)
+ * for more details.
+ *
+ * @static
+ * @since 0.1.0
+ * @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) {
+  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
+}
+
+export default keys;

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

@@ -0,0 +1,32 @@
+import arrayLikeKeys from './_arrayLikeKeys.js';
+import baseKeysIn from './_baseKeysIn.js';
+import isArrayLike from './isArrayLike.js';
+
+/**
+ * Creates an array of the own and inherited enumerable property names 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 names.
+ * @example
+ *
+ * function Foo() {
+ *   this.a = 1;
+ *   this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.keysIn(new Foo);
+ * // => ['a', 'b', 'c'] (iteration order is not guaranteed)
+ */
+function keysIn(object) {
+  return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
+}
+
+export default keysIn;

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

@@ -0,0 +1,71 @@
+import castArray from './castArray.js';
+import clone from './clone.js';
+import cloneDeep from './cloneDeep.js';
+import cloneDeepWith from './cloneDeepWith.js';
+import cloneWith from './cloneWith.js';
+import conformsTo from './conformsTo.js';
+import eq from './eq.js';
+import gt from './gt.js';
+import gte from './gte.js';
+import isArguments from './isArguments.js';
+import isArray from './isArray.js';
+import isArrayBuffer from './isArrayBuffer.js';
+import isArrayLike from './isArrayLike.js';
+import isArrayLikeObject from './isArrayLikeObject.js';
+import isBoolean from './isBoolean.js';
+import isBuffer from './isBuffer.js';
+import isDate from './isDate.js';
+import isElement from './isElement.js';
+import isEmpty from './isEmpty.js';
+import isEqual from './isEqual.js';
+import isEqualWith from './isEqualWith.js';
+import isError from './isError.js';
+import isFinite from './isFinite.js';
+import isFunction from './isFunction.js';
+import isInteger from './isInteger.js';
+import isLength from './isLength.js';
+import isMap from './isMap.js';
+import isMatch from './isMatch.js';
+import isMatchWith from './isMatchWith.js';
+import isNaN from './isNaN.js';
+import isNative from './isNative.js';
+import isNil from './isNil.js';
+import isNull from './isNull.js';
+import isNumber from './isNumber.js';
+import isObject from './isObject.js';
+import isObjectLike from './isObjectLike.js';
+import isPlainObject from './isPlainObject.js';
+import isRegExp from './isRegExp.js';
+import isSafeInteger from './isSafeInteger.js';
+import isSet from './isSet.js';
+import isString from './isString.js';
+import isSymbol from './isSymbol.js';
+import isTypedArray from './isTypedArray.js';
+import isUndefined from './isUndefined.js';
+import isWeakMap from './isWeakMap.js';
+import isWeakSet from './isWeakSet.js';
+import lt from './lt.js';
+import lte from './lte.js';
+import toArray from './toArray.js';
+import toFinite from './toFinite.js';
+import toInteger from './toInteger.js';
+import toLength from './toLength.js';
+import toNumber from './toNumber.js';
+import toPlainObject from './toPlainObject.js';
+import toSafeInteger from './toSafeInteger.js';
+import toString from './toString.js';
+
+export default {
+  castArray, clone, cloneDeep, cloneDeepWith, cloneWith,
+  conformsTo, eq, gt, gte, isArguments,
+  isArray, isArrayBuffer, isArrayLike, isArrayLikeObject, isBoolean,
+  isBuffer, isDate, isElement, isEmpty, isEqual,
+  isEqualWith, isError, isFinite, isFunction, isInteger,
+  isLength, isMap, isMatch, isMatchWith, isNaN,
+  isNative, isNil, isNull, isNumber, isObject,
+  isObjectLike, isPlainObject, isRegExp, isSafeInteger, isSet,
+  isString, isSymbol, isTypedArray, isUndefined, isWeakMap,
+  isWeakSet, lt, lte, toArray, toFinite,
+  toInteger, toLength, toNumber, toPlainObject, toSafeInteger,
+  toString
+};

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

@@ -0,0 +1,57 @@
+export { default as castArray } from './castArray.js';
+export { default as clone } from './clone.js';
+export { default as cloneDeep } from './cloneDeep.js';
+export { default as cloneDeepWith } from './cloneDeepWith.js';
+export { default as cloneWith } from './cloneWith.js';
+export { default as conformsTo } from './conformsTo.js';
+export { default as eq } from './eq.js';
+export { default as gt } from './gt.js';
+export { default as gte } from './gte.js';
+export { default as isArguments } from './isArguments.js';
+export { default as isArray } from './isArray.js';
+export { default as isArrayBuffer } from './isArrayBuffer.js';
+export { default as isArrayLike } from './isArrayLike.js';
+export { default as isArrayLikeObject } from './isArrayLikeObject.js';
+export { default as isBoolean } from './isBoolean.js';
+export { default as isBuffer } from './isBuffer.js';
+export { default as isDate } from './isDate.js';
+export { default as isElement } from './isElement.js';
+export { default as isEmpty } from './isEmpty.js';
+export { default as isEqual } from './isEqual.js';
+export { default as isEqualWith } from './isEqualWith.js';
+export { default as isError } from './isError.js';
+export { default as isFinite } from './isFinite.js';
+export { default as isFunction } from './isFunction.js';
+export { default as isInteger } from './isInteger.js';
+export { default as isLength } from './isLength.js';
+export { default as isMap } from './isMap.js';
+export { default as isMatch } from './isMatch.js';
+export { default as isMatchWith } from './isMatchWith.js';
+export { default as isNaN } from './isNaN.js';
+export { default as isNative } from './isNative.js';
+export { default as isNil } from './isNil.js';
+export { default as isNull } from './isNull.js';
+export { default as isNumber } from './isNumber.js';
+export { default as isObject } from './isObject.js';
+export { default as isObjectLike } from './isObjectLike.js';
+export { default as isPlainObject } from './isPlainObject.js';
+export { default as isRegExp } from './isRegExp.js';
+export { default as isSafeInteger } from './isSafeInteger.js';
+export { default as isSet } from './isSet.js';
+export { default as isString } from './isString.js';
+export { default as isSymbol } from './isSymbol.js';
+export { default as isTypedArray } from './isTypedArray.js';
+export { default as isUndefined } from './isUndefined.js';
+export { default as isWeakMap } from './isWeakMap.js';
+export { default as isWeakSet } from './isWeakSet.js';
+export { default as lt } from './lt.js';
+export { default as lte } from './lte.js';
+export { default as toArray } from './toArray.js';
+export { default as toFinite } from './toFinite.js';
+export { default as toInteger } from './toInteger.js';
+export { default as toLength } from './toLength.js';
+export { default as toNumber } from './toNumber.js';
+export { default as toPlainObject } from './toPlainObject.js';
+export { default as toSafeInteger } from './toSafeInteger.js';
+export { default as toString } from './toString.js';
+export { default } from './lang.default.js';