tdesign-react 0.36.5-alpha.2 → 0.37.0-alpha.2

package/esm/_chunks/dep-3faec340.js

@@ -0,0 +1,131 @@
+/**
+ * tdesign v0.37.0-alpha.1
+ * (c) 2022 tdesign
+ * @license MIT
+ */
+
+import './dep-94d2706e.js';
+import { _ as _arrayMap } from './dep-e30b4f62.js';
+import { a as _SetCache, b as _cacheHas } from './dep-b379bc04.js';
+import { _ as _arrayIncludes, a as _arrayIncludesWith } from './dep-da46e8d6.js';
+import { _ as _baseUnary } from './dep-dbf9cc0d.js';
+import { i as isArrayLikeObject_1, _ as _baseRest } from './dep-4e7b227d.js';
+
+var SetCache = _SetCache,
+    arrayIncludes = _arrayIncludes,
+    arrayIncludesWith = _arrayIncludesWith,
+    arrayMap$1 = _arrayMap,
+    baseUnary = _baseUnary,
+    cacheHas = _cacheHas;
+/* Built-in method references for those with the same name as other `lodash` methods. */
+
+var nativeMin = Math.min;
+/**
+ * The base implementation of methods like `_.intersection`, without support
+ * for iteratee shorthands, that accepts an array of arrays to inspect.
+ *
+ * @private
+ * @param {Array} arrays The arrays to inspect.
+ * @param {Function} [iteratee] The iteratee invoked per element.
+ * @param {Function} [comparator] The comparator invoked per element.
+ * @returns {Array} Returns the new array of shared values.
+ */
+
+function baseIntersection$1(arrays, iteratee, comparator) {
+  var includes = comparator ? arrayIncludesWith : arrayIncludes,
+      length = arrays[0].length,
+      othLength = arrays.length,
+      othIndex = othLength,
+      caches = Array(othLength),
+      maxLength = Infinity,
+      result = [];
+
+  while (othIndex--) {
+    var array = arrays[othIndex];
+
+    if (othIndex && iteratee) {
+      array = arrayMap$1(array, baseUnary(iteratee));
+    }
+
+    maxLength = nativeMin(array.length, maxLength);
+    caches[othIndex] = !comparator && (iteratee || length >= 120 && array.length >= 120) ? new SetCache(othIndex && array) : undefined;
+  }
+
+  array = arrays[0];
+  var index = -1,
+      seen = caches[0];
+
+  outer: while (++index < length && result.length < maxLength) {
+    var value = array[index],
+        computed = iteratee ? iteratee(value) : value;
+    value = comparator || value !== 0 ? value : 0;
+
+    if (!(seen ? cacheHas(seen, computed) : includes(result, computed, comparator))) {
+      othIndex = othLength;
+
+      while (--othIndex) {
+        var cache = caches[othIndex];
+
+        if (!(cache ? cacheHas(cache, computed) : includes(arrays[othIndex], computed, comparator))) {
+          continue outer;
+        }
+      }
+
+      if (seen) {
+        seen.push(computed);
+      }
+
+      result.push(value);
+    }
+  }
+
+  return result;
+}
+
+var _baseIntersection = baseIntersection$1;
+
+var isArrayLikeObject = isArrayLikeObject_1;
+/**
+ * Casts `value` to an empty array if it's not an array like object.
+ *
+ * @private
+ * @param {*} value The value to inspect.
+ * @returns {Array|Object} Returns the cast array-like object.
+ */
+
+function castArrayLikeObject$1(value) {
+  return isArrayLikeObject(value) ? value : [];
+}
+
+var _castArrayLikeObject = castArrayLikeObject$1;
+
+var arrayMap = _arrayMap,
+    baseIntersection = _baseIntersection,
+    baseRest = _baseRest,
+    castArrayLikeObject = _castArrayLikeObject;
+/**
+ * Creates an array of unique values that are included in all given arrays
+ * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+ * for equality comparisons. The order and references of result values are
+ * determined by the first array.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Array
+ * @param {...Array} [arrays] The arrays to inspect.
+ * @returns {Array} Returns the new array of intersecting values.
+ * @example
+ *
+ * _.intersection([2, 1], [2, 3]);
+ * // => [2]
+ */
+
+var intersection = baseRest(function (arrays) {
+  var mapped = arrayMap(arrays, castArrayLikeObject);
+  return mapped.length && mapped[0] === arrays[0] ? baseIntersection(mapped) : [];
+});
+var intersection_1 = intersection;
+
+export { intersection_1 as i };
+//# sourceMappingURL=dep-3faec340.js.map

