@daoyi/nmtl-ui 2.0.1-beta.8 → 2.0.1-beta.80

package/lib/components/index-983dcd15.js

@@ -0,0 +1,481 @@
+var queryString = {};
+
+var strictUriEncode = str => encodeURIComponent(str).replace(/[!'()*]/g, x => `%${x.charCodeAt(0).toString(16).toUpperCase()}`);
+
+var token = '%[a-f0-9]{2}';
+var singleMatcher = new RegExp(token, 'gi');
+var multiMatcher = new RegExp('(' + token + ')+', 'gi');
+
+function decodeComponents(components, split) {
+	try {
+		// Try to decode the entire string first
+		return decodeURIComponent(components.join(''));
+	} catch (err) {
+		// Do nothing
+	}
+
+	if (components.length === 1) {
+		return components;
+	}
+
+	split = split || 1;
+
+	// Split the array in 2 parts
+	var left = components.slice(0, split);
+	var right = components.slice(split);
+
+	return Array.prototype.concat.call([], decodeComponents(left), decodeComponents(right));
+}
+
+function decode(input) {
+	try {
+		return decodeURIComponent(input);
+	} catch (err) {
+		var tokens = input.match(singleMatcher);
+
+		for (var i = 1; i < tokens.length; i++) {
+			input = decodeComponents(tokens, i).join('');
+
+			tokens = input.match(singleMatcher);
+		}
+
+		return input;
+	}
+}
+
+function customDecodeURIComponent(input) {
+	// Keep track of all the replacements and prefill the map with the `BOM`
+	var replaceMap = {
+		'%FE%FF': '\uFFFD\uFFFD',
+		'%FF%FE': '\uFFFD\uFFFD'
+	};
+
+	var match = multiMatcher.exec(input);
+	while (match) {
+		try {
+			// Decode as big chunks as possible
+			replaceMap[match[0]] = decodeURIComponent(match[0]);
+		} catch (err) {
+			var result = decode(match[0]);
+
+			if (result !== match[0]) {
+				replaceMap[match[0]] = result;
+			}
+		}
+
+		match = multiMatcher.exec(input);
+	}
+
+	// Add `%C2` at the end of the map to make sure it does not replace the combinator before everything else
+	replaceMap['%C2'] = '\uFFFD';
+
+	var entries = Object.keys(replaceMap);
+
+	for (var i = 0; i < entries.length; i++) {
+		// Replace all decoded components
+		var key = entries[i];
+		input = input.replace(new RegExp(key, 'g'), replaceMap[key]);
+	}
+
+	return input;
+}
+
+var decodeUriComponent = function (encodedURI) {
+	if (typeof encodedURI !== 'string') {
+		throw new TypeError('Expected `encodedURI` to be of type `string`, got `' + typeof encodedURI + '`');
+	}
+
+	try {
+		encodedURI = encodedURI.replace(/\+/g, ' ');
+
+		// Try the built in decoder first
+		return decodeURIComponent(encodedURI);
+	} catch (err) {
+		// Fallback to a more advanced decoder
+		return customDecodeURIComponent(encodedURI);
+	}
+};
+
+var splitOnFirst = (string, separator) => {
+	if (!(typeof string === 'string' && typeof separator === 'string')) {
+		throw new TypeError('Expected the arguments to be of type `string`');
+	}
+
+	if (separator === '') {
+		return [string];
+	}
+
+	const separatorIndex = string.indexOf(separator);
+
+	if (separatorIndex === -1) {
+		return [string];
+	}
+
+	return [
+		string.slice(0, separatorIndex),
+		string.slice(separatorIndex + separator.length)
+	];
+};
+
+(function (exports) {
+	const strictUriEncode$1 = strictUriEncode;
+	const decodeComponent = decodeUriComponent;
+	const splitOnFirst$1 = splitOnFirst;
+
+	const isNullOrUndefined = value => value === null || value === undefined;
+
+	function encoderForArrayFormat(options) {
+		switch (options.arrayFormat) {
+			case 'index':
+				return key => (result, value) => {
+					const index = result.length;
+
+					if (
+						value === undefined ||
+						(options.skipNull && value === null) ||
+						(options.skipEmptyString && value === '')
+					) {
+						return result;
+					}
+
+					if (value === null) {
+						return [...result, [encode(key, options), '[', index, ']'].join('')];
+					}
+
+					return [
+						...result,
+						[encode(key, options), '[', encode(index, options), ']=', encode(value, options)].join('')
+					];
+				};
+
+			case 'bracket':
+				return key => (result, value) => {
+					if (
+						value === undefined ||
+						(options.skipNull && value === null) ||
+						(options.skipEmptyString && value === '')
+					) {
+						return result;
+					}
+
+					if (value === null) {
+						return [...result, [encode(key, options), '[]'].join('')];
+					}
+
+					return [...result, [encode(key, options), '[]=', encode(value, options)].join('')];
+				};
+
+			case 'comma':
+			case 'separator':
+				return key => (result, value) => {
+					if (value === null || value === undefined || value.length === 0) {
+						return result;
+					}
+
+					if (result.length === 0) {
+						return [[encode(key, options), '=', encode(value, options)].join('')];
+					}
+
+					return [[result, encode(value, options)].join(options.arrayFormatSeparator)];
+				};
+
+			default:
+				return key => (result, value) => {
+					if (
+						value === undefined ||
+						(options.skipNull && value === null) ||
+						(options.skipEmptyString && value === '')
+					) {
+						return result;
+					}
+
+					if (value === null) {
+						return [...result, encode(key, options)];
+					}
+
+					return [...result, [encode(key, options), '=', encode(value, options)].join('')];
+				};
+		}
+	}
+
+	function parserForArrayFormat(options) {
+		let result;
+
+		switch (options.arrayFormat) {
+			case 'index':
+				return (key, value, accumulator) => {
+					result = /\[(\d*)\]$/.exec(key);
+
+					key = key.replace(/\[\d*\]$/, '');
+
+					if (!result) {
+						accumulator[key] = value;
+						return;
+					}
+
+					if (accumulator[key] === undefined) {
+						accumulator[key] = {};
+					}
+
+					accumulator[key][result[1]] = value;
+				};
+
+			case 'bracket':
+				return (key, value, accumulator) => {
+					result = /(\[\])$/.exec(key);
+					key = key.replace(/\[\]$/, '');
+
+					if (!result) {
+						accumulator[key] = value;
+						return;
+					}
+
+					if (accumulator[key] === undefined) {
+						accumulator[key] = [value];
+						return;
+					}
+
+					accumulator[key] = [].concat(accumulator[key], value);
+				};
+
+			case 'comma':
+			case 'separator':
+				return (key, value, accumulator) => {
+					const isArray = typeof value === 'string' && value.split('').indexOf(options.arrayFormatSeparator) > -1;
+					const newValue = isArray ? value.split(options.arrayFormatSeparator).map(item => decode(item, options)) : value === null ? value : decode(value, options);
+					accumulator[key] = newValue;
+				};
+
+			default:
+				return (key, value, accumulator) => {
+					if (accumulator[key] === undefined) {
+						accumulator[key] = value;
+						return;
+					}
+
+					accumulator[key] = [].concat(accumulator[key], value);
+				};
+		}
+	}
+
+	function validateArrayFormatSeparator(value) {
+		if (typeof value !== 'string' || value.length !== 1) {
+			throw new TypeError('arrayFormatSeparator must be single character string');
+		}
+	}
+
+	function encode(value, options) {
+		if (options.encode) {
+			return options.strict ? strictUriEncode$1(value) : encodeURIComponent(value);
+		}
+
+		return value;
+	}
+
+	function decode(value, options) {
+		if (options.decode) {
+			return decodeComponent(value);
+		}
+
+		return value;
+	}
+
+	function keysSorter(input) {
+		if (Array.isArray(input)) {
+			return input.sort();
+		}
+
+		if (typeof input === 'object') {
+			return keysSorter(Object.keys(input))
+				.sort((a, b) => Number(a) - Number(b))
+				.map(key => input[key]);
+		}
+
+		return input;
+	}
+
+	function removeHash(input) {
+		const hashStart = input.indexOf('#');
+		if (hashStart !== -1) {
+			input = input.slice(0, hashStart);
+		}
+
+		return input;
+	}
+
+	function getHash(url) {
+		let hash = '';
+		const hashStart = url.indexOf('#');
+		if (hashStart !== -1) {
+			hash = url.slice(hashStart);
+		}
+
+		return hash;
+	}
+
+	function extract(input) {
+		input = removeHash(input);
+		const queryStart = input.indexOf('?');
+		if (queryStart === -1) {
+			return '';
+		}
+
+		return input.slice(queryStart + 1);
+	}
+
+	function parseValue(value, options) {
+		if (options.parseNumbers && !Number.isNaN(Number(value)) && (typeof value === 'string' && value.trim() !== '')) {
+			value = Number(value);
+		} else if (options.parseBooleans && value !== null && (value.toLowerCase() === 'true' || value.toLowerCase() === 'false')) {
+			value = value.toLowerCase() === 'true';
+		}
+
+		return value;
+	}
+
+	function parse(input, options) {
+		options = Object.assign({
+			decode: true,
+			sort: true,
+			arrayFormat: 'none',
+			arrayFormatSeparator: ',',
+			parseNumbers: false,
+			parseBooleans: false
+		}, options);
+
+		validateArrayFormatSeparator(options.arrayFormatSeparator);
+
+		const formatter = parserForArrayFormat(options);
+
+		// Create an object with no prototype
+		const ret = Object.create(null);
+
+		if (typeof input !== 'string') {
+			return ret;
+		}
+
+		input = input.trim().replace(/^[?#&]/, '');
+
+		if (!input) {
+			return ret;
+		}
+
+		for (const param of input.split('&')) {
+			let [key, value] = splitOnFirst$1(options.decode ? param.replace(/\+/g, ' ') : param, '=');
+
+			// Missing `=` should be `null`:
+			// http://w3.org/TR/2012/WD-url-20120524/#collect-url-parameters
+			value = value === undefined ? null : ['comma', 'separator'].includes(options.arrayFormat) ? value : decode(value, options);
+			formatter(decode(key, options), value, ret);
+		}
+
+		for (const key of Object.keys(ret)) {
+			const value = ret[key];
+			if (typeof value === 'object' && value !== null) {
+				for (const k of Object.keys(value)) {
+					value[k] = parseValue(value[k], options);
+				}
+			} else {
+				ret[key] = parseValue(value, options);
+			}
+		}
+
+		if (options.sort === false) {
+			return ret;
+		}
+
+		return (options.sort === true ? Object.keys(ret).sort() : Object.keys(ret).sort(options.sort)).reduce((result, key) => {
+			const value = ret[key];
+			if (Boolean(value) && typeof value === 'object' && !Array.isArray(value)) {
+				// Sort object keys, not values
+				result[key] = keysSorter(value);
+			} else {
+				result[key] = value;
+			}
+
+			return result;
+		}, Object.create(null));
+	}
+
+	exports.extract = extract;
+	exports.parse = parse;
+
+	exports.stringify = (object, options) => {
+		if (!object) {
+			return '';
+		}
+
+		options = Object.assign({
+			encode: true,
+			strict: true,
+			arrayFormat: 'none',
+			arrayFormatSeparator: ','
+		}, options);
+
+		validateArrayFormatSeparator(options.arrayFormatSeparator);
+
+		const shouldFilter = key => (
+			(options.skipNull && isNullOrUndefined(object[key])) ||
+			(options.skipEmptyString && object[key] === '')
+		);
+
+		const formatter = encoderForArrayFormat(options);
+
+		const objectCopy = {};
+
+		for (const key of Object.keys(object)) {
+			if (!shouldFilter(key)) {
+				objectCopy[key] = object[key];
+			}
+		}
+
+		const keys = Object.keys(objectCopy);
+
+		if (options.sort !== false) {
+			keys.sort(options.sort);
+		}
+
+		return keys.map(key => {
+			const value = object[key];
+
+			if (value === undefined) {
+				return '';
+			}
+
+			if (value === null) {
+				return encode(key, options);
+			}
+
+			if (Array.isArray(value)) {
+				return value
+					.reduce(formatter(key), [])
+					.join('&');
+			}
+
+			return encode(key, options) + '=' + encode(value, options);
+		}).filter(x => x.length > 0).join('&');
+	};
+
+	exports.parseUrl = (input, options) => {
+		return {
+			url: removeHash(input).split('?')[0] || '',
+			query: parse(extract(input), options)
+		};
+	};
+
+	exports.stringifyUrl = (input, options) => {
+		const url = removeHash(input.url).split('?')[0] || '';
+		const queryFromUrl = exports.extract(input.url);
+		const parsedQueryFromUrl = exports.parse(queryFromUrl);
+		const hash = getHash(input.url);
+		const query = Object.assign(parsedQueryFromUrl, input.query);
+		let queryString = exports.stringify(query, options);
+		if (queryString) {
+			queryString = `?${queryString}`;
+		}
+
+		return `${url}${queryString}${hash}`;
+	};
+} (queryString));
+
+export { queryString as q };

package/lib/components/isObjectLike-e111475d.js

@@ -0,0 +1,190 @@
+import { c as commonjsGlobal } from './_commonjsHelpers-70de2c37.js';
+
+/**
+ * Checks if `value` is the
+ * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
+ * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an object, else `false`.
+ * @example
+ *
+ * _.isObject({});
+ * // => true
+ *
+ * _.isObject([1, 2, 3]);
+ * // => true
+ *
+ * _.isObject(_.noop);
+ * // => true
+ *
+ * _.isObject(null);
+ * // => false
+ */
+
+function isObject(value) {
+  var type = typeof value;
+  return value != null && (type == 'object' || type == 'function');
+}
+
+var isObject_1 = isObject;
+
+/** Detect free variable `global` from Node.js. */
+
+var freeGlobal$1 = typeof commonjsGlobal == 'object' && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;
+
+var _freeGlobal = freeGlobal$1;
+
+var freeGlobal = _freeGlobal;
+
+/** Detect free variable `self`. */
+var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
+
+/** Used as a reference to the global object. */
+var root$1 = freeGlobal || freeSelf || Function('return this')();
+
+var _root = root$1;
+
+var root = _root;
+
+/** Built-in value references. */
+var Symbol$2 = root.Symbol;
+
+var _Symbol = Symbol$2;
+
+var Symbol$1 = _Symbol;
+
+/** Used for built-in method references. */
+var objectProto$1 = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto$1.hasOwnProperty;
+
+/**
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+var nativeObjectToString$1 = objectProto$1.toString;
+
+/** Built-in value references. */
+var symToStringTag$1 = Symbol$1 ? Symbol$1.toStringTag : undefined;
+
+/**
+ * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @returns {string} Returns the raw `toStringTag`.
+ */
+function getRawTag$1(value) {
+  var isOwn = hasOwnProperty.call(value, symToStringTag$1),
+      tag = value[symToStringTag$1];
+
+  try {
+    value[symToStringTag$1] = undefined;
+    var unmasked = true;
+  } catch (e) {}
+
+  var result = nativeObjectToString$1.call(value);
+  if (unmasked) {
+    if (isOwn) {
+      value[symToStringTag$1] = tag;
+    } else {
+      delete value[symToStringTag$1];
+    }
+  }
+  return result;
+}
+
+var _getRawTag = getRawTag$1;
+
+/** Used for built-in method references. */
+
+var objectProto = Object.prototype;
+
+/**
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+var nativeObjectToString = objectProto.toString;
+
+/**
+ * Converts `value` to a string using `Object.prototype.toString`.
+ *
+ * @private
+ * @param {*} value The value to convert.
+ * @returns {string} Returns the converted string.
+ */
+function objectToString$1(value) {
+  return nativeObjectToString.call(value);
+}
+
+var _objectToString = objectToString$1;
+
+var Symbol = _Symbol,
+    getRawTag = _getRawTag,
+    objectToString = _objectToString;
+
+/** `Object#toString` result references. */
+var nullTag = '[object Null]',
+    undefinedTag = '[object Undefined]';
+
+/** Built-in value references. */
+var symToStringTag = Symbol ? Symbol.toStringTag : undefined;
+
+/**
+ * The base implementation of `getTag` without fallbacks for buggy environments.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @returns {string} Returns the `toStringTag`.
+ */
+function baseGetTag(value) {
+  if (value == null) {
+    return value === undefined ? undefinedTag : nullTag;
+  }
+  return (symToStringTag && symToStringTag in Object(value))
+    ? getRawTag(value)
+    : objectToString(value);
+}
+
+var _baseGetTag = baseGetTag;
+
+/**
+ * Checks if `value` is object-like. A value is object-like if it's not `null`
+ * and has a `typeof` result of "object".
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+ * @example
+ *
+ * _.isObjectLike({});
+ * // => true
+ *
+ * _.isObjectLike([1, 2, 3]);
+ * // => true
+ *
+ * _.isObjectLike(_.noop);
+ * // => false
+ *
+ * _.isObjectLike(null);
+ * // => false
+ */
+
+function isObjectLike(value) {
+  return value != null && typeof value == 'object';
+}
+
+var isObjectLike_1 = isObjectLike;
+
+export { _root as _, _baseGetTag as a, isObject_1 as b, _freeGlobal as c, isObjectLike_1 as i };

package/lib/components/style-inject.es-1f59c1d0.js

@@ -1 +1,28 @@
-function e(e,t){void 0===t&&(t={});var d=t.insertAt;if(e&&"undefined"!=typeof document){var n=document.head||document.getElementsByTagName("head")[0],s=document.createElement("style");s.type="text/css","top"===d&&n.firstChild?n.insertBefore(s,n.firstChild):n.appendChild(s),s.styleSheet?s.styleSheet.cssText=e:s.appendChild(document.createTextNode(e))}}export{e as s};
+function styleInject(css, ref) {
+  if ( ref === void 0 ) ref = {};
+  var insertAt = ref.insertAt;
+
+  if (!css || typeof document === 'undefined') { return; }
+
+  var head = document.head || document.getElementsByTagName('head')[0];
+  var style = document.createElement('style');
+  style.type = 'text/css';
+
+  if (insertAt === 'top') {
+    if (head.firstChild) {
+      head.insertBefore(style, head.firstChild);
+    } else {
+      head.appendChild(style);
+    }
+  } else {
+    head.appendChild(style);
+  }
+
+  if (style.styleSheet) {
+    style.styleSheet.cssText = css;
+  } else {
+    style.appendChild(document.createTextNode(css));
+  }
+}
+
+export { styleInject as s };

package/lib/components/toConsumableArray-dbe8af76.js

@@ -0,0 +1,19 @@
+import { l as _arrayLikeToArray, n as _unsupportedIterableToArray } from './defaultTheme-ed7746fe.js';
+
+function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+
+function _iterableToArray(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+function _toConsumableArray(arr) {
+  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+
+export { _toConsumableArray as _ };