@soul-refiner/design-system 2.0.0-alpha.2 → 2.0.0-alpha.20

package/dist/node_modules/lodash/_baseSetToString.js

@@ -0,0 +1,30 @@
+'use strict';
+
+var constant$1 = require('./constant.js');
+var _defineProperty = require('./_defineProperty.js');
+var identity$1 = require('./identity.js');
+
+var constant = constant$1.constant_1,
+    defineProperty = _defineProperty._defineProperty,
+    identity = identity$1.identity_1;
+
+/**
+ * The base implementation of `setToString` without support for hot loop shorting.
+ *
+ * @private
+ * @param {Function} func The function to modify.
+ * @param {Function} string The `toString` result.
+ * @returns {Function} Returns `func`.
+ */
+var baseSetToString = !defineProperty ? identity : function(func, string) {
+  return defineProperty(func, 'toString', {
+    'configurable': true,
+    'enumerable': false,
+    'value': constant(string),
+    'writable': true
+  });
+};
+
+var _baseSetToString = baseSetToString;
+
+exports._baseSetToString = _baseSetToString;

package/dist/node_modules/lodash/_baseSlice.js

@@ -0,0 +1,36 @@
+'use strict';
+
+/**
+ * The base implementation of `_.slice` without an iteratee call guard.
+ *
+ * @private
+ * @param {Array} array The array to slice.
+ * @param {number} [start=0] The start position.
+ * @param {number} [end=array.length] The end position.
+ * @returns {Array} Returns the slice of `array`.
+ */
+
+function baseSlice(array, start, end) {
+  var index = -1,
+      length = array.length;
+
+  if (start < 0) {
+    start = -start > length ? 0 : (length + start);
+  }
+  end = end > length ? length : end;
+  if (end < 0) {
+    end += length;
+  }
+  length = start > end ? 0 : ((end - start) >>> 0);
+  start >>>= 0;
+
+  var result = Array(length);
+  while (++index < length) {
+    result[index] = array[index + start];
+  }
+  return result;
+}
+
+var _baseSlice = baseSlice;
+
+exports._baseSlice = _baseSlice;

package/dist/node_modules/lodash/_baseTimes.js

@@ -0,0 +1,25 @@
+'use strict';
+
+/**
+ * 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;
+}
+
+var _baseTimes = baseTimes;
+
+exports._baseTimes = _baseTimes;

package/dist/node_modules/lodash/_baseToString.js

@@ -0,0 +1,46 @@
+'use strict';
+
+var _Symbol = require('./_Symbol.js');
+var _arrayMap = require('./_arrayMap.js');
+var isArray$1 = require('./isArray.js');
+var isSymbol$1 = require('./isSymbol.js');
+
+var Symbol = _Symbol._Symbol,
+    arrayMap = _arrayMap._arrayMap,
+    isArray = isArray$1.isArray_1,
+    isSymbol = isSymbol$1.isSymbol_1;
+
+/** Used as references for various `Number` constants. */
+var INFINITY = 1 / 0;
+
+/** Used to convert symbols to primitives and strings. */
+var symbolProto = Symbol ? Symbol.prototype : undefined,
+    symbolToString = symbolProto ? symbolProto.toString : undefined;
+
+/**
+ * The base implementation of `_.toString` which doesn't convert nullish
+ * values to empty strings.
+ *
+ * @private
+ * @param {*} value The value to process.
+ * @returns {string} Returns the string.
+ */
+function baseToString(value) {
+  // Exit early for strings to avoid a performance hit in some environments.
+  if (typeof value == 'string') {
+    return value;
+  }
+  if (isArray(value)) {
+    // Recursively convert values (susceptible to call stack limits).
+    return arrayMap(value, baseToString) + '';
+  }
+  if (isSymbol(value)) {
+    return symbolToString ? symbolToString.call(value) : '';
+  }
+  var result = (value + '');
+  return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
+}
+
+var _baseToString = baseToString;
+
+exports._baseToString = _baseToString;

package/dist/node_modules/lodash/_baseUnary.js

