cnhis-design-vue 3.1.6-beta.1 → 3.1.6-beta.2

package/es/node_modules/ids/dist/index.esm.mjs

@@ -1 +1,164 @@
-var t,o,r=(t=function(t){var o=t.exports=function(t,r){if(r||(r=16),void 0===t&&(t=128),t<=0)return"0";for(var e=Math.log(Math.pow(2,t))/Math.log(r),n=2;e===1/0;n*=2)e=Math.log(Math.pow(2,t/n))/Math.log(r)*n;var a=e-Math.floor(e),i="";for(n=0;n<Math.floor(e);n++)i=Math.floor(Math.random()*r).toString(r)+i;if(a){var s=Math.pow(r,a);i=Math.floor(Math.random()*s).toString(r)+i}var h=parseInt(i,r);return h!==1/0&&h>=Math.pow(2,t)?o(t,r):i};o.rack=function(t,r,e){var n=function(n){var i=0;do{if(i++>10){if(!e)throw new Error("too many ID collisions, use more bits");t+=e}var s=o(t,r)}while(Object.hasOwnProperty.call(a,s));return a[s]=n,s},a=n.hats={};return n.get=function(t){return n.hats[t]},n.set=function(t,o){return n.hats[t]=o,n},n.bits=t||128,n.base=r||16,n}},t(o={exports:{}},o.exports),o.exports);function e(t){if(!(this instanceof e))return new e(t);t=t||[128,36,1],this._seed=t.length?r.rack(t[0],t[1],t[2]):t}e.prototype.next=function(t){return this._seed(t||!0)},e.prototype.nextPrefixed=function(t,o){var r;do{r=t+this.next(!0)}while(this.assigned(r));return this.claim(r,o),r},e.prototype.claim=function(t,o){this._seed.set(t,o||!0)},e.prototype.assigned=function(t){return this._seed.get(t)||!1},e.prototype.unclaim=function(t){delete this._seed.hats[t]},e.prototype.clear=function(){var t,o=this._seed.hats;for(t in o)this.unclaim(t)};export{e as default};
+function createCommonjsModule(fn, module) {
+	return module = { exports: {} }, fn(module, module.exports), module.exports;
+}
+
+var hat_1 = createCommonjsModule(function (module) {
+var hat = module.exports = function (bits, base) {
+    if (!base) base = 16;
+    if (bits === undefined) bits = 128;
+    if (bits <= 0) return '0';
+    
+    var digits = Math.log(Math.pow(2, bits)) / Math.log(base);
+    for (var i = 2; digits === Infinity; i *= 2) {
+        digits = Math.log(Math.pow(2, bits / i)) / Math.log(base) * i;
+    }
+    
+    var rem = digits - Math.floor(digits);
+    
+    var res = '';
+    
+    for (var i = 0; i < Math.floor(digits); i++) {
+        var x = Math.floor(Math.random() * base).toString(base);
+        res = x + res;
+    }
+    
+    if (rem) {
+        var b = Math.pow(base, rem);
+        var x = Math.floor(Math.random() * b).toString(base);
+        res = x + res;
+    }
+    
+    var parsed = parseInt(res, base);
+    if (parsed !== Infinity && parsed >= Math.pow(2, bits)) {
+        return hat(bits, base)
+    }
+    else return res;
+};
+
+hat.rack = function (bits, base, expandBy) {
+    var fn = function (data) {
+        var iters = 0;
+        do {
+            if (iters ++ > 10) {
+                if (expandBy) bits += expandBy;
+                else throw new Error('too many ID collisions, use more bits')
+            }
+            
+            var id = hat(bits, base);
+        } while (Object.hasOwnProperty.call(hats, id));
+        
+        hats[id] = data;
+        return id;
+    };
+    var hats = fn.hats = {};
+    
+    fn.get = function (id) {
+        return fn.hats[id];
+    };
+    
+    fn.set = function (id, value) {
+        fn.hats[id] = value;
+        return fn;
+    };
+    
+    fn.bits = bits || 128;
+    fn.base = base || 16;
+    return fn;
+};
+});
+
+/**
+ * Create a new id generator / cache instance.
+ *
+ * You may optionally provide a seed that is used internally.
+ *
+ * @param {Seed} seed
+ */
+
+function Ids(seed) {
+  if (!(this instanceof Ids)) {
+    return new Ids(seed);
+  }
+
+  seed = seed || [128, 36, 1];
+  this._seed = seed.length ? hat_1.rack(seed[0], seed[1], seed[2]) : seed;
+}
+/**
+ * Generate a next id.
+ *
+ * @param {Object} [element] element to bind the id to
+ *
+ * @return {String} id
+ */
+
+Ids.prototype.next = function (element) {
+  return this._seed(element || true);
+};
+/**
+ * Generate a next id with a given prefix.
+ *
+ * @param {Object} [element] element to bind the id to
+ *
+ * @return {String} id
+ */
+
+
+Ids.prototype.nextPrefixed = function (prefix, element) {
+  var id;
+
+  do {
+    id = prefix + this.next(true);
+  } while (this.assigned(id)); // claim {prefix}{random}
+
+
+  this.claim(id, element); // return
+
+  return id;
+};
+/**
+ * Manually claim an existing id.
+ *
+ * @param {String} id
+ * @param {String} [element] element the id is claimed by
+ */
+
+
+Ids.prototype.claim = function (id, element) {
+  this._seed.set(id, element || true);
+};
+/**
+ * Returns true if the given id has already been assigned.
+ *
+ * @param  {String} id
+ * @return {Boolean}
+ */
+
+
+Ids.prototype.assigned = function (id) {
+  return this._seed.get(id) || false;
+};
+/**
+ * Unclaim an id.
+ *
+ * @param  {String} id the id to unclaim
+ */
+
+
+Ids.prototype.unclaim = function (id) {
+  delete this._seed.hats[id];
+};
+/**
+ * Clear all claimed ids.
+ */
+
+
+Ids.prototype.clear = function () {
+  var hats = this._seed.hats,
+      id;
+
+  for (id in hats) {
+    this.unclaim(id);
+  }
+};
+
+export { Ids as default };

