@limetech/lime-elements 39.24.1 → 39.24.2

package/dist/cjs/_getTag-BC28Za7d.js

@@ -0,0 +1,355 @@
+'use strict';
+
+var isObject = require('./isObject-B6Osvvqp.js');
+var isObjectLike = require('./isObjectLike-Dlpn-j-1.js');
+var isArrayLike = require('./isArrayLike-C2RwZMG4.js');
+var _getNative = require('./_getNative-Cf52giNE.js');
+
+/* Built-in method references that are verified to be native. */
+var WeakMap = _getNative.getNative(isObject.root, 'WeakMap');
+
+/** Used for built-in method references. */
+var objectProto$2 = 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$2;
+
+  return value === proto;
+}
+
+/** `Object#toString` result references. */
+var argsTag$1 = '[object Arguments]';
+
+/**
+ * The base implementation of `_.isArguments`.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an `arguments` object,
+ */
+function baseIsArguments(value) {
+  return isObjectLike.isObjectLike(value) && isObject.baseGetTag(value) == argsTag$1;
+}
+
+/** Used for built-in method references. */
+var objectProto$1 = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty$1 = objectProto$1.hasOwnProperty;
+
+/** Built-in value references. */
+var propertyIsEnumerable = objectProto$1.propertyIsEnumerable;
+
+/**
+ * Checks if `value` is likely an `arguments` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an `arguments` object,
+ *  else `false`.
+ * @example
+ *
+ * _.isArguments(function() { return arguments; }());
+ * // => true
+ *
+ * _.isArguments([1, 2, 3]);
+ * // => false
+ */
+var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {
+  return isObjectLike.isObjectLike(value) && hasOwnProperty$1.call(value, 'callee') &&
+    !propertyIsEnumerable.call(value, 'callee');
+};
+
+/**
+ * This method returns `false`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.13.0
+ * @category Util
+ * @returns {boolean} Returns `false`.
+ * @example
+ *
+ * _.times(2, _.stubFalse);
+ * // => [false, false]
+ */
+function stubFalse() {
+  return false;
+}
+
+/** Detect free variable `exports`. */
+var freeExports$1 = typeof exports == 'object' && exports && !exports.nodeType && exports;
+
+/** Detect free variable `module`. */
+var freeModule$1 = freeExports$1 && typeof module == 'object' && module && !module.nodeType && module;
+
+/** Detect the popular CommonJS extension `module.exports`. */
+var moduleExports$1 = freeModule$1 && freeModule$1.exports === freeExports$1;
+
+/** Built-in value references. */
+var Buffer = moduleExports$1 ? isObject.root.Buffer : undefined;
+
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;
+
+/**
+ * Checks if `value` is a buffer.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.3.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.
+ * @example
+ *
+ * _.isBuffer(new Buffer(2));
+ * // => true
+ *
+ * _.isBuffer(new Uint8Array(2));
+ * // => false
+ */
+var isBuffer = nativeIsBuffer || stubFalse;
+
+/** `Object#toString` result references. */
+var argsTag = '[object Arguments]',
+    arrayTag = '[object Array]',
+    boolTag = '[object Boolean]',
+    dateTag = '[object Date]',
+    errorTag = '[object Error]',
+    funcTag = '[object Function]',
+    mapTag$1 = '[object Map]',
+    numberTag = '[object Number]',
+    objectTag$1 = '[object Object]',
+    regexpTag = '[object RegExp]',
+    setTag$1 = '[object Set]',
+    stringTag = '[object String]',
+    weakMapTag$1 = '[object WeakMap]';
+
+var arrayBufferTag = '[object ArrayBuffer]',
+    dataViewTag$1 = '[object DataView]',
+    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[dataViewTag$1] = typedArrayTags[dateTag] =
+typedArrayTags[errorTag] = typedArrayTags[funcTag] =
+typedArrayTags[mapTag$1] = typedArrayTags[numberTag] =
+typedArrayTags[objectTag$1] = typedArrayTags[regexpTag] =
+typedArrayTags[setTag$1] = typedArrayTags[stringTag] =
+typedArrayTags[weakMapTag$1] = false;
+
+/**
+ * The base implementation of `_.isTypedArray` without Node.js optimizations.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
+ */
+function baseIsTypedArray(value) {
+  return isObjectLike.isObjectLike(value) &&
+    isArrayLike.isLength(value.length) && !!typedArrayTags[isObject.baseGetTag(value)];
+}
+
+/**
+ * The base implementation of `_.unary` without support for storing metadata.
+ *
+ * @private
+ * @param {Function} func The function to cap arguments for.
+ * @returns {Function} Returns the new capped function.
+ */
+function baseUnary(func) {
+  return function(value) {
+    return func(value);
+  };
+}
+
+/** Detect free variable `exports`. */
+var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;
+
+/** Detect free variable `module`. */
+var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;
+
+/** Detect the popular CommonJS extension `module.exports`. */
+var moduleExports = freeModule && freeModule.exports === freeExports;
+
+/** Detect free variable `process` from Node.js. */
+var freeProcess = moduleExports && isObject.freeGlobal.process;
+
+/** Used to access faster Node.js helpers. */
+var nodeUtil = (function() {
+  try {
+    // Use `util.types` for Node.js 10+.
+    var types = freeModule && freeModule.require && freeModule.require('util').types;
+
+    if (types) {
+      return types;
+    }
+
+    // Legacy `process.binding('util')` for Node.js < 10.
+    return freeProcess && freeProcess.binding && freeProcess.binding('util');
+  } catch (e) {}
+}());
+
+/* 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;
+
+/**
+ * Creates a unary function that invokes `func` with its argument transformed.
+ *
+ * @private
+ * @param {Function} func The function to wrap.
+ * @param {Function} transform The argument transform.
+ * @returns {Function} Returns the new function.
+ */
+function overArg(func, transform) {
+  return function(arg) {
+    return func(transform(arg));
+  };
+}
+
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeKeys = overArg(Object.keys, Object);
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ */
+function baseKeys(object) {
+  if (!isPrototype(object)) {
+    return nativeKeys(object);
+  }
+  var result = [];
+  for (var key in Object(object)) {
+    if (hasOwnProperty.call(object, key) && key != 'constructor') {
+      result.push(key);
+    }
+  }
+  return result;
+}
+
+/* Built-in method references that are verified to be native. */
+var Map = _getNative.getNative(isObject.root, 'Map');
+
+/* Built-in method references that are verified to be native. */
+var DataView = _getNative.getNative(isObject.root, 'DataView');
+
+/* Built-in method references that are verified to be native. */
+var Promise$1 = _getNative.getNative(isObject.root, 'Promise');
+
+/* Built-in method references that are verified to be native. */
+var Set = _getNative.getNative(isObject.root, 'Set');
+
+/** `Object#toString` result references. */
+var mapTag = '[object Map]',
+    objectTag = '[object Object]',
+    promiseTag = '[object Promise]',
+    setTag = '[object Set]',
+    weakMapTag = '[object WeakMap]';
+
+var dataViewTag = '[object DataView]';
+
+/** Used to detect maps, sets, and weakmaps. */
+var dataViewCtorString = _getNative.toSource(DataView),
+    mapCtorString = _getNative.toSource(Map),
+    promiseCtorString = _getNative.toSource(Promise$1),
+    setCtorString = _getNative.toSource(Set),
+    weakMapCtorString = _getNative.toSource(WeakMap);
+
+/**
+ * Gets the `toStringTag` of `value`.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @returns {string} Returns the `toStringTag`.
+ */
+exports.getTag = isObject.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 && exports.getTag(new 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 = isObject.baseGetTag(value),
+        Ctor = result == objectTag ? value.constructor : undefined,
+        ctorString = Ctor ? _getNative.toSource(Ctor) : '';
+
+    if (ctorString) {
+      switch (ctorString) {
+        case dataViewCtorString: return dataViewTag;
+        case mapCtorString: return mapTag;
+        case promiseCtorString: return promiseTag;
+        case setCtorString: return setTag;
+        case weakMapCtorString: return weakMapTag;
+      }
+    }
+    return result;
+  };
+}
+
+exports.Map = Map;
+exports.Set = Set;
+exports.baseKeys = baseKeys;
+exports.baseUnary = baseUnary;
+exports.isArguments = isArguments;
+exports.isBuffer = isBuffer;
+exports.isPrototype = isPrototype;
+exports.isTypedArray = isTypedArray;
+exports.nodeUtil = nodeUtil;
+exports.overArg = overArg;