@@ -0,0 +1,19 @@
+'use strict';
+
+/**
+ * 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);
+  };
+}
+
+var _baseUnary = baseUnary;
+
+exports._baseUnary = _baseUnary;

package/dist/node_modules/lodash/_baseUnset.js

@@ -0,0 +1,29 @@
+'use strict';
+
+var _castPath = require('./_castPath.js');
+var last$1 = require('./last.js');
+var _parent = require('./_parent.js');
+var _toKey = require('./_toKey.js');
+
+var castPath = _castPath._castPath,
+    last = last$1.last_1,
+    parent = _parent._parent,
+    toKey = _toKey._toKey;
+
+/**
+ * The base implementation of `_.unset`.
+ *
+ * @private
+ * @param {Object} object The object to modify.
+ * @param {Array|string} path The property path to unset.
+ * @returns {boolean} Returns `true` if the property is deleted, else `false`.
+ */
+function baseUnset(object, path) {
+  path = castPath(path, object);
+  object = parent(object, path);
+  return object == null || delete object[toKey(last(path))];
+}
+
+var _baseUnset = baseUnset;
+
+exports._baseUnset = _baseUnset;

package/dist/node_modules/lodash/_baseValues.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var _arrayMap = require('./_arrayMap.js');
+
+var arrayMap = _arrayMap._arrayMap;
+
+/**
+ * The base implementation of `_.values` and `_.valuesIn` which creates an
+ * array of `object` property values corresponding to the property names
+ * of `props`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {Array} props The property names to get values for.
+ * @returns {Object} Returns the array of property values.
+ */
+function baseValues(object, props) {
+  return arrayMap(props, function(key) {
+    return object[key];
+  });
+}
+
+var _baseValues = baseValues;
+
+exports._baseValues = _baseValues;

package/dist/node_modules/lodash/_cacheHas.js

@@ -0,0 +1,18 @@
+'use strict';
+
+/**
+ * Checks if a `cache` value for `key` exists.
+ *
+ * @private
+ * @param {Object} cache The cache to query.
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+
+function cacheHas(cache, key) {
+  return cache.has(key);
+}
+
+var _cacheHas = cacheHas;
+
+exports._cacheHas = _cacheHas;

package/dist/node_modules/lodash/_castPath.js

@@ -0,0 +1,30 @@
+'use strict';
+
+var isArray$1 = require('./isArray.js');
+var _isKey = require('./_isKey.js');
+var _stringToPath = require('./_stringToPath.js');
+var toString$1 = require('./toString.js');
+
+var isArray = isArray$1.isArray_1,
+    isKey = _isKey._isKey,
+    stringToPath = _stringToPath._stringToPath,
+    toString = toString$1.toString_1;
+
+/**
+ * Casts `value` to a path array if it's not one.
+ *
+ * @private
+ * @param {*} value The value to inspect.
+ * @param {Object} [object] The object to query keys on.
+ * @returns {Array} Returns the cast property path array.
+ */
+function castPath(value, object) {
+  if (isArray(value)) {
+    return value;
+  }
+  return isKey(value, object) ? [value] : stringToPath(toString(value));
+}
+
+var _castPath = castPath;
+
+exports._castPath = _castPath;

package/dist/node_modules/lodash/_cloneArrayBuffer.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var _Uint8Array = require('./_Uint8Array.js');
+
+var Uint8Array = _Uint8Array._Uint8Array;
+
+/**
+ * Creates a clone of `arrayBuffer`.
+ *
+ * @private
+ * @param {ArrayBuffer} arrayBuffer The array buffer to clone.
+ * @returns {ArrayBuffer} Returns the cloned array buffer.
+ */
+function cloneArrayBuffer(arrayBuffer) {
+  var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
+  new Uint8Array(result).set(new Uint8Array(arrayBuffer));
+  return result;
+}
+
+var _cloneArrayBuffer = cloneArrayBuffer;
+
+exports._cloneArrayBuffer = _cloneArrayBuffer;

package/dist/node_modules/lodash/_cloneBuffer.js