package/esm/_chunks/dep-3faec340.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dep-3faec340.js","sources":["../../node_modules/lodash/_baseIntersection.js","../../node_modules/lodash/_castArrayLikeObject.js","../../node_modules/lodash/intersection.js"],"sourcesContent":["var SetCache = require('./_SetCache'),\n    arrayIncludes = require('./_arrayIncludes'),\n    arrayIncludesWith = require('./_arrayIncludesWith'),\n    arrayMap = require('./_arrayMap'),\n    baseUnary = require('./_baseUnary'),\n    cacheHas = require('./_cacheHas');\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMin = Math.min;\n\n/**\n * The base implementation of methods like `_.intersection`, without support\n * for iteratee shorthands, that accepts an array of arrays to inspect.\n *\n * @private\n * @param {Array} arrays The arrays to inspect.\n * @param {Function} [iteratee] The iteratee invoked per element.\n * @param {Function} [comparator] The comparator invoked per element.\n * @returns {Array} Returns the new array of shared values.\n */\nfunction baseIntersection(arrays, iteratee, comparator) {\n  var includes = comparator ? arrayIncludesWith : arrayIncludes,\n      length = arrays[0].length,\n      othLength = arrays.length,\n      othIndex = othLength,\n      caches = Array(othLength),\n      maxLength = Infinity,\n      result = [];\n\n  while (othIndex--) {\n    var array = arrays[othIndex];\n    if (othIndex && iteratee) {\n      array = arrayMap(array, baseUnary(iteratee));\n    }\n    maxLength = nativeMin(array.length, maxLength);\n    caches[othIndex] = !comparator && (iteratee || (length >= 120 && array.length >= 120))\n      ? new SetCache(othIndex && array)\n      : undefined;\n  }\n  array = arrays[0];\n\n  var index = -1,\n      seen = caches[0];\n\n  outer:\n  while (++index < length && result.length < maxLength) {\n    var value = array[index],\n        computed = iteratee ? iteratee(value) : value;\n\n    value = (comparator || value !== 0) ? value : 0;\n    if (!(seen\n          ? cacheHas(seen, computed)\n          : includes(result, computed, comparator)\n        )) {\n      othIndex = othLength;\n      while (--othIndex) {\n        var cache = caches[othIndex];\n        if (!(cache\n              ? cacheHas(cache, computed)\n              : includes(arrays[othIndex], computed, comparator))\n            ) {\n          continue outer;\n        }\n      }\n      if (seen) {\n        seen.push(computed);\n      }\n      result.push(value);\n    }\n  }\n  return result;\n}\n\nmodule.exports = baseIntersection;\n","var isArrayLikeObject = require('./isArrayLikeObject');\n\n/**\n * Casts `value` to an empty array if it's not an array like object.\n *\n * @private\n * @param {*} value The value to inspect.\n * @returns {Array|Object} Returns the cast array-like object.\n */\nfunction castArrayLikeObject(value) {\n  return isArrayLikeObject(value) ? value : [];\n}\n\nmodule.exports = castArrayLikeObject;\n","var arrayMap = require('./_arrayMap'),\n    baseIntersection = require('./_baseIntersection'),\n    baseRest = require('./_baseRest'),\n    castArrayLikeObject = require('./_castArrayLikeObject');\n\n/**\n * Creates an array of unique values that are included in all given arrays\n * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons. The order and references of result values are\n * determined by the first array.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {...Array} [arrays] The arrays to inspect.\n * @returns {Array} Returns the new array of intersecting values.\n * @example\n *\n * _.intersection([2, 1], [2, 3]);\n * // => [2]\n */\nvar intersection = baseRest(function(arrays) {\n  var mapped = arrayMap(arrays, castArrayLikeObject);\n  return (mapped.length && mapped[0] === arrays[0])\n    ? baseIntersection(mapped)\n    : [];\n});\n\nmodule.exports = intersection;\n"],"names":["SetCache","require$$0","arrayIncludes","require$$1","arrayIncludesWith","require$$2","arrayMap","require$$3","baseUnary","require$$4","cacheHas","require$$5","nativeMin","Math","min","baseIntersection","arrays","iteratee","comparator","includes","length","othLength","othIndex","caches","Array","maxLength","Infinity","result","array","undefined","index","seen","outer","value","computed","cache","push","_baseIntersection","isArrayLikeObject","castArrayLikeObject","_castArrayLikeObject","baseRest","intersection","mapped","intersection_1"],"mappings":"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"}