package/es/node_modules/inherits/inherits.mjs

@@ -1 +1,19 @@
-import{getDefaultExportFromCjs as r}from"../../_virtual/_commonjsHelpers.mjs";import{i as t}from"../../_virtual/inherits.mjs";import{__require as i}from"./inherits_browser.mjs";!function(r){try{var t=require("util");if("function"!=typeof t.inherits)throw"";r.exports=t.inherits}catch(t){r.exports=i()}}(t);var e=r(t.exports);export{e as default};
+import { getDefaultExportFromCjs } from '../../_virtual/_commonjsHelpers.mjs';
+import { i as inherits$1 } from '../../_virtual/inherits.mjs';
+import { __require as requireInherits_browser } from './inherits_browser.mjs';
+
+(function (module) {
+	try {
+	  var util = require('util');
+	  /* istanbul ignore next */
+	  if (typeof util.inherits !== 'function') throw '';
+	  module.exports = util.inherits;
+	} catch (e) {
+	  /* istanbul ignore next */
+	  module.exports = requireInherits_browser();
+	}
+} (inherits$1));
+
+var inherits = /*@__PURE__*/getDefaultExportFromCjs(inherits$1.exports);
+
+export { inherits as default };

package/es/node_modules/inherits/inherits_browser.mjs

@@ -1 +1,38 @@
-import{i as t}from"../../_virtual/inherits_browser.mjs";var r;function e(){return r||(r=1,"function"==typeof Object.create?t.exports=function(t,r){r&&(t.super_=r,t.prototype=Object.create(r.prototype,{constructor:{value:t,enumerable:!1,writable:!0,configurable:!0}}))}:t.exports=function(t,r){if(r){t.super_=r;var e=function(){};e.prototype=r.prototype,t.prototype=new e,t.prototype.constructor=t}}),t.exports}export{e as __require};
+import { i as inherits_browser } from '../../_virtual/inherits_browser.mjs';
+
+var hasRequiredInherits_browser;
+
+function requireInherits_browser () {
+	if (hasRequiredInherits_browser) return inherits_browser.exports;
+	hasRequiredInherits_browser = 1;
+	if (typeof Object.create === 'function') {
+	  // implementation from standard node.js 'util' module
+	  inherits_browser.exports = function inherits(ctor, superCtor) {
+	    if (superCtor) {
+	      ctor.super_ = superCtor;
+	      ctor.prototype = Object.create(superCtor.prototype, {
+	        constructor: {
+	          value: ctor,
+	          enumerable: false,
+	          writable: true,
+	          configurable: true
+	        }
+	      });
+	    }
+	  };
+	} else {
+	  // old school shim for old browsers
+	  inherits_browser.exports = function inherits(ctor, superCtor) {
+	    if (superCtor) {
+	      ctor.super_ = superCtor;
+	      var TempCtor = function () {};
+	      TempCtor.prototype = superCtor.prototype;
+	      ctor.prototype = new TempCtor();
+	      ctor.prototype.constructor = ctor;
+	    }
+	  };
+	}
+	return inherits_browser.exports;
+}
+
+export { requireInherits_browser as __require };

package/es/node_modules/inherits-browser/dist/index.es.mjs

@@ -1 +1,3 @@
-function e(e,t){t&&(e.super_=t,e.prototype=Object.create(t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}))}export{e as default};
+function e(e,t){t&&(e.super_=t,e.prototype=Object.create(t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}));}
+
+export { e as default };

package/es/node_modules/min-dash/dist/index.esm.mjs