@@ -0,0 +1,48 @@
+'use strict';
+
+var _cloneBuffer = require('../../_virtual/_cloneBuffer.js');
+var _root = require('./_root.js');
+
+_cloneBuffer.__module.exports;
+
+(function (module, exports) {
+	var root = _root._root;
+
+	/** Detect free variable `exports`. */
+	var freeExports = exports && !exports.nodeType && exports;
+
+	/** Detect free variable `module`. */
+	var freeModule = freeExports && 'object' == 'object' && module && !module.nodeType && module;
+
+	/** Detect the popular CommonJS extension `module.exports`. */
+	var moduleExports = freeModule && freeModule.exports === freeExports;
+
+	/** Built-in value references. */
+	var Buffer = moduleExports ? root.Buffer : undefined,
+	    allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined;
+
+	/**
+	 * Creates a clone of  `buffer`.
+	 *
+	 * @private
+	 * @param {Buffer} buffer The buffer to clone.
+	 * @param {boolean} [isDeep] Specify a deep clone.
+	 * @returns {Buffer} Returns the cloned buffer.
+	 */
+	function cloneBuffer(buffer, isDeep) {
+	  if (isDeep) {
+	    return buffer.slice();
+	  }
+	  var length = buffer.length,
+	      result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);
+
+	  buffer.copy(result);
+	  return result;
+	}
+
+	module.exports = cloneBuffer; 
+} (_cloneBuffer.__module, _cloneBuffer.__module.exports));
+
+var _cloneBufferExports = _cloneBuffer.__module.exports;
+
+exports._cloneBufferExports = _cloneBufferExports;

package/dist/node_modules/lodash/_cloneDataView.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var _cloneArrayBuffer = require('./_cloneArrayBuffer.js');
+
+var cloneArrayBuffer = _cloneArrayBuffer._cloneArrayBuffer;
+
+/**
+ * Creates a clone of `dataView`.
+ *
+ * @private
+ * @param {Object} dataView The data view to clone.
+ * @param {boolean} [isDeep] Specify a deep clone.
+ * @returns {Object} Returns the cloned data view.
+ */
+function cloneDataView(dataView, isDeep) {
+  var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;
+  return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
+}
+
+var _cloneDataView = cloneDataView;
+
+exports._cloneDataView = _cloneDataView;

package/dist/node_modules/lodash/_cloneRegExp.js

@@ -0,0 +1,22 @@
+'use strict';
+
+/** Used to match `RegExp` flags from their coerced string values. */
+
+var reFlags = /\w*$/;
+
+/**
+ * Creates a clone of `regexp`.
+ *
+ * @private
+ * @param {Object} regexp The regexp to clone.
+ * @returns {Object} Returns the cloned regexp.
+ */
+function cloneRegExp(regexp) {
+  var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
+  result.lastIndex = regexp.lastIndex;
+  return result;
+}
+
+var _cloneRegExp = cloneRegExp;
+
+exports._cloneRegExp = _cloneRegExp;

package/dist/node_modules/lodash/_cloneSymbol.js

@@ -0,0 +1,24 @@
+'use strict';
+
+var _Symbol = require('./_Symbol.js');
+
+var Symbol = _Symbol._Symbol;
+
+/** Used to convert symbols to primitives and strings. */
+var symbolProto = Symbol ? Symbol.prototype : undefined,
+    symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;
+
+/**
+ * Creates a clone of the `symbol` object.
+ *
+ * @private
+ * @param {Object} symbol The symbol object to clone.
+ * @returns {Object} Returns the cloned symbol object.
+ */
+function cloneSymbol(symbol) {
+  return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};
+}
+
+var _cloneSymbol = cloneSymbol;
+
+exports._cloneSymbol = _cloneSymbol;

package/dist/node_modules/lodash/_cloneTypedArray.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var _cloneArrayBuffer = require('./_cloneArrayBuffer.js');
+
+var cloneArrayBuffer = _cloneArrayBuffer._cloneArrayBuffer;
+
+/**
+ * Creates a clone of `typedArray`.
+ *
+ * @private
+ * @param {Object} typedArray The typed array to clone.
+ * @param {boolean} [isDeep] Specify a deep clone.
+ * @returns {Object} Returns the cloned typed array.
+ */
+function cloneTypedArray(typedArray, isDeep) {
+  var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
+  return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
+}
+
+var _cloneTypedArray = cloneTypedArray;
+
+exports._cloneTypedArray = _cloneTypedArray;

