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

package/dist/node_modules/lodash/_baseIsMatch.js

@@ -0,0 +1,69 @@
+'use strict';
+
+var _Stack = require('./_Stack.js');
+var _baseIsEqual = require('./_baseIsEqual.js');
+
+var Stack = _Stack._Stack,
+    baseIsEqual = _baseIsEqual._baseIsEqual;
+
+/** Used to compose bitmasks for value comparisons. */
+var COMPARE_PARTIAL_FLAG = 1,
+    COMPARE_UNORDERED_FLAG = 2;
+
+/**
+ * The base implementation of `_.isMatch` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Object} object The object to inspect.
+ * @param {Object} source The object of property values to match.
+ * @param {Array} matchData The property names, values, and compare flags to match.
+ * @param {Function} [customizer] The function to customize comparisons.
+ * @returns {boolean} Returns `true` if `object` is a match, else `false`.
+ */
+function baseIsMatch(object, source, matchData, customizer) {
+  var index = matchData.length,
+      length = index,
+      noCustomizer = !customizer;
+
+  if (object == null) {
+    return !length;
+  }
+  object = Object(object);
+  while (index--) {
+    var data = matchData[index];
+    if ((noCustomizer && data[2])
+          ? data[1] !== object[data[0]]
+          : !(data[0] in object)
+        ) {
+      return false;
+    }
+  }
+  while (++index < length) {
+    data = matchData[index];
+    var key = data[0],
+        objValue = object[key],
+        srcValue = data[1];
+
+    if (noCustomizer && data[2]) {
+      if (objValue === undefined && !(key in object)) {
+        return false;
+      }
+    } else {
+      var stack = new Stack;
+      if (customizer) {
+        var result = customizer(objValue, srcValue, key, object, source, stack);
+      }
+      if (!(result === undefined
+            ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack)
+            : result
+          )) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+var _baseIsMatch = baseIsMatch;
+
+exports._baseIsMatch = _baseIsMatch;

package/dist/node_modules/lodash/_baseIsNative.js

@@ -0,0 +1,56 @@
+'use strict';
+
+var isFunction$1 = require('./isFunction.js');
+var _isMasked = require('./_isMasked.js');
+var isObject$1 = require('./isObject.js');
+var _toSource = require('./_toSource.js');
+
+var isFunction = isFunction$1.isFunction_1,
+    isMasked = _isMasked._isMasked,
+    isObject = isObject$1.isObject_1,
+    toSource = _toSource._toSource;
+
+/**
+ * Used to match `RegExp`
+ * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
+ */
+var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+
+/** Used to detect host constructors (Safari). */
+var reIsHostCtor = /^\[object .+?Constructor\]$/;
+
+/** 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 detect if a method is native. */
+var reIsNative = RegExp('^' +
+  funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
+  .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
+);
+
+/**
+ * The base implementation of `_.isNative` without bad shim checks.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a native function,
+ *  else `false`.
+ */
+function baseIsNative(value) {
+  if (!isObject(value) || isMasked(value)) {
+    return false;
+  }
+  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
+  return pattern.test(toSource(value));
+}
+
+var _baseIsNative = baseIsNative;
+
+exports._baseIsNative = _baseIsNative;

package/dist/node_modules/lodash/_baseIsSet.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var _getTag = require('./_getTag.js');
+var isObjectLike$1 = require('./isObjectLike.js');
+
+var getTag = _getTag._getTag,
+    isObjectLike = isObjectLike$1.isObjectLike_1;
+
+/** `Object#toString` result references. */
+var setTag = '[object Set]';
+
+/**
+ * The base implementation of `_.isSet` without Node.js optimizations.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a set, else `false`.
+ */
+function baseIsSet(value) {
+  return isObjectLike(value) && getTag(value) == setTag;
+}
+
+var _baseIsSet = baseIsSet;
+
+exports._baseIsSet = _baseIsSet;

package/dist/node_modules/lodash/_baseIsTypedArray.js

@@ -0,0 +1,68 @@
+'use strict';
+
+var _baseGetTag = require('./_baseGetTag.js');
+var isLength$1 = require('./isLength.js');
+var isObjectLike$1 = require('./isObjectLike.js');
+
+var baseGetTag = _baseGetTag._baseGetTag,
+    isLength = isLength$1.isLength_1,
+    isObjectLike = isObjectLike$1.isObjectLike_1;
+
+/** `Object#toString` result references. */
+var argsTag = '[object Arguments]',
+    arrayTag = '[object Array]',
+    boolTag = '[object Boolean]',
+    dateTag = '[object Date]',
+    errorTag = '[object Error]',
+    funcTag = '[object Function]',
+    mapTag = '[object Map]',
+    numberTag = '[object Number]',
+    objectTag = '[object Object]',
+    regexpTag = '[object RegExp]',
+    setTag = '[object Set]',
+    stringTag = '[object String]',
+    weakMapTag = '[object WeakMap]';
+
+var arrayBufferTag = '[object ArrayBuffer]',
+    dataViewTag = '[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] = typedArrayTags[dateTag] =
+typedArrayTags[errorTag] = typedArrayTags[funcTag] =
+typedArrayTags[mapTag] = typedArrayTags[numberTag] =
+typedArrayTags[objectTag] = typedArrayTags[regexpTag] =
+typedArrayTags[setTag] = typedArrayTags[stringTag] =
+typedArrayTags[weakMapTag] = 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(value) &&
+    isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
+}
+
+var _baseIsTypedArray = baseIsTypedArray;
+
+exports._baseIsTypedArray = _baseIsTypedArray;

package/dist/node_modules/lodash/_baseIteratee.js

@@ -0,0 +1,41 @@
+'use strict';
+
+var _baseMatches = require('./_baseMatches.js');
+var _baseMatchesProperty = require('./_baseMatchesProperty.js');
+var identity$1 = require('./identity.js');
+var isArray$1 = require('./isArray.js');
+var property$1 = require('./property.js');
+
+var baseMatches = _baseMatches._baseMatches,
+    baseMatchesProperty = _baseMatchesProperty._baseMatchesProperty,
+    identity = identity$1.identity_1,
+    isArray = isArray$1.isArray_1,
+    property = property$1.property_1;
+
+/**
+ * The base implementation of `_.iteratee`.
+ *
+ * @private
+ * @param {*} [value=_.identity] The value to convert to an iteratee.
+ * @returns {Function} Returns the iteratee.
+ */
+function baseIteratee(value) {
+  // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.
+  // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details.
+  if (typeof value == 'function') {
+    return value;
+  }
+  if (value == null) {
+    return identity;
+  }
+  if (typeof value == 'object') {
+    return isArray(value)
+      ? baseMatchesProperty(value[0], value[1])
+      : baseMatches(value);
+  }
+  return property(value);
+}
+
+var _baseIteratee = baseIteratee;
+
+exports._baseIteratee = _baseIteratee;

package/dist/node_modules/lodash/_baseKeys.js

@@ -0,0 +1,37 @@
+'use strict';
+
+var _isPrototype = require('./_isPrototype.js');
+var _nativeKeys = require('./_nativeKeys.js');
+
+var isPrototype = _isPrototype._isPrototype,
+    nativeKeys = _nativeKeys._nativeKeys;
+
+/** 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;
+}
+
+var _baseKeys = baseKeys;
+
+exports._baseKeys = _baseKeys;

package/dist/node_modules/lodash/_baseKeysIn.js

@@ -0,0 +1,41 @@
+'use strict';
+
+var isObject$1 = require('./isObject.js');
+var _isPrototype = require('./_isPrototype.js');
+var _nativeKeysIn = require('./_nativeKeysIn.js');
+
+var isObject = isObject$1.isObject_1,
+    isPrototype = _isPrototype._isPrototype,
+    nativeKeysIn = _nativeKeysIn._nativeKeysIn;
+
+/** 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 `_.keysIn` 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 baseKeysIn(object) {
+  if (!isObject(object)) {
+    return nativeKeysIn(object);
+  }
+  var isProto = isPrototype(object),
+      result = [];
+
+  for (var key in object) {
+    if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+
+var _baseKeysIn = baseKeysIn;
+
+exports._baseKeysIn = _baseKeysIn;

package/dist/node_modules/lodash/_baseMap.js

@@ -0,0 +1,29 @@
+'use strict';
+
+var _baseEach = require('./_baseEach.js');
+var isArrayLike$1 = require('./isArrayLike.js');
+
+var baseEach = _baseEach._baseEach,
+    isArrayLike = isArrayLike$1.isArrayLike_1;
+
+/**
+ * The base implementation of `_.map` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array} Returns the new mapped array.
+ */
+function baseMap(collection, iteratee) {
+  var index = -1,
+      result = isArrayLike(collection) ? Array(collection.length) : [];
+
+  baseEach(collection, function(value, key, collection) {
+    result[++index] = iteratee(value, key, collection);
+  });
+  return result;
+}
+
+var _baseMap = baseMap;
+
+exports._baseMap = _baseMap;

package/dist/node_modules/lodash/_baseMatches.js

@@ -0,0 +1,30 @@
+'use strict';
+
+var _baseIsMatch = require('./_baseIsMatch.js');
+var _getMatchData = require('./_getMatchData.js');
+var _matchesStrictComparable = require('./_matchesStrictComparable.js');
+
+var baseIsMatch = _baseIsMatch._baseIsMatch,
+    getMatchData = _getMatchData._getMatchData,
+    matchesStrictComparable = _matchesStrictComparable._matchesStrictComparable;
+
+/**
+ * The base implementation of `_.matches` which doesn't clone `source`.
+ *
+ * @private
+ * @param {Object} source The object of property values to match.
+ * @returns {Function} Returns the new spec function.
+ */
+function baseMatches(source) {
+  var matchData = getMatchData(source);
+  if (matchData.length == 1 && matchData[0][2]) {
+    return matchesStrictComparable(matchData[0][0], matchData[0][1]);
+  }
+  return function(object) {
+    return object === source || baseIsMatch(object, source, matchData);
+  };
+}
+
+var _baseMatches = baseMatches;
+
+exports._baseMatches = _baseMatches;

package/dist/node_modules/lodash/_baseMatchesProperty.js

@@ -0,0 +1,45 @@
+'use strict';
+
+var _baseIsEqual = require('./_baseIsEqual.js');
+var get$1 = require('./get.js');
+var hasIn$1 = require('./hasIn.js');
+var _isKey = require('./_isKey.js');
+var _isStrictComparable = require('./_isStrictComparable.js');
+var _matchesStrictComparable = require('./_matchesStrictComparable.js');
+var _toKey = require('./_toKey.js');
+
+var baseIsEqual = _baseIsEqual._baseIsEqual,
+    get = get$1.get_1,
+    hasIn = hasIn$1.hasIn_1,
+    isKey = _isKey._isKey,
+    isStrictComparable = _isStrictComparable._isStrictComparable,
+    matchesStrictComparable = _matchesStrictComparable._matchesStrictComparable,
+    toKey = _toKey._toKey;
+
+/** Used to compose bitmasks for value comparisons. */
+var COMPARE_PARTIAL_FLAG = 1,
+    COMPARE_UNORDERED_FLAG = 2;
+
+/**
+ * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`.
+ *
+ * @private
+ * @param {string} path The path of the property to get.
+ * @param {*} srcValue The value to match.
+ * @returns {Function} Returns the new spec function.
+ */
+function baseMatchesProperty(path, srcValue) {
+  if (isKey(path) && isStrictComparable(srcValue)) {
+    return matchesStrictComparable(toKey(path), srcValue);
+  }
+  return function(object) {
+    var objValue = get(object, path);
+    return (objValue === undefined && objValue === srcValue)
+      ? hasIn(object, path)
+      : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
+  };
+}
+
+var _baseMatchesProperty = baseMatchesProperty;
+
+exports._baseMatchesProperty = _baseMatchesProperty;

package/dist/node_modules/lodash/_baseMerge.js

@@ -0,0 +1,54 @@
+'use strict';
+
+var _Stack = require('./_Stack.js');
+var _assignMergeValue = require('./_assignMergeValue.js');
+var _baseFor = require('./_baseFor.js');
+var _baseMergeDeep = require('./_baseMergeDeep.js');
+var isObject$1 = require('./isObject.js');
+var keysIn$1 = require('./keysIn.js');
+var _safeGet = require('./_safeGet.js');
+
+var Stack = _Stack._Stack,
+    assignMergeValue = _assignMergeValue._assignMergeValue,
+    baseFor = _baseFor._baseFor,
+    baseMergeDeep = _baseMergeDeep._baseMergeDeep,
+    isObject = isObject$1.isObject_1,
+    keysIn = keysIn$1.keysIn_1,
+    safeGet = _safeGet._safeGet;
+
+/**
+ * The base implementation of `_.merge` without support for multiple sources.
+ *
+ * @private
+ * @param {Object} object The destination object.
+ * @param {Object} source The source object.
+ * @param {number} srcIndex The index of `source`.
+ * @param {Function} [customizer] The function to customize merged values.
+ * @param {Object} [stack] Tracks traversed source values and their merged
+ *  counterparts.
+ */
+function baseMerge(object, source, srcIndex, customizer, stack) {
+  if (object === source) {
+    return;
+  }
+  baseFor(source, function(srcValue, key) {
+    stack || (stack = new Stack);
+    if (isObject(srcValue)) {
+      baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);
+    }
+    else {
+      var newValue = customizer
+        ? customizer(safeGet(object, key), srcValue, (key + ''), object, source, stack)
+        : undefined;
+
+      if (newValue === undefined) {
+        newValue = srcValue;
+      }
+      assignMergeValue(object, key, newValue);
+    }
+  }, keysIn);
+}
+
+var _baseMerge = baseMerge;
+
+exports._baseMerge = _baseMerge;