@@ -1 +1,169 @@
-var n=Object.prototype.toString,t=Object.prototype.hasOwnProperty;function r(n){return void 0===n}function o(n){return void 0!==n}function e(t){return"[object Array]"===n.call(t)}function c(t){return"[object Object]"===n.call(t)}function u(t){return"[object Number]"===n.call(t)}function i(t){var r=n.call(t);return"[object Function]"===r||"[object AsyncFunction]"===r||"[object GeneratorFunction]"===r||"[object AsyncGeneratorFunction]"===r||"[object Proxy]"===r}function a(n,r){return t.call(n,r)}function f(n,t){var o;if(!r(n)){var c=e(n)?p:j;for(var u in n)if(a(n,u)&&!1===t(o=n[u],c(u)))return o}}function b(n){return n&&Object.keys(n)||[]}function l(n){return b(n).length}function j(n){return n}function p(n){return Number(n)}function v(n,t){return n.bind(t)}function y(){return y=Object.assign||function(n){for(var t=1;t<arguments.length;t++){var r=arguments[t];for(var o in r)Object.prototype.hasOwnProperty.call(r,o)&&(n[o]=r[o])}return n},y.apply(this,arguments)}function O(n){for(var t=arguments.length,r=new Array(t>1?t-1:0),o=1;o<t;o++)r[o-1]=arguments[o];return y.apply(void 0,[n].concat(r))}function s(n,t){var r={};return f(Object(n),(function(n,o){-1===t.indexOf(o)&&(r[o]=n)})),r}export{O as assign,v as bind,f as forEach,a as has,e as isArray,o as isDefined,i as isFunction,u as isNumber,c as isObject,r as isUndefined,b as keys,s as omit,l as size};
+/**
+ * Flatten array, one level deep.
+ *
+ * @param {Array<?>} arr
+ *
+ * @return {Array<?>}
+ */
+
+var nativeToString = Object.prototype.toString;
+var nativeHasOwnProperty = Object.prototype.hasOwnProperty;
+function isUndefined(obj) {
+  return obj === undefined;
+}
+function isDefined(obj) {
+  return obj !== undefined;
+}
+function isArray(obj) {
+  return nativeToString.call(obj) === '[object Array]';
+}
+function isObject(obj) {
+  return nativeToString.call(obj) === '[object Object]';
+}
+function isNumber(obj) {
+  return nativeToString.call(obj) === '[object Number]';
+}
+function isFunction(obj) {
+  var tag = nativeToString.call(obj);
+  return tag === '[object Function]' || tag === '[object AsyncFunction]' || tag === '[object GeneratorFunction]' || tag === '[object AsyncGeneratorFunction]' || tag === '[object Proxy]';
+}
+/**
+ * Return true, if target owns a property with the given key.
+ *
+ * @param {Object} target
+ * @param {String} key
+ *
+ * @return {Boolean}
+ */
+
+function has(target, key) {
+  return nativeHasOwnProperty.call(target, key);
+}
+/**
+ * Iterate over collection; returning something
+ * (non-undefined) will stop iteration.
+ *
+ * @param  {Array|Object} collection
+ * @param  {Function} iterator
+ *
+ * @return {Object} return result that stopped the iteration
+ */
+
+function forEach(collection, iterator) {
+  var val, result;
+
+  if (isUndefined(collection)) {
+    return;
+  }
+
+  var convertKey = isArray(collection) ? toNum : identity;
+
+  for (var key in collection) {
+    if (has(collection, key)) {
+      val = collection[key];
+      result = iterator(val, convertKey(key));
+
+      if (result === false) {
+        return val;
+      }
+    }
+  }
+}
+/**
+ * Get the collections keys.
+ *
+ * @param  {Object|Array} collection
+ *
+ * @return {Array}
+ */
+
+function keys(collection) {
+  return collection && Object.keys(collection) || [];
+}
+/**
+ * Shorthand for `keys(o).length`.
+ *
+ * @param  {Object|Array} collection
+ *
+ * @return {Number}
+ */
+
+function size(collection) {
+  return keys(collection).length;
+}
+
+function identity(arg) {
+  return arg;
+}
+
+function toNum(arg) {
+  return Number(arg);
+}
+/**
+ * Bind function against target <this>.
+ *
+ * @param  {Function} fn
+ * @param  {Object}   target
+ *
+ * @return {Function} bound function
+ */
+
+function bind(fn, target) {
+  return fn.bind(target);
+}
+
+function _extends() {
+  _extends = Object.assign || function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+
+    return target;
+  };
+
+  return _extends.apply(this, arguments);
+}
+
+/**
+ * Convenience wrapper for `Object.assign`.
+ *
+ * @param {Object} target
+ * @param {...Object} others
+ *
+ * @return {Object} the target
+ */
+
+function assign(target) {
+  for (var _len = arguments.length, others = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    others[_key - 1] = arguments[_key];
+  }
+
+  return _extends.apply(void 0, [target].concat(others));
+}
+/**
+ * Pick all target properties, excluding the given ones.
+ *
+ * @param {Object} target
+ * @param {Array} properties
+ *
+ * @return {Object} target
+ */
+
+function omit(target, properties) {
+  var result = {};
+  var obj = Object(target);
+  forEach(obj, function (prop, key) {
+    if (properties.indexOf(key) === -1) {
+      result[key] = prop;
+    }
+  });
+  return result;
+}
+
+export { assign, bind, forEach, has, isArray, isDefined, isFunction, isNumber, isObject, isUndefined, keys, omit, size };