package/dist/node_modules/lodash/_copyArray.js

@@ -0,0 +1,25 @@
+'use strict';
+
+/**
+ * Copies the values of `source` to `array`.
+ *
+ * @private
+ * @param {Array} source The array to copy values from.
+ * @param {Array} [array=[]] The array to copy values to.
+ * @returns {Array} Returns `array`.
+ */
+
+function copyArray(source, array) {
+  var index = -1,
+      length = source.length;
+
+  array || (array = Array(length));
+  while (++index < length) {
+    array[index] = source[index];
+  }
+  return array;
+}
+
+var _copyArray = copyArray;
+
+exports._copyArray = _copyArray;

package/dist/node_modules/lodash/_copyObject.js

@@ -0,0 +1,47 @@
+'use strict';
+
+var _assignValue = require('./_assignValue.js');
+var _baseAssignValue = require('./_baseAssignValue.js');
+
+var assignValue = _assignValue._assignValue,
+    baseAssignValue = _baseAssignValue._baseAssignValue;
+
+/**
+ * Copies properties of `source` to `object`.
+ *
+ * @private
+ * @param {Object} source The object to copy properties from.
+ * @param {Array} props The property identifiers to copy.
+ * @param {Object} [object={}] The object to copy properties to.
+ * @param {Function} [customizer] The function to customize copied values.
+ * @returns {Object} Returns `object`.
+ */
+function copyObject(source, props, object, customizer) {
+  var isNew = !object;
+  object || (object = {});
+
+  var index = -1,
+      length = props.length;
+
+  while (++index < length) {
+    var key = props[index];
+
+    var newValue = customizer
+      ? customizer(object[key], source[key], key, object, source)
+      : undefined;
+
+    if (newValue === undefined) {
+      newValue = source[key];
+    }
+    if (isNew) {
+      baseAssignValue(object, key, newValue);
+    } else {
+      assignValue(object, key, newValue);
+    }
+  }
+  return object;
+}
+
+var _copyObject = copyObject;
+
+exports._copyObject = _copyObject;

package/dist/node_modules/lodash/_copySymbols.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var _copyObject = require('./_copyObject.js');
+var _getSymbols = require('./_getSymbols.js');
+
+var copyObject = _copyObject._copyObject,
+    getSymbols = _getSymbols._getSymbols;
+
+/**
+ * Copies own symbols of `source` to `object`.
+ *
+ * @private
+ * @param {Object} source The object to copy symbols from.
+ * @param {Object} [object={}] The object to copy symbols to.
+ * @returns {Object} Returns `object`.
+ */
+function copySymbols(source, object) {
+  return copyObject(source, getSymbols(source), object);
+}
+
+var _copySymbols = copySymbols;
+
+exports._copySymbols = _copySymbols;

package/dist/node_modules/lodash/_copySymbolsIn.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var _copyObject = require('./_copyObject.js');
+var _getSymbolsIn = require('./_getSymbolsIn.js');
+
+var copyObject = _copyObject._copyObject,
+    getSymbolsIn = _getSymbolsIn._getSymbolsIn;
+
+/**
+ * Copies own and inherited symbols of `source` to `object`.
+ *
+ * @private
+ * @param {Object} source The object to copy symbols from.
+ * @param {Object} [object={}] The object to copy symbols to.
+ * @returns {Object} Returns `object`.
+ */
+function copySymbolsIn(source, object) {
+  return copyObject(source, getSymbolsIn(source), object);
+}
+
+var _copySymbolsIn = copySymbolsIn;
+
+exports._copySymbolsIn = _copySymbolsIn;

package/dist/node_modules/lodash/_coreJsData.js