package/dist/node_modules/lodash/_baseMergeDeep.js

@@ -0,0 +1,114 @@
+'use strict';
+
+var _assignMergeValue = require('./_assignMergeValue.js');
+var _cloneBuffer = require('./_cloneBuffer.js');
+var _cloneTypedArray = require('./_cloneTypedArray.js');
+var _copyArray = require('./_copyArray.js');
+var _initCloneObject = require('./_initCloneObject.js');
+var isArguments$1 = require('./isArguments.js');
+var isArray$1 = require('./isArray.js');
+var isArrayLikeObject$1 = require('./isArrayLikeObject.js');
+var isBuffer$1 = require('./isBuffer.js');
+var isFunction$1 = require('./isFunction.js');
+var isObject$1 = require('./isObject.js');
+var isPlainObject$1 = require('./isPlainObject.js');
+var isTypedArray$1 = require('./isTypedArray.js');
+var _safeGet = require('./_safeGet.js');
+var toPlainObject$1 = require('./toPlainObject.js');
+
+var assignMergeValue = _assignMergeValue._assignMergeValue,
+    cloneBuffer = _cloneBuffer._cloneBufferExports,
+    cloneTypedArray = _cloneTypedArray._cloneTypedArray,
+    copyArray = _copyArray._copyArray,
+    initCloneObject = _initCloneObject._initCloneObject,
+    isArguments = isArguments$1.isArguments_1,
+    isArray = isArray$1.isArray_1,
+    isArrayLikeObject = isArrayLikeObject$1.isArrayLikeObject_1,
+    isBuffer = isBuffer$1.isBufferExports,
+    isFunction = isFunction$1.isFunction_1,
+    isObject = isObject$1.isObject_1,
+    isPlainObject = isPlainObject$1.isPlainObject_1,
+    isTypedArray = isTypedArray$1.isTypedArray_1,
+    safeGet = _safeGet._safeGet,
+    toPlainObject = toPlainObject$1.toPlainObject_1;
+
+/**
+ * A specialized version of `baseMerge` for arrays and objects which performs
+ * deep merges and tracks traversed objects enabling objects with circular
+ * references to be merged.
+ *
+ * @private
+ * @param {Object} object The destination object.
+ * @param {Object} source The source object.
+ * @param {string} key The key of the value to merge.
+ * @param {number} srcIndex The index of `source`.
+ * @param {Function} mergeFunc The function to merge values.
+ * @param {Function} [customizer] The function to customize assigned values.
+ * @param {Object} [stack] Tracks traversed source values and their merged
+ *  counterparts.
+ */
+function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {
+  var objValue = safeGet(object, key),
+      srcValue = safeGet(source, key),
+      stacked = stack.get(srcValue);
+
+  if (stacked) {
+    assignMergeValue(object, key, stacked);
+    return;
+  }
+  var newValue = customizer
+    ? customizer(objValue, srcValue, (key + ''), object, source, stack)
+    : undefined;
+
+  var isCommon = newValue === undefined;
+
+  if (isCommon) {
+    var isArr = isArray(srcValue),
+        isBuff = !isArr && isBuffer(srcValue),
+        isTyped = !isArr && !isBuff && isTypedArray(srcValue);
+
+    newValue = srcValue;
+    if (isArr || isBuff || isTyped) {
+      if (isArray(objValue)) {
+        newValue = objValue;
+      }
+      else if (isArrayLikeObject(objValue)) {
+        newValue = copyArray(objValue);
+      }
+      else if (isBuff) {
+        isCommon = false;
+        newValue = cloneBuffer(srcValue, true);
+      }
+      else if (isTyped) {
+        isCommon = false;
+        newValue = cloneTypedArray(srcValue, true);
+      }
+      else {
+        newValue = [];
+      }
+    }
+    else if (isPlainObject(srcValue) || isArguments(srcValue)) {
+      newValue = objValue;
+      if (isArguments(objValue)) {
+        newValue = toPlainObject(objValue);
+      }
+      else if (!isObject(objValue) || isFunction(objValue)) {
+        newValue = initCloneObject(srcValue);
+      }
+    }
+    else {
+      isCommon = false;
+    }
+  }
+  if (isCommon) {
+    // Recursively merge objects and arrays (susceptible to call stack limits).
+    stack.set(srcValue, newValue);
+    mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
+    stack['delete'](srcValue);
+  }
+  assignMergeValue(object, key, newValue);
+}
+
+var _baseMergeDeep = baseMergeDeep;
+
+exports._baseMergeDeep = _baseMergeDeep;