package/esm/_chunks/dep-435e8ffa.js

@@ -0,0 +1,511 @@
+/**
+ * tdesign v0.37.0-alpha.1
+ * (c) 2022 tdesign
+ * @license MIT
+ */
+
+import './dep-94d2706e.js';
+import { a as _ListCache, _ as _MapCache } from './dep-de98d0de.js';
+import { _ as _Map } from './dep-94059e8f.js';
+import { a as _root } from './dep-943e887b.js';
+import { i as isObject_1 } from './dep-5a3089ef.js';
+import './dep-28fad2c8.js';
+import { _ as _getPrototype } from './dep-f2599a54.js';
+import { _ as _isPrototype, i as isBuffer$1, a as isTypedArray_1 } from './dep-6bf8c3c4.js';
+import { a as _assignValue, _ as _baseAssignValue } from './dep-81ae8a67.js';
+import { i as isArguments_1 } from './dep-f678b01d.js';
+import { i as isArray_1 } from './dep-2a4fc099.js';
+import { _ as _isIndex } from './dep-97f07cd8.js';
+import { i as isArrayLike_1 } from './dep-4da704e4.js';
+
+var ListCache$2 = _ListCache;
+/**
+ * Removes all key-value entries from the stack.
+ *
+ * @private
+ * @name clear
+ * @memberOf Stack
+ */
+
+function stackClear$1() {
+  this.__data__ = new ListCache$2();
+  this.size = 0;
+}
+
+var _stackClear = stackClear$1;
+
+/**
+ * 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$1(key) {
+  var data = this.__data__,
+      result = data['delete'](key);
+  this.size = data.size;
+  return result;
+}
+
+var _stackDelete = stackDelete$1;
+
+/**
+ * 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$1(key) {
+  return this.__data__.get(key);
+}
+
+var _stackGet = stackGet$1;
+
+/**
+ * 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$1(key) {
+  return this.__data__.has(key);
+}
+
+var _stackHas = stackHas$1;
+
+var ListCache$1 = _ListCache,
+    Map = _Map,
+    MapCache = _MapCache;
+/** 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$1(key, value) {
+  var data = this.__data__;
+
+  if (data instanceof ListCache$1) {
+    var pairs = data.__data__;
+
+    if (!Map || pairs.length < LARGE_ARRAY_SIZE - 1) {
+      pairs.push([key, value]);
+      this.size = ++data.size;
+      return this;
+    }
+
+    data = this.__data__ = new MapCache(pairs);
+  }
+
+  data.set(key, value);
+  this.size = data.size;
+  return this;
+}
+
+var _stackSet = stackSet$1;
+
+var ListCache = _ListCache,
+    stackClear = _stackClear,
+    stackDelete = _stackDelete,
+    stackGet = _stackGet,
+    stackHas = _stackHas,
+    stackSet = _stackSet;
+/**
+ * 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 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;
+var _Stack = Stack;
+
+var _cloneBuffer$1 = {exports: {}};
+
+(function (module, exports) {
+  var root = _root;
+  /** Detect free variable `exports`. */
+
+  var freeExports = 'object' == 'object' && 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$1, _cloneBuffer$1.exports);
+
+var _cloneBuffer = _cloneBuffer$1.exports;
+
+var root = _root;
+/** Built-in value references. */
+
+var Uint8Array$1 = root.Uint8Array;
+var _Uint8Array = Uint8Array$1;
+
+var 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$1(arrayBuffer) {
+  var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
+  new Uint8Array(result).set(new Uint8Array(arrayBuffer));
+  return result;
+}
+
+var _cloneArrayBuffer = cloneArrayBuffer$1;
+
+var 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;
+
+/**
+ * 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;
+
+var isObject$1 = isObject_1;
+/** Built-in value references. */
+
+var objectCreate = Object.create;
+/**
+ * The base implementation of `_.create` without support for assigning
+ * properties to the created object.
+ *
+ * @private
+ * @param {Object} proto The object to inherit from.
+ * @returns {Object} Returns the new object.
+ */
+
+var baseCreate$1 = function () {
+  function object() {}
+
+  return function (proto) {
+    if (!isObject$1(proto)) {
+      return {};
+    }
+
+    if (objectCreate) {
+      return objectCreate(proto);
+    }
+
+    object.prototype = proto;
+    var result = new object();
+    object.prototype = undefined;
+    return result;
+  };
+}();
+
+var _baseCreate = baseCreate$1;
+
+var baseCreate = _baseCreate,
+    getPrototype = _getPrototype,
+    isPrototype$1 = _isPrototype;
+/**
+ * Initializes an object clone.
+ *
+ * @private
+ * @param {Object} object The object to clone.
+ * @returns {Object} Returns the initialized clone.
+ */
+
+function initCloneObject(object) {
+  return typeof object.constructor == 'function' && !isPrototype$1(object) ? baseCreate(getPrototype(object)) : {};
+}
+
+var _initCloneObject = initCloneObject;
+
+var assignValue = _assignValue,
+    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;
+
+/**
+ * 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$1(n, iteratee) {
+  var index = -1,
+      result = Array(n);
+
+  while (++index < n) {
+    result[index] = iteratee(index);
+  }
+
+  return result;
+}
+
+var _baseTimes = baseTimes$1;
+
+var baseTimes = _baseTimes,
+    isArguments = isArguments_1,
+    isArray = isArray_1,
+    isBuffer = isBuffer$1.exports,
+    isIndex = _isIndex,
+    isTypedArray = isTypedArray_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;
+/**
+ * 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$1(value, inherited) {
+  var isArr = 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 ((inherited || 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;
+}
+
+var _arrayLikeKeys = arrayLikeKeys$1;
+
+/**
+ * This function is like
+ * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
+ * except that it includes inherited enumerable properties.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ */
+
+function nativeKeysIn$1(object) {
+  var result = [];
+
+  if (object != null) {
+    for (var key in Object(object)) {
+      result.push(key);
+    }
+  }
+
+  return result;
+}
+
+var _nativeKeysIn = nativeKeysIn$1;
+
+var isObject = isObject_1,
+    isPrototype = _isPrototype,
+    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$1(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$1;
+
+var arrayLikeKeys = _arrayLikeKeys,
+    baseKeysIn = _baseKeysIn,
+    isArrayLike = isArrayLike_1;
+/**
+ * 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);
+}
+
+var keysIn_1 = keysIn;
+
+export { _copyObject as _, _cloneBuffer$1 as a, _cloneTypedArray as b, _copyArray as c, _initCloneObject as d, _Stack as e, _cloneArrayBuffer as f, _arrayLikeKeys as g, _Uint8Array as h, keysIn_1 as k };
+//# sourceMappingURL=dep-435e8ffa.js.map