@@ -0,0 +1,12 @@
+'use strict';
+
+var _root = require('./_root.js');
+
+var root = _root._root;
+
+/** Used to detect overreaching core-js shims. */
+var coreJsData = root['__core-js_shared__'];
+
+var _coreJsData = coreJsData;
+
+exports._coreJsData = _coreJsData;

package/dist/node_modules/lodash/_createAggregator.js

@@ -0,0 +1,32 @@
+'use strict';
+
+var _arrayAggregator = require('./_arrayAggregator.js');
+var _baseAggregator = require('./_baseAggregator.js');
+var _baseIteratee = require('./_baseIteratee.js');
+var isArray$1 = require('./isArray.js');
+
+var arrayAggregator = _arrayAggregator._arrayAggregator,
+    baseAggregator = _baseAggregator._baseAggregator,
+    baseIteratee = _baseIteratee._baseIteratee,
+    isArray = isArray$1.isArray_1;
+
+/**
+ * Creates a function like `_.groupBy`.
+ *
+ * @private
+ * @param {Function} setter The function to set accumulator values.
+ * @param {Function} [initializer] The accumulator object initializer.
+ * @returns {Function} Returns the new aggregator function.
+ */
+function createAggregator(setter, initializer) {
+  return function(collection, iteratee) {
+    var func = isArray(collection) ? arrayAggregator : baseAggregator,
+        accumulator = initializer ? initializer() : {};
+
+    return func(collection, setter, baseIteratee(iteratee), accumulator);
+  };
+}
+
+var _createAggregator = createAggregator;
+
+exports._createAggregator = _createAggregator;

package/dist/node_modules/lodash/_createAssigner.js

@@ -0,0 +1,44 @@
+'use strict';
+
+var _baseRest = require('./_baseRest.js');
+var _isIterateeCall = require('./_isIterateeCall.js');
+
+var baseRest = _baseRest._baseRest,
+    isIterateeCall = _isIterateeCall._isIterateeCall;
+
+/**
+ * Creates a function like `_.assign`.
+ *
+ * @private
+ * @param {Function} assigner The function to assign values.
+ * @returns {Function} Returns the new assigner function.
+ */
+function createAssigner(assigner) {
+  return baseRest(function(object, sources) {
+    var index = -1,
+        length = sources.length,
+        customizer = length > 1 ? sources[length - 1] : undefined,
+        guard = length > 2 ? sources[2] : undefined;
+
+    customizer = (assigner.length > 3 && typeof customizer == 'function')
+      ? (length--, customizer)
+      : undefined;
+
+    if (guard && isIterateeCall(sources[0], sources[1], guard)) {
+      customizer = length < 3 ? undefined : customizer;
+      length = 1;
+    }
+    object = Object(object);
+    while (++index < length) {
+      var source = sources[index];
+      if (source) {
+        assigner(object, source, index, customizer);
+      }
+    }
+    return object;
+  });
+}
+
+var _createAssigner = createAssigner;
+
+exports._createAssigner = _createAssigner;

package/dist/node_modules/lodash/_createBaseEach.js

@@ -0,0 +1,38 @@
+'use strict';
+
+var isArrayLike$1 = require('./isArrayLike.js');
+
+var isArrayLike = isArrayLike$1.isArrayLike_1;
+
+/**
+ * Creates a `baseEach` or `baseEachRight` function.
+ *
+ * @private
+ * @param {Function} eachFunc The function to iterate over a collection.
+ * @param {boolean} [fromRight] Specify iterating from right to left.
+ * @returns {Function} Returns the new base function.
+ */
+function createBaseEach(eachFunc, fromRight) {
+  return function(collection, iteratee) {
+    if (collection == null) {
+      return collection;
+    }
+    if (!isArrayLike(collection)) {
+      return eachFunc(collection, iteratee);
+    }
+    var length = collection.length,
+        index = fromRight ? length : -1,
+        iterable = Object(collection);
+
+    while ((fromRight ? index-- : ++index < length)) {
+      if (iteratee(iterable[index], index, iterable) === false) {
+        break;
+      }
+    }
+    return collection;
+  };
+}
+
+var _createBaseEach = createBaseEach;
+
+exports._createBaseEach = _createBaseEach;