package/dist/cjs/_isIndex-Bu45fvR7.js

@@ -0,0 +1,27 @@
+'use strict';
+
+/** 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) {
+  var type = typeof value;
+  length = length == null ? MAX_SAFE_INTEGER : length;
+
+  return !!length &&
+    (type == 'number' ||
+      (type != 'symbol' && reIsUint.test(value))) &&
+        (value > -1 && value % 1 == 0 && value < length);
+}
+
+exports.isIndex = isIndex;

package/dist/cjs/{_isIterateeCall-CPWXFS_s.js → _isIterateeCall-BUGt9SrH.js}

@@ -1,8 +1,9 @@
 'use strict';
 
 var toNumber = require('./toNumber-v-1DEwWD.js');
-var eq = require('./eq-B1KBAwmK.js');
-var isArrayLike = require('./isArrayLike-_dR1U5-Y.js');
+var eq = require('./eq-DFcUoVzv.js');
+var isArrayLike = require('./isArrayLike-C2RwZMG4.js');
+var _isIndex = require('./_isIndex-Bu45fvR7.js');
 var isObject = require('./isObject-B6Osvvqp.js');
 
 /** Used as references for various `Number` constants. */
@@ -60,7 +61,7 @@ function isIterateeCall(value, index, object) {
   }
   var type = typeof index;
   if (type == 'number'
-        ? (isArrayLike.isArrayLike(object) && isArrayLike.isIndex(index, object.length))
+        ? (isArrayLike.isArrayLike(object) && _isIndex.isIndex(index, object.length))
         : (type == 'string' && index in object)
       ) {
     return eq.eq(object[index], value);

package/dist/cjs/{cloneDeep-CxFNKF1Y.js → cloneDeep-hE40Q8aw.js}

@@ -1,9 +1,10 @@
 'use strict';
 
-var _baseIsEqual = require('./_baseIsEqual-aOPReRWl.js');
-var _assignValue = require('./_assignValue-DpsLUlF4.js');
-var _getAllKeysIn = require('./_getAllKeysIn-BQIV8aw7.js');
+var _baseIsEqual = require('./_baseIsEqual-CQZKiKbe.js');
+var _assignValue = require('./_assignValue-DQh76m39.js');
+var _getAllKeysIn = require('./_getAllKeysIn-BJsgUTAt.js');
 var isObject = require('./isObject-B6Osvvqp.js');
+var _getTag = require('./_getTag-BC28Za7d.js');
 var isArray = require('./isArray-BuFVIU_i.js');
 var isObjectLike = require('./isObjectLike-Dlpn-j-1.js');
 
@@ -363,7 +364,7 @@ function initCloneByTag(object, tag, isDeep) {
  * @returns {Object} Returns the initialized clone.
  */
 function initCloneObject(object) {
-  return (typeof object.constructor == 'function' && !_baseIsEqual.isPrototype(object))
+  return (typeof object.constructor == 'function' && !_getTag.isPrototype(object))
     ? baseCreate(_getAllKeysIn.getPrototype(object))
     : {};
 }
@@ -379,11 +380,11 @@ var mapTag$1 = '[object Map]';
  * @returns {boolean} Returns `true` if `value` is a map, else `false`.
  */
 function baseIsMap(value) {
-  return isObjectLike.isObjectLike(value) && _baseIsEqual.getTag(value) == mapTag$1;
+  return isObjectLike.isObjectLike(value) && _getTag.getTag(value) == mapTag$1;
 }
 
 /* Node.js helper references. */
-var nodeIsMap = _baseIsEqual.nodeUtil && _baseIsEqual.nodeUtil.isMap;
+var nodeIsMap = _getTag.nodeUtil && _getTag.nodeUtil.isMap;
 
 /**
  * Checks if `value` is classified as a `Map` object.
@@ -402,7 +403,7 @@ var nodeIsMap = _baseIsEqual.nodeUtil && _baseIsEqual.nodeUtil.isMap;
  * _.isMap(new WeakMap);
  * // => false
  */
-var isMap = nodeIsMap ? _baseIsEqual.baseUnary(nodeIsMap) : baseIsMap;
+var isMap = nodeIsMap ? _getTag.baseUnary(nodeIsMap) : baseIsMap;
 
 /** `Object#toString` result references. */
 var setTag$1 = '[object Set]';
@@ -415,11 +416,11 @@ var setTag$1 = '[object Set]';
  * @returns {boolean} Returns `true` if `value` is a set, else `false`.
  */
 function baseIsSet(value) {
-  return isObjectLike.isObjectLike(value) && _baseIsEqual.getTag(value) == setTag$1;
+  return isObjectLike.isObjectLike(value) && _getTag.getTag(value) == setTag$1;
 }
 
 /* Node.js helper references. */
-var nodeIsSet = _baseIsEqual.nodeUtil && _baseIsEqual.nodeUtil.isSet;
+var nodeIsSet = _getTag.nodeUtil && _getTag.nodeUtil.isSet;
 
 /**
  * Checks if `value` is classified as a `Set` object.
@@ -438,7 +439,7 @@ var nodeIsSet = _baseIsEqual.nodeUtil && _baseIsEqual.nodeUtil.isSet;
  * _.isSet(new WeakSet);
  * // => false
  */
-var isSet = nodeIsSet ? _baseIsEqual.baseUnary(nodeIsSet) : baseIsSet;
+var isSet = nodeIsSet ? _getTag.baseUnary(nodeIsSet) : baseIsSet;
 
 /** Used to compose bitmasks for cloning. */
 var CLONE_DEEP_FLAG$1 = 1,
@@ -528,10 +529,10 @@ function baseClone(value, bitmask, customizer, key, object, stack) {
       return copyArray(value, result);
     }
   } else {
-    var tag = _baseIsEqual.getTag(value),
+    var tag = _getTag.getTag(value),
         isFunc = tag == funcTag || tag == genTag;
 
-    if (_baseIsEqual.isBuffer(value)) {
+    if (_getTag.isBuffer(value)) {
       return cloneBuffer(value, isDeep);
     }
     if (tag == objectTag || tag == argsTag || (isFunc && !object)) {

package/dist/cjs/{difference-Bfsq4sXB.js → difference-B543MGsY.js}

@@ -1,11 +1,12 @@
 'use strict';
 
-var _baseIsEqual = require('./_baseIsEqual-aOPReRWl.js');
+var _baseIsEqual = require('./_baseIsEqual-CQZKiKbe.js');
 var isObject = require('./isObject-B6Osvvqp.js');
+var _getTag = require('./_getTag-BC28Za7d.js');
 var isArray = require('./isArray-BuFVIU_i.js');
 var identity = require('./identity-Dz5mxHaJ.js');
-var _defineProperty = require('./_defineProperty-BDFOiqJL.js');
-var isArrayLike = require('./isArrayLike-_dR1U5-Y.js');
+var _defineProperty = require('./_defineProperty-Csu6P9HT.js');
+var isArrayLike = require('./isArrayLike-C2RwZMG4.js');
 var isObjectLike = require('./isObjectLike-Dlpn-j-1.js');
 
 /**
@@ -257,7 +258,7 @@ var spreadableSymbol = isObject.Symbol ? isObject.Symbol.isConcatSpreadable : un
  * @returns {boolean} Returns `true` if `value` is flattenable, else `false`.
  */
 function isFlattenable(value) {
-  return isArray.isArray(value) || _baseIsEqual.isArguments(value) ||
+  return isArray.isArray(value) || _getTag.isArguments(value) ||
     !!(spreadableSymbol && value && value[spreadableSymbol]);
 }
 

package/dist/cjs/eq-DFcUoVzv.js

@@ -0,0 +1,39 @@
+'use strict';
+
+/**
+ * Performs a
+ * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+ * comparison between two values to determine if they are equivalent.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @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 = { 'a': 1 };
+ * var other = { 'a': 1 };
+ *
+ * _.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);
+}
+
+exports.eq = eq;

package/dist/cjs/file-metadata-BrhOssGG.js

@@ -0,0 +1,76 @@
+'use strict';
+
+var icons = require('./icons-isR5V1X0.js');
+var getIconProps = require('./get-icon-props-CwpDdQDI.js');
+
+/**
+ *
+ * @param file
+ */
+function getFileIcon(file) {
+    const name = getIconProps.getIconName(file.icon);
+    if (name) {
+        return name;
+    }
+    const extension = getExtension(file);
+    if (!extension) {
+        return;
+    }
+    return icons.getIconForFile(extension);
+}
+/**
+ *
+ * @param file
+ */
+function getFileColor(file) {
+    const color = getIconProps.getIconColor(file.icon, file.iconColor);
+    if (color) {
+        return color;
+    }
+    const extension = getExtension(file);
+    if (!extension) {
+        return;
+    }
+    return icons.getIconFillColorForFile(extension);
+}
+/**
+ *
+ * @param file
+ */
+function getFileBackgroundColor(file) {
+    const backgroundColor = getIconProps.getIconBackgroundColor(file.icon, file.iconBackgroundColor);
+    if (backgroundColor) {
+        return backgroundColor;
+    }
+    const extension = getExtension(file);
+    if (!extension) {
+        return;
+    }
+    return icons.getIconBackgroundColorForFile(extension);
+}
+/**
+ *
+ * @param file
+ */
+function getFileExtensionTitle(file) {
+    const name = getIconProps.getIconName(file.icon);
+    if (name) {
+        return name;
+    }
+    return getExtension(file);
+}
+/**
+ *
+ * @param file
+ */
+function getExtension(file) {
+    if (!file) {
+        return;
+    }
+    return file.filename.split('.').pop();
+}
+
+exports.getFileBackgroundColor = getFileBackgroundColor;
+exports.getFileColor = getFileColor;
+exports.getFileExtensionTitle = getFileExtensionTitle;
+exports.getFileIcon = getFileIcon;

package/dist/cjs/{files-Cf615Ytp.js → files-Bt11HLi4.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var fileMetadata = require('./file-metadata-rQ0WzFlZ.js');
+var fileMetadata = require('./file-metadata-BrhOssGG.js');
 
 /**
  *

package/dist/cjs/{focus-trigger-element-Brw8VubX.js → focus-trigger-element-BfnJmxKO.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var _assignValue = require('./_assignValue-DpsLUlF4.js');
+var _assignValue = require('./_assignValue-DQh76m39.js');
 
 /**
  * This base implementation of `_.zipObject` which assigns values using `assignFunc`.