@limetech/lime-crm-building-blocks 1.120.0 → 1.121.0

package/dist/cjs/{_getTag-CdUodI28.js → _Uint8Array-CXHKqIsu.js}

@@ -1,9 +1,33 @@
 'use strict';
 
-var _Map = require('./_Map-BlpAtLvq.js');
+var _MapCache = require('./_MapCache-DHOVMBKi.js');
 
 /* Built-in method references that are verified to be native. */
-var WeakMap = _Map.getNative(_Map.root, 'WeakMap');
+var WeakMap = _MapCache.getNative(_MapCache.root, 'WeakMap');
+
+/** Used as references for various `Number` constants. */
+var MAX_SAFE_INTEGER$1 = 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) {
+  var type = typeof value;
+  length = length == null ? MAX_SAFE_INTEGER$1 : length;
+
+  return !!length &&
+    (type == 'number' ||
+      (type != 'symbol' && reIsUint.test(value))) &&
+        (value > -1 && value % 1 == 0 && value < length);
+}
 
 /** Used as references for various `Number` constants. */
 var MAX_SAFE_INTEGER = 9007199254740991;
@@ -65,11 +89,11 @@ function isLength(value) {
  * // => false
  */
 function isArrayLike(value) {
-  return value != null && isLength(value.length) && !_Map.isFunction(value);
+  return value != null && isLength(value.length) && !_MapCache.isFunction(value);
 }
 
 /** Used for built-in method references. */
-var objectProto$2 = Object.prototype;
+var objectProto$4 = Object.prototype;
 
 /**
  * Checks if `value` is likely a prototype object.
@@ -80,11 +104,30 @@ var objectProto$2 = Object.prototype;
  */
 function isPrototype(value) {
   var Ctor = value && value.constructor,
-      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto$2;
+      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto$4;
 
   return value === proto;
 }
 
+/**
+ * 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;
+}
+
 /** `Object#toString` result references. */
 var argsTag$1 = '[object Arguments]';
 
@@ -96,17 +139,17 @@ var argsTag$1 = '[object Arguments]';
  * @returns {boolean} Returns `true` if `value` is an `arguments` object,
  */
 function baseIsArguments(value) {
-  return _Map.isObjectLike(value) && _Map.baseGetTag(value) == argsTag$1;
+  return _MapCache.isObjectLike(value) && _MapCache.baseGetTag(value) == argsTag$1;
 }
 
 /** Used for built-in method references. */
-var objectProto$1 = Object.prototype;
+var objectProto$3 = Object.prototype;
 
 /** Used to check objects for own properties. */
-var hasOwnProperty$1 = objectProto$1.hasOwnProperty;
+var hasOwnProperty$2 = objectProto$3.hasOwnProperty;
 
 /** Built-in value references. */
-var propertyIsEnumerable = objectProto$1.propertyIsEnumerable;
+var propertyIsEnumerable$1 = objectProto$3.propertyIsEnumerable;
 
 /**
  * Checks if `value` is likely an `arguments` object.
@@ -127,8 +170,8 @@ var propertyIsEnumerable = objectProto$1.propertyIsEnumerable;
  * // => false
  */
 var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {
-  return _Map.isObjectLike(value) && hasOwnProperty$1.call(value, 'callee') &&
-    !propertyIsEnumerable.call(value, 'callee');
+  return _MapCache.isObjectLike(value) && hasOwnProperty$2.call(value, 'callee') &&
+    !propertyIsEnumerable$1.call(value, 'callee');
 };
 
 /**
@@ -158,7 +201,7 @@ var freeModule$1 = freeExports$1 && typeof module == 'object' && module && !modu
 var moduleExports$1 = freeModule$1 && freeModule$1.exports === freeExports$1;
 
 /** Built-in value references. */
-var Buffer = moduleExports$1 ? _Map.root.Buffer : undefined;
+var Buffer = moduleExports$1 ? _MapCache.root.Buffer : undefined;
 
 /* Built-in method references for those with the same name as other `lodash` methods. */
 var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;
@@ -233,8 +276,8 @@ typedArrayTags[weakMapTag$1] = false;
  * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
  */
 function baseIsTypedArray(value) {
-  return _Map.isObjectLike(value) &&
-    isLength(value.length) && !!typedArrayTags[_Map.baseGetTag(value)];
+  return _MapCache.isObjectLike(value) &&
+    isLength(value.length) && !!typedArrayTags[_MapCache.baseGetTag(value)];
 }
 
 /**
@@ -260,7 +303,7 @@ var freeModule = freeExports && typeof module == 'object' && module && !module.n
 var moduleExports = freeModule && freeModule.exports === freeExports;
 
 /** Detect free variable `process` from Node.js. */
-var freeProcess = moduleExports && _Map.freeGlobal.process;
+var freeProcess = moduleExports && _MapCache.freeGlobal.process;
 
 /** Used to access faster Node.js helpers. */
 var nodeUtil = (function() {
@@ -299,6 +342,47 @@ var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
  */
 var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
 
+/** Used for built-in method references. */
+var objectProto$2 = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty$1 = objectProto$2.hasOwnProperty;
+
+/**
+ * Creates an array of the enumerable property names of the array-like `value`.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @param {boolean} inherited Specify returning inherited property names.
+ * @returns {Array} Returns the array of property names.
+ */
+function arrayLikeKeys(value, inherited) {
+  var isArr = _MapCache.isArray(value),
+      isArg = !isArr && isArguments(value),
+      isBuff = !isArr && !isArg && isBuffer(value),
+      isType = !isArr && !isArg && !isBuff && isTypedArray(value),
+      skipIndexes = isArr || isArg || isBuff || isType,
+      result = skipIndexes ? baseTimes(value.length, String) : [],
+      length = result.length;
+
+  for (var key in value) {
+    if ((hasOwnProperty$1.call(value, key)) &&
+        !(skipIndexes && (
+           // Safari 9 has enumerable `arguments.length` in strict mode.
+           key == 'length' ||
+           // Node.js 0.10 has enumerable non-index properties on buffers.
+           (isBuff && (key == 'offset' || key == 'parent')) ||
+           // PhantomJS 2 has enumerable non-index properties on typed arrays.
+           (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||
+           // Skip index properties.
+           isIndex(key, length)
+        ))) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+
 /**
  * Creates a unary function that invokes `func` with its argument transformed.
  *
@@ -317,10 +401,10 @@ function overArg(func, transform) {
 var nativeKeys = overArg(Object.keys, Object);
 
 /** Used for built-in method references. */
-var objectProto = Object.prototype;
+var objectProto$1 = Object.prototype;
 
 /** Used to check objects for own properties. */
-var hasOwnProperty = objectProto.hasOwnProperty;
+var hasOwnProperty = objectProto$1.hasOwnProperty;
 
 /**
  * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
@@ -342,14 +426,267 @@ function baseKeys(object) {
   return result;
 }
 
+/**
+ * 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);
+}
+
+/**
+ * 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;
+}
+
+/**
+ * Removes all key-value entries from the stack.
+ *
+ * @private
+ * @name clear
+ * @memberOf Stack
+ */
+function stackClear() {
+  this.__data__ = new _MapCache.ListCache;
+  this.size = 0;
+}
+
+/**
+ * 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__,
+      result = data['delete'](key);
+
+  this.size = data.size;
+  return result;
+}
+
+/**
+ * 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) {
+  return this.__data__.get(key);
+}
+
+/**
+ * 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) {
+  return this.__data__.has(key);
+}
+
+/** 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 instance.
+ */
+function stackSet(key, value) {
+  var data = this.__data__;
+  if (data instanceof _MapCache.ListCache) {
+    var pairs = data.__data__;
+    if (!_MapCache.Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {
+      pairs.push([key, value]);
+      this.size = ++data.size;
+      return this;
+    }
+    data = this.__data__ = new _MapCache.MapCache(pairs);
+  }
+  data.set(key, value);
+  this.size = data.size;
+  return this;
+}
+
+/**
+ * Creates a stack cache object to store key-value pairs.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function Stack(entries) {
+  var data = this.__data__ = new _MapCache.ListCache(entries);
+  this.size = data.size;
+}
+
+// Add methods to `Stack`.
+Stack.prototype.clear = stackClear;
+Stack.prototype['delete'] = stackDelete;
+Stack.prototype.get = stackGet;
+Stack.prototype.has = stackHas;
+Stack.prototype.set = stackSet;
+
+/**
+ * A specialized version of `_.filter` 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 {Array} Returns the new filtered array.
+ */
+function arrayFilter(array, predicate) {
+  var index = -1,
+      length = array == null ? 0 : array.length,
+      resIndex = 0,
+      result = [];
+
+  while (++index < length) {
+    var value = array[index];
+    if (predicate(value, index, array)) {
+      result[resIndex++] = value;
+    }
+  }
+  return result;
+}
+
+/**
+ * This method returns a new empty array.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.13.0
+ * @category Util
+ * @returns {Array} Returns the new empty array.
+ * @example
+ *
+ * var arrays = _.times(2, _.stubArray);
+ *
+ * console.log(arrays);
+ * // => [[], []]
+ *
+ * console.log(arrays[0] === arrays[1]);
+ * // => false
+ */
+function stubArray() {
+  return [];
+}
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Built-in value references. */
+var propertyIsEnumerable = objectProto.propertyIsEnumerable;
+
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeGetSymbols = Object.getOwnPropertySymbols;
+
+/**
+ * Creates an array of the own enumerable symbols of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of symbols.
+ */
+var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
+  if (object == null) {
+    return [];
+  }
+  object = Object(object);
+  return arrayFilter(nativeGetSymbols(object), function(symbol) {
+    return propertyIsEnumerable.call(object, symbol);
+  });
+};
+
+/**
+ * The base implementation of `getAllKeys` and `getAllKeysIn` which uses
+ * `keysFunc` and `symbolsFunc` to get the enumerable property names and
+ * symbols of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {Function} keysFunc The function to get the keys of `object`.
+ * @param {Function} symbolsFunc The function to get the symbols of `object`.
+ * @returns {Array} Returns the array of property names and symbols.
+ */
+function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+  var result = keysFunc(object);
+  return _MapCache.isArray(object) ? result : arrayPush(result, symbolsFunc(object));
+}
+
+/**
+ * Creates an array of own enumerable property names and symbols of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names and symbols.
+ */
+function getAllKeys(object) {
+  return baseGetAllKeys(object, keys, getSymbols);
+}
+
 /* Built-in method references that are verified to be native. */
-var DataView = _Map.getNative(_Map.root, 'DataView');
+var DataView = _MapCache.getNative(_MapCache.root, 'DataView');
 
 /* Built-in method references that are verified to be native. */
-var Promise$1 = _Map.getNative(_Map.root, 'Promise');
+var Promise$1 = _MapCache.getNative(_MapCache.root, 'Promise');
 
 /* Built-in method references that are verified to be native. */
-var Set = _Map.getNative(_Map.root, 'Set');
+var Set = _MapCache.getNative(_MapCache.root, 'Set');
 
 /** `Object#toString` result references. */
 var mapTag = '[object Map]',
@@ -361,11 +698,11 @@ var mapTag = '[object Map]',
 var dataViewTag = '[object DataView]';
 
 /** Used to detect maps, sets, and weakmaps. */
-var dataViewCtorString = _Map.toSource(DataView),
-    mapCtorString = _Map.toSource(_Map.Map),
-    promiseCtorString = _Map.toSource(Promise$1),
-    setCtorString = _Map.toSource(Set),
-    weakMapCtorString = _Map.toSource(WeakMap);
+var dataViewCtorString = _MapCache.toSource(DataView),
+    mapCtorString = _MapCache.toSource(_MapCache.Map),
+    promiseCtorString = _MapCache.toSource(Promise$1),
+    setCtorString = _MapCache.toSource(Set),
+    weakMapCtorString = _MapCache.toSource(WeakMap);
 
 /**
  * Gets the `toStringTag` of `value`.
@@ -374,18 +711,18 @@ var dataViewCtorString = _Map.toSource(DataView),
  * @param {*} value The value to query.
  * @returns {string} Returns the `toStringTag`.
  */
-exports.getTag = _Map.baseGetTag;
+exports.getTag = _MapCache.baseGetTag;
 
 // Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.
 if ((DataView && exports.getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||
-    (_Map.Map && exports.getTag(new _Map.Map) != mapTag) ||
+    (_MapCache.Map && exports.getTag(new _MapCache.Map) != mapTag) ||
     (Promise$1 && exports.getTag(Promise$1.resolve()) != promiseTag) ||
     (Set && exports.getTag(new Set) != setTag) ||
     (WeakMap && exports.getTag(new WeakMap) != weakMapTag)) {
   exports.getTag = function(value) {
-    var result = _Map.baseGetTag(value),
+    var result = _MapCache.baseGetTag(value),
         Ctor = result == objectTag ? value.constructor : undefined,
-        ctorString = Ctor ? _Map.toSource(Ctor) : '';
+        ctorString = Ctor ? _MapCache.toSource(Ctor) : '';
 
     if (ctorString) {
       switch (ctorString) {
@@ -400,13 +737,21 @@ if ((DataView && exports.getTag(new DataView(new ArrayBuffer(1))) != dataViewTag
   };
 }
 
-exports.baseKeys = baseKeys;
+/** Built-in value references. */
+var Uint8Array = _MapCache.root.Uint8Array;
+
+exports.Stack = Stack;
+exports.Uint8Array = Uint8Array;
+exports.arrayPush = arrayPush;
 exports.baseUnary = baseUnary;
+exports.getAllKeys = getAllKeys;
 exports.isArguments = isArguments;
 exports.isArrayLike = isArrayLike;
 exports.isBuffer = isBuffer;
+exports.isIndex = isIndex;
 exports.isLength = isLength;
 exports.isPrototype = isPrototype;
 exports.isTypedArray = isTypedArray;
+exports.keys = keys;
 exports.nodeUtil = nodeUtil;
 exports.overArg = overArg;

package/dist/cjs/{_baseIsEqual-BtwicGmu.js → _baseIsEqual-Ba8g_ag_.js}

@@ -1,9 +1,7 @@
 'use strict';
 
-var _Uint8Array = require('./_Uint8Array-C_lvn5HO.js');
-var _MapCache = require('./_MapCache-De1Fwe0H.js');
-var _Map = require('./_Map-BlpAtLvq.js');
-var _getTag = require('./_getTag-CdUodI28.js');
+var _Uint8Array = require('./_Uint8Array-CXHKqIsu.js');
+var _MapCache = require('./_MapCache-DHOVMBKi.js');
 
 /** Used to stand-in for `undefined` hash values. */
 var HASH_UNDEFINED = '__lodash_hash_undefined__';
@@ -224,7 +222,7 @@ var arrayBufferTag = '[object ArrayBuffer]',
     dataViewTag = '[object DataView]';
 
 /** Used to convert symbols to primitives and strings. */
-var symbolProto = _Map.Symbol ? _Map.Symbol.prototype : undefined,
+var symbolProto = _MapCache.Symbol ? _MapCache.Symbol.prototype : undefined,
     symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;
 
 /**
@@ -425,10 +423,10 @@ var hasOwnProperty = objectProto.hasOwnProperty;
  * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
  */
 function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
-  var objIsArr = _Map.isArray(object),
-      othIsArr = _Map.isArray(other),
-      objTag = objIsArr ? arrayTag : _getTag.getTag(object),
-      othTag = othIsArr ? arrayTag : _getTag.getTag(other);
+  var objIsArr = _MapCache.isArray(object),
+      othIsArr = _MapCache.isArray(other),
+      objTag = objIsArr ? arrayTag : _Uint8Array.getTag(object),
+      othTag = othIsArr ? arrayTag : _Uint8Array.getTag(other);
 
   objTag = objTag == argsTag ? objectTag : objTag;
   othTag = othTag == argsTag ? objectTag : othTag;
@@ -437,8 +435,8 @@ function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
       othIsObj = othTag == objectTag,
       isSameTag = objTag == othTag;
 
-  if (isSameTag && _getTag.isBuffer(object)) {
-    if (!_getTag.isBuffer(other)) {
+  if (isSameTag && _Uint8Array.isBuffer(object)) {
+    if (!_Uint8Array.isBuffer(other)) {
       return false;
     }
     objIsArr = true;
@@ -446,7 +444,7 @@ function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
   }
   if (isSameTag && !objIsObj) {
     stack || (stack = new _Uint8Array.Stack);
-    return (objIsArr || _getTag.isTypedArray(object))
+    return (objIsArr || _Uint8Array.isTypedArray(object))
       ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)
       : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
   }
@@ -487,7 +485,7 @@ function baseIsEqual(value, other, bitmask, customizer, stack) {
   if (value === other) {
     return true;
   }
-  if (value == null || other == null || (!_Map.isObjectLike(value) && !_Map.isObjectLike(other))) {
+  if (value == null || other == null || (!_MapCache.isObjectLike(value) && !_MapCache.isObjectLike(other))) {
     return value !== value && other !== other;
   }
   return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);

package/dist/cjs/{_defineProperty-eImBwVFM.js → _defineProperty-Bl_qu8Vn.js}

@@ -1,10 +1,10 @@
 'use strict';
 
-var _Map = require('./_Map-BlpAtLvq.js');
+var _MapCache = require('./_MapCache-DHOVMBKi.js');
 
 var defineProperty = (function() {
   try {
-    var func = _Map.getNative(Object, 'defineProperty');
+    var func = _MapCache.getNative(Object, 'defineProperty');
     func({}, '', {});
     return func;
   } catch (e) {}

package/dist/cjs/{get-BRGtX379.js → get-D1lIKhWp.js}

@@ -1,8 +1,7 @@
 'use strict';
 
-var _Map = require('./_Map-BlpAtLvq.js');
-var isSymbol = require('./isSymbol-D8S28StA.js');
-var _MapCache = require('./_MapCache-De1Fwe0H.js');
+var _MapCache = require('./_MapCache-DHOVMBKi.js');
+var isSymbol = require('./isSymbol-BJj6FNl6.js');
 
 /**
  * A specialized version of `_.map` for arrays without support for iteratee
@@ -25,7 +24,7 @@ function arrayMap(array, iteratee) {
 }
 
 /** Used to convert symbols to primitives and strings. */
-var symbolProto = _Map.Symbol ? _Map.Symbol.prototype : undefined,
+var symbolProto = _MapCache.Symbol ? _MapCache.Symbol.prototype : undefined,
     symbolToString = symbolProto ? symbolProto.toString : undefined;
 
 /**
@@ -41,7 +40,7 @@ function baseToString(value) {
   if (typeof value == 'string') {
     return value;
   }
-  if (_Map.isArray(value)) {
+  if (_MapCache.isArray(value)) {
     // Recursively convert values (susceptible to call stack limits).
     return arrayMap(value, baseToString) + '';
   }
@@ -65,7 +64,7 @@ var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,
  * @returns {boolean} Returns `true` if `value` is a property name, else `false`.
  */
 function isKey(value, object) {
-  if (_Map.isArray(value)) {
+  if (_MapCache.isArray(value)) {
     return false;
   }
   var type = typeof value;
@@ -228,7 +227,7 @@ function toString(value) {
  * @returns {Array} Returns the cast property path array.
  */
 function castPath(value, object) {
-  if (_Map.isArray(value)) {
+  if (_MapCache.isArray(value)) {
     return value;
   }
   return isKey(value, object) ? [value] : stringToPath(toString(value));

package/dist/cjs/{isSymbol-D8S28StA.js → isSymbol-BJj6FNl6.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var _Map = require('./_Map-BlpAtLvq.js');
+var _MapCache = require('./_MapCache-DHOVMBKi.js');
 
 /** `Object#toString` result references. */
 var symbolTag = '[object Symbol]';
@@ -24,7 +24,7 @@ var symbolTag = '[object Symbol]';
  */
 function isSymbol(value) {
   return typeof value == 'symbol' ||
-    (_Map.isObjectLike(value) && _Map.baseGetTag(value) == symbolTag);
+    (_MapCache.isObjectLike(value) && _MapCache.baseGetTag(value) == symbolTag);
 }
 
 exports.isSymbol = isSymbol;

package/dist/cjs/limebb-component-config.cjs.entry.js

@@ -2,10 +2,9 @@
 
 var index = require('./index-C_OnxXhP.js');
 var index_esm = require('./index.esm-iA818ZYg.js');
-var get = require('./get-BRGtX379.js');
-require('./_Map-BlpAtLvq.js');
-require('./isSymbol-D8S28StA.js');
-require('./_MapCache-De1Fwe0H.js');
+var get = require('./get-D1lIKhWp.js');
+require('./_MapCache-DHOVMBKi.js');
+require('./isSymbol-BJj6FNl6.js');
 
 const LimeWebComponentTemplate = (props, children) => {
     const Name = props.name;