package/dist/node_modules/lodash/_baseProperty.js

@@ -0,0 +1,19 @@
+'use strict';
+
+/**
+ * The base implementation of `_.property` without support for deep paths.
+ *
+ * @private
+ * @param {string} key The key of the property to get.
+ * @returns {Function} Returns the new accessor function.
+ */
+
+function baseProperty(key) {
+  return function(object) {
+    return object == null ? undefined : object[key];
+  };
+}
+
+var _baseProperty = baseProperty;
+
+exports._baseProperty = _baseProperty;

package/dist/node_modules/lodash/_basePropertyDeep.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var _baseGet = require('./_baseGet.js');
+
+var baseGet = _baseGet._baseGet;
+
+/**
+ * A specialized version of `baseProperty` which supports deep paths.
+ *
+ * @private
+ * @param {Array|string} path The path of the property to get.
+ * @returns {Function} Returns the new accessor function.
+ */
+function basePropertyDeep(path) {
+  return function(object) {
+    return baseGet(object, path);
+  };
+}
+
+var _basePropertyDeep = basePropertyDeep;
+
+exports._basePropertyDeep = _basePropertyDeep;

package/dist/node_modules/lodash/_baseRest.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var identity$1 = require('./identity.js');
+var _overRest = require('./_overRest.js');
+var _setToString = require('./_setToString.js');
+
+var identity = identity$1.identity_1,
+    overRest = _overRest._overRest,
+    setToString = _setToString._setToString;
+
+/**
+ * The base implementation of `_.rest` which doesn't validate or coerce arguments.
+ *
+ * @private
+ * @param {Function} func The function to apply a rest parameter to.
+ * @param {number} [start=func.length-1] The start position of the rest parameter.
+ * @returns {Function} Returns the new function.
+ */
+function baseRest(func, start) {
+  return setToString(overRest(func, start, identity), func + '');
+}
+
+var _baseRest = baseRest;
+
+exports._baseRest = _baseRest;